Phenquestions
Kommunikasjonen og dataoverføringen mellom frontend og backend til ethvert program skjer via APIer (Application Programming Interface). Det er mange forskjellige typer API-er som brukes til å kommunisere mellom front- og back-end-applikasjoner som RESTful API, SOAP API, GraphQL API, etc. GraphQL API er en relativt ny teknologi, og den er mye raskere enn andre typer APIer tilgjengelig. Å hente data fra databasen ved hjelp av GraphQL api er mye raskere enn REST API. Mens du bruker GraphQL API, har klienten kontroll for å hente bare de nødvendige dataene i stedet for å få alle detaljene; det er derfor GraphQL API fungerer raskere enn REST API.
Installere pakker
Vi skal bygge en node.js-applikasjon ved hjelp av GraphQL API, så vi må installere node.js og npm for dette før du starter prosjektet.
[e-postbeskyttet]: ~ $ sudo apt-get update -y[e-postbeskyttet]: ~ $ sudo apt-get install nodejs
[e-postbeskyttet]: ~ $ sudo apt-get install npm
Sette opp prosjekt
Vi vil bruke 'ekspress' rammeverk fra node.js for å bygge applikasjonen vår. Lag en katalog som heter 'graphql' og start prosjektet.
[e-postbeskyttet]: ~ $ mkdir graphql[e-postbeskyttet]: ~ $ cd graphql /
[e-postbeskyttet]: ~ $ npm init -y
MongoDB-oppsett
I vårt GraphQL-prosjekt vil vi bruke MongoDB som vår database. MongoDB er en skjemafri database og lagrer data i form av nøkkelpar. For å installere mongoDB, følg trinnene.
Importer den offentlige GPG-nøkkelen for MongoDB.
[e-postbeskyttet]: ~ $ wget -qO - https: // www.mongodb.org / statisk / pgp / server-4.4.asc | sudo apt-key add -
Opprett listefilen for Mongodb.
Oppdater lokale arkiver.
[e-postbeskyttet]: ~ $ sudo apt-get update -yInstaller mongodb-pakken.
[e-postbeskyttet]: ~ $ sudo apt-get install -y mongodb-orgStart og aktiver mongod.service.
[e-postbeskyttet]: ~ $ sudo systemctl start Mongod.service[e-postbeskyttet]: ~ $ sudo systemctl aktiver mongod.service
Installere npm-moduler
For GraphQL-applikasjonen vår, må vi installere noen npm-pakker. Vi vil installere cors, express, body-parser, mangoose, etc.
[e-postbeskyttet]: ~ $ cd graphql /[e-postbeskyttet]: ~ $ npm installer cors express body-parser Mongoose --Save
For å lage en GraphQL api, må vi installere en ekstra npm-pakke kalt 'apollo-server-express.'Denne npm-pakken brukes til å kjøre graphQL-server med all Node.js HTTP-rammer som 'express.'
[e-postbeskyttet]: ~ $ npm installer apollo-server-express --saveDefinere MongoDB-skjema
Nå har vi satt opp miljøet for GraphQL-applikasjonen vår i Node.js, og det er på tide å definere et skjema for søknaden vår. Lag en fil 'modeller / student.js 'i prosjektets rotkatalog.
// definere studentskjemaconst mongoose = krever ('mangoose');
const studentSchema = ny Mongoose.Skjema (
Navn:
type: streng,
kreves: sant
,
klasse:
type: Antall,
kreves: sant
,
hovedfag:
type: String,
kreves: sant
,
tidsstempler: sant
);
const Student = Mongoose.modell ('Student', studentSchema);
modul.eksport = Student, studentSchema
I det ovennevnte skjemaet må hver elev ha navn, klasse og hovedfag.
Bygge GraphQL API
Etter å ha opprettet studentskjemaet, vil vi nå bygge GraphQL API. Lag et 'skjema.js 'for å skrive GraphQL-parametere. Det er to parametere, 'typer' og 'resolvers', brukt i GraphQL API. I 'typer' vil vi spesifisere skjemaet vårt, spørringene (f.eks.g., Gjøre GET-forespørsler) og mutasjoner (e.g., Gjør UPDATE eller SLETT forespørsler) til det angitte skjemaet. Vi vil skrive de forskjellige metodene som er definert i 'typer' for å koble spørsmål og mutasjoner med databasen i 'resolvers.'
// importerer skjema og modulconst gql = krever ('apollo-server-express');
const Student = krever ('./ modeller / student ').Student;
// Definere skjema, spørring og mutasjonstype
const typeDefs = gql '
skriv student
jeg gjorde!,
navn: String!,
klasse: Int!,
dur: String!
skriv spørring
getStudents: [Student],
getStudentById (id: ID!): Student
type mutasjon
addStudent (navn: String!, klasse: Int!, dur: String! ): Student
updateStudent (navn: String!, klasse: Int!, dur: String! ): Student
deleteStudent (id: ID! ): Student
'
// Definere løsere
const resolvers =
Spørring:
getStudents: (foreldre, args) =>
tilbake Student.finne();
,
getStudentById: (foreldre, args) =>
tilbake Student.findById (arg.id);
,
Mutasjon:
addStudent: (foreldre, args) =>
la student = ny student (
navn: args.Navn,
klasse: args.klasse,
major: args.major
);
returstudent.lagre();
,
updateStudent: (foreldre, args) =>
hvis(!argumenterer.id) returnere;
tilbake Student.findOneAndUpdate (
_id: args.id
,
$ sett:
navn: args.Navn,
klasse: args.klasse,
major: args.major
,
new: true, (err, Student) =>
hvis (feiler)
konsoll.logg (feil);
annet ;
)
modul.eksport =
typeDefs,
resolvers
Opprette GraphQL API Server
Nå er vi nesten ferdige med å lage GraphQL-applikasjonen. Det eneste trinnet igjen er å opprette serveren. Opprett en fil med navnet 'app.js 'for å konfigurere serverparametere.
// importere nødvendige pakkerconst express = krever ('express');
const mongoose = krever ('mangoose');
const bodyParser = krever ('body-parser');
const cors = krever ('cors');
const ApolloServer = krever ('apollo-server-express');
// importeringsskjema
const typeDefs, resolvers = krever ('./ skjema ');
// kobler til MongoDB
const url = “mongodb: // 127.0.0.1: 27017 / studenter ”;
const connect = mangoose.koble til (url, useNewUrlParser: true);
koble.deretter ((db) =>
konsoll.logg ('Tilkobling vellykket');
, (err) =>
konsoll.logg (feil);
);
// oppretter server
const server = ny ApolloServer (
typeDefs: typeDefs,
resolvers: resolvers
);
const app = express ();
app.bruk (bodyParser.json ());
app.bruk ('*', cors ());
server.ApplyMiddleware (app);
app.hør (8000, () =>
konsoll.logg ('lytter til 8000');
)
Testing av GraphQL API
Vi har vår grafQL-server oppe på port 8000, og det er på tide å teste GraphQL API. Åpne GraphQL-nettsiden i nettleseren ved å gå til følgende url.
http: // localhost: 8000 / graphql
Og den åpner følgende webside.
Legg studenten til databasen ved hjelp av graphQL API.
På samme måte kan du legge til flere studenter, og etter å ha lagt til studenten, få alle studentene ved hjelp av GraphQL API.
Legg merke til ID-en til noen av studentene og få den spesifikke studenten ved hjelp av id-en.
Konklusjon
Å hente data fra databasen ved hjelp av standard REST API gjør spørringen treg, da noen ganger får vi mer data enn nødvendig. Ved hjelp av GraphQL kan vi hente nøyaktig de nødvendige dataene som gjør GraphQL API raskere. I dette demoprosjektet har vi bare et enkelt skjema, så vi har opprettet GraphQL API for det eneste skjemaet. Vi har også definert tre til fire metoder for skjemaet. Du kan opprette mer enn ett spørsmål eller mutasjoner i henhold til applikasjonen din.
