Java annotation

@ Annotations

Natanael Fonseca
Arquiteto de Software

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

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.

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.

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 {
}

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.

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

@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;

@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;

@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.

Exemplo
@MyAnnotation em nível de Classe

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public String name();
public String value();
}

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() {
}

}

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());
}
}

}

Exemplo
@MyAnnotation em nível de campo

@Target(ElementType. FIELD)
}

Exemplo
@MyAnnotation em nível de campo


public String nome;
private String telefone;

}

Como Processar
@MyAnnotation em nível de Campo


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();

}
}

}
}

Exemplo
@MyAnnotation em nível de método

@Target(ElementType. METHOD)
}

Exemplo


public void exibirMsg(){
}

}

Como Processar


Method[] metodos = aClass.getMethods(); Obtém os métodos públicos da classe
for (Method method : metodos) {

Annotation[] annotations = method.getDeclaredAnnotations();

}
}

}

}

Exemplo
@MyAnnotation em nível de parâmetro

@Target(ElementType. PARAMETER)
}

Exemplo


public String exibirPessoaConcatenandoCom(
@MyAnnotation(name="Ola", value="Beleza")
String palavra
){
return "";
}
}

Como Processar


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++];

System.out.println("param: " + parameterType.getName());
System.out.println("name : " + myAnnotation.name());
}
}
}
}
}

Java annotation

Mais conteúdo relacionado

Mais procurados (20)

Destaque (10)

Semelhante a Java annotation (20)

Mais de Natanael Fonseca (14)

Último (7)

Java annotation