Upload
natanael-fonseca
View
1.606
Download
0
Embed Size (px)
DESCRIPTION
Apresentando conceitos de Annotations em Java
Citation preview
Annotations
Natanael FonsecaArquiteto 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
@TargetIndica 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 @interface MyAnnotation { 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
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType. FIELD)
public @interface MyAnnotation { public String name(); public String value();}
Exemplo@MyAnnotation em nível de campo
public class Pessoa {
@MyAnnotation(name="Natanael Fonseca", value="Qualquer coisa")
public String nome; private String telefone;
}
Como Processar@MyAnnotation em nível de Campo
public static void main(String[] args) {
Class aClass = Pessoa.class;
Field[] fields = aClass.getFields();
System.out.print(" Field" + fields.length ); 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()); } }
} }
Obtém os campos públicos da classe,Sendo assim, somente campos públicosSerão lidos desta forma.
Exemplo@MyAnnotation em nível de método
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType. METHOD)
public @interface MyAnnotation { public String name(); public String value();}
Exemplo@MyAnnotation em nível de método
public class Pessoa {
@MyAnnotation(name="Natanael Fonseca", value="Qualquer coisa")
public void exibirMsg(){ }
}
Como Processar@MyAnnotation em nível de método
public static void main(String[] args) {
Class aClass = Pessoa.class;
Method[] metodos = aClass.getMethods();
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()); } }
}
}
Obtém os métodos públicos da classe
Exemplo@MyAnnotation em nível de parâmetro
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType. PARAMETER)
public @interface MyAnnotation { public String name(); public String value();}
Exemplo@MyAnnotation em nível de parâmetro
public class Pessoa {
public String exibirPessoaConcatenandoCom( @MyAnnotation(name="Ola", value="Beleza") String palavra ){ return ""; } }
public static void main(String[] args) {
Class aClass = Pessoa.class;
Method[] methods = aClass.getMethods();
for (Method method : methods) {
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()); } } } }}
De cada método, obtém as anotações aplicadas
Como Processar@MyAnnotation em nível de parâmetro