Como criar uma API REST com Spring Boot

2023/01/16

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 é se familiarizar com o básico do Spring e configurar um aplicativo Spring Boot. Você precisará alterar as dependências, no entanto. Além da dependência da Web, você precisará obter a dependência do Spring Data Java Persistent API (JPA) e o driver do banco de dados que pretende usar (este aplicativo usará o 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.

package com.onlineshopaholics.api.model;

import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; import jakarta.persistence.Table;


@Table(name="customer")
@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name="customername")
    private String name;
    private String email;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }

public void setEmail(String email) { this.email = email; } }

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 atendem 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.

package com.onlineshopaholics.api.repository;

import org.springframework.data.repository.CrudRepository; import com.onlineshopaholics.api.model.Customer;


public interface CustomerRepository extends CrudRepository<Customer, Integer>{}

O repositório do cliente estende a interface CrudRepositoy<T,ID> do Spring , passando a classe de modelo Customer junto com o tipo do identificador exclusivo da 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.

package com.onlineshopaholics.api.controller;

import java.util.Optional;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import com.onlineshopaholics.api.model.Customer;
import com.onlineshopaholics.api.repository.CustomerRepository;
@RestController
@RequestMapping("/customers")
public class CustomerController {
    @Autowired
    private CustomerRepository customerRepository;
    // create new customer
    @PostMapping("/add")
    public Customer addNewCustomer(@RequestBody Customer newCustomer){
        Customer user = new Customer();
        user.setName(newCustomer.getName());
        user.setEmail(newCustomer.getEmail());
        customerRepository.save(user);
        return user; 
    }
    // view all customers
    @GetMapping("view/all")
    public @ResponseBody Iterable<Customer> getAllCustomers(){
        return customerRepository.findAll();
    }
    // view specific customer
    @GetMapping("view/{id}")
    public Optional<Customer> getCustomer(@PathVariable Integer id) {
        return customerRepository.findById(id);
    }
    // update an existing customer
    @PutMapping("/edit/{id}")
    public String update(@RequestBody Customer updateCustomer, @PathVariable Integer id) {
        return customerRepository.findById(id)
                 .map(customer -> {
                       customer.setName(updateCustomer.getName());
                       customer.setEmail(updateCustomer.getEmail());
                       customerRepository.save(customer);
                       return "Customer details have been successfully updated!";
                 }).orElseGet(() -> {
                       return "This customer doesn't exist";
                 });
    }
    // delete customer
    @DeleteMapping("delete/{id}")
    public String delete(@PathVariable("id")Integer id) {
        customerRepository.deleteById(id); 
        return "Customer has been successfully deleted!";
    }
}

O controlador acima equipa a API REST com operações CRUD, usando cinco dos métodos de interface CrudRepository<T,ID> (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 arquivo application.properties 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=update spring.jpa.open-in-view=false spring.datasource.url=jdbc:mysql://${MYSQL_HOST:localhost}:3306/onlineshopaholics spring.datasource.username=root spring.datasource.password=securepw spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

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 ferramenta de teste de API REST popular e você pode usá-la 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 de 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.