Phenquestions
A comunicação e a transferência de dados entre o front-end e o back-end de qualquer aplicativo ocorre por meio de APIs (Interface de Programação de Aplicativos). Existem muitos tipos diferentes de APIs usados para se comunicar entre os aplicativos de front e back-end, como API RESTful, API SOAP, API GraphQL, etc. A API GraphQL é uma tecnologia relativamente nova e muito mais rápida do que outros tipos de APIs disponíveis. Buscar dados do banco de dados usando a API GraphQL é muito mais rápido do que a API REST. Ao usar a API GraphQL, o cliente tem controle para buscar apenas os dados necessários em vez de obter todos os detalhes; é por isso que a API GraphQL funciona mais rápido do que a API REST.
Instalando Pacotes
Vamos construir um nó.aplicação js usando GraphQL API, então precisamos instalar o nó.js e npm para isso antes de iniciar o projeto.
[email protegido]: ~ $ sudo apt-get update -y[email protegido]: ~ $ sudo apt-get install nodejs
[email protegido]: ~ $ sudo apt-get install npm
Configurando Projeto
Usaremos a estrutura 'expressa' do nó.js para construir nosso aplicativo. Crie um diretório chamado 'graphql' e inicie o projeto.
[email protegido]: ~ $ mkdir graphql[email protegido]: ~ $ cd graphql /
[email protegido]: ~ $ npm init -y
Configuração do MongoDB
Em nosso projeto GraphQL, usaremos MongoDB como nosso banco de dados. MongoDB é um banco de dados sem esquema e armazena dados na forma de pares de chaves. Para instalar o mongoDB, siga as etapas fornecidas.
Importe a chave GPG pública para MongoDB.
[email protegido]: ~ $ wget -qO - https: // www.Mongodb.org / static / pgp / server-4.4.asc | sudo apt-key add -
Crie o arquivo de lista para mongodb.
Atualizar repositórios locais.
[email protegido]: ~ $ sudo apt-get update -yInstale o pacote mongodb.
[email protegido]: ~ $ sudo apt-get install -y mongodb-orgIniciar e habilitar mongod.serviço.
[email protegido]: ~ $ sudo systemctl start mongod.serviço[email protegido]: ~ $ sudo systemctl enable mongod.serviço
Instalando Módulos NPM
Para nosso aplicativo GraphQL, precisamos instalar alguns pacotes npm. Vamos instalar cors, express, body-parser, mongoose, etc.
[email protegido]: ~ $ cd graphql /[email protected]: ~ $ npm install cors express body-parser mongoose --save
Para criar uma API GraphQL, precisamos instalar um pacote npm extra chamado 'apollo-server-express.'Este pacote npm é usado para executar o servidor GraphQL com todos os Nó.frameworks HTTP js como 'express.'
[email protegido]: ~ $ npm install apollo-server-express --saveDefinindo o esquema MongoDB
Agora temos nosso ambiente configurado para nosso aplicativo GraphQL no Node.js, e é hora de definir um esquema para nosso aplicativo. Criar um arquivo 'modelos / alunos.js 'no diretório raiz do projeto.
// definindo o esquema do alunoconst mongoose = require ('mongoose');
const studentSchema = novo mangusto.Esquema(
nome:
tipo: String,
requerido: verdadeiro
,
aula:
tipo: número,
requerido: verdadeiro
,
maior:
tipo: String,
requerido: verdadeiro
,
timestamps: true
);
const Student = mangusto.modelo ('Student', studentSchema);
módulo.exportações = Student, studentSchema
No esquema definido acima, cada aluno deve ter um nome, classe e especialização.
Construindo API GraphQL
Depois de criar o esquema do aluno, iremos construir a API GraphQL. Crie um 'esquema.js 'para escrever parâmetros GraphQL. Existem dois parâmetros, 'tipos' e 'resolvedores', usados na API GraphQL. Em 'tipos', iremos especificar nosso esquema, as consultas (e.g., Fazer solicitações GET) e mutações (e.g., Fazendo solicitações de UPDATE ou DELETE) para o esquema especificado. Vamos escrever os diferentes métodos definidos em 'tipos' para ligar as consultas e mutações com o banco de dados em 'resolvedores.'
// importando esquema e móduloconst gql = require ('apollo-server-express');
const Student = require ('./ models / student ').Aluna;
// Definindo Esquema, Consulta e Tipo de Mutação
const typeDefs = gql '
type Student
Eu fiz!,
nome: String!,
classe: Int!,
principal: String!
tipo Query
getStudents: [Student],
getStudentById (id: ID!): Aluna
type Mutation
addStudent (nome: String!, classe: Int!, major: String! ): Aluna
updateStudent (nome: String!, classe: Int!, major: String! ): Aluna
deleteStudent (id: ID! ): Aluna
'
// Definindo Resolvers
const resolvers =
Inquerir:
getStudents: (parent, args) =>
voltar estudante.achar();
,
getStudentById: (pai, args) =>
voltar estudante.findById (args.eu ia);
,
Mutação:
addStudent: (pai, args) =>
let student = new Student (
nome: args.nome,
classe: args.aula,
major: args.maior
);
estudante de retorno.Salve ();
,
updateStudent: (pai, args) =>
E se(!args.id) return;
voltar estudante.findOneAndUpdate (
_id: args.eu ia
,
$ set:
nome: args.nome,
classe: args.aula,
major: args.maior
,
novo: verdadeiro, (err, aluno) =>
if (err)
console.log (errar);
senão ;
)
módulo.exportações =
typeDefs,
resolvedores
Criação do servidor GraphQL API
Agora estamos quase terminando de criar o aplicativo GraphQL. A única etapa que resta é criar o servidor. Crie um arquivo chamado 'app.js 'para configurar os parâmetros do servidor.
// importando pacotes necessáriosconst express = require ('express');
const mangusto = requer ('mangusto');
const bodyParser = require ('body-parser');
const cors = require ('cors');
const ApolloServer = require ('apollo-server-express');
// importando esquema
const typeDefs, resolvers = require ('./esquema');
// conectando ao MongoDB
const url = “mongodb: // 127.0.0.1: 27017 / alunos ”;
const connect = mongoose.conectar (url, useNewUrlParser: true);
conectar.então ((db) =>
console.log ('Conexão bem-sucedida');
, (errar) =>
console.log (errar);
);
// criando servidor
const server = new ApolloServer (
typeDefs: typeDefs,
resolvers: resolvers
);
const app = express ();
aplicativo.use (bodyParser.json ());
aplicativo.use ('*', cors ());
servidor.applyMiddleware (app);
aplicativo.ouvir (8000, () =>
console.log ('ouvindo 8000');
)
Testando a API GraphQL
Temos nosso servidor GraphQL instalado e funcionando na porta 8000 e é hora de testar a API GraphQL. Abra a página da web GraphQL no navegador visitando o seguinte url.
http: // localhost: 8000 / graphql
E vai abrir a seguinte página da web.
Adicione o aluno ao banco de dados usando a API GraphQL.
Da mesma forma, adicione mais alunos e, depois de adicionar o aluno, obtenha todos os alunos usando a API GraphQL.
Observe o ID de qualquer um dos Alunos e obtenha o aluno específico usando seu ID.
Conclusão
Buscar dados do banco de dados usando a API REST padrão torna a consulta lenta, pois às vezes obtemos mais dados do que o necessário. Usando GraphQL, podemos buscar exatamente os dados necessários que tornam a API GraphQL mais rápida. Neste projeto de demonstração, temos apenas um único esquema, portanto, criamos a API GraphQL para esse esquema único. Além disso, definimos três a quatro métodos para o esquema. Você pode criar mais de uma consulta ou mutações de acordo com sua aplicação.
