Spring Validation como validar campos com Spring Boot na Prática

Spring Boot Validation é um componente do Spring Framework que facilita a validação de dados nas aplicações Spring Boot.

A validação é um aspecto importante no desenvolvimento de software, garantindo que os dados inseridos pelo usuário ou processados pelo sistema estejam corretos e dentro dos parâmetros esperados.

Com o Spring Boot Validation, você pode definir regras de validação para seus objetos de maneira declarativa e robusta.

Iniciando um projeto com Spring Validation

Abaixo, vamos começar um projeto com Spring Boot para utilizar a biblioteca em um projeto, com exemplos práticos.

Primeiramente, precisamos adicionar as dependências em nosso projeto, Siga abaixo os passos para as configurações:

Projetos que utilizam o Maven:

Adicione a seguinte dependência no seu arquivo pom.xml

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

Projetos que utilizam o Gradle:

Adicione a seguinte dependência no seu arquivo build.gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-validation'
}

Essas dependências incluem o suporte necessário para a Bean Validation e integram-se perfeitamente com o ecossistema Spring Boot, permitindo que você utilize as anotações de validação mencionadas anteriormente.

Funcionamento Básico do Spring Validation

O Spring Boot Validation usa anotações como @NotNull, @Size, @Email, entre outras, para definir restrições diretamente nos campos das classes de modelo. Por exemplo:

package br.com.virandoprogramador.model

public class Usuario {
    @NotNull(message = "O nome não pode ser nulo")
    private String nome;

    @Email(message = "Email deve ser válido")
    private String email;

    @Size(min = 8, message = "A senha deve ter no mínimo 8 caracteres")
    private String senha;

    // getters e setters
}

Estas anotações são processadas em tempo de execução para garantir que os dados estejam de acordo com as restrições definidas antes que o processamento continue. Isso é especialmente útil ao lidar com dados recebidos de formulários da web ou APIs.

Exemplos de Validações Comuns

• Obrigatoriedade: @NotNull, @NotEmpty
• Tamanho: @Size, @Length
• Formato: @Email, @Pattern
• Numérico: @Min, @Max

Integração com Controladores Spring

A validação pode ser integrada facilmente aos controladores Spring usando a anotação @Valid ou @Validated nos parâmetros dos métodos dos controladores. Por exemplo:

package br.com.virandoprogramador.controller

@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {

    @PostMapping
    public ResponseEntity<String> criarUsuario(@Valid @RequestBody Usuario usuario, BindingResult result) {
        if (result.hasErrors()) {
            return ResponseEntity.badRequest().body(result.getAllErrors().toString());
        }
        // lógica para salvar o usuário
        return ResponseEntity.ok("Usuário criado com sucesso!");
    }
}

Nesse exemplo, o Spring automaticamente valida o objeto Usuario antes de chamar o método do controlador. Se houver qualquer violação das regras de validação, as mensagens de erro podem ser acessadas através do BindingResult.

Principais Anotações do Spring Validation

Abaixo, vamos detalhar um pouco mais sobre 9 principais anotações com exemplos:

@Null

public class Usuario {
    @Null(message = "O campo deve ser nulo")
    private String campoNulo;
}

A anotação @Null garante que o campo seja null

@NotNull

public class Usuario {
    @NotNull(message = "O nome não pode ser nulo")
    private String nome;
}

A anotação @NotNull garante que o campo não seja null.

@AssertTrue

public class Usuario {
    @AssertTrue(message = "Deve ser verdadeiro")
    private boolean ativo;
}

A anotação @AssertTrue garante que o campo booleano seja true. Não podendo ser guardado um valor falso.

@AssertFalse

public class Usuario {
    @AssertFalse(message = "Deve ser falso")
    private boolean desativado;
}

A anotação @AssertFalse garante que o campo booleano seja false.

@Min

public class Usuario {
    @Min(value = 18, message = "A idade deve ser no mínimo 18")
    private int idade;
}

A anotação @Min garante que o valor numérico seja maior ou igual ao valor especificado.

@Max

public class Usuario {
    @Max(value = 100, message = "A idade deve ser no máximo 100")
    private int idade;
}

A anotação @Max garante que o valor numérico seja menor ou igual ao valor especificado.

@DecimalMin

public class Produto {
    @DecimalMin(value = "0.0", inclusive = false, message = "O preço deve ser maior que 0")
    private BigDecimal preco;
}

