Um guia de validação de entrada com Spring Boot

{"id":1,"name":"John Doe Updated","email":"john.doe.updated@example.com","password":"newP@ssW0rd!"}

Se você é desenvolvedor Java, provavelmente conhece o Spring Boot, um framework robusto que simplifica o desenvolvimento de aplicações independentes, baseadas em Spring e prontas para produção. Entre os muitos recursos que ele oferece está o Bean Validation, essencial para garantir a integridade dos dados e melhorar a experiência do usuário.

O Bean Validation pode ser usado em aplicações Spring Boot para validar entradas e formulários, validar dados antes de salvá-los em um banco de dados e aplicar diferentes políticas de segurança. Com ele, desenvolvedores podem evitar erros, melhorar a qualidade geral da aplicação e garantir a consistência dos dados em toda a aplicação.

Neste artigo, você vai conhecer as diferentes aplicações do Bean Validation e aprender a implementá-lo no Spring Boot para usá-lo com eficiência nos seus próprios projetos.

O que é Bean Validation

O Bean Validation permite aplicar restrições aos modelos de dados da sua aplicação para garantir que os dados sigam regras específicas antes de serem processados ou armazenados. Isso é possível por meio da integração com o Jakarta Bean Validation, que fornece um conjunto de anotações e interfaces para definir e validar restrições.

Com o Bean Validation, os desenvolvedores economizam tempo e recursos ao detectar erros e inconsistências logo no início do processo de desenvolvimento. Além disso, ele ajuda a melhorar a experiência geral do usuário ao reduzir a quantidade de dados incorretos inseridos.

Veja alguns casos de uso comuns do Bean Validation no desenvolvimento de aplicações:

Validação de entradas e formulários

Um dos casos de uso mais comuns do Bean Validation é a validação de entradas e formulários. Isso ajuda a garantir que os usuários informem os dados no formato correto (por exemplo, validação de um formulário de cadastro com endereços de e-mail, nomes de usuário e senhas).

Validação de dados antes de salvá-los em um banco de dados

Outra aplicação do Bean Validation é validar os dados antes de salvá-los em um banco de dados. Essa técnica ajuda a garantir que os dados informados sejam consistentes e precisos. Assim, é possível evitar erros e reduzir o risco de corrupção dos dados.

Aplicação de políticas de segurança

O Bean Validation também pode ser usado para aplicar políticas de segurança, validando entradas de usuários ou dados mapeados do banco de dados para garantir que atendam a critérios específicos, como os requisitos de força de uma senha. A validação tem um papel importante na prevenção de ataques de injeção e ajuda a evitar vulnerabilidades de segurança, como cross-site scripting (XSS) armazenado.

Validação da lógica de negócios

O Bean Validation pode ser usado para validar a lógica de negócios e garantir que ela atenda a requisitos ou padrões específicos. Ao definir restrições de validação, como a complexidade da senha ou quantidades e preços válidos de itens de um pedido, o Bean Validation verifica os dados automaticamente e aplica as regras necessárias. Isso elimina a necessidade de verificações manuais e garante que a aplicação siga padrões ou requisitos específicos.

Implementação do Bean Validation no Spring Boot

Neste tutorial, você vai implementar o Bean Validation em uma aplicação simples de criação, leitura, atualização e exclusão (CRUD) com um banco de dados em memória. Os usuários informam nome, e-mail e senha, que precisam atender a critérios específicos para serem aceitos. A arquitetura de alto nível usada aqui inclui um servidor de back-end com APIs RESTful e um banco de dados H2 em memória.

Quando uma aplicação cliente chama o serviço web (a aplicação deste tutorial), a solicitação é enviada ao UserController. Em seguida, o controller valida os dados da solicitação. Se os dados forem válidos, a solicitação segue para o UserRepository, que se comunica com o banco de dados em memória e retorna a resposta correspondente. Caso contrário, os dados são inválidos e a solicitação retorna ao cliente com uma mensagem de erro:

Pré-requisitos

Antes de começar a implementação, verifique se você instalou as seguintes ferramentas e tecnologias:

• Java Development Kit (JDK) versão 17 ou posterior.

• Uma IDE, como IntelliJ IDEA ou Eclipse. Neste tutorial, usamos o IntelliJ IDEA Community Edition.

• Maven versão 3.8.6 ou posterior.

Crie um novo projeto Spring Boot

