NodeJS

Introducere în realizarea API-urilor și aplicațiilor GraphQL în nod.js

Introducere în realizarea API-urilor și aplicațiilor GraphQL în nod.js

Comunicarea și transferul de date între front-end și backend-ul oricărei aplicații are loc prin intermediul API-urilor (Interfață de programare a aplicațiilor). Există multe tipuri diferite de API-uri utilizate pentru a comunica între aplicațiile front-end și back-end, cum ar fi API RESTful, SOAP API, GraphQL API etc. API-ul GraphQL este o tehnologie relativ nouă și este mult mai rapid decât alte tipuri de API-uri disponibile. Preluarea datelor din baza de date folosind API GraphQL este mult mai rapidă decât API-ul REST. În timp ce folosește API-ul GraphQL, clientul are controlul pentru a prelua doar datele necesare în loc să obțină toate detaliile; de aceea API-ul GraphQL funcționează mai repede decât API-ul REST.

Instalarea pachetelor

Vom construi un nod.js folosind API-ul GraphQL, deci trebuie să instalăm nodul.js și npm pentru aceasta înainte de a începe proiectul.

[e-mail protejat]: ~ $ sudo apt-get update -y
[e-mail protejat]: ~ $ sudo apt-get install nodejs
[e-mail protejat]: ~ $ sudo apt-get install npm

Configurarea proiectului

Vom folosi cadrul „expres” de la nod.js pentru a construi aplicația noastră. Creați un director numit „graphql” și inițiați proiectul.

[e-mail protejat]: ~ $ mkdir graphql
[e-mail protejat]: ~ $ cd graphql /
[e-mail protejat]: ~ $ npm init -y

Configurare MongoDB

În proiectul nostru GraphQL, vom folosi MongoDB ca bază de date. MongoDB este o bază de date fără schemă și stochează date sub formă de perechi de chei. Pentru a instala mongoDB, urmați pașii dați.

Importați cheia publică GPG pentru MongoDB.

[e-mail protejat]: ~ $ wget -qO - https: // www.mongodb.org / static / pgp / server-4.4.asc | sudo apt-key add -


Creați fișierul listă pentru mongodb.

[e-mail protejat]: ~ $ echo "deb [arch = amd64, arm64] https: // repo.mongodb.org / apt / ubuntu bionic / mongodb-org / 4.4 multiverse "| sudo tee / etc / apt / sources.listă.d / mongodb-org-4.4.listă

Actualizați depozitele locale.

[e-mail protejat]: ~ $ sudo apt-get update -y

Instalați pachetul mongodb.

[e-mail protejat]: ~ $ sudo apt-get install -y mongodb-org

Porniți și activați mongod.serviciu.

[e-mail protejat]: ~ $ sudo systemctl start mongod.serviciu
[e-mail protejat]: ~ $ sudo systemctl activate mongod.serviciu

Instalarea modulelor npm

Pentru aplicația noastră GraphQL, trebuie să instalăm câteva pachete npm. Vom instala cors, express, body-parser, mangust etc.

[e-mail protejat]: ~ $ cd graphql /
[e-mail protejat]: ~ $ npm instalează cors express body-parser mongoose --save

Pentru a crea o API GraphQL, trebuie să instalăm un pachet npm suplimentar numit 'apollo-server-express.'Acest pachet npm este folosit pentru a rula serverul graphQL cu toate nodurile.js cadrele HTTP precum 'express.'

[e-mail protejat]: ~ $ npm instalați apollo-server-express --save

Definirea schemei MongoDB

Acum avem mediul nostru configurat pentru aplicația noastră GraphQL în Node.js, și este timpul să definim o schemă pentru aplicația noastră. Creați un fișier 'modele / student.js 'în directorul rădăcină al proiectului.

// definirea schemei elevilor
const mongoose = require ('mongoose');
const studentSchema = mangustă nouă.Schemă(
Nume:
tip: Șir,
obligatoriu: adevărat
,
clasa:
tip: Număr,
obligatoriu: adevărat
,
major:
tip: Șir,
obligatoriu: adevărat

,
marcaje de timp: adevărat
);
const Student = mangusta.model („Student”, studentSchema);
modul.exporturi = Student, studentSchema

În schema definită mai sus, fiecare elev trebuie să aibă un nume, o clasă și o majoritate.

Construirea API-ului GraphQL

După crearea schemei Student, acum vom construi API GraphQL. Creați o schemă.js 'pentru a scrie parametrii GraphQL. Există doi parametri, „tipuri” și „rezolutori”, utilizați în API-ul GraphQL. În „tipuri”, vom specifica schema noastră, interogările (e.g., Efectuarea de cereri GET) și mutații (e.g., Efectuarea de solicitări UPDATE sau DELETE) la schema specificată. Vom scrie diferitele metode definite în „tipuri” pentru a lega interogările și mutațiile cu baza de date în „rezolutori”.'

