Tutorial de GraphQL: Introdução ao Spring para GraphQL

No cenário em constante evolução do desenvolvimento web, GraphQL emergiu como uma alternativa poderosa às APIs REST tradicionais, oferecendo uma abordagem mais flexível e eficiente para a recuperação de dados. Se você está ansioso para explorar essa tecnologia criativa e integrá-la perfeitamente ao Spring, você veio ao lugar certo.

Bem-vindo ao nosso tutorial abrangente sobre GraphQL, onde embarcaremos em uma jornada para desmistificar os conceitos de GraphQL e guiá-lo pelo processo de início com o Spring para GraphQL.

O que é Spring GraphQL e suas principais características

Spring GraphQL é uma extensão do popular Spring Framework que capacita os desenvolvedores a construir APIs baseadas em GraphQL de forma perfeita. Ele combina o poder da facilidade de desenvolvimento do Spring Boot com a flexibilidade e eficiência do GraphQL, tornando-se uma escolha ideal para desenvolver APIs modernas.

As principais características do Spring GraphQL incluem:

• Desenvolvimento orientado a esquema: Com o Spring GraphQL, os desenvolvedores podem começar definindo o esquema da API usando a Linguagem de Definição de Esquema GraphQL (SDL). Essa abordagem orientada a esquema garante que o design da API seja claro e bem definido desde o início, promovendo um processo de desenvolvimento mais organizado e estruturado.
• Recuperação de dados com resolvers: O Spring GraphQL simplifica a recuperação de dados fornecendo resolvers. Os resolvers são responsáveis por buscar os dados necessários para cada campo em uma consulta GraphQL. Os desenvolvedores podem implementar resolvers para recuperar dados de várias fontes, como bancos de dados, APIs externas ou qualquer outro repositório de dados, permitindo maior flexibilidade e reutilização.
• Integração com o ecossistema Spring: Como parte da família Spring, o Spring GraphQL se integra perfeitamente a outros componentes do Spring, como Spring Data JPA para interações com o banco de dados e Spring Security para autenticação e autorização. Essa integração estreita garante uma experiência de desenvolvimento suave e coesa.
• Atualizações em tempo real com assinaturas: O Spring GraphQL suporta atualizações de dados em tempo real através de assinaturas GraphQL. As assinaturas permitem que os clientes se inscrevam em eventos específicos e recebam atualizações de dados em tempo real à medida que esses eventos ocorrem. Esse recurso é particularmente útil para construir aplicações em tempo real, como sistemas de chat ou feeds de dados ao vivo.

Como configurar seu ambiente?

Antes de começar sua jornada com GraphQL e Spring, verifique se a sua configuração está pronta. Veja como você pode preparar seu ambiente para construir um projeto Spring Boot com GraphQL:

Pré-requisitos:

• JDK 17: Instale o JDK 17 em seu sistema. Você pode baixá-lo da Oracle ou OpenJDK.
• Compreensão básica do Spring Boot: Conheça o básico do Spring Boot. Isso ajudará ao combinar com GraphQL.

Criando um projeto Spring Boot:

Spring Initializr: Vá para start.spring.io, seu ponto de partida para projetos Spring Boot.

Primeiro, forneça os detalhes da configuração do projeto, como nomear seu projeto, especificar um nome de grupo no formato de domínio reverso (por exemplo, com.exemplo) e designar um nome de pacote para o código Java do seu aplicativo. Você também pode incluir metadados, como uma descrição e versão, se necessário.

Segundo, adicione as dependências necessárias. Na seção Dependências, selecione "Spring Web" para habilitar suporte para criar aplicações web com Spring. Da mesma forma, marque "Spring GraphQL" para habilitar recursos relacionados ao GraphQL. Depois de configurar seu projeto e escolher as dependências, clique no botão "Gerar" para prosseguir.

Importando seu projeto para seu IDE:

Primeiro, extraia o conteúdo do arquivo ZIP para acessar seu conteúdo. Segundo, abra seu Ambiente de Desenvolvimento Integrado (IDE), como IntelliJ IDEA. Em seguida, importe o projeto que você extraiu anteriormente.

É isso! Seu ambiente está configurado, você criou um projeto Spring Boot e tem o GraphQL a bordo. Seu IDE é seu espaço de brincadeiras para aventuras de codificação.

Como configurar a camada de dados?

Nesta seção, criaremos um exemplo simples, como uma cafeteria, para demonstrar como o GraphQL pode aprimorar a recuperação e a gestão de dados.

Introdução ao exemplo:

Imagine que você está desenvolvendo uma API para uma cafeteria para gerenciar seu cardápio e pedidos. Para ilustrar isso, definiremos modelos de dados básicos para itens de café e clientes, e configuraremos um serviço para lidar com esses dados.

Definindo modelos de dados básicos:

Vamos começar criando dois modelos de dados simples: Coffee e Size. Esses modelos serão implementados como classes Java, cada uma com atributos representando informações relevantes.
Você precisará criar duas classes em dois arquivos diferentes e, em cada classe, você deve adicionar construtores, getters e setters para os atributos.

public class Coffee {
    private int id;
    private String name;
    private Size size;

    // Construtores, getters, setters
}

public class Size {
    private int id;
    private String name;

    // Construtores, getters, setters
}

Após criar e adicionar essas classes, você precisa garantir que elas estejam localizadas no pacote apropriado dentro do seu projeto Spring Boot. A estrutura do pacote deve refletir o nome do pacote que você forneceu ao gerar o projeto no Spring Initializr.

Aqui está como você pode adicionar setters, getters e construtores para a classe Coffee.java.

Configurando a gestão de dados:

Criaremos uma simples classe CoffeeService para servir como um repositório de dados em memória e gerenciar dados de café. Para demonstrar, popularemos esse repositório com alguns itens de café de exemplo.

import java.util.ArrayList;
import java.util.List;

@Component
public class CoffeeService {

	private final List<Coffee> coffees = new ArrayList<>();

	@PostConstruct
	public void init() {
    	Size smallSize = new Size(1, "Pequeno");
    	Size mediumSize = new Size(2, "Médio");
    	Size largeSize = new Size(3, "Grande");

    	coffees.add(new Coffee(1, "Espresso", smallSize));
    	coffees.add(new Coffee(2, "Latte", mediumSize));
    	coffees.add(new Coffee(3, "Cappuccino", largeSize));
	}

	public List<Coffee> getAllCoffees() {
    	return coffees;
	}

	public Coffee getCoffeeById(int id) {
    	return coffees.stream()
        	.filter(coffee -> coffee.getId() == id)
        	.findFirst()
        	.orElse(null);
	}
}

A classe CoffeeService gerencia dados relacionados a café, atuando como um sistema de armazenamento e recuperação. Ela inicializa dados de café de exemplo ao ser criada, oferecendo métodos para recuperar todos os cafés ou um específico pelo ID. Essa abstração simplifica o acesso e a manipulação de dados, preparando os dados para interação dentro do esquema GraphQL.

Como criar o esquema GraphQL?

Crie um arquivo chamado schema.graphqls na pasta src/main/resources e defina o esquema GraphQL usando a Linguagem de Definição de Esquema (SDL).

type Query {
	getAllCoffees: [Coffee!]!
	getCoffeeById(id: Int!): Coffee
}

type Coffee {
	id: Int!
	name: String!
	size: Size!
}

type Size {
	id: Int!
	name: String!
}

Aqui está como você pode fazê-lo.

Criar Fetchers de Dados:

O código define uma classe chamada CoffeeDataFetcher responsável por recuperar dados para consultas GraphQL. Ela está anotada com @Component para ser gerenciada pelo Spring. O fetcher getAllCoffees() recupera uma lista de itens de café usando o método coffeeService.getAllCoffees(). O fetcher getCoffeeById() extrai um ID dos argumentos de consulta e o utiliza para buscar um item de café específico no CoffeeService.

import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CoffeeDataFetcher {

	@Autowired
	private CoffeeService coffeeService;

	public DataFetcher<List<Coffee>> getAllCoffees() {
    	return environment -> coffeeService.getAllCoffees();
	}

	public DataFetcher<Coffee> getCoffeeById() {
    	return environment -> {
        	int id = environment.getArgument("id");
        	return coffeeService.getCoffeeById(id);
    	};
	}
}

Aqui está como você pode fazê-lo.

Criar Controlador GraphQL:

No Spring, os controladores GraphQL fornecem endpoints para interagir com seu esquema GraphQL. Esses controladores lidam com consultas de entrada e retornam os dados correspondentes.

import graphql.GraphQL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GraphQLController {

	@Autowired
	private GraphQL graphQL;

	@PostMapping("/graphql")
	public Map<String, Object> executeQuery(@RequestBody String query) {
    	ExecutionResult executionResult = graphQL.execute(query);
    	return executionResult.toSpecification();
	}
}

Este controlador lidará com consultas GraphQL de entrada e interagirá com seu esquema GraphQL. Ele fornece um endpoint RESTful em /graphql que aceita requisições POST com a consulta GraphQL no corpo da requisição. O controlador então usa a instância GraphQL para executar a consulta e retorna o resultado da execução como um mapa.

Spring GraphQL é um framework poderoso que capacita os desenvolvedores a construir APIs eficientes usando a linguagem de consulta GraphQL. Ao contrário das APIs REST tradicionais, onde vários endpoints ditam a recuperação de dados, o GraphQL empodera os clientes a especificar exatamente quais dados precisam em uma única requisição, reduzindo a recuperação excessiva ou insuficiente de dados. O Spring GraphQL aproveita as forças do ecossistema Spring, combinando a simplicidade do Spring Boot com a flexibilidade do GraphQL.

O processo envolve definir seus modelos de dados, criar uma camada de serviço para gerenciar os dados e estabelecer um esquema com tipos e consultas. A abordagem orientada a esquema do Spring GraphQL garante um design claro e um processo de desenvolvimento estruturado. A recuperação de dados é simplificada por meio de resolvers, e atualizações em tempo real são facilitadas por assinaturas.

Ferramentas de Teste GraphQL:

O GraphQL se tornou uma maneira popular de construir APIs, e testá-las é crucial para garantir que funcionem corretamente. As ferramentas de teste ajudam os desenvolvedores a verificar se suas APIs GraphQL estão funcionando conforme o esperado.

Uma dessas ferramentas é Apidog, que oferece uma gama de recursos para facilitar os testes de API. Vamos ver o que o Apidog pode fazer e mencionar algumas outras ferramentas de teste úteis para GraphQL.

Apidog:

Apidog é um kit de ferramentas versátil que cobre todo o processo de criação de APIs. É como um canivete suíço para APIs, ajudando com design, teste e muito mais. Aqui está o que o Apidog oferece:

O que o Apidog oferece para teste GraphQL:

O Apidog também funciona bem para testar APIs GraphQL. Ele possui recursos como:

• Suporte para GraphQL: O Apidog pode testar e depurar APIs GraphQL.
• Automação: Ele pode automatizar tarefas e manter suas definições de API em sincronia.
• Integração com Banco de Dados: O Apidog pode se conectar a bancos de dados para melhores testes.

Conclusão

À medida que as APIs continuam evoluindo, a combinação de GraphQL, Spring GraphQL e ferramentas como Apidog reestrutura como as APIs são feitas. Essa combinação proporciona aos desenvolvedores mais controle e eficiência, resultando em APIs robustas, adaptáveis e de alto desempenho.