Como criar uma API REST com Spring Boot

A sigla REST significa REpresentational State Transfer, enquanto API significa Application Programming Interface. Juntos, eles se referem a uma API REST. Uma API REST é um serviço que transfere solicitações e respostas entre dois sistemas de software, em uma arquitetura REST.

A arquitetura REST cria serviços da Web acessíveis por meio de URLs usando um dos quatro verbos de solicitação: POST, GET, PUT e DELETE. Então, você poderia dizer que uma API REST é um software que permite criar, ler, atualizar e excluir recursos por meio de URLs.

Você pode aprender como criar uma API REST usando Spring Boot.

Inicializando o aplicativo Spring Boot

A primeira coisa que você deve fazer é familiarize-se com os fundamentos do Spring e configurar um aplicativo Spring Boot. Você precisará alterar as dependências, no entanto. Além da dependência web, você precisará obter a dependência Spring Data Java Persistent API (JPA) e o driver do banco de dados que pretende usar (este aplicativo usará MySQL).

Para esta API REST, você precisará de um controlador, um modelo e um repositório. Assim, a API REST terá a seguinte estrutura de arquivos:

Criando o modelo

A primeira classe que você precisará criar é o modelo de cliente, que armazena a lógica de dados.

pacote com.onlineshopaholics.api.model;
importar jakarta.persistence. Coluna;
importar jakarta.persistence. Entidade;
importar jakarta.persistence. valor gerado;
importar jakarta.persistence. Tipo de Geração;
importar jakarta.persistence. Eu ia;
importar jakarta.persistence. Mesa;
@Mesa(nome="cliente")
@Entidade
públicoaulaCliente{
@Eu ia
@GeneratedValue(estratégia = GenerationType. AUTO)
privado ID inteiro;
@Coluna(nome="nome do cliente")
privado Nome da cadeia;
privado Cadeia de e-mail;
público inteiro getId(){
retornar eu ia;
 }
públicovaziosetId(ID inteiro){
esse.id = id;
 }
público Corda obterNome(){
retornar nome;
 }
públicovazionome do conjunto(Nome da sequência){
esse.nome = nome;
 }
público Corda getEmail(){
retornar e-mail;
 }
públicovaziodefinir e-mail(Sequência de e-mail){
esse.email = e-mail;
 }
}

Na classe de cliente acima, você verá que cada cliente terá um ID, nome e e-mail. Você também notará várias anotações que servem a propósitos diferentes.

• @Entity: Declara a classe cliente como uma entidade JPA. Isso significa que o JPA usará os campos da classe para criar colunas em um banco de dados relacional.
• @Table: Designa o nome da tabela que será mapeada para a classe de modelo do cliente.
• @Id: Designa uma propriedade que identificará exclusivamente a entidade no banco de dados.
• @GeneratedValue e @GenerationType: trabalham juntos para especificar uma estratégia de geração automática para o campo ao qual está associado. Assim, o campo id irá gerar automaticamente um valor único cada vez que você criar um novo cliente.
• @Column: Designa uma propriedade que mapeia para uma coluna no banco de dados. Portanto, a propriedade name será mapeada para uma coluna customername no banco de dados.

Criando o repositório

Este repositório permitirá que você interaja com os dados do cliente no banco de dados.

pacote com.onlineshopaholics.api.repository;
importar org.springframework.data.repository. CrudRepository;
importar com.onlineshopaholics.api.model. Cliente;
públicointerfaceCustomerRepositoryestendeCrudRepositoryName<Cliente, inteiro>{}

O repositório do cliente se estende Spring's CrudRepository interface, passando-a para a classe de modelo Customer juntamente com o tipo de identificador exclusivo para a entidade, Integer.

A interface CrudRepository fornece acesso a mais de 10 operações, incluindo os métodos CRUD genéricos necessários para a API REST. Portanto, como o CrudRepository já define os métodos necessários, não há necessidade de declará-los explicitamente na interface CustomerRepository.

Criando o Controlador

O controlador permite que você atualize os dados em seu banco de dados usando o modelo e o repositório.

