Noções básicas de validação do Java Bean

1. Visão geral

Neste artigo rápido, examinaremosthe basics of validating a Java bean com a estrutura padrão - JSR 380, também conhecido comoBean Validation 2.0.

Validar a entrada do usuário é, obviamente, um requisito super comum na maioria dos aplicativos, e a estrutura de Validação do Java Bean se tornou o padrão de fato para lidar com esse tipo de lógica.

Leitura adicional:

Validação no Spring Boot

Aprenda como validar objetos de domínio no Spring Boot usando o Hibernate Validator, a implementação de referência da estrutura de Validação de Bean.

Restrições de método com a validação de bean 2.0

Uma introdução às restrições de método usando o Bean Validation 2.0.

2. JSR 380

JSR 380 é uma especificação da API Java para validação de bean, parte de JavaEE e JavaSE, que garante que as propriedades de um bean atendam a critérios específicos, usando anotações como@NotNull,@Min e@Max.

Esta versão requer Java 8 ou superior e tira proveito dos novos recursos adicionados no Java 8, como anotações de tipo, e oferece suporte a novos tipos comoOptionaleLocalDate.

Para obter informações completas sobre as especificações, vá em frente e leiaJSR 380.

3. Dependências

Vamos usar um exemplo Maven para mostrar as dependências necessárias, mas é claro, esses jars podem ser adicionados de várias maneiras.

3.1. API de validação

De acordo com a especificação JSR 380, a dependênciavalidation-api contém as APIs de validação padrão:


    javax.validation
    validation-api
    2.0.0.Final

3.2. Implementação de referência da API de validação

O Hibernate Validator é a implementação de referência da API de validação.

Para usá-lo, devemos adicionar as seguintes dependências:


    org.hibernate.validator
    hibernate-validator
    6.0.2.Final


    org.hibernate.validator
    hibernate-validator-annotation-processor
    6.0.2.Final

Uma observação rápida aqui é quehibernate-validator is entirely separate from the persistence aspects of Hibernatee adicionando-o como uma dependência, não estamos adicionando esses aspectos de persistência ao projeto.

3.3. Dependências de linguagem de expressão

O JSR 380 fornece suporte para interpolação de variáveis, permitindo expressões dentro das mensagens de violação.

Para analisar essas expressões, precisamos adicionar uma dependência na API da linguagem de expressão e na implementação dessa API. O GlassFish fornece a implementação de referência:


    javax.el
    javax.el-api
    3.0.0



    org.glassfish.web
    javax.el
    2.2.6

Se esses JARs não forem adicionados, você receberá uma mensagem de erro no tempo de execução, como mostrado abaixo:

HV000183: Não foi possível carregar ‘javax.el.ExpressionFactory '. Verifique se você tem as dependências EL no caminho de classe ou use ParameterMessageInterpolator em vez disso

4. Usando anotações de validação

Usaremos um beanUser como o exemplo principal aqui e trabalharemos para adicionar alguma validação simples a ele:

import javax.validation.constraints.AssertTrue;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.constraints.Email;

public class User {

    @NotNull(message = "Name cannot be null")
    private String name;

    @AssertTrue
    private boolean working;

    @Size(min = 10, max = 200, message
      = "About Me must be between 10 and 200 characters")
    private String aboutMe;

    @Min(value = 18, message = "Age should not be less than 18")
    @Max(value = 150, message = "Age should not be greater than 150")
    private int age;

    @Email(message = "Email should be valid")
    private String email;

    // standard setters and getters
}

Todas as anotações usadas no exemplo são anotações JSR padrão:

@NotNull - valida que o valor da propriedade anotada não énull
@AssertTrue - valida que o valor da propriedade anotada étrue
@Size - valida que o valor da propriedade anotada tem um tamanho entre os atributosminemax; pode ser aplicado aString,Collection,Map e propriedades da matriz
@Min -vValida que a propriedade anotada tem um valor não menor que o atributovalue
@Max - valida que a propriedade anotada tem um valor não maior que o atributovalue
@Email - valida se a propriedade anotada é um endereço de e-mail válido

Algumas anotações aceitam atributos adicionais, mas o atributomessage é comum a todos eles. Essa é a mensagem que normalmente será renderizada quando o valor da propriedade respectiva falhar na validação.

Algumas anotações adicionais que podem ser encontradas no JSR são:

@NotEmpty - valida se a propriedade não é nula ou vazia; pode ser aplicado aos valoresString,Collection,Map ouArray
@NotBlank - pode ser aplicado apenas a valores de texto e validado se a propriedade não é nula ou espaço em branco
@Positive e@PositiveOrZero - aplicam-se a valores numéricos e validam se eles são estritamente positivos ou positivos incluindo 0
@Negative e@NegativeOrZero - aplicam-se a valores numéricos e validam que são estritamente negativos ou negativos, incluindo 0
@Paste@PastOrPresent - validam se um valor de data está no passado ou no passado incluindo o presente; pode ser aplicado a tipos de data, incluindo aqueles adicionados em Java 8
*@Future* and *@FutureOrPresent* - valida se um valor de data está no futuro, ou no futuro incluindo o presente

The validation annotations can also be applied to elements of a collection:

List<@NotBlank String> preferences;

Nesse caso, qualquer valor adicionado à lista de preferências será validado.

A especificaçãoalso supports the new Optional type em Java 8:

private LocalDate dateOfBirth;

public Optional<@Past LocalDate> getDateOfBirth() {
    return Optional.of(dateOfBirth);
}

Aqui, a estrutura de validação desembrulhará automaticamente o valorLocalDate e o validará.

5. Validação Programática

Algumas estruturas - como o Spring - têm maneiras simples de acionar o processo de validação usando apenas anotações. Isso ocorre principalmente para que não tenhamos que interagir com a API de validação programática.

Vamos agora seguir a rota manual e configurar tudo de forma programática:

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();

Para validar um bean, devemos primeiro ter um objetoValidator, que é construído usando umValidatorFactory.

5.1. Definindo o Bean

Agora vamos configurar este usuário inválido - com um valorname nulo:

User user = new User();
user.setWorking(true);
user.setAboutMe("Its all about me!");
user.setAge(50);

5.2. Validar o feijão

Agora que temos umValidator, podemos validar nosso bean passando-o para o métodovalidate. Quaisquer violações das restrições definidas no objetoUser serão retornadas comoSet.

Set> violations = validator.validate(user);

Ao iterar as violações, podemos obter todas as mensagens de violação usando o métodogetMessage.

for (ConstraintViolation violation : violations) {
    log.error(violation.getMessage());
}

Em nosso exemplo (ifNameIsNull_nameValidationFails), o conjunto conteria um únicoConstraintViolation, com a mensagem “Name cannot be null”.

6. Conclusão

Este tutorial se concentrou em uma passagem simples pela API de validação Java padrão e ilustrou os fundamentos da validação de bean usando anotações e APIsjavax.validation.

Uma implementação dos conceitos neste artigo pode ser encontrada no projeto GitHub. Apresentaremos mais recursos do JSR 380 e do Hibernate Validator nos próximos artigos.

Todos os trechos de código podem ser encontradosover on GitHub.

TOC

Noções básicas de validação do Java Bean