Wprowadzenie do tworzenia interfejsów API i aplikacji GraphQL w węźle.JS

Komunikacja i przesyłanie danych między frontem a backendem dowolnej aplikacji występuje za pośrednictwem interfejsu API (interfejs programowania aplikacji). Istnieje wiele różnych rodzajów interfejsów API używanych do komunikacji między aplikacjami z przodu i zaplecza, takich jak RESTful API, API SOAP, API GraphQL itp. API GraphQL jest stosunkowo nową technologią i jest znacznie szybszy niż inne dostępne rodzaje interfejsów API. Pobieranie danych z bazy danych za pomocą API GraphQL jest znacznie szybsze niż interfejs API REST. Korzystając z API GraphQL, klient ma kontrolę, aby pobrać tylko wymagane dane zamiast uzyskać wszystkie szczegóły; Dlatego API GraphQL działa szybciej niż API REST.

Instalowanie pakietów

Zbudujemy węzeł.Aplikacja JS za pomocą API GraphQL, więc musimy zainstalować węzeł.JS i NPM do tego przed rozpoczęciem projektu.

Ubuntu@ubuntu: ~ $ sudo apt -get aktualizacja -y
Ubuntu@ubuntu: ~ $ sudo apt-get instaluj nodejs
Ubuntu@ubuntu: ~ $ sudo apt-get instaluj npm

Konfigurowanie projektu

Użyjemy ram „Express” z węzła.JS, aby zbudować naszą aplikację. Utwórz katalog o nazwie „GraphQL” i zainicjuj projekt.

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

Konfiguracja MongoDB

W naszym projekcie GraphQL użyjemy MongoDB jako naszej bazy danych. MongoDB to baza danych Schemales i przechowuje dane w postaci par kluczowych. Aby zainstalować MongoDB, wykonaj podane kroki.

Zaimportuj publiczny klucz GPG dla MongoDB.

ubuntu@ubuntu: ~ $ wget -qo - https: // www.MongoDB.ORG/STATIC/PGP/SERVER-4.4.ASC | sudo apt-key add -

Utwórz plik listy dla MongoDB.

Ubuntu@ubuntu: ~ $ echo "deb [arch = amd64, arm64] https: // repo.MongoDB.Org/Apt/Ubuntu Bionic/MongoDB-org/4.4 Multiverse "| sudo tee/etc/apt/Źródła.lista.D/MongoDB-org-4.4.lista

Zaktualizuj lokalne repozytoria.

Ubuntu@ubuntu: ~ $ sudo apt -get aktualizacja -y

Zainstaluj pakiet MongoDB.

Ubuntu@ubuntu: ~ $ sudo apt-get instaluj -y MongoDB-org

Rozpocznij i włącz Mongood.praca.

Ubuntu@ubuntu: ~ $ sudo systemctl start Mongood.praca
Ubuntu@ubuntu: ~ $ sudo systemctl Włącz Mongood.praca

Instalowanie modułów NPM

W naszej aplikacji GraphQL musimy zainstalować niektóre pakiety NPM. Zainstalujemy CORS, Express, Body-Parser, Mongoose itp.

Ubuntu@ubuntu: ~ $ cd Graphql/
Ubuntu@ubuntu: ~ $ npm instalacja CORS Express Body-Parser Mongoose-Save

Aby utworzyć interfejs API GraphQL, musimy zainstalować dodatkowy pakiet NPM o nazwie „Apollo-Server-Express.„Ten pakiet NPM służy do uruchamiania GraphQL Server ze wszystkimi węzłami.JS HTTP Frameworks, takie jak „Express.'

Ubuntu@ubuntu: ~ $ npm instaluj apollo-server-express-save

Definiowanie schematu MongoDB

Teraz mamy skonfigurowane środowisko dla naszej aplikacji GraphQL w węźle.JS i nadszedł czas, aby zdefiniować schemat naszej aplikacji. Utwórz modele/uczeń pliku.JS w katalogu głównym projektu.

// Definiowanie schematu uczniów
const mongoose = wymaga („mongoose”);
const studentschema = nowy Mongoose.Schemat(
nazwa:
Typ: String,
Wymagane: prawda
,
klasa:
Typ: Numer,
Wymagane: prawda
,
główny:
Typ: String,
Wymagane: prawda

,
Timestampy: True
);
const Student = Mongoose.model („student”, studencichema);
moduł.Exports = Student, studentschema

W wyżej zdefiniowanym schemacie każdy uczeń musi mieć imię, klasę i główne.

Budowanie API GraphQL

