Phenquestions
Die Kommunikation und Datenübertragung zwischen Frontend und Backend einer beliebigen Anwendung erfolgt über APIs (Application Programming Interface). Es gibt viele verschiedene Arten von APIs, die verwendet werden, um zwischen den Front- und Back-End-Anwendungen zu kommunizieren, wie RESTful API, SOAP API, GraphQL API usw. Die GraphQL-API ist eine relativ neue Technologie und viel schneller als andere verfügbare API-Typen. Das Abrufen von Daten aus der Datenbank mit der GraphQL-API ist viel schneller als mit der REST-API. Bei der Verwendung der GraphQL-API hat der Client die Kontrolle, nur die erforderlichen Daten abzurufen, anstatt alle Details abzurufen. Aus diesem Grund arbeitet die GraphQL-API schneller als die REST-API.
Pakete installieren
Wir bauen einen Knoten.js-Anwendung, die die GraphQL-API verwendet, also müssen wir node installieren.js und npm dafür, bevor Sie das Projekt starten.
[email protected]:~$ sudo apt-get update -y[email protected]:~$ sudo apt-get install nodejs
[email protected]:~$ sudo apt-get install npm
Projekt einrichten
Wir verwenden das 'Express'-Framework von node.js, um unsere Anwendung zu erstellen. Erstellen Sie ein Verzeichnis namens 'graphql' und starten Sie das Projekt.
[email protected]:~$ mkdir graphql[email protected]:~$ cd graphql/
[email protected]:~$ npm init -y
MongoDB-Einrichtung
In unserem GraphQL-Projekt werden wir MongoDB als Datenbank verwenden. MongoDB ist eine schemalose Datenbank und speichert Daten in Form von Schlüsselpaaren. Um mongoDB zu installieren, befolgen Sie die angegebenen Schritte.
Importieren Sie den öffentlichen GPG-Schlüssel für MongoDB.
[email protected]:~$ wget -qO - https://www.mongodb.org/static/pgp/server-4.4.aufsteigend | sudo apt-key hinzufügen -
Erstellen Sie die Listendatei für mongodb.
Lokale Repositorys aktualisieren.
[email protected]:~$ sudo apt-get update -yMongodb-Paket installieren.
[email protected]:~$ sudo apt-get install -y mongodb-orgMongod starten und aktivieren.Bedienung.
[email protected]:~$ sudo systemctl start mongod.Bedienung[email protected]:~$ sudo systemctl enable mongod.Bedienung
Installieren von npm-Modulen
Für unsere GraphQL-Anwendung müssen wir einige npm-Pakete installieren. Wir werden Cors, Express, Body-Parser, Mungo usw. installieren.
[email protected]:~$ cd graphql/[email protected]:~$ npm install cors express body-parser mungo --save
Um eine GraphQL-API zu erstellen, müssen wir ein zusätzliches npm-Paket namens 'apollo-server-express . installieren.' Dieses npm-Paket wird verwendet, um den graphQL-Server mit allen Node auszuführen.js HTTP-Frameworks wie 'express.'
[email protected]:~$ npm install apollo-server-express --saveMongoDB-Schema definieren
Jetzt haben wir unsere Umgebung für unsere GraphQL-Anwendung in Node eingerichtet.js, und es ist an der Zeit, ein Schema für unsere Anwendung zu definieren. Erstellen Sie eine Datei 'Modelle/Student.js' im Projekt-Stammverzeichnis.
// Schülerschema definierenconst Mungo = erfordern('Mungo');
const studentSchema = neuer Mungo.Schema(
Name:
Typ: String,
erforderlich: wahr
,
Klasse:
Nummer eingeben,
erforderlich: wahr
,
Haupt:
Typ: String,
erforderlich: wahr
,
Zeitstempel: wahr
);
const Student = Mungo.model('Student', studentSchema);
Modul.exports = Student, studentSchema
Im oben definierten Schema muss jeder Schüler einen Namen, eine Klasse und ein Hauptfach haben.
Erstellen der GraphQL-API
Nachdem wir das Student-Schema erstellt haben, erstellen wir nun die GraphQL-API. Erstellen Sie ein "Schema".js' zum Schreiben von GraphQL-Parametern. Es gibt zwei Parameter, "Typen" und "Resolver", die in der GraphQL-API verwendet werden. In 'Typen' spezifizieren wir unser Schema, die Abfragen (z.G., GET-Anfragen stellen) und Mutationen (z.G., Senden von UPDATE- oder DELETE-Anfragen) an das angegebene Schema. Wir werden die verschiedenen in 'Typen' definierten Methoden schreiben, um die Abfragen und Mutationen mit der Datenbank in 'Resolver' zu verknüpfen.'
// Schema und Modul importierenconst gql = require('apollo-server-express');
const Student = erfordern('./models/student').Schüler;
// Schema, Abfrage und Mutationstyp definieren
const typeDefs = gql '
Typ Student
Ich tat!,
Name: String!,
Klasse: Int!,
Hauptfach: Streicher!
Typ Abfrage
getStudents: [Student],
getStudentById(id: ID!): Schüler
Typ Mutation
addStudent( name: String!, Klasse: Int!, Hauptfach: Streicher! ): Schüler
updateStudent( name: String!, Klasse: Int!, Hauptfach: Streicher! ): Schüler
deleteStudent( id: ID! ): Schüler
'
// Definieren von Resolvern
const-Resolver =
Abfrage:
getStudents: (Elternteil, Argumente) =>
Schüler zurück.finden();
,
getStudentById: (Elternteil, Argumente) =>
Schüler zurück.findById(args.Ich würde);
,
Mutation:
addStudent: (Elternteil, Argumente) =>
let student = new student(
Name: args.Name,
Klasse: Argumente.Klasse,
Hauptfach: Argumente.Haupt
);
Schüler zurück.speichern();
,
updateStudent: (Elternteil, Argumente) =>
wenn(!args.id) Rückkehr;
Schüler zurück.findOneAndUpdate(
_id: args.Ich würde
,
$set:
Name: args.Name,
Klasse: Argumente.Klasse,
Hauptfach: Argumente.Haupt
,
new: true , (err, Student) =>
wenn(err)
Konsole.log(err);
sonst ;
)
Modul.Exporte =
TypDefs,
Resolver
Erstellen eines GraphQL-API-Servers
Jetzt sind wir fast fertig mit der Erstellung der GraphQL-Anwendung. Der einzige Schritt, der übrig bleibt, ist den Server zu erstellen. Erstellen Sie eine Datei namens 'app.js', um Serverparameter zu konfigurieren.
// erforderliche Pakete importierenconst express = require('express');
const Mungo = erfordern('Mungo');
const bodyParser = require('body-parser');
const cors = require('cors');
const ApolloServer = require('apollo-server-express');
// Schema importieren
const typeDefs, Resolver = require('./Schema');
// Verbindung zu MongoDB
const-URL = “mongodb://127.0.0.1:27017/Studenten“;
const connect = Mungo.connect(url, useNewUrlParser: true );
verbinden.dann((db) =>
Konsole.log('Verbindung erfolgreich');
, (irrt) =>
Konsole.log(err);
);
// Server erstellen
const server = neuer ApolloServer(
typeDefs: typeDefs,
Resolver: Resolver
);
const app = express();
App.verwenden (bodyParser.json());
App.use('*', cors());
Server.ApplyMiddleware( app );
App.zuhören( 8000, () =>
Konsole.log('auf 8000 hören');
)
Testen der GraphQL-API
Wir haben unseren graphQL-Server auf Port 8000 in Betrieb und es ist an der Zeit, die GraphQL-API zu testen. Öffnen Sie die GraphQL-Webseite im Browser, indem Sie die folgende URL aufrufen.
http://localhost:8000/graphql
Und es öffnet sich die folgende Webseite.
Fügen Sie den Schüler mithilfe der graphQL-API zur Datenbank hinzu.
Fügen Sie auf ähnliche Weise weitere Schüler hinzu, und nachdem Sie den Schüler hinzugefügt haben, erhalten Sie alle Schüler mit der GraphQL-API.
Notieren Sie sich die ID eines der Schüler und rufen Sie den jeweiligen Schüler mit seiner ID ab.
Fazit
Das Abrufen von Daten aus der Datenbank mithilfe der Standard-REST-API verlangsamt die Abfrage, da wir manchmal mehr Daten als erforderlich erhalten. Mit GraphQL können wir genau die erforderlichen Daten abrufen, die die GraphQL-API schneller machen. In diesem Demoprojekt haben wir nur ein einziges Schema, daher haben wir die GraphQL-API für dieses einzelne Schema erstellt. Außerdem haben wir drei bis vier Methoden für das Schema definiert. Sie können je nach Anwendung mehr als eine Abfrage oder Mutation erstellen.
