Explicación detallada de los conceptos básicos de la anotación del lenguaje Java

1. RetentionPolicy. Cuando el archivo Java se compila en un archivo de clase, la anotación se abandona;

2. RetentionPolicy.Class: la anotación se retiene al archivo de clase, pero se abandona cuando JVM carga el archivo de clase. Este es el ciclo de vida predeterminado;

3. RetentionPolicy.Runtime: la anotación no solo se guarda en el archivo de clase, sino que aún existe después de que JVM carga el archivo de clase;

Estos tres ciclos de vida corresponden a: archivo fuente Java (archivo .java) --->. Archivo de clase ----> bytecode en la memoria.

Entonces, ¿cómo eliges el ciclo de vida de la anotación adecuado?

En primer lugar, debemos aclarar la fuente del ciclo de vida de la fuente <class <Runtime, por lo que donde el primero puede actuar, el segundo puede actuar. En general, si necesita obtener información de anotación dinámica en tiempo de ejecución, solo puede usar la anotación de tiempo de ejecución; Si desea realizar algunas operaciones de preprocesamiento en el momento de la compilación, como generar algún código auxiliar (como Butterknife), puede usar la anotación de clase; Si solo realiza algunas operaciones de verificación, como @Override y @SupessWarnings, puede usar la anotación de origen.

La siguiente es una aplicación simple de anotaciones de tiempo de ejecución.

Obtener anotación

Debe obtener anotaciones de tiempo de ejecución a través de la reflexión, que se pueden obtener del paquete, clase, campo, método ... los métodos básicos son los mismos. Varios métodos comunes son los siguientes:

 /*** Obtenga la anotación del tipo especificado*/public <a extiende anotación> a getAnnotation (clase <a> anotationType);/*** Obtenga todas las anotaciones, si alguna*/anotación pública [] getAnnotations ();/*** obtenga todas las anotaciones, ignore las anotaciones*/anotaciones públicas [] getDeCannotations (); existe en este elemento, returue verdadero si hay, de lo contrario, falso*/pública boolean isannotationPresent (class <? extiende la anotación> anotationType);/***Obtenga todas las anotaciones para los parámetros en el método*/anotación pública [] [] getparameterNotations ();

Para usar estas funciones, primero debe obtener los elementos correspondientes a través de la reflexión: clase, campo, método, etc.

Anotaciones personalizadas

Echemos un vistazo a la forma simple de usar anotaciones personalizadas. Aquí primero definimos 3 anotaciones de tiempo de ejecución:

 // Clase aplicable, interfaz (incluido el tipo de anotación) o enum @Retention (retentionPolicy.Runtime) @Target (elementType.type) public @interface classInfo {String value (); } // Atributos de campo aplicables, también incluyen enum constantes @Retention (retentionPolicy.Runtime) @Target (elementType.field) public @Interface FieldInfo {int [] value (); } // Método aplicable @Retention (retentionPolicy.Runtime) @Target (elementType.method) public @Interface MethodInfo {String Name () predeterminado "Long"; String data (); int Age () predeterminado 27; }

Estas tres anotaciones son aplicables a diferentes elementos y todos tienen diferentes atributos. Al usar anotaciones, debe establecer estos valores de atributos.

Defina otra clase de prueba para usar estas anotaciones:

 /*** Test Annotation*/@classInfo ("Test Class") Class pública TestRunteMeanNotation {@FieldInfo (value = {1, 2}) public String String FieldInfo = "FileDInfo";@FieldInfo (value = {10086}) public int i = 100; @methodinfo (name = "BlueBird", data, ",") getMethodinfo () {return testRunteMeanNotation.class.getSimplename ();}}

Todavía es muy simple de usar. Finalmente, veamos cómo obtener información de anotación en el código:

 /*** Test Runtime Annotation*/private void _testruntIneanNotation () {StringBuffer sb = new StringBuffer (); class <?> Cls = testRunTimeanNotation.class; constructor <?> [] constructores = cl.getConductors (); // Obtenga la anotación del tipo especificado SB.append ("Class Annotation: Annotation: Annotation: Annotation: Annotation:" Annotation: "Annotation:" ") .Append ("/n "); classInfo classInfo = cls.getAnnotation (classInfo.class); if (classInfo! = null) {sb.append (modifier.ToString (cls.getModifiers ())). append (" ") .Append (cls.getSimphename ()). Append ("/""); valor: ") .append (classInfo.value ()). append ("/n/n ");} sb.append (" annotación de campo: ") .append ("/n "); campo [] fields = cls.getDeClaredFields (); for (campo campo: campos) {fieldinfo fieldinfo.getannotatation (fieldinfiels); (fieldInfo! = null) {sb.append (modifier.ToString (field.getModifiers ())). append ("") .append (field.gettype (). getSimplename ()). append ("") .append (field.getName (). Append ("/n"); sb.append ("valor de annotación:" valor de annotación: ") .Append (arrays.toString (fieldInfo.Value ())). append ("/n/n ");}} sb.append (" anotación del método: ") .append ("/n "); métodos = métodos = cls.getDeclaredMethods (); para (método: método: método) {método MethodInfo = Method.getAnnotation (MethodInfo.Class); if (MethodInfo! = NULL) {SB.Append (Modifier.ToString (Method.getModifiers ())). Append ("") .Append (Method.getRetReturType (). .Append (método.getName ()). append ("/n"); sb.append ("valor de anotación:") .Append ("/n"); sb.append ("name:") .Append (métodos.name ()). append ("/n"); sb.pend ("datos:: ") .Append (MethodInfo.Data ()). Append ("/n "); sb.append (" Age: ") .Append (MethodInfo.age ()). Append ("/n ");}} System.out.print (sb.ToString ());}

Las operaciones se realizan para obtener el elemento correspondiente a través de la reflexión, luego obtener la anotación en el elemento y finalmente obtener el valor de atributo de la anotación.

Echemos un vistazo a la salida, aquí la mostraré directamente en mi teléfono:

Resumir

Lo anterior es toda la explicación detallada de los conceptos básicos de la anotación del lenguaje Java, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!