pacote com.onlineshopaholics.api.controller;
importar java.util. Opcional;
importar org.springframework.beans.factory.annotation. Autoligado;
importar org.springframework.web.bind.annotation. DeleteMapping;
importar org.springframework.web.bind.annotation. GetMapping;
importar org.springframework.web.bind.annotation. Variável de Caminho;
importar org.springframework.web.bind.annotation. PostMapping;
importar org.springframework.web.bind.annotation. PutMapping;
importar org.springframework.web.bind.annotation. Corpo da Solicitação;
importar org.springframework.web.bind.annotation. Mapeamento de Pedidos;
importar org.springframework.web.bind.annotation. RequestParam;
importar org.springframework.web.bind.annotation. Corpo da Resposta;
importar org.springframework.web.bind.annotation. RestController;
importar com.onlineshopaholics.api.model. Cliente;
importar com.onlineshopaholics.api.repository. CustomerRepository;
@RestController
@RequestMapping("/clientes")
públicoaulaClienteControlador{
@Autowired
privado CustomerRepository customerRepository;
//cria novo cliente
@PostMapping("/adicionar")
público Cliente adicionarNovoCliente(@RequestBody Cliente novoCliente){
 Usuário cliente = novo Cliente();
 user.setName (newCustomer.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (usuário);
retornar do utilizador; 
 }
// ver todos os clientes
@GetMapping("ver tudo")
público@ResponseBodyIterávelgetAllCustomers(){
retornar customerRepository.findAll();
 }
// visualizar cliente específico
@GetMapping("visualizar/{id}")
público Opcionalobtercliente(@PathVariable Id inteiro){
retornar customerRepository.findById (id);
 }
// atualiza um cliente existente
@PutMapping("/edit/{id}")
público Corda atualizar(@RequestBody Customer updateCustomer, @PathVariable Integer id){
retornar customerRepository.findById (id)
 .map (cliente -> {
 cliente.setName (updateCustomer.getName());
 cliente.setEmail (updateCustomer.getEmail());
 customerRepository.save (cliente);
retornar"Os detalhes do cliente foram atualizados com sucesso!";
 }).orElseGet(() -> {
retornar"Este cliente não existe";
 });
 }
// exclui cliente
@DeleteMapping("excluir/{id}")
público Corda excluir(@PathVariable("eu ia")ID inteiro) {
 customerRepository.deleteById (id); 
retornar"Cliente excluído com sucesso!";
 }
}

O controlador acima equipa a API REST com operações CRUD, usando cinco dos CrudRepository métodos de interface (cada um atribuído a um método específico). O controlador também usa várias anotações importantes do Spring que permitem que ele execute suas funções.

• @RestController: esta anotação serve a dois propósitos. Ele marca uma classe para descoberta por varredura de componentes. Ele também diz ao Spring para escrever o valor de retorno para todos os métodos, nesta classe, no corpo da resposta.
• @RequestMapping: define o padrão de solicitação de linha de base que o controlador manipulará. Assim, este controller irá tratar todas as requisições para “/customers”.
• @ResponseBody: permite que um método retorne uma entidade inteira.
• @RequestBody: Permite converter o corpo da solicitação em um objeto.
• @RequestParam: permite isolar uma propriedade de um objeto.
• @PathVariable: permite mapear um valor de solicitação para um espaço reservado. Ele mapeia o ID fornecido ao método delete com um valor existente no banco de dados.
• @PostMapping: Permite criar recursos.
• @GetMapping: permite que você leia dados de recursos.
• @PutMapping: Permite atualizar recursos.
• @DeleteMapping: permite excluir recursos.

Conectando o banco de dados ao seu aplicativo

Para conectar um banco de dados a qualquer aplicativo Spring, você precisará usar o application.properties arquivo na pasta de recursos. Este arquivo está inicialmente vazio, então você pode preenchê-lo com as propriedades apropriadas para o banco de dados que você pretende usar. Esta aplicação utilizará um banco de dados MySQL, portanto, o arquivo application.properties conterá os seguintes dados:

spring.jpa.hibernate.ddl-auto=atualizar
spring.jpa.open-in-view=false
spring.datasource.url=jdbc: mysql://${MYSQL_HOST: localhost}:3306/onlineshopaholics
spring.datasource.username=raiz
spring.datasource.password=securepw
spring.datasource.driver-class-name=com.mysql.cj.jdbc. Motorista

Os dados acima mostram que este aplicativo se conectará a um banco de dados MySQL chamado onlineshopaholics, com um nome de usuário “root” e “securepw” como senha. Sua próxima etapa é criar o banco de dados e a tabela de clientes no MySQL.

Criando solicitações

Existem muitas ferramentas que você pode usar para testar sua API REST. Postman é uma popular ferramenta de teste de API REST, e você pode usá-lo para testar a API simples que você criou. Depois de criar a tabela MySQL e executar o aplicativo Spring, você pode iniciar o Postman e experimentar os quatro verbos de solicitação.

Solicitação POST

Essa solicitação permitirá que você crie novos clientes usando a API REST. Para concluir esta solicitação, você precisará ir para a seção de cabeçalhos da sua solicitação de postagem e criar um novo cabeçalho (Tipo de conteúdo). Você deve definir o valor desse cabeçalho como application/json, pois estará criando novos clientes usando JSON.

No corpo da requisição, você precisará alterar o tipo para raw e inserir seu JSON. Em seguida, você precisará inserir o URL da postagem:

O envio da solicitação retornará a seguinte resposta:

Você pode ver que a solicitação foi bem-sucedida e que o novo cliente também possui um ID.

Solicitação GET

Agora que você tem um cliente, pode visualizá-lo com a solicitação get que retorna todos os clientes:

Ou cada cliente por id:

Solicitação PUT

Você pode atualizar Janet com um novo sobrenome e e-mail.

Apagar solicitação

Você também pode excluir Janet do banco de dados.

Teste sua API REST Spring usando JUnit

Com o Spring Boot, você pode testar qualquer aplicativo (incluindo APIs REST) ​​usando o arquivo de teste do Spring. O teste de software é importante para o Spring Boot. Cada aplicativo Spring inicializado usa JUnit para teste e permite que você envie solicitações para suas APIs REST.