Para criar um novo projeto Spring Boot, acesse o Spring Initializr e escolha as seguintes opções:

• Tipo de projeto: Maven Project

• Linguagem: Java

• Empacotamento: Jar

• Versão do Java: 17

• Spring Boot: 3.1.0 (SNAPSHOT)
  

Informe os seguintes dados na seção Metadados do projeto:

• Group: com.example

• Artifact: simple-crud-bean-validation

• Name: simple-crud-bean-validation

• Description: Uma aplicação CRUD simples com Spring Boot

• Package name: com.example.simplecrud

Adicione também as seguintes dependências:

• Web: Spring Web

• Validação: Bean Validation

• H2 Database: H2 Database

• Spring Data JPA: Spring Data and Hibernate

Clique em Generate para baixar o projeto em um arquivo ZIP. Em seguida, extraia o arquivo e importe o projeto na IDE de sua preferência.

Implemente a aplicação

Vamos seguir a estrutura padrão de projetos Spring Boot. Veja a estrutura completa do projeto:

Modelo User

Para implementar a aplicação, comece criando o diretório model em src/main/java/com/example/simplecrudbeanvalidation. Em seguida, dentro do diretório model, crie um arquivo chamado User.java e adicione os campos e as anotações do Bean Validation a seguir à classe User:

1import jakarta.persistence.*;
2import jakarta.validation.constraints.*;
3
4@Entity
5@Table(name="users")
6public class User {
7
8    @Id
9    @GeneratedValue(strategy = GenerationType.IDENTITY)
10    private Long id;
11
12    @NotNull
13    @NotEmpty
14    @Pattern(regexp = "[a-zA-Z0-9 ]")
15    private String name;
16
17    @NotNull
18    @NotEmpty
19    @Email
20    @Pattern(regexp=".+@.+\\..+")
21    private String email;
22
23    @NotNull
24    @NotEmpty
25    @Size(min = 8, max = 64)
26    private String password;
27
28    public Long getId() {
29        return id;
30    }
31
32    public void setId(Long id) {
33        this.id = id;
34    }
35
36    public String getName() {
37        return name;
38    }
39
40    public void setName(String name) {
41        this.name = name;
42    }
43
44    public String getEmail() {
45        return email;
46    }
47
48    public void setEmail(String email) {
49        this.email = email;
50    }
51
52    public String getPassword() {
53        return password;
54    }
55
56    public void setPassword(String password) {
57        this.password = password;
58    }
59
60    public User(Long id, String name, String email, String password){
61        this.id = id;
62        this.name = name;
63        this.email = email;
64        this.password = password;
65    }
66
67    //default constructor
68    public User(){}
69}

Este código define uma classe Java chamada User, que representa uma tabela chamada users em um banco de dados, usando anotações da Jakarta Persistence API (JPA). Ela tem quatro variáveis de instância — id, name, email e password — com getters e setters correspondentes. Cada campo tem determinadas restrições de validação, como @NotNull, @NotEmpty, @Email, @Size e @Pattern. @Pattern indica que a senha deve ter de oito a 64 caracteres e conter pelo menos um dígito, uma letra minúscula, uma letra maiúscula e um caractere especial. Além disso, @Pattern também é usado na propriedade name para evitar injeções de scripts. A classe pode ser usada como modelo para armazenar e recuperar dados de usuários em um banco de dados.

Repositório User

Para lidar com operações CRUD usando um banco de dados em memória, crie o diretório repository dentro de src/main/java/com/example/simplecrudbeanvalidation. Em seguida, dentro do diretório directory, crie um arquivo chamado UserRepository.java para definir a interface UserRepository, conforme abaixo:

1import com.example.simplecrudbeanvalidation.model.User;
2import org.springframework.data.repository.CrudRepository;
3import org.springframework.stereotype.Repository;
4
5@Repository
6public interface UserRepository extends CrudRepository<User, Long> {
7}

Este código define uma interface Java chamada UserRepository, que estende a interface CrudRepository fornecida pelo Spring Data JPA. A interface UserRepository especifica dois parâmetros genéricos para CrudRepository: User, o tipo de entidade gerenciada por este repositório, e Long, o tipo da chave primária da entidade.

Ao estender CrudRepository, UserRepository herda vários métodos para realizar operações CRUD na entidade User. Esses métodos podem ser usados para interagir com um banco de dados em memória e gerenciar objetos User sem precisar de configurações complexas ou de um servidor de banco de dados completo.