// importarea schemei și a modulului
const gql = require ('apollo-server-express');
const Student = require ('./ modele / student ').Student;
// Definirea schemei, a interogării și a tipului de mutație
const typeDefs = gql '
tip Student
am facut!,
nume: String!,
clasa: Int!,
major: String!

tastați interogare
getStudents: [Student],
getStudentById (id: ID!): Student

tip Mutație
addStudent (nume: String!, clasa: Int!, major: String! ): Student
updateStudent (nume: String!, clasa: Int!, major: String! ): Student
deleteStudent (id: ID! ): Student
'
// Definirea rezolvatoarelor
const resolvers =
Interogare:
getStudents: (părinte, args) =>
întoarce-te Student.găsi();
,
getStudentById: (părinte, args) =>
întoarce-te Student.findById (arg.id);

,
Mutație:
addStudent: (părinte, args) =>
let student = student nou (
nume: args.Nume,
clasa: args.clasă,
major: args.major
);
student întoarcere.Salvați();
,
updateStudent: (părinte, args) =>
dacă(!argumente.id) returnare;
întoarce-te Student.findOneAndUpdate (
_id: args.id
,

$ set:
nume: args.Nume,
clasa: args.clasă,
major: args.major

,
nou: adevărat, (eroare, student) =>
dacă (greșește)
consolă.jurnal (eroare);
altceva ;
)



modul.exporturi =
typeDefs,
rezolvatori

Crearea serverului API GraphQL

Acum aproape am terminat de creat aplicația GraphQL. Singurul pas rămas este crearea serverului. Creați un fișier numit „aplicație”.js 'pentru a configura parametrii serverului.

// importul pachetelor necesare
const express = require ('express');
const mongoose = require ('mongoose');
const bodyParser = require ('body-parser');
const cors = require ('cors');
const ApolloServer = require ('apollo-server-express');
// importarea schemei
const typeDefs, resolvers = require ('./schemă');
// conectarea la MongoDB
const url = „mongodb: // 127.0.0.1: 27017 / studenți ”;
const connect = mangustă.conectare (url, useNewUrlParser: true);
conectați.atunci ((db) =>
consolă.log („Conexiune reușită”);
, (eroare) =>
consolă.jurnal (eroare);
);
// crearea serverului
server const = nou ApolloServer (
typeDefs: tipDefs,
rezolvatori: rezolvatori
);
const app = express ();
aplicație.utilizați (bodyParser.json ());
aplicație.use ('*', cors ());
Server.applyMiddleware (app);
aplicație.asculta (8000, () =>

consolă.jurnal ('ascultarea a 8000');
)

Testarea API-ului GraphQL

Avem serverul nostru graphQL pornit și rulat pe portul 8000 și este timpul să testăm API-ul GraphQL. Deschideți pagina web GraphQL din browser accesând următoarea adresă URL.

http: // localhost: 8000 / graphql

Și va deschide următoarea pagină web.


Adăugați elevul la baza de date folosind API-ul graphQL.


În mod similar, adăugați mai mulți studenți și, după adăugarea acestuia, obțineți toți studenții folosind API-ul GraphQL.


Rețineți ID-ul oricăruia dintre studenți și obțineți studentul specific folosind id-ul acestuia.

Concluzie

Preluarea datelor din baza de date utilizând API-ul REST standard face căutarea lentă, deoarece uneori obținem mai multe date decât este necesar. Folosind GraphQL, putem prelua exact datele necesare, ceea ce face ca API-ul GraphQL să fie mai rapid. În acest proiect demonstrativ, avem doar o singură schemă, așa că am creat API GraphQL pentru acea schemă. De asemenea, am definit trei până la patru metode pentru schemă. Puteți crea mai multe interogări sau mutații în funcție de aplicația dvs.

Best Gamepad Mapping Apps for Linux
If you like to play games on Linux with a gamepad instead of a typical keyboard and mouse input system, there are some useful apps for you. Many PC ga...
Instrumente utile pentru jucătorii Linux
Dacă vă place să jucați jocuri pe Linux, este posibil să fi folosit aplicații și utilitare precum Wine, Lutris și OBS Studio pentru a îmbunătăți exper...
Jocuri HD remasterizate pentru Linux care nu au avut niciodată lansare Linux mai devreme
Mulți dezvoltatori și editori de jocuri vin cu remasterizarea HD a jocurilor vechi pentru a prelungi durata de viață a francizei, vă rog fanilor să so...