As anotações Java fornecem algumas informações sobre o código, mas não afetam diretamente o conteúdo do código que anota. Neste tutorial, aprenderemos as anotações Java, como personalizar anotações, o uso de anotações e como analisar anotações por meio de reflexão.
Java 1.5 introduziu anotações, e as anotações são amplamente utilizadas em muitas estruturas Java atuais, como Hibernate, Jersey e Spring. As anotações são incorporadas ao programa como metadados do programa. As anotações podem ser analisadas por algumas ferramentas de análise ou ferramentas de compilação. Também podemos declarar que as anotações têm efeito durante a compilação ou execução.
Antes de as anotações serem usadas, os dados de origem do programa são apenas por meio de anotações java e javadoc, mas as funções fornecidas pelas anotações excedem em muito essas. A anotação não contém apenas metadados, mas também pode ser usada no processo de execução do programa, e o interpretador de anotações pode fixar a ordem de execução do programa por meio da anotação. Por exemplo, em Jersey webservice, adicionamos uma anotação PATH na forma de uma string URI ao método , então o interpretador jerser determinará o método para chamar o URI fornecido durante a execução do programa.
Crie anotações personalizadas em Java
Criar uma anotação customizada é semelhante a criar uma interface, mas a palavra-chave da interface da anotação precisa começar com o símbolo @. Podemos declarar métodos para anotações. Vamos dar uma olhada no exemplo de anotação primeiro e, em seguida, discutir algumas de suas características.
package com.journaldev.annotations;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo{
String author() default 'Pankaj';
String date();
int revision() default 1;
String comments();
}- O método de anotação não pode ter parâmetros;
- O tipo de valor de retorno do método de anotação é limitado a: tipo básico, String, Enums, Annotation ou uma matriz desses tipos;
- Os métodos de anotação podem ter valores padrão;
- A própria anotação pode conter metanotações, que são usadas para anotar outras anotações.
Existem quatro tipos de metanotações:
@ Documented-Indica que o elemento com esta anotação pode ser documentado por ferramentas como javadoc. Este tipo deve ser usado para anotar tipos que afetam o uso do cliente de declarações de elementos anotados. Se uma declaração for anotada com Documented, este tipo de anotação será usado como a API pública do membro do programa marcado.
@Target ——Especifique o intervalo de elementos do programa que podem ser anotados por este tipo de anotação. O valor desta meta-anotação pode ser TYPE, METHOD, CONSTRUCTOR, FIELD, etc. Se a meta-anotação de destino não aparecer, então a anotação definida pode ser aplicada a qualquer elemento do programa.
@Inherited -Indica que o tipo de anotação é herdado automaticamente. Se o usuário consultar o tipo de metanotação na classe atual e a declaração da classe atual não contiver esse tipo de metanotação, ele também consultará automaticamente se há uma metanotação herdada na classe pai da classe atual. Esta ação será repetida para saber o tipo de anotação Foi encontrado ou consultado para a classe pai de nível superior.
@Retention ——Especifica por quanto tempo a anotação é retida. O valor de RetentionPolicy é SOURCE, CLASS, RUNTIME.
Anotações integradas em Java
Java fornece três anotações integradas.
@Override -Quando quisermos sobrescrever o método na classe pai, precisamos usar esta anotação para informar ao compilador que queremos sobrescrever este método. Dessa forma, o compilador exibirá uma mensagem de erro quando o método na classe pai for removido ou alterado.
@Deprecated —— Quando queremos que o compilador saiba que um método não é recomendado, devemos usar esta anotação. Java recomenda o uso desta anotação no javadoc, devemos fornecer porque este método não é recomendado e métodos alternativos.
@SuppressWarnings -Isto apenas diz ao compilador para ignorar mensagens de aviso específicas, como o uso de tipos de dados nativos em genéricos. Sua política de retenção é SOURCE (nota do tradutor: válida no arquivo fonte) e é descartada pelo compilador.
Vejamos um exemplo de anotações integradas em Java, consulte as anotações personalizadas mencionadas acima.
package com.journaldev.annotations;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
public class AnnotationExample {
public static void main(String[] args) {
}
@Override
@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 1)
public String toString() {
return 'Overriden toString method';
}
@Deprecated
@MethodInfo(comments = 'deprecated method', date = 'Nov 17 2012')
public static void oldMethod() {
System.out.println('old method, don't use it.');
}
@SuppressWarnings({ 'unchecked', 'deprecation' })
@MethodInfo(author = 'Pankaj', comments = 'Main method', date = 'Nov 17 2012', revision = 10)
public static void genericsTest() throws FileNotFoundException {
List l = new ArrayList();
l.add('abc');
oldMethod();
}
}Acredito que este exemplo pode ser autoexplicativo e pode mostrar a aplicação em diferentes cenários.
Análise de anotação Java
Usaremos tecnologia de reflexão para analisar as anotações das classes java. Em seguida, a RetentionPolicy da anotação deve ser definida como RUNTIME, caso contrário, as informações de anotação da classe java estarão indisponíveis durante a execução, portanto, não podemos obter dados relacionados à anotação dela.
package com.journaldev.annotations;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
public class AnnotationParsing {
public static void main(String[] args) {
try {
for (Method method : AnnotationParsing.class
.getClassLoader()
.loadClass(('com.journaldev.annotations.AnnotationExample'))
.getMethods()) {
// checks if MethodInfo annotation is present for the method
if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
try {
// iterates all the annotations available in the method
for (Annotation anno : method.getDeclaredAnnotations()) {
System.out.println('Annotation in Method ''+ method + '' : ' + anno);
}
MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
if (methodAnno.revision() == 1) {
System.out.println('Method with revision no 1 = '+ method);
}
} catch (Throwable ex) {
ex.printStackTrace();
}
}
}
} catch (SecurityException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}Executar o programa acima resultará em:
Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)
Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)
Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)Este é todo o conteúdo deste tutorial, espero que você possa aprender algo com ele.
Finalmente
Responda aos dados por mensagem privada para receber um resumo das perguntas da entrevista em Java de um grande fabricante + manual do Alibaba Taishan + um guia de aprendizagem para pontos de conhecimento + um resumo dos pontos de conhecimento básicos do Java em um documento pdf de 300 páginas!
O conteúdo desses materiais são todos os pontos de conhecimento que o entrevistador deve perguntar durante a entrevista. O capítulo inclui muitos pontos de conhecimento, incluindo conhecimento básico, coleções Java, JVM, simultaneidade multi-thread, princípios de primavera, microsserviços, Netty e RPC, Kafka , Diário, padrão de design, algoritmo Java, banco de dados, Zookeeper, cache distribuído, estrutura de dados, etc. 