Beans Validation

Figura 1: Utilizando Beans Validation

Beans Validation

A garantia de que os dados sejam utilizados de forma correta e as regras sobre estes permaneçam consistentes para uma eficaz utilização das aplicações computacionais, sempre foram um desafio para os programadores. Com a chegada da JSR 303, conhecida como Bean Validation, os programadores Java passaram a ter um rápido recurso de validação e controle sobre os dados utilizados nas aplicações, mantendo o código claro e enxuto.

Esta não é a primeira opção conhecida para validação de dados, mas tornou-se a referência dentro da linguagem Java e foi estabelecida através do estudo da técnica de validação oferecida pelo framework de persistência de dados Hibernate e sua biblioteca Hibernate Validation.

Ambas as ferramentas foram criadas com o intuito de diminuir a quantidade de código criada diretamente dentro da aplicação e facilitar as validações de dados e torná-la uma tarefa mais clara e simples de ser utilizada.

Introdução a Persistência

Desde o início do desenvolvimento de aplicativos, viu-se a necessidade de criar formas de garantir que as informações passadas pelos usuários fossem aquelas que deveriam, realmente, chegar às regras de negócios e aos campos de persistência.

Com o decorrer do tempo e as evoluções nas características das linguagens de programação, a chegada de novos tipos de dados e formatos de dados que deveriam ser tratados, viu-se a necessidade de garantir que estes fossem tratados de forma mais exigente, para que as aplicações gerassem uma quantidade pequena ou nenhum erro. Mas essa é uma tarefa árdua.

Nas implementações convencionais, muitas camadas de código podem ser utilizadas para garantir que os dados sejam entregues no formato correto, mas isso pode gerar uma grande quantidade de código, dificultando a implementação e criando uma estrutura de software difícil de manter. Assim, surgiu a implementação do JSR 303: Bean Validation.

Validação de Dados

As aplicações computacionais basicamente tratam de fluxos de dados. Estes dados podem vir de um sistema persistente (banco de dados) ou de dispositivos de entrada de dados (teclado, mouse, mídias removíveis). A garantia de integridade e consistência desses dados e que estes são os dados corretos, é essencial para manter um sistema estável e funcional. A validação de dados é a técnica utilizada para ter essa consistência, observando o formato que este dado deve conter e que tipos de tarefas serão permitidas para estes dados (COUTINHO, 2008).

Validações de dados demandavam de grande reescrita de código, em várias partes da aplicação, desde sua parte visual, onde os dados poderiam ser inseridos por um usuário para persistência, até na própria classe de persistência para garantir que os dados que chegassem ao banco de dados fossem correlatos a estes. Estas validações em várias camadas diferentes da aplicação estão sujeitas a erros e a uma grande quantidade de reimplementação de código em cada campo, muitas vezes sendo implementado diretamente sobre as classes para facilitar a manutenção, mas dificultando a reutilização destas classes em outros projetos (HIBERNATE, 2013).

Com a criação da implementação JSR 303 – Bean Validation, sendo esta integrante à plataforma JEE 6, foi definido um padrão de API para utilizar-se de anotações sobre metadados e assim tentar substituir de forma mais dinâmica as validações em várias camadas evitando a duplicação de códigos bem como os deixando mais claro (JAVA COMMUNITY PROCESS).

JSR 303

A JSR 303, enumerada como 1.0, é a implementação de referência criada sobre o framework de validação da Hibernate. Esta implementação é desenvolvida sobre a licença Open Source Apache, podendo ser alterada, desde que esta mesma licença permaneça na nova versão (HIBERNATE, 2013).

Esta implementação foi desenvolvida por um grupo de especialistas na área de tecnologia, boa parte dos integrantes de grandes empresas como Google, Oracle e Sun, que foi absorvida pela Oracle, e liderados por Emmanuel Bernard, da Hed Rat.

Além da JSR 303, está em andamento sua atualização que é conhecida como JSR 349, até o momento enumerada como versão 1.1 (BEAN VALIDATION).

Ambas as referências permitem a validação tanto do Bean, quanto das chamadas de métodos, garantindo que os retornos dos métodos ou os valores dos parâmetros que sejam usados nestes sejam do tipo necessário. As anotações de validação podem ser vistas no Quadro 1, onde a primeira coluna é a anotação, a segunda como deve funcionar e a terceira possui um exe

Anotação Descrição Exemplo
@ AssertFalse O valor do campo ou propriedade deve ser falso. @ AssertFalse
boolean isUnsupported;
@ AssertTrue O valor do campo ou propriedade deve ser verdadeiro. @ AssertTrue
boolean isActive;
@ DecimalMax O valor do campo ou propriedade deve ser um valor decimal menor do que ou igual ao número no elemento de valor. @ DecimalMax ("30,00")
BigDecimal desconto;
@ DecimalMin O valor do campo ou propriedade deve ser um valor decimal maior ou igual ao número no elemento de valor. @ DecimalMin ("5.00")
BigDecimal desconto;
@ Digits O valor do campo ou propriedade deve ser um número dentro de um intervalo especificado. O elemento inteiro especifica o máximo de dígitos integrais para o número, eo elemento fração especifica o máximo de dígitos fracionários para o número. @ Digits (integer = 6 fração, = 2)
BigDecimal preço;
@ Future O valor do campo ou propriedade deve ser uma data no futuro. @ Future
Data eventData;
@ Max O valor do campo ou propriedade deve ser um valor inteiro menor do que ou igual ao número no elemento de valor. @ Max (10)
int quantidade;
@ Min O valor do campo ou propriedade deve ser um valor inteiro maior que ou igual ao número no elemento de valor. @ Min (5)
int quantidade;
@ NotNull O valor do campo ou da propriedade não deve ser nula. @ NotNull
String nome;
@ Null O valor do campo ou propriedade deve ser nula. @ Null
String nome;
@ Past O valor do campo ou propriedade deve ser uma data no passado. @ Past
Date aniversario;
@ Pattern O valor do campo ou propriedade deve corresponder a expressão regular definida no elemento regexp. @ Pattern (regexp = "\ \ (\ \ d {3} \ \) \ \ d {3} - \ \ d {4}")
String telefone;
@ Size O tamanho do campo ou propriedade é avaliado e devem coincidir com os limites especificados. Se o campo ou propriedade é uma String, o tamanho da string é avaliado. Se o campo ou propriedade é uma coleção, o tamanho da coleção é avaliado. Se o campo ou propriedade é um mapa, o tamanho do Mapa é avaliado. Se o campo ou propriedade é uma matriz, o tamanho da matriz é avaliado. O uso dos dois elementos, max e min, para especificar os limites é opcional, sendo obrigatório o uso de apenas um deles. @ Size (min = 2, max = 240).
String nome;

