Avaliação: | Publicado em: 28/11/2006

Annotations em uso

Eder Magalhaes Eder Andrade de Magalhães, trabalha com desenvolvimento de software desde 2000, em diversos segmentos como Logística, CallCenter (CRM/CTI), Instituição bancária e outros. Atualmente é Arquiteto de Software pelo Instituto Metodista de Ensino Superior. É Sun Certified Programmer for the Java, Sun Certified Web Component Developer for J EE , Sun Certified Business Component Developer for the Java EE

Annotations em uso

Olá, pretendo mostrar neste artigo a utilização de Annotations, em um exemplo para resolver problemas de infra-estrutura do nosso código. Me refiro a infra-estrutura a regras nem sempre tão relacionadas ao negócio, mas fundamentais ao comportamento do software como um todo. Usaremos um exemplo ilustrativo de como efetuar validação no preenchimento de campos em Javabean.

Annotations são meta-informações que "anotam" (marcação) dados no código. O esquema de criação de Annotations foi implementado na versão 5 do Java, mas este conceito já era presente em versões anteriores de uma forma um pouco diferente. Como é o caso da marcação Javadoc @Deprecated que marca um pedaço de código como depreciado, informando ao programador que evite o uso da API em marcada.

Annotations não interferem diretamente na semântica da linguagem, mas sim na maneira que ferramentas e bibliotecas tratam o código. Annotations podem ser lidas de arquivos fonte (.java), .class, ou em run time por Reflexão. No exemplo veremos a abordagem em run time. Não faz parte do escopo deste artigo detalhar o esquema de reflection.

Problema:
Precisamos implementar um esquema de validação dos atributos do JavaBean Pessoa: Nome, Sobrenome e CPF. Mas no nosso caso não seria interessante chamadas explicitas para validar o campo, algo do tipo:

 if (pessoa.getNome == null)  
        ...

Visto que hoje precisamos validar o preenchimento do bean Pessoa, mas em futuro bem próximo teremos de implementar novas versões para outros beans, como Endereço, Departamento, Funcionário, etc.

Solução: Annotations!

Abaixo segue o código da nossa anotação:

/*                                          
 * imports ignorados                        
 */                                         
1  @Retention(RetentionPolicy.RUNTIME)      
2  @Target(ElementType.FIELD)               
3  public @interface Obrigatorio {}         

Na linha 1 informamos qual é a retenção, ou seja, em que situação a marcação será usada. No nosso exemplo em run time, outras opções seriam: SOURCE  e CLASS.
Na linha 2 definimos a qual elemento sofrerá anotação, no nosso caso FIELD. Outros valores seriam: TYPE (class e interface), METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE e PACKAGE.
Na linha 3 a declaração da Annotation, note a keywork @interface!

Agora vamos partir para o nosso JavaBean Pessoa:

/*                                          
 * imports ignorados                        
 */                                         
1  public class Pessoa {                    
2    @Obrigatorio private String nome;      
3    @Obrigatorio private String sobrenome; 
4    @Obrigatorio private String cpf;       
5    @Obrigatorio private int idade;        
                                            
     /** getters e setters omitidos ... */  

Note que nas linhas 2, 3, 4 e 5 junto da declaração dos campos, definimos também as marcações de obrigatoridade. Agora para encerrar o nosso exemplo, vamos declarar a classe responsável por validar o JavaBean, ValidadorBean!

/*                                                     
 * imports ignorados                                   
 */                                                    
   public class ValidadorBean {                        
                                                       
1    public void validar(Object obj) throws Exception {
2       Class classe = obj.getClass();                 
3       Field[] fields = classe.getDeclaredFields();   
4       for (Field field : fields) {                   
5         if (field                                    
              .isAnnotationPresent(Obrigatorio.class)) {
6             field.setAccessible(true);               
7             if (field.get(obj) == null)              
8               throw new Exception("Campo"+                             field.getName()+" não preenchido!");   
          }                                            
        }                                              
        System.out.println("Validação OK !");          
     }                                                 
   }                                                   


Este código é o mais complexo, pois lida com algumas API's de Reflection. Nas linhas 2, 3, 4, 5 e 6, o método avalia o objeto recebido por parâmetro e percorre seus campos verificando se o mesmo está marcado com a Annotation @Obrigatorio, caso
esteja torna o atributo acessível, e na linha 7 verifica se o campo tem valor.

Código de execução do programa:

  public static void main(String[] args) {
      try {
          Pessoa pessoa = new Pessoa();
          pessoa.setNome("João");
          ValidadorBean validador = new ValidadorBean();
          validador.validar(pessoa);
      } catch (Exception ex) {
          System.err.println(ex.getMessage());
      }
  }

Veja o resultado de uma execução do sistema:

Campo sobrenome não preenchido!                         

Este é um exemplo muito simples, e provavelmente sofria alterações para um ambiente real, mas a idéia é mostrar o poder e a facilidade que o desenvolvedor ganhar ao usar Annotations.

Como desafio poderiamos implementar novas funcionalidades neste exemplo, como validar tamanhos de uma String ou algo desse tipo. Agora é com vc!

Até a próxima, []'s.

• annotation_infra.zip

• http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
• http://en.wikipedia.org/wiki/Java_annotation