Controller User

Para criar a classe UserController, que define os endpoints da API RESTful e a lógica de validação, comece criando um diretório chamado controller dentro de src/main/java/com/example/simplecrudbeanvalidation. No diretório controller, crie um arquivo chamado UserController.java com o seguinte conteúdo:

1import com.example.simplecrudbeanvalidation.model.User;
2import com.example.simplecrudbeanvalidation.repository.UserRepository;
3import jakarta.validation.Valid;
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.http.ResponseEntity;
6import org.springframework.validation.annotation.Validated;
7import org.springframework.web.bind.annotation.*;
8import java.util.List;
9import java.util.Optional;
10
11@RestController
12@RequestMapping("/api/users")
13@Validated
14public class UserController
15{
16   @Autowired
17   private UserRepository userRepository;
18
19   @GetMapping
20   public List<User> getAllUsers() {
21       return (List<User>) userRepository.findAll();
22   }
23
24   @GetMapping("/{id}")
25   public ResponseEntity<User> getUserById(@PathVariable Long id) {
26       Optional<User> userOptional = userRepository.findById(id);
27       if (userOptional.isPresent()) {
28           return ResponseEntity.ok(userOptional.get());
29       } else {
30           return ResponseEntity.notFound().build();
31       }
32   }
33
34   @PostMapping
35   public User createUser(@Valid @RequestBody User user) {
36       return userRepository.save(user);
37   }
38
39   @PutMapping("/{id}")
40   public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody User updatedUser) {
41       Optional<User> userOptional = userRepository.findById(id);
42       if (userOptional.isPresent()) {
43           User user = userOptional.get();
44           user.setName(updatedUser.getName());
45           user.setEmail(updatedUser.getEmail());
46           user.setPassword(updatedUser.getPassword());
47           userRepository.save(user);
48           return ResponseEntity.ok(user);
49       } else {
50           return ResponseEntity.notFound().build();
51       }
52   }
53
54   @DeleteMapping("/{id}")
55   public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
56       if (userRepository.existsById(id)) {
57           userRepository.deleteById(id);
58           return ResponseEntity.ok().build();
59       } else {
60           return ResponseEntity.notFound().build();
61       }
62   }
63}

Este código define uma classe Spring Boot RestController chamada UserController, que gerencia solicitações HTTP para administrar objetos User. A classe contém cinco métodos que tratam de diferentes solicitações HTTP: recuperar todos os usuários, recuperar um usuário pelo ID, criar um usuário, atualizar um usuário existente e excluir um usuário.

A anotação @Autowired injeta a dependência UserRepository na classe UserController. A classe UserController é associada ao endpoint /api/users por meio da anotação @RequestMapping, que direciona as solicitações HTTP recebidas para este controller. Além disso, a anotação @Validated habilita a validação dos parâmetros da solicitação. Em conjunto, esse código fornece uma API RESTful para operações CRUD em objetos User, usando Spring Data e um banco de dados em memória.

Configure o banco de dados em memória

Para configurar o banco de dados em memória, abra o arquivo application.properties em src/main/resources/ e adicione as seguintes configurações:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Esta configuração do Spring Boot cria um banco de dados H2 em memória chamado testdb e configura seu driver, nome de usuário e senha. Ela também especifica o dialeto H2 a ser usado nas operações de banco de dados com Hibernate.

Teste unitário do Bean Validation

Depois de configurar o banco de dados em memória, você pode começar a testar o Bean Validation com testes unitários. Para isso, crie o diretório controller dentro de src/test/java/com/example/simplecrudbeanvalidation. Em seguida, dentro do diretório controller, crie um arquivo chamado UserControllerTest.java e escreva testes para verificar se as restrições do Bean Validation estão funcionando como esperado.

Na classe UserControllerTest, adicione o seguinte código:

1import com.example.simplecrudbeanvalidation.model.User;
2import com.example.simplecrudbeanvalidation.repository.UserRepository;
3import com.fasterxml.jackson.databind.ObjectMapper;
4import org.junit.jupiter.api.Test;
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
7import org.springframework.boot.test.context.SpringBootTest;
8import org.springframework.boot.test.mock.mockito.MockBean;
9import org.springframework.http.MediaType;
10import org.springframework.test.web.servlet.MockMvc;
11import java.util.Arrays;
12import java.util.Optional;
13import static org.hamcrest.Matchers.hasSize;
14import static org.mockito.Mockito.*;
15import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
16import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
17
18@SpringBootTest
19@AutoConfigureMockMvc
20public class UserControllerTest {
21
22    @Autowired
23    private MockMvc mockMvc;
24
25    @MockBean
26    private UserRepository userRepository;
27
28    @Autowired
29    private ObjectMapper objectMapper;
30
31    @Test
32    public void createUser_validData_success() throws Exception {
33        User newUser = new User(null, "John Doe", "john.doe@example.com", "p@ssW0rd!");
34        User savedUser = new User(1L, newUser.getName(), newUser.getEmail(), newUser.getPassword());
35
36        when(userRepository.save(any(User.class))).thenReturn(savedUser);
37
38        mockMvc.perform(post("/api/users")
39                        .contentType(MediaType.APPLICATION_JSON)
40                        .content(objectMapper.writeValueAsString(newUser)))
41                .andExpect(status().isOk())
42                .andExpect(jsonPath("$.id").value(savedUser.getId()))
43                .andExpect(jsonPath("$.name").value(savedUser.getName()))
44                .andExpect(jsonPath("$.email").value(savedUser.getEmail()))
45                .andExpect(jsonPath("$.password").value(savedUser.getPassword()));
46    }
47
48    @Test
49    public void createUser_invalidData_failure() throws Exception {
50        User invalidUser = new User(null, "", "invalid-email", "123");
51
52        mockMvc.perform(post("/api/users")
53                        .contentType(MediaType.APPLICATION_JSON)
54                        .content(objectMapper.writeValueAsString(invalidUser)))
55                .andExpect(status().isBadRequest());
56    }
57
58    @Test
59    public void getAllUsers() throws Exception {
60        User user1 = new User(1L, "John Doe", "john.doe@example.com", "p@ssW0rd!");
61        User user2 = new User(2L, "Jane Doe", "jane.doe@example.com", "p@ssW0rd!");
62        when(userRepository.findAll()).thenReturn(Arrays.asList(user1, user2));
63        mockMvc.perform(get("/api/users"))
64                .andExpect(status().isOk())
65                .andExpect(jsonPath("$", hasSize(2)))
66                .andExpect(jsonPath("$[0].id").value(user1.getId()))
67                .andExpect(jsonPath("$[0].name").value(user1.getName()))
68                .andExpect(jsonPath("$[0].email").value(user1.getEmail()))
69                .andExpect(jsonPath("$[0].password").value(user1.getPassword()))
70                .andExpect(jsonPath("$[1].id").value(user2.getId()))
71                .andExpect(jsonPath("$[1].name").value(user2.getName()))
72                .andExpect(jsonPath("$[1].email").value(user2.getEmail()))
73                .andExpect(jsonPath("$[1].password").value(user2.getPassword()));
74    }
75
76    @Test
77    public void getUserById_found() throws Exception {
78        User user = new User(1L, "John Doe", "john.doe@example.com", "p@ssW0rd!");
79        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
80        mockMvc.perform(get("/api/users/{id}", user.getId()))
81                .andExpect(status().isOk())
82                .andExpect(jsonPath("$.id").value(user.getId()))
83                .andExpect(jsonPath("$.name").value(user.getName()))
84                .andExpect(jsonPath("$.email").value(user.getEmail()))
85                .andExpect(jsonPath("$.password").value(user.getPassword()));
86    }
87
88    @Test
89    public void getUserById_notFound() throws Exception {
90        Long userId = 1L;
91        when(userRepository.findById(userId)).thenReturn(Optional.empty());
92        mockMvc.perform(get("/api/users/{id}", userId))
93                .andExpect(status().isNotFound());
94    }
95}

Este código reúne testes JUnit para a classe UserController. Os testes usam a classe MockMvc para simular solicitações HTTP ao endpoint /api/users e verificar se os métodos correspondentes da classe UserController as tratam corretamente. Os cenários incluem criar um usuário com dados válidos e inválidos, recuperar todos os usuários e recuperar um usuário pelo ID, tanto quando ele existe quanto quando não existe.

A anotação @SpringBootTest carrega o contexto da aplicação, e a anotação @MockBean cria um mock da dependência UserRepository da classe UserController. No conjunto, esses testes garantem que a classe UserController funcione corretamente e responda como esperado a diferentes solicitações HTTP.