Po utworzeniu schematu studenckiego zbudujemy teraz API GraphQL. Utwórz schemat.JS ', aby zapisać parametry GraphQL. Istnieją dwa parametry, „typy” i „rozdzielcze”, używane w API GraphQL. W „Typach” określamy nasz schemat, zapytania (e.G., Składanie żądań) i mutacje (e.G., Dokonywanie aktualizacji lub usuwania żądań) do określonego schematu. Napiszemy różne metody zdefiniowane w „Typach”, aby połączyć zapytania i mutacje z bazą danych w „Resicvers.'

// Importowanie schematu i modułu
const gql = wymaga („apollo-server-express”);
const Student = wymaga ('./modele/uczeń ').Student;
// definiowanie schematu, zapytania i typu mutacji
const typedefs = gql '
Wpisz Student
Zrobiłem!,
Nazwa: ciąg!,
klasa: int!,
Major: String!

Wpisz zapytanie
GetStudents: [Student],
getStudentByid (id: id!): Student

Mutacja typu
addStudent (nazwa: ciąg!, klasa: int!, Major: String! ): Student
UpdateStudent (nazwa: ciąg!, klasa: int!, Major: String! ): Student
DeleTestudent (id: id! ): Student
'
// definiowanie rozdzielczości
const Resistvers =
Zapytanie:
getStudents: (rodzic, args) =>
powrót studenta.znajdować();
,
getStudentById: (rodzic, args) =>
powrót studenta.FindById (args.ID);

,
Mutacja:
addStudent: (rodzic, args) =>
Pozwól studentowi = nowy student (
Nazwa: Args.nazwa,
Klasa: Args.klasa,
Major: Args.główny
);
powrót studenta.ratować();
,
UpdateStudent: (macierz, args) =>
Jeśli(!Args.id) return;
powrót studenta.FindoneAndupDate (
_id: Args.ID
,

$ set:
Nazwa: Args.nazwa,
Klasa: Args.klasa,
Major: Args.główny

,
new: true, (err, student) =>
if (err)
konsola.log (err);
w przeciwnym razie ;
)



moduł.Exports =
Typedefs,
Resicvers

Tworzenie serwera API GraphQL

Teraz prawie skończyliśmy tworzenie aplikacji GraphQL. Jedynym krokiem jest utworzenie serwera. Utwórz plik o nazwie „aplikacja.JS 'konfigurowanie parametrów serwera.

// importowanie wymaganych pakietów
const express = wymaga („express”);
const mongoose = wymaga („mongoose”);
const bodyparser = wymaga („body-parser”);
const cors = wymaga („cors”);
const apolloserver = wymaga („apollo-server-express”);
// Importowanie schematu
const typeDefs, resolvers = wymaga ('./schemat');
// Łączenie z MongoDB
const url = „MongoDB: // 127.0.0.1: 27017/studenci ”;
const Connect = Mongoose.connect (url, usenewurlParser: true);
łączyć.następnie ((db) =>
konsola.log („połączenie udane”);
, (err) =>
konsola.log (err);
);
// tworzenie serwera
const Server = nowy ApollOserver (
Typedefs: Typedefs,
Resicvers: Resicvers
);
const app = express ();
App.Używanie (Bodyparser.JSON ());
App.Użyj ('*', cors ());
serwer.applateMiddleware (app);
App.Słuchaj (8000, () =>

konsola.Log („Słuchanie 8000”);
)

Testowanie API GraphQL

Mamy nasz serwer GraphQL w Port 8000 i nadszedł czas, aby przetestować API GraphQL. Otwórz stronę GraphQL w przeglądarce, odwiedzając następujący adres URL.

http: // localhost: 8000/graftql

I otworzy następującą stronę internetową.

Dodaj ucznia do bazy danych za pomocą API GraphQL.

Podobnie dodaj więcej uczniów, a po dodaniu ucznia weź wszystkich uczniów za pomocą API GraphQL.

Zwróć uwagę na identyfikator któregokolwiek ze studentów i uzyskaj konkretnego ucznia za pomocą jego identyfikatora.

Wniosek

Pobieranie danych z bazy danych za pomocą standardowego interfejsu API REST sprawia, że ​​zapytanie jest powolne, ponieważ czasami otrzymujemy więcej danych niż wymagane. Korzystając z GraphQL, możemy pobrać dokładnie wymagane dane, które przyspieszają API GraphQL. W tym projekcie demonstracyjnym mamy tylko jeden schemat, więc stworzyliśmy API GraphQL dla tego pojedynczego schematu. Ponadto zdefiniowaliśmy od trzech do czterech metod schematu. Możesz utworzyć więcej niż jedno zapytanie lub mutacje zgodnie z aplikacją.