A anotação @DecimalMin garante que o valor decimal seja maior ou igual ao valor especificado.

@DecimalMax

public class Produto {
    @DecimalMax(value = "10000.0", message = "O preço deve ser menor ou igual a 10000")
    private BigDecimal preco;
}

A anotação @DecimalMax garante que o valor decimal seja menor ou igual ao valor especificado.

@Email

public class Usuario {
    @Email(message = "Email deve ser válido")
    private String email;
}

A anotação @Email garante que o campo contenha um endereço de e-mail válido.

Cada uma dessas anotações ajuda a garantir que os dados atendam aos requisitos especificados antes de serem processados pela aplicação, melhorando a integridade e a segurança dos dados.

Outras anotações:

1. @NegativeOrZero
2. @Positive
3. @PositiveOrZero
4. @Size
5. @Digits
6. @Past
7. @PastOrPresent
8. @Future
9. @FutureOrPresent
10. @Pattern
11. @Negative
12. @NotEmpty
13. @NotBlank
14. @Length (do Hibernate Validator)
15. @Range (do Hibernate Validator)
16. @CreditCardNumber (do Hibernate Validator)
17. @EAN (do Hibernate Validator)
18. @ISBN (do Hibernate Validator)
19. @Currency (do Hibernate Validator)
20. @URL (do Hibernate Validator)
21. @UUID (do Hibernate Validator)
22. @ScriptAssert (do Hibernate Validator)
23. @ParameterScriptAssert (do Hibernate Validator)

Benefícios do Spring Boot Validation

1. Facilidade de uso: A integração com o Spring Boot permite configurar validações de forma simples e intuitiva.
2. Anotações poderosas: O uso de anotações Java proporciona uma maneira declarativa de definir regras de validação diretamente nos modelos.
3. Personalização: Possibilidade de criar validações customizadas para atender necessidades específicas do negócio.
4. Integração com JSR 380 (Bean Validation 2.0): O Spring Boot Validation é compatível com a especificação Bean Validation 2.0, garantindo a padronização e interoperabilidade.
5. Mensagens de erro: Fácil configuração de mensagens de erro personalizadas para uma melhor experiência do usuário.
6. Suporte a grupos de validação: Permite aplicar diferentes regras de validação em diferentes contextos.

Por Que Utilizar as Anotações do Spring Boot Validation para Validar os Campos?

A validação de dados é uma prática essencial no desenvolvimento de software, garantindo que as entradas dos usuários sejam corretas e seguras antes de serem processadas pelo sistema.

O Spring Boot Validation oferece uma abordagem eficaz e eficiente para realizar essa validação, utilizando anotações que simplificam e padronizam o processo. Abaixo, estão algumas razões para adotar as anotações do Spring Boot Validation para validar campos em suas aplicações:

1. Simplicidade e Clareza

As anotações do Spring Boot Validation, como @NotNull, @Size, @Email, entre outras, permitem definir regras de validação diretamente nos campos das classes de modelo.

Isso torna o código mais legível e autoexplicativo, pois as regras de validação estão declaradas no próprio local onde os dados são definidos.

2. Redução de Código Boilerplate

Utilizar anotações reduz significativamente a quantidade de código boilerplate necessário para realizar validações.

Sem essas anotações, você precisaria escrever manualmente verificações em vários pontos do seu código, o que é propenso a erros e aumenta a complexidade.

3. Integração Transparente com Spring

As anotações de validação integram-se perfeitamente com o ecossistema Spring, especialmente com Spring MVC e Spring Data.

Isso permite que você valide automaticamente as entradas dos usuários em controladores e serviços, garantindo que os dados sejam verificados antes de qualquer processamento adicional.

4. Mensagens de Erro Amigáveis

As anotações permitem definir mensagens de erro customizadas, proporcionando feedback claro e útil para os usuários finais. Isso melhora a experiência do usuário ao fornecer informações precisas sobre como corrigir os dados inseridos.

Conclusão sobre essa biblioteca do Spring Boot

Utilizar as anotações do Spring Boot Validation para validar campos oferece uma série de benefícios, desde a simplicidade e clareza do código até a padronização e extensibilidade das regras de validação.

Essa abordagem não só melhora a qualidade e a segurança dos dados na sua aplicação, como também facilita a manutenção e a evolução do sistema. Se você está desenvolvendo com Spring Boot, aproveitar as anotações de validação é uma escolha inteligente e eficiente.