Para executar os testes, abra um terminal ou shell, acesse o diretório raiz do projeto e rode o seguinte comando:

mvn test

Você verá que todos os testes passaram:

…output omitted…
[INFO] Results:
[INFO] 
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
[INFO] 
[INFO] ------------------------------------------------------------------------
…output omitted…

Execute e teste suas APIs

No IntelliJ, clique com o botão direito no arquivo SimpleCrudBeanValidationApplication.java e selecione Run 'SimpleCrudBeanValidationApplication.main()':

Outra opção é executar a aplicação no terminal ou shell com os seguintes comandos:

mvn clean install
java -jar target/simple-crud-bean-validation-0.0.1-SNAPSHOT.jar

Depois de iniciar a aplicação Spring Boot, você pode testar as operações CRUD usando comandos curl no terminal ou shell, de forma semelhante a uma aplicação de front-end ou ao Postman ao chamar essas APIs.

Para testar as operações CRUD, comece criando um usuário:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"}' http://localhost:8080/api/users

A saída será semelhante a esta:

{"id":1,"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"} 

Em seguida, liste todos os usuários:

curl -X GET http://localhost:8080/api/users

A saída será semelhante a esta:

{"id":1,"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"}

Agora, busque o usuário pelo ID. Substitua <id> pelo ID do usuário que você quer recuperar:

curl -X GET http://localhost:8080/api/users/<id>

A saída será:

{"id":1,"name":"John Doe","email":"john.doe@example.com","password":"p@ssW0rd!"}

Atualize o usuário, substituindo <id> pelo ID do usuário que você quer atualizar:

curl -X PUT -H "Content-Type: application/json" -d '{"name":"John Doe Updated","email":"john.doe.updated@example.com","password":"newP@ssW0rd!"}' http://localhost:8080/api/users/<id>

A saída será semelhante a esta:

{"id":1,"name":"John Doe Updated","email":"john.doe.updated@example.com","password":"newP@ssW0rd!"}

Em seguida, exclua um usuário, substituindo <id> pelo ID do usuário que você quer excluir:

curl -X DELETE http://localhost:8080/api/users/<id>

Este comando não gera nenhuma saída.

Com estes comandos curl, você pode testar as operações CRUD da sua API RESTful de usuários. Lembre-se de substituir <id> pelo ID de usuário apropriado em cada comando. Seguindo estas etapas, você pode interagir com sua aplicação Spring Boot e verificar se as restrições do Bean Validation estão funcionando como esperado durante a execução.

Se você executar estas solicitações curl novamente com dados incorretos, como um e-mail inválido, uma senha inválida ou valores vazios, verá que a API retorna um erro de solicitação inválida. Essa mensagem indica que a validação no nível do controller, também conhecida como Bean Validation, não foi aprovada.

Vamos ver alguns exemplos de solicitações inválidas. Aqui, você cria um usuário com um endereço de e-mail inválido:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"johexample","password":"p@ssW0rd!"}' http://localhost:8080/api/users

A saída será semelhante a esta:

{"timestamp":"2023-03-28T10:27:21.884+00:00","status":400,"error":"Bad Request","path":"/api/users"}

Agora, você cria um usuário com uma senha inválida:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"joh@example.com","password":"test"}' http://localhost:8080/api/users

A saída será a seguinte:

{"timestamp":"2023-03-28T10:29:30.793+00:00","status":400,"error":"Bad Request","path":"/api/users"}

Concluindo a validação

Neste artigo, você aprendeu a implementar o Bean Validation do Spring Boot em uma aplicação CRUD simples. Você criou um projeto com o Spring Initializr, adicionou as dependências necessárias e implementou um modelo de usuário com anotações do Bean Validation. Também implementou um UserRepository e um UserController com endpoints de API RESTful que usam o Bean Validation, além de escrever testes para verificar se as restrições do Bean Validation estão funcionando como esperado.

Para reforçar a segurança da sua aplicação, use o Snyk Code, uma ferramenta SAST que detecta padrões de código inseguros capazes de levar a ataques de injeção. Você pode usar a extensão plugin Snyk Security para IntelliJ IDE para integrar essa análise ao seu fluxo de desenvolvimento.

Agora que você entende como funciona o Bean Validation do Spring Boot, pode implementá-lo nos seus próprios projetos para garantir a integridade dos dados e melhorar a experiência dos usuários. Para conferir o código completo, acesse o seguinte repositório no GitHub.