Annotations – interfaces "diferentes"

Numa discussão com um amigo, surgiu o tema sobre como classificar uma annotation. Será um interface ou uma classe, visto que embora seja definido com @ interface, podemos atribuir e retirar valores da annotation, indiciando que existe uma implementação dos métodos.

Na realidade, uma annotation é um tipo de interface. Tal como todas as classes que criamos extendem implícitamente a classe Object, sempre que criamos uma annotation esta extende implícitamente o interface Annotation. O interface annotation tem a seguinte definição:

 public interface Annotation { boolean equals(Object obj); int hashpre(); String toString(); Class annotationType(); } 

Se quisermos criar uma nova annotation, podemos declará-la da seguinte forma:

 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @ interface Teste{ String umMembro(); } 

Definimos uma annotation de teste com um membro do tipo String. Definimos com a Retention que a annotation vai estar disponível em runtime, e definimos no target que esta annotation pode ser utilizada em métodos. Utilizaríamos a annotation, por exemplo, neste simples bloco de código:

 public class AnnotationsTest { @Teste(umMembro="textoMembro") public void umMetodo() {} } 

Estamos então a anotar o nosso método com a anotação que criámos anteriormente, e a definir uma propriedade exemplo. A primeira questão a reparar é que a annotation é um interface mas estamos a atribuir-lhe valores quando utilizamos a annotation, e podemos consultar as annotations definidas em run-time (porque colocámos retention = RUNTIME na definição da annotation). Podemos simplesmente, adicionar um método main a esta nossa classe AnnotationsTest para tentar perceber um pouco melhor o que acontece.

 public static void main(String[] args) throws NoSuchMethodException {< AnnotationsTest at = new AnnotationsTest(); Annotation[] annots = at.getClass().getMethod("umMetodo").getAnnotations(); for(Annotation annot : annots) { System.out.println("Annotation? " + annot.annotationTyp
order diflucan
e().isAnnotation()); System.out.println("Interface? " + annot.annotationType().isInterface()); System.out.println("Nome da classe da annotation: " + annot.getClass()); System.out.println("Nome do tipo da annotation: " + annot.annotationType().toString()); Teste t = (Teste) annot; System.out.println("Valor do umMembro: " + t.umMembro()); } } 

Na linha 3, vamos buscar todas as annotations do método umMetodo(). Isto é possível, porque com a introdução das annotations no Java 5, todos os elementos sobre os quais podemos aplicar anotações passaram a implementar o interface AnnotatedElement, que fornece um modo de se aceder às annotations numa classe, método, variável, parametro ou mesmo package. Depois percorremos a anotações e fazemos uns testes para ver o que

nos diz sobre o que é uma anotação. O output é o seguinte:

 Annotation? true Interface? true Nome da classe da annotation: class $Proxy3 Nome do tipo da annotation: interface zonaj.testes.annotations.Teste Valor do umMembro: textoMembro 

As primeiras duas linhas confirma-se o que já se sabia, a Annotation é um interface. Na terceira linha vem a explicação para as nossas dúvidas: a classe da anotação é um $Proxy3, nitidamente um proxy gerado pelo compilador em run-time. Este proxy é que implementa automáticamente os métodos para as propriedades definidadas na nossa anotação, bem como

os métodos do interface Annotation.
Nas duas outras linhas de output, vemos que o annotationType é o Teste que criámos e vemos como obter o valor indicado na anotação do método. Este método de geração de proxies não é muito explicado mas funciona aproximadamente como o Annotation Processing Tool (apt) que é uma aplicação que nos permite criar factories para gerar proxies e processar anotações.
De resto, uma anotação não é uma classe, é um interface. Só é criado um proxy automaticamente para poder ser utilizada.