Java: Anotações, ClassLoader e Reflexão

Bom, neste exemplo vamos construir uma classe "base" para ser utilizada dentro da camada onde tratamos as requisições Http. Desta forma, iremos automatizar o preenchimento de objetos a partir de parâmetros existentes no pedido HTTP. 

Vamos começar por criar a anotação @Inspect que será utilizada para marcar métodos a serem executados em um processo durante o processamento de auto preenchimento.

Ex.:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Inspect {
    public String attributeName() default "";
}

No exemplo acima a anotação "Inspect" possui um atributo chamado "attributeName" que será utilizado para indicar o elemento a ser pesquisado, para ser considerado no momento da utilização do método ao qual a notação estiver associada. Veremos isto mais adiante.

Como já foi explicado, as anotações possuem escopo e deve ser explicitado o nível de disponibilidade. Para isto utilizamos os elementos "@Target" e o "@Retention".

O próximo passo será criar a classe "base" com a lógica necessária para fazer a carga automática, utilizando eventuais anotações existentes.

Ex.:

public class ParamsInspect {
   public boolean autoLoad (HttpServletRequest request) {
      String chave = null;
      Annotation anno = null;
      Class<?> clazz = this.getClass();
      for (Method method : clazz.getDeclaredMethods()) {
         if (method.isAnnotationPresent(Inspect.class) //Possui a anotação Inspect
             && method..getParameters().size()==1 //Possui apenas 1 argumento
             && (method..getParameter(0) instanceof String )) {  //O argumento é String
            anno = method.getAnnotation(Inspect .class);
            chave = anno.attributeName();
            if (request.getParameter(chave)!=null) {
               method.invoke(request.getParameter(chave));
            } else if (request.getAttribute(chave)!=null ) {
               method.invoke(request.getAttributer(chave));
            }//if-else
         }//if
      }//for
   }
}

A nossa classe base "ParamsInspect" possui o método "autoLoad" que irá fazer uma auto avaliação em busca de métodos que estejam anotados com a anotação "@Inspect" e que possuam apenas 1 argumento do tipo "String".

Em seguida será verificado no elemento "request", a presença de algum valor associado ao identificado "attributeName", que for definido junto a anotação do método.

E sempre que estas condições forem encontradas, o método em questão será executado, buscando nos parâmetros ou atributos do elemento "request" e passando-o como argumento na chamada do método.

Para que este procedimento fique claro, vamos agora construir uma classe derivada de nossa classe base "ParamsInspect.

Ex.:
public class Bicicleta extends ParamsInspect {
   private String marca;
   private String modelo;
   private int nroMudancas;

   //Setter methods
   @Inspect(attributeName="marcaBike")
   public void setMarca (String marca) {
      this.marca = marca;
   }

   @Inspect(attributeName="modeloIndicado")
   public void setModelo (String modelo) {
      this.modelo = modelo;
   }
  
   @Inspect(attributeName="mudanca")
   public void setNroMudancas (String nro) {
      this.nroMudancas = Integer.parseInt(nro!=null?nro:0);
   }

   public void setNroMudancas (int nro) {
      this.nroMudancas = nro;
   }
 
   @Inspect(attributeName="qqCoisa")
   public void outroMetodoQualquer (String valor) {
      System.out.println(valor);
   }

  //Getter methods
}

//Dentro do método "service" da "Servlet" temos o seguinte código...
public void service (HttpServletRequest request, HttpServletResponse response) {
   ...
   Bicicleta bicicleta = new Bicicleta();
   bicicleta.autoLoad(request);
   ...
}

A analisar o exemplo anterior existe o pressuposto de que o Request HTTP deva possuir os parâmetros: marcaBike, modeloIndicado, mudanca, qqCoisa.

Então no método "service" estamos a instanciar um objeto do tipo "Bicicleta" e utilizamos o modelo que criamos, o "autoLoad", para preencher o objeto com os valores existentes no elemento "request".

Observe que o atributo "attributeName" que criamos para a nossa anotação "@Inspect" nos permite a flexibilidade de buscar qualquer valor dentro do "request". Ou seja, não precisamos padronizar de forma ao elemento do "request" ter o mesmo nome do atributo da classe. Assim ficamos com maior flexibilidade.

Outro ponto importante do exemplo é o método "outroMetodoQualquer", este foi adicionado para mostrar que não estamos restritos a métodos "setters". Podemos criar métodos e utilizá-los de forma dinâmica, desde que atendam a assinatura padronizada em nossa nova funcionalidade. Ou seja, possua apenas 1 argumento do tipo "String".

O atributo "nroMudancas" foi adicionado do tipo "int" para mostrar que, nestes casos, será necessário criar uma "versão" do "setter" com argumento "String" que seja capaz de resolver e guardar o valor no respetivo atributo da classe.

Então, repare que após o código "bicicleta.autoLoad(request)" ser processado, o objeto "bicicleta" já possuirá valores em seu interior. Os valore do fornecidos no "request". Com isto criamos uma funcionalidade que nos permite reduzir bastante o número de linhas de código necessárias sempre que estamos a fazer este "parse" de "Elementos Web" para objetos Java.

Poderíamos aqui imaginar inúmeras novas funcionalidades genéricas a serem implementadas em classes base para automatizar rotinas corriqueiras na programação. Podemos adicionar um método a nossa classe base (parseToEntity(Object obj) ) para converter o nosso objeto em uma entidade Hibernate. Adotando a mesma estratégia; criar uma anotação para ser utilizada nas classes "Entities" que serão utilizadas no argumento "obj", do método "parseToEntity".

Ou seja, após realizar o "parse" já poderíamos guardar as informações em base de dados, através do próprio Hibernate "save()".

Busca de Anotações no Contexto