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:

@NegativeOrZero
@Positive
@PositiveOrZero
@Size
@Digits
@Past
@PastOrPresent
@Future
@FutureOrPresent
@Pattern
@Negative
@NotEmpty
@NotBlank
@Length (do Hibernate Validator)
@Range (do Hibernate Validator)
@CreditCardNumber (do Hibernate Validator)
@EAN (do Hibernate Validator)
@ISBN (do Hibernate Validator)
@Currency (do Hibernate Validator)
@URL (do Hibernate Validator)
@UUID (do Hibernate Validator)
@ScriptAssert (do Hibernate Validator)
@ParameterScriptAssert (do Hibernate Validator)

Encerramento sobre o assunto

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.

4.8/5 - (6 votos)