Phenquestions
Kommunikation og dataoverførsel mellem frontend og backend på enhver applikation sker via API'er (Application Programming Interface). Der er mange forskellige typer API'er, der bruges til at kommunikere mellem front- og back-end-applikationer som RESTful API, SOAP API, GraphQL API osv. GraphQL API er en relativt ny teknologi, og den er meget hurtigere end andre typer API'er til rådighed. At hente data fra databasen ved hjælp af GraphQL api er meget hurtigere end REST API. Mens du bruger GraphQL API, har klienten kontrol til kun at hente de krævede data i stedet for at få alle detaljerne; Derfor fungerer GraphQL API hurtigere end REST API.
Installation af pakker
Vi bygger en knude.js-applikation ved hjælp af GraphQL API, så vi skal installere node.js og npm for dette inden projektet startes.
[e-mail-beskyttet]: ~ $ sudo apt-get update -y[e-mail-beskyttet]: ~ $ sudo apt-get install nodejs
[e-mail-beskyttet]: ~ $ sudo apt-get install npm
Opsætning af projekt
Vi bruger 'ekspress' rammen fra node.js til at opbygge vores applikation. Opret en mappe med navnet 'graphql' og start projektet.
[e-mail-beskyttet]: ~ $ mkdir graphql[e-mail-beskyttet]: ~ $ cd graphql /
[e-mail-beskyttet]: ~ $ npm init -y
MongoDB-opsætning
I vores GraphQL-projekt bruger vi MongoDB som vores database. MongoDB er en skemaløs database og gemmer data i form af nøglepar. Følg de givne trin for at installere mongoDB.
Importer den offentlige GPG-nøgle til MongoDB.
[e-mail-beskyttet]: ~ $ wget -qO - https: // www.mongodb.org / statisk / pgp / server-4.4.asc | sudo apt-key tilføj -
Opret listefilen til mongodb.
Opdater lokale arkiver.
[e-mail-beskyttet]: ~ $ sudo apt-get update -yInstaller mongodb-pakke.
[e-mail-beskyttet]: ~ $ sudo apt-get install -y mongodb-orgStart og aktiver mongod.service.
[e-mail-beskyttet]: ~ $ sudo systemctl start mongod.service[e-mailbeskyttet]: ~ $ sudo systemctl aktiver mongod.service
Installation af npm-moduler
Til vores GraphQL-applikation skal vi installere nogle npm-pakker. Vi installerer kors, express, body-parser, mangoose osv.
[e-mail-beskyttet]: ~ $ cd graphql /[e-mail-beskyttet]: ~ $ npm installer cors express body-parser mangoose - gem
For at oprette en GraphQL-API er vi nødt til at installere en ekstra npm-pakke med navnet 'apollo-server-express.'Denne npm-pakke bruges til at køre graphQL-server med al node.js HTTP-rammer som 'express'.''
[email protected]: ~ $ npm installer apollo-server-express --saveDefinition af MongoDB-skema
Nu har vi indstillet vores miljø til vores GraphQL-applikation i Node.js, og det er på tide at definere et skema til vores ansøgning. Opret en fil 'modeller / studerende.js 'i projektets rodmappe.
// definerer elevskemaconst mongoose = kræve ('mangoose');
const studentSchema = ny mango.Skema (
navn:
type: streng,
krævet: sandt
,
klasse:
type: Antal,
krævet: sandt
,
større:
type: streng,
krævet: sandt
,
tidsstempler: sandt
);
const Student = Mongoose.model ('Student', studentSchema);
modul.eksport = Student, studentSchema
I det ovenfor definerede skema skal alle studerende have et navn, klasse og hovedfag.
Opbygning af GraphQL API
Efter oprettelse af studentskemaet bygger vi nu GraphQL API. Opret et 'skema.js 'for at skrive GraphQL-parametre. Der er to parametre, 'typer' og 'resolvere', der bruges i GraphQL API. I 'typer' specificerer vi vores skema, forespørgslerne (f.eks.g., At foretage GET-anmodninger) og mutationer (e.g., Foretagelse af UPDATE eller SLET anmodninger) til det angivne skema. Vi skriver de forskellige metoder, der er defineret i 'typer' for at forbinde forespørgsler og mutationer med databasen i 'opløsere.''
// import af skema og modulconst gql = kræve ('apollo-server-express');
const Student = kræve ('./ modeller / studerende ').Studerende;
// Definere skema, forespørgsel og mutationstype
const typeDefs = gql '
skriv studerende
jeg gjorde!,
navn: String!,
klasse: Int!,
major: String!
skriv forespørgsel
getStudents: [Student],
getStudentById (id: ID!): Studerende
type mutation
addStudent (navn: String!, klasse: Int!, major: String! ): Studerende
updateStudent (navn: String!, klasse: Int!, major: String! ): Studerende
deleteStudent (id: ID! ): Studerende
'
// Definering af resolvere
const resolvers =
Forespørgsel:
getStudents: (forælder, args) =>
returner studerende.finde();
,
getStudentById: (forælder, args) =>
returner studerende.findById (arg.id);
,
Mutation:
addStudent: (forælder, args) =>
lad studerende = ny elev (
navn: args.navn,
klasse: args.klasse,
major: args.major
);
tilbagevendende studerende.Gemme();
,
updateStudent: (forælder, args) =>
hvis(!argumenterer.id) returnere;
returner studerende.findOneAndUpdate (
_id: args.id
,
$ sæt:
navn: args.navn,
klasse: args.klasse,
major: args.major
,
new: true, (err, Student) =>
hvis (fejler)
konsol.log (fejler);
andet ;
)
modul.eksport =
typeDefs,
opløsere
Oprettelse af GraphQL API-server
Nu er vi næsten færdige med at oprette GraphQL-applikationen. Det eneste trin tilbage er at oprette serveren. Opret en fil med navnet 'app.js 'for at konfigurere serverparametre.
// import af nødvendige pakkerconst express = kræve ('express');
const mongoose = kræve ('mangoose');
const bodyParser = kræve ('body-parser');
const cors = kræve ('cors');
const ApolloServer = kræver ('apollo-server-express');
// importskema
const typeDefs, resolvers = kræver ('./ skema ');
// opretter forbindelse til MongoDB
const url = “mongodb: // 127.0.0.1: 27017 / studerende ”;
const connect = mangoose.forbinde (url, useNewUrlParser: true);
Opret forbindelse.derefter ((db) =>
konsol.log ('Forbindelse lykkedes');
, (err) =>
konsol.log (fejler);
);
// opretter server
const server = ny ApolloServer (
typeDefs: typeDefs,
resolvers: resolvers
);
const app = express ();
app.brug (bodyParser.json ());
app.brug ('*', cors ());
server.ApplyMiddleware (app);
app.lyt (8000, () =>
konsol.log ('lytter til 8000');
)
Test af GraphQL API
Vi har vores grafQL-server kørende på port 8000, og det er på tide at teste GraphQL API. Åbn GraphQL-websiden i browseren ved at besøge følgende url.
http: // localhost: 8000 / graphql
Og det åbner følgende webside.
Føj den studerende til databasen ved hjælp af graphQL API.
Tilsvarende tilføj flere studerende, og efter at have tilføjet den studerende skal du få alle de studerende ved hjælp af GraphQL API.
Bemærk id'et for en af studerende, og få den specifikke studerende ved hjælp af sit id.
Konklusion
At hente data fra databasen ved hjælp af standard REST API gør forespørgslen langsom, da vi nogle gange får flere data end krævet. Ved hjælp af GraphQL kan vi hente nøjagtigt de krævede data, der gør GraphQL API hurtigere. I dette demoprojekt har vi kun et enkelt skema, så vi har oprettet GraphQL API til det samme skema. Vi har også defineret tre til fire metoder til skemaet. Du kan oprette mere end en forespørgsel eller mutationer i henhold til din applikation.