Tabela 1: Anotações do Bean Validation. Fonte: Oracle (adaptado).

Validação do Bean

A validação do Bean é extremamente importante devido ao fato de este ser a entidade persistida na base de dados. Essas validações são estáticas e, portanto, não mudam de forma já que o Bean não muda durante a execução da aplicação (COUTINHO, 2008). Assim pode-se utilizar do exemplo do Listagem 1 como uma validação de Bean.

Listagem 1: Exemplo de validação com anotações

//suprimidos os imports e declaração do pacote
@Entity
public class Pessoa{
         @Id
         @GeneratedValue
         private Long id;
         @NotNull
         @Size(min=1, max=16)
         private String nome;
         @NotNull 
         @Size(min=1, max=16)
         private String sobreNome;
 
         @Past
         private Date dataNascimento;

//suprimidos getters e setters
}

Pode-se observar que as anotações do JSR 303 não impedem as anotações de persistência JPA coexistir. Muito pelo contrário, essas anotações também podem e devem ser utilizadas para, ao mesmo tempo que efetuar as validações, efetuar a persistência de forma simplificada.

Neste exemplo, deve-se tomar o cuidado de averiguar se os atributos nome e sobreNome são nulos, mas não vazios. Caso o atributo receba uma String vazia, ou seja, um parâmetro inicializado como “”, este valor será repassado à validação e será considerado válido (ORACLE).

Caso seja necessário enviar uma informação ao usuário, pode-se utilizar da propriedade message da validação, que possibilita informar qual campo está inválido para a persistência. Segue abaixo o exemplo na Listagem 2.

Listagem 2: Exemplo de uso de anotações de mensagens nos atributos

//suprimidos os imports e declaração do pacote
@Entity
public class Pessoa{
         @Id
         @GeneratedValue
         private Long id;
         @NotNull
         @Size(min=1, max=16)
         private String nome;
         @NotNull (message = “Preencha o sobrenome.”)
         @Size(min=1, max=16)
         private String sobreNome;
         @Past (message = “A data de nascimento deve ser anterior a data atual.”)
         private Date dataNascimento;

public Date getDataNascimento(){
                 return dataNascimento;
}
//suprimidos getters e setters
}

Com este formato, é possível capturar a mensagem de erro caso o atributo que esteja sendo persistido não se encaixe no argumento solicitado. A mensagem poderá ser exibida informando o usuário qual o campo deverá ser corrigido. Esta é uma possibilidade.

Validação de Métodos

As validações de alguns frameworks, como o Hibernate e o Spring, também podem ser utilizadas sobre os métodos das classes. Sempre que o método contiver um retorno, este pode ser verificado para que retorne o valor necessário ao contexto da aplicação (HIBERNATE, 2013). Exemplificando segue abaixo a Listagem 3.

Listagem 3: Exemplo de uso de anotações de mensagens nos métodos

//suprimidos os atributos
@Past (message = “A data de nascimento deve ser anterior a data atual.”)
@NotNull (message = “A data de nascimento deve ser preenchida.”)
public Date getDataNascimento(){
                 return dataNascimento;
}

Também é possível efetuar anotações dentro dos parâmetros passados para os métodos permitindo uma validação anterior a sua execução, mostrando como forte característica da implementação Bean Validate a diminuição de repetição de códigos em diferentes partes da aplicação.

Conclusão

Nesta visão panorâmica que se pode adquirir com o Java Bean Validate, compreende-se que esta API Java é uma ferramenta poderosa em relação às tecnologias já existentes, permite com simples anotações realizar tarefas complexas que antes demandavam muito tempo, ainda quando não eram apenas cópias de packages existentes.

As facilidades introduzidas pelas validações através de anotações evitam a duplicação de código em diferentes pontos da aplicação. Deixam claro e permitem que a especificação tome conta das validações, deixando a equipe de programação com maior tempo para outros problemas encontrados na codificação.

Conforme verificado, quando utilizadas estas anotações e outras características que a ferramenta nos conduz, já que acarretará numa menor quantidade de código e revalidações em diferentes locais da aplicação, facilitando a manutenção em qualquer ambiente de programação ou ainda para qualquer aplicativo.

8. Referências

Links Úteis

  • O que é Git?:
    Neste curso você aprenderá o que é o Git, ferramenta para controle de versão mais utilizada por desenvolvedores de software.
  • Entity Framework: Como monitorar os comandos SQL gerados:
    Aprenda neste microexemplo a monitorar as instruções SQL que são executadas pelo Entity Framework quando efetuamos operações de acesso ao banco de dados em nossas aplicações.

Saiba mais sobre Bean Validation ;)

Colabore com nosso Fórum