Validando dados do formulário

Validar os dados de entrada é uma tarefa muito importante para qualquer aplicação. É uma das principais formas de garantir a integridade dos dados e a segurança da aplicação.

A validação consiste na verificação das informações inseridas pelo usuário, para garantir que elas estão de acordo com o esperado. Por exemplo, se o usuário está inserindo um e-mail, é necessário verificar se o texto inserido possui o formato de um e-mail válido. Outro exemplo, é a validação de campo não vazio, ou seja, obrigar o usuário a inserir alguma informação naquele campo.

Faça um teste e acesse o formulário de adicionar um novo produto, deixe todos os campos vazios e clique em salvar. Perceba que a aplicação não faz nenhuma validação e salva o produto com todos os campos vazios. Isso não é uma abordagem correta, pois pode gerar diversos tipos de problemas na aplicação. Por isso a validação é uma etapa fundamental de qualquer sistema.

Validando o formulário

O Spring Boot possui uma biblioteca chamada spring-boot-starter-validation que facilita bastante o trabalho de validação. Para utilizá-la, basta adicioná-la como dependência no arquivo pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Agora, vamos adicionar as anotações de validação nos campos do formulário. Para isso, vamos utilizar a anotação @NotBlank que valida se o campo não está vazio. Essa anotação é do pacote jakarta.validation.constraints, por isso é necessário importá-lo. A anotação possui uma mensagem que será exibida caso o campo esteja vazio definida através do atributo message da anotação.

import jakarta.validation.constraints.NotBlank;

public class Product {
    private String id;
    @NotBlank(message = "Nome é obrigatório")
    private String name;
    @NotBlank(message = "Descrição é obrigatória")
    private String description;
    private double price;

    ...
}

Modificando a vinculação entre formulário e controlador

Até então estávamos utilizando o @RequestParam para fazer a vinculação entre o formulário e o controlador e não tem nenhum problema nisso, porém existe uma maneira mais fácil para vincular o HTML do formulário com o Controlador e essa forma é utilizada pelo validador do spring.

Em vez de utilizar o @RequestParam e pegar individualmente cada campo do formulário podemos vincular essas duas pontas através da anotação @ModelAttribute no controlador e a utilização da diretriz th:object e th:field no formulário.

Primeiramente vamos alterar o controlador:

@PostMapping("/")
public String store(@ModelAttribute Product product) {
    ...
}

Dessa maneira o Spring vai tentar transformar diretamente os dados do formulário em um objeto do tipo Product. A segunda modificação é no formulário:

<form action="/products/" method="post" th:object="${product}">

    <label for="title">Título</label>
    <input type="text" th:field="${product.title}" placeholder="title" id="title">


    <label for="price">Preço</label>
    <input type="number" th:field="${product.price}" placeholder="price" id="price" step="any">
    
    ...

</form>

Veja que adicionamos o th:object diretamente na tag form, enquanto que a o th:field foi substituído pelo atributo name do form. Desta maneira fizemos a vinculação (binding) entre o formulário HTML e o controlador Java.

Validando o objeto recebido no controlador

Apenas a adição das anotações no model não é suficiente para que a validação funcione. É necessário alterar o método store do controller para que ele valide o objeto Product, usando novamente uma anotação, desta vez a anotação @Valid. A anotação vai verificar se os campos são validos.

Além da anotação @Valid é necessário adicionar um parâmetro do tipo BindingResult no método. Essa classe é responsável por armazenar o resultado da validação. Após as alterações o método deverá ficar da seguinte maneira:

@PostMapping("/products/store")
public String store(@Valid @ModelAttribute Product product, BindingResult result) {
    
    if (result.hasErrors()) {   
        return "create";    
    }
    
    /*Continua caso não apresente nenhum erro*/

    return "redirect:/products";
}

O último detalhe é com relação ao objeto da classe BindingResult que possui o método hasErrors() que verifica se a validação foi executada com sucesso retornando true caso tenha algum tipo de erro e false caso contrário. Com isso é possível restringir a adição do novo produto caso a validação não tenha sido executada com sucesso e retornar para a página de criação do produto enviando um objeto result com as mensagens de erro.

Exibindo as mensagens de erro

O Thymeleaf possui uma forma de exibir as mensagens de erro de validação. Basta usar o atributo th:errors acompanhado do campo que está sendo validado. Por exemplo, para exibir as mensagens de erro do campo title basta usar o atributo th:errors="${product.title}". O mesmo deve ser feito para os outros campos.

<form action="/products/" method="post" th:object="${product}">

    <label for="title">Título</label>
    <input type="text" th:field="${product.title}" placeholder="title" id="title">
    <div class="error" th:errors="{product.title}">Erro no Título</div>

    <!-- A forma abaixo faz a mesma coisa porém com a escrita diferente -->
    <label for="price">Preço</label>
    <input type="number" th:field="*{price}" placeholder="price" id="price" step="any">
    <div class="error" th:errors="*{price}">Erro no Título</div>

    ...

</form>

Suba a aplicação e acesse a página de criação de um novo produto. Deixe todos os campos vazios e clique em salvar. Perceba que a aplicação não salva o produto e exibe as mensagens de erro. Caso a validação não funcione, tente parar o servidor e fazer um reinicio limpo (usando o comando mvn clean spring-boot:run).

Além da anotação para validação de campo não vazio, o spring possui outras anotações para validação de outros tipos de dados. A seguir é mostrada uma tabela com algumas dessas anotações:

Validando o campo de preço

O campo de preço é um campo numérico com casas decimais. Logo é preciso verificar se esse campo possui no máximo 2 dígitos decimais. Também é possível verificar um valor mínimo para o campo, visto que não faz sentido permitir a entrada de um valor menor do que zero.

Para isso vamos utilizar as anotações @DecimalMin e @Digits. A primeira anotação verifica se o valor do campo é maior ou igual ao valor definido. A segunda anotação verifica se o valor do campo possui o número de dígitos definido. A anotação @Digits possui dois atributos, o atributo integer que define o número de dígitos inteiros e o atributo fraction que define o número de dígitos decimais.

public class Product {

    @DecimalMin(value = "0.01", inclusive = true, message = "O preço deve ser maior que 0.00")
    @Digits(integer = 5, fraction = 2, message = "O preço deve ter no máximo 5 dígitos inteiros e 2 dígitos decimais")
    private double price;
    ...

Nesse exemplo estamos delimitando um valor máximo de preço que pode ser adicionado mas isso vai depender das regras de negócio da sua própria aplicação.