Einführung in die Erstellung von GraphQL -APIs und -Apps im Knoten.JS

Die Kommunikations- und Datenübertragung zwischen dem Frontend und dem Backend einer Anwendung erfolgt über APIs (Anwendungsprogrammierschnittstelle). Es gibt viele verschiedene Arten von APIs, die verwendet werden, um zwischen den Vorder- und Back-End-Anwendungen wie RESTful-API, SOAP-API, GraphQL-API usw. zu kommunizieren, usw. Die GraphQL -API ist eine relativ neue Technologie und ist viel schneller als andere verfügbare Arten von APIs. Das Abrufen von Daten aus der Datenbank mithilfe der GraphQL -API ist viel schneller als die Rest -API. Während der Verwendung von GraphQL -API hat der Client die Kontrolle, nur die erforderlichen Daten abzurufen, anstatt alle Details zu erhalten. Deshalb arbeitet die GraphQL -API schneller als die REST -API.

Pakete installieren

Wir werden einen Knoten bauen.JS -Anwendung mithilfe der GraphQL -API, daher müssen wir den Knoten installieren.JS und NPM dafür, bevor Sie das Projekt starten.

Ubuntu@Ubuntu: ~ $ sudo apt -Get -Update -y
Ubuntu@Ubuntu: ~ $ sudo apt-Get Installieren Sie NodeJs
Ubuntu@Ubuntu: ~ $ sudo apt-Get Installieren Sie NPM

Projekt einrichten

Wir werden das "Express" -Regel vom Knoten verwenden.JS, um unsere Bewerbung aufzubauen. Erstellen Sie ein Verzeichnis namens "GraphQL" und initiieren Sie das Projekt.

Ubuntu@Ubuntu: ~ $ mkdir graphql
Ubuntu@Ubuntu: ~ $ CD Graphql/
Ubuntu@Ubuntu: ~ $ npm init -y

MongoDB -Setup

In unserem GraphQL -Projekt werden wir MongoDB als unsere Datenbank verwenden. MongoDB ist eine Schemaless -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.

Ubuntu@Ubuntu: ~ $ wget -qo - https: // www.MongoDb.org/static/pgp/server-4.4.ASC | sudo apt-key add -

Erstellen Sie die Listendatei für MongoDB.

Ubuntu@Ubuntu: ~ $ echo "Deb [Arch = AMD64, ARM64] https: // repo.MongoDb.org/apt/ubuntu bionic/mongoDB-org/4.4 Multiverse "| sudo tee/etc/apt/Quellen.Liste.d/mongoDb-org-4.4.Liste

Aktualisieren Sie lokale Repositories.

Ubuntu@Ubuntu: ~ $ sudo apt -Get -Update -y

Installieren Sie das MongoDB -Paket.

Ubuntu@Ubuntu: ~ $ sudo apt-Get install -y mongoDb-org

Beginnen Sie und aktivieren Sie Mongod.Service.

Ubuntu@Ubuntu: ~ $ sudo systemctl starten mongod.Service
Ubuntu@Ubuntu: ~ $ sudo systemCtl aktivieren Mongod.Service

Installieren von NPM -Modulen

Für unsere GraphQL -Anwendung müssen wir einige NPM -Pakete installieren. Wir werden CORs, Express, Body-Parser, Mongoose usw. installieren.

Ubuntu@Ubuntu: ~ $ CD Graphql/
Ubuntu@Ubuntu: ~ $ npm install CORS Express Body-Parser Mongoose-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 Knoten auszuführen.JS HTTP -Frameworks wie 'Express.''

Ubuntu@ubuntu: ~ $ npm install apollo-server-express--Save

Definieren von MongoDB -Schema

Jetzt haben wir unsere Umgebung für unsere GraphQL -Anwendung im Knoten eingerichtet.JS, und es ist Zeit, ein Schema für unsere Anwendung zu definieren. Erstellen Sie eine Datei 'Modelle/Student.JS 'im Projekt Root Directory.

// Definieren des Schülerschemas
const mongoose = erfordern ('mongoose');
const studentschema = neuer Mongoose.Schema(
Name:
Typ: Zeichenfolge,
Erforderlich: wahr
,
Klasse:
Nummer eingeben,
Erforderlich: wahr
,
wesentlich:
Typ: Zeichenfolge,
Erforderlich: wahr

,
Zeitstempel: Richtig
);
const student = mongoose.Modell ('Student', Studentschema);
Modul.exports = student, studentschema

Im oben definierten Schema muss jeder Schüler einen Namen, eine Klasse und einen Major haben.

Erstellen von GraphQL -API

