El uso de la anotación Anotación comprensión en profundidad de las anotaciones en Java Meta anotación de anotaciones personalizadas

anotación

1. Concepto

(1) Anotación: se usa para explicar el programa, para que la computadora vea, nuevas características después del
uso de JDK1.5 :@注解名称

(2) Anotación: Describe el programa en texto para los codificadores.

2. Función

(1) Escribe un documento
Genera un documento de documento a partir de las anotaciones identificadas en el código:

① Crea una clase

/**
 * 注解javadoc演示
 * @author 周杰伦  表示此类(文档)作者
 * @version 1.0  表示此类(文档)的版本
 * @since 1.8  表示从JDK1.8之后可以使用此类
 */
public class AnnoDemo1 {
    
    
    /**
     * 计算两数的和
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     */
    public int add(int a, int b ){
    
    
        return a + b;
    }
}

② Utilice las instrucciones de javadoc para este archivo java

③ Abra el archivo doc

(2) Análisis de código: utilice la reflexión para analizar el código a través de las anotaciones en el código.

(3) Verificación de compilación: realice la verificación de compilación a través de anotaciones, como@Override

3. Anotaciones personalizadas

(1) Formato

public @interface 注解名称 {
    
    
// 属性列表；
}

(2) Esencia

Annotation es esencialmente una interfaz que hereda la interfaz de Annotation de forma predeterminada, como sigue:

public interface 自定义注解 extends java.lang.annotation.Annotation {
    
    }

(3) Atributos en anotaciones

Los atributos anotados son métodos abstractos en la interfaz

Reclamación:

① El tipo de valor de retorno de la propiedad:
i. Tipo de datos básicos
ii. Tipo de cadena Cadena
iii. Enumeración
iiii. Nota
iiiii. Matriz de los tipos anteriores
Nota: no se permiten otros tipos como el tipo de clase y el vacío

② Después de definir el atributo, debe asignar un valor al atributo cuando lo use

// 自定义注解
public @interface MyAnno {
    
    
    //以下均为省略了abstract关键字的抽象方法

    Person per(); //枚举类型，其中有P1，P2

    MyAnno2 anno2(); // 注解类型，定义另一个注解MyAnno2

    String[] strs(); // 数组类型

    //使用default关键字给属性赋值，表示默认初始值，
    //则使用注解时，可以不给此属性赋值，而使用默认值
    int value() default 15; //基本数据类型
}

// 使用注解
// 数组赋值时，值使用{}包裹，如果数组中只有一个值，可以省略{}
@MyAnno(per = Person.P1, anno2 = @MyAnno2, strs={
    
    "bbb", "ccc"})
public class Worker {
    
     // 自定义类
    //成员变量、属性
}

Nota:

1. Si solo hay un atributo en la anotación y el nombre es valor, no importa cuál sea el tipo de valor, el valor se puede omitir al asignarlo, y el valor se puede definir directamente, como@SuppressWarnings(“all”)

2. Se pueden usar varias anotaciones diferentes al mismo tiempo para la misma clase o método

4. Meta anotaciones

Las anotaciones que se utilizan para describir las anotaciones. Escriba metaanotaciones en la línea superior de las anotaciones personalizadas. Hay cuatro tipos:

(1) @Target： Describe la posición donde la anotación puede funcionar.
Atributo: ElementType [] value (); Entre ellos, ElementType es un tipo enumerado, valor comúnmente utilizado:

• TYPE significa que puede actuar en la clase
• MÉTODO significa que puede actuar sobre métodos
• FIELD significa que puede actuar sobre variables

(2) @Retention: Describe la etapa en la que se retiene la anotación.
Atributo: valor de RetentionPolicy (); donde RetentionPolicy es un tipo enumerado y su valor es:

• RUNTIME significa que la anotación actual se mantendrá en el archivo de clase y la JVM la leerá. Este valor es el más utilizado y también puede tomar el valor SOURCE, CLASS

(3) @Documented: los comentarios descriptivos se pueden extraer en documentos API

(4) @Inherited: Las anotaciones descriptivas se pueden heredar: si la clase padre usa la anotación descrita por esta meta-anotación, la subclase que hereda esta clase será automáticamente descrita por esta anotación incluso si no escribe ninguna anotación.

@Target({
    
    ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
//自定义注解Pro
public @interface Pro {
    
    
    String className();
    String methodName();
}

5. Obtenga el valor del atributo de la anotación

// 使用上述自定义注解Pro
@Pro(className = "cn.itcast.annotation.Demo1", methodName = "show")
public class ReflectTest {
    
    
    public static void main(String[] args) throws Exception {
    
    
        // 1. 使用该类的字节码文件对象解析注解
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        // 2. 获取指定的注解对象
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        // 第二步其实就是在内存中生成了一个该注解接口的子类实现对象
        
        /*
            public class ProImpl implements Pro{
                public String className(){
                    return "cn.itcast.annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }
            }
        */
        
        // 3. 调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className); //cn.itcast.annotation.Demo1
        System.out.println(methodName); //show
    }
}

Nota: Cuando utilice varias anotaciones, llame al método getAnnotation () del parámetro nulo del objeto Class para obtener todos los objetos de anotación y devolver Annoation []