Phenquestions
Komunikacja i przesyłanie danych między frontendem a backendem dowolnej aplikacji odbywa się za pośrednictwem interfejsów API (interfejs programowania aplikacji). Istnieje wiele różnych typów interfejsów API używanych do komunikacji między aplikacjami frontowymi i końcowymi, takimi jak RESTful API, SOAP API, GraphQL API itp. API GraphQL to stosunkowo nowa technologia i jest znacznie szybsza niż inne dostępne typy API. Pobieranie danych z bazy danych za pomocą GraphQL api jest znacznie szybsze niż REST API. Korzystając z GraphQL API, klient ma kontrolę nad pobieraniem tylko wymaganych danych zamiast pobierania wszystkich szczegółów; dlatego GraphQL API działa szybciej niż REST API.
Instalowanie pakietów
Zbudujemy węzeł.aplikacja js korzystająca z GraphQL API, więc musimy zainstalować node.js i npm do tego przed rozpoczęciem projektu.
[ochrona poczty e-mail]:~$ sudo apt-get update -y[email protected]:~$ sudo apt-get install nodejs
[ochrona poczty e-mail]:~$ sudo apt-get install npm
Konfiguracja projektu
Użyjemy frameworka „ekspresowego” z węzła.js do zbudowania naszej aplikacji. Utwórz katalog o nazwie 'graphql' i zainicjuj projekt.
[email chroniony]:~$ mkdir graphql[ochrona poczty e-mail]:~$ cd graphql/
[email chroniony]:~$ npm init -y
Konfiguracja MongoDB
W naszym projekcie GraphQL użyjemy MongoDB jako naszej bazy danych. MongoDB to nieschematyczna baza danych, która przechowuje dane w postaci par kluczy. Aby zainstalować mongoDB, wykonaj podane kroki.
Zaimportuj publiczny klucz GPG dla MongoDB.
[email chroniony]:~$ wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -
Utwórz plik listy dla mongodb.
Zaktualizuj lokalne repozytoria.
[ochrona poczty e-mail]:~$ sudo apt-get update -yZainstaluj pakiet mongodb.
[ochrona poczty e-mail]:~$ sudo apt-get install -y mongodb-orgUruchom i włącz mongod.usługa.
[ochrona poczty e-mail]:~$ sudo systemctl start mongod.usługa[ochrona poczty e-mail]:~$ sudo systemctl enable mongod.usługa
Instalowanie modułów npm
Dla naszej aplikacji GraphQL musimy zainstalować kilka pakietów npm. Zamontujemy cors, express, body-parser, mangusta itp.
[ochrona poczty e-mail]:~$ cd graphql/[email protected]:~$ npm install cors express body-parser mangusta --save
Aby utworzyć GraphQL api, musimy zainstalować dodatkowy pakiet npm o nazwie 'apollo-server-express.' Ten pakiet npm służy do uruchamiania serwera graphQL ze wszystkimi węzłami.Js frameworki HTTP, takie jak „express”.'
[ochrona poczty e-mail]:~$ npm zainstaluj apollo-server-express --saveDefiniowanie schematu MongoDB
Teraz mamy skonfigurowane środowisko dla naszej aplikacji GraphQL w Node.js i czas na zdefiniowanie schematu dla naszej aplikacji. Utwórz plik 'modele/student.js' w katalogu głównym projektu.
// definiowanie schematu uczniaconst mangusta = require('mongusta');
const studentSchema = nowa mangusta.Schemat(
Nazwa:
typ: Ciąg,
wymagane: prawda
,
klasa:
typ: Numer,
wymagane: prawda
,
poważny:
typ: Ciąg,
wymagane: prawda
,
znaczniki czasu: prawda
);
const Student = mangusta.model('Student', StudentSchema);
moduł.eksport = Student, studentSchema
W powyższym schemacie każdy uczeń musi mieć imię, klasę i kierunek.
Budowanie API GraphQL
Po utworzeniu schematu Studenta zbudujemy teraz GraphQL API. Utwórz „schemat.js' do zapisu parametrów GraphQL. W interfejsie API GraphQL używane są dwa parametry, „typy” i „rozwiązania”. W „typach” określimy nasz schemat, zapytania (e.sol., Wykonywanie żądań GET) oraz mutacje (e.sol., Wykonywanie żądań UPDATE lub DELETE) do określonego schematu. Napiszemy różne metody zdefiniowane w 'typach', aby połączyć zapytania i mutacje z bazą danych w 'resolverach.'
// importowanie schematu i modułuconst gql = require('apollo-server-express');
const Student = wymagaj('./modelki/studentka').Student;
// Definiowanie schematu, zapytania i typu mutacji
const typeDefs = gql '
wpisz Uczeń
Zrobiłem!,
nazwa: Ciąg!,
klasa: Int!,
kierunek: String!
wpisz zapytanie
getStudents: [Student],
getStudentById(id: ID!): Student
typ Mutacja
addStudent( nazwa: String:!, klasa: Int!, kierunek: String! ): Student
updateStudent( nazwa: String!, klasa: Int!, kierunek: String! ): Student
usuńUczeń( id: ID! ): Student
'
// Definiowanie resolwerów
stałe rozwiązania =
Zapytanie:
getStudents: (rodzic, args) =>
powrót Student.odnaleźć();
,
getStudentById: (rodzic, argumenty) =>
powrót Student.findById(args.ID);
,
Mutacja:
addStudent: (rodzic, args) =>
niech student = nowy student(
nazwa: argumenty.Nazwa,
klasa: args.klasa,
główny: args.poważny
);
powrót studenta.zapisać();
,
updateStudent: (rodzic, args) =>
gdyby(!argumenty.id) zwrot;
powrót Student.findOneAndUpdate(
_id: argumenty.ID
,
$zestaw:
nazwa: argumenty.Nazwa,
klasa: args.klasa,
główny: args.poważny
,
nowy: prawda , (błąd, uczeń) =>
jeśli (błąd)
konsola.log(błąd);
inny ;
)
moduł.eksport =
typeDefs,
resolwery
Tworzenie GraphQL API Server
Teraz prawie skończyliśmy tworzenie aplikacji GraphQL. Jedyny krok, który pozostał, to utworzenie serwera. Utwórz plik o nazwie „app.js' do konfiguracji parametrów serwera.
// importowanie wymaganych pakietówconst express = require('express');
const mangusta = require('mongusta');
const bodyParser = require('parser-ciała');
const cors = require('cors');
const ApolloServer = require('apollo-server-express');
// importowanie schematu
const typeDefs, resolvery = require('./schemat');
// łączenie z MongoDB
const url = “mongodb://127.0.0.1:27017/studenci”;
const connect = mangusta.connect(url, useNewUrlParser: true );
połączyć.wtedy((db) =>
konsola.log('Połączenie powiodło się');
, (błąd) =>
konsola.log(błąd);
);
// tworzenie serwera
const server = nowy ApolloServer(
typeDefs: typeDefs,
przeliczniki: przeliczniki
);
const aplikacja = express();
aplikacja.użyj (bodyParser.json());
aplikacja.użyj('*', cors());
serwer.zastosujMiddleware( aplikacja );
aplikacja.słuchaj( 8000, () =>
konsola.log('nasłuchiwanie 8000');
)
Testowanie GraphQL API
Mamy serwer graphQL działający na porcie 8000 i czas przetestować API GraphQL. Otwórz stronę GraphQL w przeglądarce, odwiedzając następujący adres URL.
http://localhost:8000/graphql
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 zdobądź wszystkich uczniów za pomocą GraphQL API.
Zanotuj identyfikator dowolnego Studenta i uzyskaj konkretnego ucznia za pomocą jego identyfikatora.
Wniosek
Pobieranie danych z bazy danych za pomocą standardowego REST API spowalnia zapytanie, ponieważ czasami otrzymujemy więcej danych niż jest to wymagane. Korzystając z GraphQL możemy pobrać dokładnie te dane, które przyspieszają GraphQL API. W tym projekcie demonstracyjnym mamy tylko jeden schemat, więc stworzyliśmy GraphQL API dla tego pojedynczego schematu. Ponadto zdefiniowaliśmy trzy do czterech metod dla schematu. Możesz utworzyć więcej niż jedno zapytanie lub mutacje zgodnie z Twoją aplikacją.