Nach dem Erstellen des Schülerschemas werden wir nun GraphQL API erstellen. Erstellen Sie ein 'Schema.JS ', um GraphQL -Parameter zu schreiben. Es gibt zwei Parameter, "Typen" und "Resolver", die in der GraphQL -API verwendet werden. In 'Typen' werden wir unser Schema, die Abfragen (e), angeben.G., Get -Anfragen machen) und Mutationen (e.G., Aktualisierung oder Löschen von Anforderungen) auf 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 importieren
const gql = require ('apollo-server-express');
const student = fordern ('./Models/Student ').Student;
// Definieren von Schema, Abfrage und Mutationstyp
const typedefs = gql '
Geben Sie Schüler ein
Ich tat!,
Name: Zeichenfolge!,
Klasse: int!,
Major: String!

Geben Sie Abfrage ein
Getstudents: [Student],
GetStudentbyId (ID: ID!): Student

Typ Mutation
AddStudent (Name: String!, Klasse: int!, Major: String! ): Student
updatestudent (Name: String!, Klasse: int!, Major: String! ): Student
Löschen (ID: ID! ): Student
'
// Definieren von Resolver
const resolvers =
Anfrage:
Getstudents: (Elternteil, args) =>
Student zurückkehren.finden();
,
GetstudentbyId: (Elternteil, Args) =>
Student zurückkehren.FindById (Args.Ausweis);

,
Mutation:
addStudent: (übergeordnet, args) =>
lass Student = New Student (
Name: Args.Name,
Klasse: Args.Klasse,
Major: Args.wesentlich
);
Student zurückkehren.speichern();
,
updatestudent: (übergeordnet, args) =>
Wenn(!Args.id) zurück;
Student zurückkehren.FindoneAndupdate (
_id: args.Ausweis
,

$ set:
Name: Args.Name,
Klasse: Args.Klasse,
Major: Args.wesentlich

,
new: true, (err, student) =>
if (err)
Konsole.log (err);
anders ;
)



Modul.exports =
Typedefs,
Resolver

Erstellen von GraphQL -API -Server

Jetzt sind wir fast fertig damit, die GraphQL -Anwendung zu erstellen. Der einzige Schritt übrig ist das Erstellen des Servers. Erstellen Sie eine Datei namens 'App.JS ', um Serverparameter zu konfigurieren.

// erforderliche Pakete importieren
const express = forderung ('express');
const mongoose = erfordern ('mongoose');
const bodyparser = fordern ('Body-Parser');
const cors = fordern ('cors');
const apolloserver = require ('apollo-server-express');
// Schema importieren
const typedefs, resolvers = required ('./Schema');
// Verbindung zu MongoDB herstellen
const url = “MongoDB: // 127.0.0.1: 27017/Studenten “;
const connect = mongoose.Connect (URL, usenewurlParser: true);
verbinden.dann ((db) =>
Konsole.log ('Verbindung erfolgreich');
, (err) =>
Konsole.log (err);
);
// Server erstellen
const server = neuer Apolloserver (
Typedefs: Typedefs,
Resolver: Resolver
);
const App = express ();
App.Verwendung (Bodyparser.JSON ());
App.Verwendung ('*', cors ());
Server.applyMiddleware (app);
App.Hören Sie (8000, () =>

Konsole.log ('8000' anhören);
)

Testen der GraphQL -API

Wir haben unseren GraphQL -Server auf Port 8000 und es ist Zeit, die GraphQL -API zu testen. Öffnen Sie die GraphQL -Webseite auf dem Browser, indem Sie die folgende URL besuchen.

http: // localhost: 8000/graphql

Und es wird die folgende Webseite öffnen.

Fügen Sie den Schüler mithilfe der GraphQL -API in die Datenbank hinzu.

Fügen Sie in ähnlicher Weise weitere Schüler hinzu und erhalten Sie nach dem Hinzufügen des Schülers alle Schüler mithilfe von GraphQL -API.

Beachten Sie die ID eines der Schüler und bringen Sie den spezifischen Schüler mit seiner ID ein.

Abschluss

Wenn Sie Daten aus der Datenbank mit der Standard -REST -API abrufen. Mit GraphQL können wir genau die erforderlichen Daten abrufen, die die GraphQL -API schneller machen. In diesem Demo -Projekt haben wir nur ein einziges Schema, daher haben wir GraphQL -API für dieses einzelne Schema erstellt. Außerdem haben wir drei bis vier Methoden für das Schema definiert. Sie können mehr als eine Abfrage oder Mutationen gemäß Ihrer Anwendung erstellen.