Apresentando conceitos de Annotations em Java

1. @ Annotations
Natanael Fonseca
Arquiteto de Software

2. Conceito
Adicionam “metadados” que não interferem
diretamente no código anotado, mas que
podem ser utilizadas posteriormente para
obter informações relevantes.
Exemplo:
• @Override
• @SuppressWarnings

3. Diferentes usos
• Fornecer informações para o compilador:
Anotações podem ser utilizadas pelo compilador para detectar errors ou suprimir
warnings.
• Compiler-time and deployment-time processing
Alguns “Software tools” podem processar anotações para gerar código, gerar XML,
realizar validações em campos e etc.
• Processamento em Runtime
Algumas anotações estão disponíveis para serem processadas em Runtime.

4. Usadas pelo Compilador
• @Deprecated
Indica que o elemento marcado está "depreciado" e não deveria mais ser utilizado.
O compilador gera um "warning" quando você utiliza um método que possui esta
anotação.
• @Override
Informa ao compilador que o elemento está sobrescrevendo um outros elemento
declarado na superclasse.
• @SuppressWarnings
Diz ao compilador para suprimir especificos "warnings" que poderiam ser gerados.

5. Criando suas próprias anotações
Segue a mesma regra de criação de uma
interface, mas coloca-se simbolo “@” antes da
palavra chave “interface”.
Ex:
public @interface MyAnnotation {
}

6. Algumas Regras
• A declaração dos métodos não deveriam ter
quaisquer parâmetros, não deveriam lançar
quaisquer exceções e o tipo de retorno deve ser
um dos seguintes:
– Primitivos;
– String;
– Class;
– Enum;
– Array de um dos tipos acima.

7. Meta-Annotation
Conhecidas como Anotação de anotação e
servem para definir o comportamento da
anotação sendo criada, são elas:
– Target
– Retention
– Documented
– Inherited

8. @Target
Indica em qual elemento da classe a anotação pode ser aplicada:
• @Target(ElementType.TYPE) - Pode ser aplicado a qualquer elemento da
classe;
• @Target(ElementType.FIELD) - Pode ser aplicado a um campo ou
propriedade;
• @Target(ElementType.METHOD)- Pode ser aplicado a um método;
• @Target(ElementType.PARAMETER) - Pode ser aplicado a parâmetros de
um método;
• @Target(ElementType.CONSTRUCTOR) - Pode ser aplicado a contrutores;
• @Target(ElementType.LOCAL_VARIABLE) - Pode ser aplicado a variáveis
locais;
• @Target(ElementType.ANNOTATION_TYPE) - Indica que o próprio tipo
declarado é um anotação de anotação;

9. @Retention
Indica onde e quanto tempo as anotações deste
tipo serão obtidas, pode possuir três valores :
• RetentionPolicy.SOURCE – Serão obtidas
somente em nível de fonte e serão ignoradas pelo
compilador;
• RetentionPolicy.CLASS—Serão obtidas apenas
em nível de compilação pelo compilador e serão
ignoradas pela VM;
• RetentionPolicy.RUNTIME— Obtidas pela VM e
Serão lidas apenas em runtime;

10. @Documented e @Inherited
@Documented: Indica se a anotação pertencerá ao
javadoc ou algum outro gerador de documentação
por padrão;
@Inherited: Indica se a anotação será herdada
pelas subclasses automaticamente, sendo assim,
Caso haja uma consulta procurando por uma
anotação qualquer, se a classe consultada não
possuir a anotação a classe pai será consultada por
padrão.

11. Exemplo
@MyAnnotation em nível de Classe
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyAnnotation {
public String name();
public String value();
}

12. Exemplo
@MyAnnotation em nível de classe
@MyAnnotation(name="Natanael Fonseca", value="Qualquer coisa")
public class Pessoa {
private String nome;
private String telefone;
public Pessoa() {
}
}

13. Como processar
@MyAnnotation em nível de classe
public static void main(String[] args) {
Class aClass = Pessoa.class;
Annotation[] annotations = aClass.getAnnotations();
for (Annotation annotation : annotations) {
if (annotation instanceof MyAnnotation) {
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}
}

14. Exemplo
@MyAnnotation em nível de campo
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType. FIELD)
public @interface MyAnnotation {
public String name();
public String value();
}

15. Exemplo
@MyAnnotation em nível de campo
public class Pessoa {
@MyAnnotation(name="Natanael Fonseca", value="Qualquer coisa")
public String nome;
private String telefone;
}

16. Como Processar
@MyAnnotation em nível de Campo
public static void main(String[] args) {
Class aClass = Pessoa.class;
Field[] fields = aClass.getFields(); Obtém os campos públicos da classe,
Sendo assim, somente campos públicos
System.out.print(" Field" + fields.length );
Serão lidos desta forma.
for (Field field : fields) {
System.out.print(" Field" + field.getName() );
Annotation[] annotations = field.getDeclaredAnnotations();
for (Annotation annotation : annotations) {
if (annotation instanceof MyAnnotation) {
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}
}
}

17. Exemplo
@MyAnnotation em nível de método
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType. METHOD)
public @interface MyAnnotation {
public String name();
public String value();
}

18. Exemplo
@MyAnnotation em nível de método
public class Pessoa {
@MyAnnotation(name="Natanael Fonseca", value="Qualquer coisa")
public void exibirMsg(){
}
}

19. Como Processar
@MyAnnotation em nível de método
public static void main(String[] args) {
Class aClass = Pessoa.class;
Method[] metodos = aClass.getMethods(); Obtém os métodos públicos da classe
for (Method method : metodos) {
Annotation[] annotations = method.getDeclaredAnnotations();
for (Annotation annotation : annotations) {
if (annotation instanceof MyAnnotation) {
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("name: " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}
}
}

20. Exemplo
@MyAnnotation em nível de parâmetro
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType. PARAMETER)
public @interface MyAnnotation {
public String name();
public String value();
}

21. Exemplo
@MyAnnotation em nível de parâmetro
public class Pessoa {
public String exibirPessoaConcatenandoCom(
@MyAnnotation(name="Ola", value="Beleza")
String palavra
){
return "";
}
}

22. Como Processar
@MyAnnotation em nível de parâmetro
public static void main(String[] args) {
Class aClass = Pessoa.class;
Method[] methods = aClass.getMethods();
De cada método, obtém as anotações
for (Method method : methods) { aplicadas
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Class[] parameterTypes = method.getParameterTypes();
int i = 0;
for (Annotation[] annotations : parameterAnnotations) {
Class parameterType = parameterTypes[i++];
for (Annotation annotation : annotations) {
if (annotation instanceof MyAnnotation) {
MyAnnotation myAnnotation = (MyAnnotation) annotation;
System.out.println("param: " + parameterType.getName());
System.out.println("name : " + myAnnotation.name());
System.out.println("value: " + myAnnotation.value());
}
}
}
}
}