@Annotations

02:39 in Annotations, Java

O que são as annotations?
Na verdade uma annotation não é nada, somente um enfeite para seu código. WTF? então como elas servem para fazer alguma coisa? Como que eu anoto com @Id meu JPA e ele reconheçe isso?

Na verdade não é a anotação que vai fazer isso, e sim uma outra classe responsavel por ler suas classes e identificar quais possuem a anotação, e você que criou aquela anotação simples, vai ter que escrever essa classe. Calma não se desespere, vou explicar como funciona :).

Para criar uma Anotação devemos criar uma interface Java, mas com algumas pequenas mudanças vejam a anotação abaixo


public @interface Teste{
String valor();
}


pronto temos uma anotação criada, o campo abaixo é um atributo da anotação algo que a anotação deve obrigatoriamente conter, você pode deixa-la opcional, adicionando a opção "default"


public @interface Teste{
String valor() default "";
}


As anotações são objetos simples, e eles não aceitam valores null. Vc não pode passar um objeto por exemplo seu JPA para uma anotação (infelizmente).

E agora para usar como q faz?
vamos criar uma classe de ajuda para nós aqui, ela será a classe que irá executar o comando:


public class Main{
@Teste(valor="teste")
private String teste;

public static void main(String[] args){

}
}


Nossa anotação esta funcionando, mas se vc executar o programa vc simplesmente não verá nada. Mas por que? A Anotação é so um enfeite, existe toda uma programação em reflection por traz (gambiarra?), mas não é tão complicado assim, vamos criar uma classe AnnotationResolver, que vai verificar as anotações para nós:


public class AnnotationResolver{
private Class classe;
private Field[] fields;
public AnnotationResolver(Class classe){
this.classe = classe;
//Isso é reflection carregamos todos os campos da classe informada
//Esses campos são todos os atributos declarados na classe.
this.fields = classe.getDeclaredFields();
}
public void resolve(){
for(Field f : fields){
//Eis aqui a magica do reflection
//Perguntamos se o campo tem uma anotação, e informamos a classe dessa anotação
if(f.isAnnotationPresent(Teste.class){
//Podemos pegar a instancia da anotação desse campo dessa maneira, e assim
//acessar os campos da anotação
Teste teste f.getAnnotation(Teste.class);
System.out.println(teste.valor());
}
}
}
}


Para testar nossa classe vamo esditar o metodo main da classe Main, o restante do código já informado acima foi omitido


//Codigo omitido
public static void main(String[] args){
new AnnotationResolver(Main.class).resolve();
}


Simples assim temos nossa chamada e veremos nossa anotação funcionando, execute o programa. E vamos ao resultado:

Nada.

WTF? O Que eu fiz errado? por que isso não funciona?
Bom apanhei muito para isso funcionar, a anotação tem que ter algumas anotações também (rá), primeiro você deve indicar em que momento a anotação deve ser verificada e depois informar qual o objetivo dela, se ela atige Classes, Metodos ou campos. basta editar nossa anotação e adicionar:



@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Teste{
//Codigo omitido
}


Meio estranho fazer isso mais eu sempre uso o @Retention como RUNTIME, pois é normalmente a hora que eu gosto que as anotações sejam conferidas. Agora compile e rode seu programa.

E veja só não é que funcionou?
Agora sim você tem um enfeite util para seu projeto Java (nem tão util assim no nosso exemplo).

De uma conferida no docs da sun:

• http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html