Phenquestions
Kommunikationen och dataöverföringen mellan frontend och backend för alla applikationer sker via API: er (Application Programming Interface). Det finns många olika typer av API: er som används för att kommunicera mellan front- och back-end-applikationer som RESTful API, SOAP API, GraphQL API, etc. GraphQL API är en relativt ny teknik och den är mycket snabbare än andra typer av API: er. Att hämta data från databasen med GraphQL api är mycket snabbare än REST API. Medan GraphQL API används har klienten kontroll för att bara hämta nödvändig data istället för att få alla detaljer; det är därför GraphQL API fungerar snabbare än REST API.
Installera paket
Vi kommer att bygga en nod.js-applikation med GraphQL API, så vi måste installera nod.js och npm för detta innan du startar projektet.
[e-postskyddad]: ~ $ sudo apt-get update -y[e-postskyddad]: ~ $ sudo apt-get install nodejs
[e-postskyddad]: ~ $ sudo apt-get install npm
Ställer in projekt
Vi kommer att använda "express" -ramen från nod.js för att bygga vår applikation. Skapa en katalog med namnet 'graphql' och initiera projektet.
[e-postskyddad]: ~ $ mkdir graphql[e-postskyddad]: ~ $ cd graphql /
[e-postskyddad]: ~ $ npm init -y
MongoDB-inställning
I vårt GraphQL-projekt kommer vi att använda MongoDB som vår databas. MongoDB är en schemalös databas och lagrar data i form av nyckelpar. Följ de angivna stegen för att installera mongoDB.
Importera den offentliga GPG-nyckeln för MongoDB.
[e-postskyddad]: ~ $ wget -qO - https: // www.mongodb.org / static / pgp / server-4.4.asc | sudo apt-key add -
Skapa listfilen för mongodb.
Uppdatera lokala förråd.
[e-postskyddad]: ~ $ sudo apt-get update -yInstallera mongodb-paketet.
[e-postskyddad]: ~ $ sudo apt-get install -y mongodb-orgStarta och aktivera mongod.service.
[e-postskyddad]: ~ $ sudo systemctl starta mongod.service[e-postskyddad]: ~ $ sudo systemctl aktiverar mongod.service
Installera npm-moduler
För vår GraphQL-applikation måste vi installera några npm-paket. Vi installerar kors, express, body-parser, mongoose, etc.
[e-postskyddad]: ~ $ cd graphql /[e-postskyddad]: ~ $ npm installera cors express body-parser mongoose - spara
För att skapa en GraphQL-API måste vi installera ett extra npm-paket med namnet 'apollo-server-express.'Detta npm-paket används för att köra grafQL-server med alla Node.js HTTP-ramar som 'express'.''
[e-postskyddad]: ~ $ npm installera apollo-server-express - sparaDefiniera MongoDB-schema
Nu har vi ställt in vår miljö för vår GraphQL-applikation i Node.js, och det är dags att definiera ett schema för vår applikation. Skapa en fil 'modeller / student.js 'i projektets rotkatalog.
// definiera studentschemaconst mongoose = kräver ('mongoose');
const studentSchema = ny mongoose.Schema (
namn:
typ: Sträng,
krävs: sant
,
klass:
typ: Antal,
krävs: sant
,
major:
typ: Sträng,
krävs: sant
,
tidsstämplar: sant
);
const Student = mango.modell ('Student', studentSchema);
modul.export = Student, studentSchema
I det ovan definierade schemat måste varje elev ha ett namn, klass och huvudämne.
Bygga GraphQL API
Efter att ha skapat studentschemat kommer vi nu att bygga GraphQL API. Skapa ett schema.js 'för att skriva GraphQL-parametrar. Det finns två parametrar, 'typer' och 'resolvers', som används i GraphQL API. I 'typer' kommer vi att specificera vårt schema, frågorna (t.ex.g., Att göra GET-förfrågningar) och mutationer (e.g., Att göra UPPDATERING eller RADERA begäranden) till det angivna schemat. Vi kommer att skriva de olika metoderna som definieras i 'typer' för att länka frågor och mutationer med databasen i 'resolvers.''
// importera schema och modulconst gql = kräver ('apollo-server-express');
const Student = kräver ('./ modeller / student ').Studerande;
// Definiera schema, fråga och mutationstyp
const typeDefs = gql '
typ Student
jag gjorde!,
namn: Sträng!,
klass: Int!,
major: String!
skriv fråga
getStudents: [Student],
getStudentById (id: ID!): Studerande
typ Mutation
addStudent (namn: String!, klass: Int!, major: String! ): Studerande
updateStudent (namn: String!, klass: Int!, major: String! ): Studerande
deleteStudent (id: ID! ): Studerande
'
// Definiera lösare
const resolvers =
Fråga:
getStudents: (förälder, args) =>
återvänd student.hitta();
,
getStudentById: (förälder, args) =>
återvänd student.findById (arg.id);
,
Mutation:
addStudent: (förälder, args) =>
låt student = ny student (
namn: args.namn,
klass: args.klass,
major: args.större
);
återvändande student.spara();
,
updateStudent: (förälder, args) =>
om(!args.id) returnera;
återvänd student.findOneAndUpdate (
_id: args.id
,
$ set:
namn: args.namn,
klass: args.klass,
major: args.större
,
new: true, (err, Student) =>
if (err)
trösta.log (err);
annat ;
)
modul.export =
typDefs,
resolvers
Skapa GraphQL API-server
Nu är vi nästan klara med att skapa GraphQL-applikationen. Det enda steget kvar är att skapa servern. Skapa en fil med namnet 'app.js 'för att konfigurera serverparametrar.
// importera nödvändiga paketconst express = kräver ('express');
const mongoose = kräver ('mongoose');
const bodyParser = kräver ('body-parser');
const cors = kräver ('cors');
const ApolloServer = kräver ('apollo-server-express');
// importera schema
const typeDefs, resolvers = kräver ('./ schema ');
// ansluta till MongoDB
const url = “mongodb: // 127.0.0.1: 27017 / studenter ”;
const connect = mongoose.connect (url, useNewUrlParser: true);
ansluta.sedan ((db) =>
trösta.log ('Connection Successed');
, (err) =>
trösta.log (err);
);
// skapar server
const server = ny ApolloServer (
typeDefs: typeDefs,
resolvers: resolvers
);
const app = express ();
app.användning (bodyParser.json ());
app.använd ('*', cors ());
server.ApplyMiddleware (app);
app.lyssna (8000, () =>
trösta.log ('lyssna på 8000');
)
Testa GraphQL API
Vi har vår grafQL-server igång på port 8000, och det är dags att testa GraphQL API. Öppna GraphQL-webbsidan i webbläsaren genom att besöka följande webbadress.
http: // localhost: 8000 / graphql
Och den kommer att öppna följande webbsida.
Lägg till studenten i databasen med hjälp av graphQL API.
Lägg till fler studenter på samma sätt, och efter att ha lagt till eleven, få alla studenter med hjälp av GraphQL API.
Notera ID: n för någon av studenterna och få den specifika eleven med hjälp av dess id.
Slutsats
Att hämta data från databasen med standard REST API gör frågan långsam eftersom vi ibland får mer data än vad som krävs. Med hjälp av GraphQL kan vi hämta exakt nödvändiga data som gör GraphQL API snabbare. I det här demoprojektet har vi bara ett enda schema, så vi har skapat GraphQL API för det enda schemat. Vi har också definierat tre till fyra metoder för schemat. Du kan skapa mer än en fråga eller mutationer enligt din applikation.
