Anotaciones personalizadas de Java
Las anotaciones de Java son una meta información adjunta al código, que se utiliza para analizar y usar algunas herramientas durante la compilación y el tiempo de ejecución, y sirven como funciones de explicación y configuración.
Las anotaciones no afectarán y no pueden afectar la lógica real del código, y solo jugarán un papel auxiliar. Incluido en el paquete java.lang.annotation.
1. Meta nota
La metaanotación se refiere a la anotación de la anotación. Incluyendo cuatro tipos: @Trentent @Target @Document @inhereded.
1.1. @Retention: Defina la estrategia de retención de las anotaciones
@Retention (RetentivePolicy.source) // La anotación solo existe en el código fuente y no contiene @Retention (retenciónPolicy.Class) // Se utiliza la política de retención predeterminada. La anotación existirá en el archivo de Bytecode de clase, pero no se puede obtener en tiempo de ejecución. @Retention (retenciónPolicy.Runtime) // La anotación existirá en el archivo de Bytecode de clase y se puede obtener a través de la reflexión en tiempo de ejecución.
Clase de anotación:
@Retention (retenciónPolicy.Runtime) // La anotación existirá en el archivo de Bytecode de clase. @Target ({{elementType.field, elementType.method} se puede obtener a través de la reflexión en tiempo de ejecución // define el objetivo de la anotación ** el rango del campo y el constante de enumeración/método @documentado // indica que la anotación se incluirá en el público Javadoc @interface Fieldmeta {/***es un número de serial* @@return* falso;/*** nombre de campo* @return*/string name () predeterminado "" ";/*** es editable* @return*/boolean editable editable verdadero verdadero;/*** si se muestra en la lista* @return*/boolean summary () default true;/*** descripción de campo* @return*/string description () predeterminado";/*** sorts* @return* @return Clase de entidad:
public class Annno {@FieldMeta (id = true, name = "número de serie", orden = 1) private int id; @FieldMeta (name = "name", orden = 3) name de cadena privada; @FieldMeta (name = "edad", orden = 2) private int age; @FieldMeta (descripción = "Descripción", Order = 4) public String Desc () {return "Test of Java Reflection a OB {return id;} public void setid (int id) {this.id = id;} public String getName () {return name;} public void setName (name de cadena) {this.name = name;} public int getAge () {return Age;} public void setage (int aud) {this.age = edad;}} Obtenga la clase de ayuda para la anotación:
public class SortableField {public sortableField () {} public sortablefield (fieldmeta meta, campo campo) {super (); this.meta = meta; this.field = field; this.name = field.getName (); this.type = field.gettype ();} public sortfield (fieldmeta meta, string name, class <?> type) {super (); = name; this.type = type;} private fieldmeta meta; private campo campo; privado name de cadena; clase privada <?> type; public fieldmeta getMeta () {return meta;} public void setMeta (fieldmeta meta) {this.meta = meta;} public getField () {return;} setfield (campo de campo) {this.field = campo; {nombre de retorno;} public void setName (name de cadena) {this.name = name;} public class <?> getType () {return type;} public void settype (class <?> type) {this.type = type;}} Para obtener anotaciones en tiempo de ejecución, primero cree una clase base:
Public Class Parent <T> {private class <t> entity; public parent () {init ();}@supressWarnings ("sin verificar") Lista pública <AdtableField> init () {list <AdableField> List = New ArrayList <AdtableField> ();/** GetClass (). (clase, interfaz, tipo primitivo o nulo) *, y luego lo convierte en parametrizedType. . * GetActualTyPearGuments () Devuelve una matriz de objetos de tipo que representan los parámetros de tipo reales de este tipo. * [0] es el primero en esta matriz. . * En resumen, es obtener el tipo real de parámetros genéricos de la superclase. . */entity = (class <t>) ((parameterizedType) this.getClass (). campos, pero no incluyen campos heredados* entity.getfields (); Solo devuelve todos los campos públicos accesibles de la clase o interfaz representados por el objeto*en la clase getDeclared ** () El método devuelve campos, métodos, etc. con todos los permisos de acceso; * Ver api * */field [] fields = entity.getDeClaredFields (); // for (campo f: fields) {// Obtener la anotación que contiene fieldmeta fieldmeta meta = f.getAnnotation (fieldmeta.class); if (meta! = Null) {sortablefield sf = new sortablefield (meta, f); list.add (sf); Todos los métodos públicos accesibles de la clase o interfaz representados por el método de objeto [] métodos = entity.getMethods (); para (método m: métodos) {fieldmeta meta = m.getAnnotation (fieldmeta.class); if (meta! = null) {sortablefield sf = new shortableField (meta, m.getName (), m.getReturnType ()); list.add (sf);}} // Este método es crear una nueva clase de campo para implementar el interface de comparación para el comparación para el comparación para el método de comparación para el comparación para el comparar el método de comparación. sorting // collections.sort (list, new FieldSortCom ()); colección.sort (lista, nuevo comparador <AdtableField> () {@OverridePublicC int Compare (SortableField S1, OrdleableField S2) {return S1.getMeta (). Order ()-S2.GetMeta (). Order (); // return s1.getName (). Compareeta (sog2.); También puede usar comparar para comparación}});} lista de retorno;}} Cree una subclase para heredar la clase base:
El niño de clase pública extiende a los padres <nno> {} Clase de prueba:
Public Class TestAnnotation {@SupplesSwarnings ({"no verchado", "RawTypes"}) public static void main (string [] args) {parent c = new Child (); list <dastableField> list = c.init (); // Obtenga la anotación en la clase en la clase de genérica // resultado de salida para (sortablefield l: list) {system.out.out.println (name: ("Fieldsn (" Fieldln ("Fieldln (" "Fieldln (" Fieldln ("FieldLn (" Fieldln ("". "+l.getName ()+"/t Tipo de campo: "+l.gettype ()+"/t Nombre de anotación: "+l.getmeta (). name ()+"/t annotation Descripción: "+l.getMeta (). Descripción ());}}}/////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
1. El principio de funcionamiento de la anotación:
JDK5.0 proporciona funcionalidad de anotación, lo que permite a los desarrolladores definir y usar sus propios tipos de anotación. Esta función consiste en una sintaxis que define el tipo de anotación y una sintaxis que describe la declaración de anotación, una API que lee la anotación, un archivo de clase que utiliza la anotación para modificar y la herramienta de procesamiento de anotaciones.
La anotación no afecta directamente la semántica del código, pero puede considerarse como la herramienta o la biblioteca de clases de un programa. A su vez tendrá algún efecto en la semántica del programa en ejecución.
La anotación se puede leer de varias maneras a través de un mecanismo de reflexión durante el tiempo de ejecución.
2. @Override Annotation:
java.lang
Anulación de tipo de comentario
@Target (valor = método)
@Retention (valor = fuente)
Public @Interface Override significa que una declaración de método tiene la intención de anular otra declaración de método en la superclase. Si el método anota con este tipo de anotación pero no anula el método de superclase, el compilador genera un mensaje de error.
La anotación @Override significa que la subclase debe anular el método correspondiente de la clase principal.
Anulación es una anotación marcadora utilizada para identificar la anotación. El nombre de anotación en sí representa la información que se dará al programa de herramientas.
Aquí hay un ejemplo usando @Override Annotation:
Clase A {ID de cadena privada; A (ID de cadena) {this.id = id; } @Override public string toString () {return id; }}3. @@Depreced Anotation:
java.lang
Tipo de comentario desaprobado
@Documented
@Retention (valor = tiempo de ejecución)
Public @Interface Elementos del programa desaprobado anotados con @Depreced, los programadores se desalienta de usar tales elementos, generalmente porque es peligroso o hay mejores opciones. El compilador advierte cuando usa elementos del programa no aprobados o realiza reescrituras en código no aprobado.
El método de representación de anotación de @Depreced no se recomienda.
Depreciado es una anotación marcadora.
Aquí hay un ejemplo usando la anotación @Depreced:
Clase A {ID de cadena privada; A (ID de cadena) {this.id = id; } @Depreced public void Execute () {System.out.println (id); } public static void main (string [] args) {a a a = new a ("a123"); A.Execute (); }}4. @SupplessWarnings Anotación:
java.lang
Comentario
@Target (valor = {tipo, campo, método, parámetro, constructor, local_variable})
@Retention (valor = fuente)
public @Interface SupressWarnings indica que la advertencia del compilador especificada no debe mostrarse en el elemento de comentarios (y todos los elementos del programa contenidos en ese elemento de comentarios). Tenga en cuenta que el conjunto de advertencias que no se muestran en un elemento dado es un superconjunto de todas las advertencias que no se muestran en el elemento. Por ejemplo, si comenta una clase para que desbloquee una advertencia y anotes un método para desechar otra advertencia, ambas advertencias no se mostrarán en este método.
Dependiendo del estilo, los programadores siempre deben usar esta anotación en los elementos anidados más interiores, y solo funcionará si se usa allí. Si desea descifrar una advertencia en un método específico, debe comentar el método en lugar de su clase.
@SupessWarnings La anotación indica advertencia de supresión.
Aquí hay un ejemplo usando la anotación de @SupessWarnings:
@SuppressWarnings ("sin verificar") public static void main (string [] args) {list list = new ArrayList (); list.add ("ABC");}5. Anotaciones personalizadas:
Al usar @Interface para anotaciones personalizadas, el compilador completa automáticamente la interfaz java.lang.annotation.annotation, y el compilador completan automáticamente otros detalles. Al definir anotaciones, no se pueden heredar otras anotaciones o interfaces.
Personaliza el comentario más fácil:
public @interface myAnnotation {} Use anotación personalizada: public class AnnotationTest2 {@myannotation public void ejecutute () {system.out.println ("método"); }} 5.1. Agregar variables:
public @Interface MyAnnotation {String value1 ();} Use anotaciones personalizadas: public class AnnotationTest2 {@myannotation (valor1 = "ABC") public void ejecute () {system.out.println ("método"); }}Cuando el nombre del atributo utilizado en la anotación es valor, la interfaz de valor del atributo se puede escribir directamente sin especificar el nombre del atributo al asignarlo; Excepto por los nombres variables inesperados del valor, todos los nombres de variables deben asignarse usando Name = Value.
5.2. Agregar valores predeterminados:
public @interface myAnnotation {String value1 () predeterminado "ABC";}5.3. Enumeración de uso multivariante:
public @interface myAnnotation {string value1 () predeterminado "ABC"; Myenum value2 () predeterminado myenum.sunny;} enum myenum {soleado, lluvioso} Use anotaciones personalizadas:
public class AnnotationTest2 {@myannotation (value1 = "a", value2 = myenum.sunny) public void ejecutute () {system.out.println ("método"); }} 5.4. Variables de matriz:
public @interface myAnnotation {string [] value1 () predeterminado "ABC";} Use anotaciones personalizadas:
public class AnnotationTest2 {@myannotation (value1 = {"A", "b"}) public void ejecutute () {System.out.println ("método"); }}6. Establezca el alcance de la anotación:
@Documented
@Retention (valor = tiempo de ejecución)
@Target (valor = Annotation_Type)
La retención pública @Interface indica cuánto tiempo debe retener la anotación del tipo de anotación. Si no existe una anotación de retención en la declaración de tipo de comentarios, la política de retención predeterminada a RetentionPolicy.class.
Los meta comentarios objetivo solo son válidos cuando el tipo de meta comentario se usa directamente para los comentarios. Si el tipo de meta comentario se usa como miembro de otro tipo de comentario, no es válido.
Public enum retención
Extiende la política de retención de comentarios de Enum <RetentionPolicy. Las constantes para este tipo de enumación describen diferentes estrategias para mantener comentarios. Se utilizan con tipos de meta comentarios de retención para especificar cuánto tiempo se conservan las anotaciones.
CLASE
El compilador registrará comentarios en el archivo de clase, pero la VM no necesita mantener los comentarios en tiempo de ejecución.
Tiempo de ejecución
El compilador registrará los comentarios en el archivo de clase, y la VM conservará los comentarios en tiempo de ejecución, por lo que se puede leer reflexivamente.
FUENTE
Comentarios para descartar el compilador. @Retention Annotation puede proporcionar una política de retención de anotación para los compiladores al definir las anotaciones.
La anotación que pertenece a la política de retención de clase es @SuppressWarnings, que no se almacenará en el archivo .class.
6.1. Ejemplos de uso en anotaciones personalizadas:
@Retention (retentionPolicy.class) public @Interface MyAnnotation {String [] value1 () predeterminado "ABC";}7. Ejemplo de uso de reflexión para leer información de anotación de la política de retención de tiempo de ejecución:
java.lang.reflect
Interfaz anotatedelement
Todas las clases de implementación conocidas:
AccesibleBject, clase, constructor, campo, método, paquete representa un elemento comentado del programa que actualmente se ejecuta en esta VM. Esta interfaz permite la lectura reflexiva de comentarios. Todos los comentarios devueltos por los métodos en esta interfaz son inmutables y serializables. La persona que llama puede modificar la matriz devuelta por el accesor del miembro enumerado de la matriz asignada; Esto no tendrá ningún efecto en la matriz devuelta por otras personas que llaman.
Si un método en esta interfaz devuelve un comentario (directa o indirectamente) que contiene un miembro de clase asignado que hace referencia a una clase que no es accesible en esta VM, intentando leer la clase llamando al método devuelto por la clase relevante en el comentario devuelto dará como resultado una typenotpresentException.
isannotation presente
Boolean isannotationPresent (class <? Extiende Annotation> AnnotationClass) Devuelve verdadero si el comentario del tipo especificado existe en este elemento, de lo contrario devuelve falso. Este método está diseñado principalmente para facilitar el acceso a los comentarios de la etiqueta.
parámetro:
anotationClass - objeto de clase correspondiente al tipo de anotación
devolver:
Devolver verdadero Si el comentario del tipo de comentario especificado existe en este objeto, de lo contrario falso
Tirar:
NullpointerException: si la clase de anotación dada es nula
Comience con la siguiente versión:
1.5
getAnnotation
<T extiende la anotación> t getAnnotation (clase <t> anotationClass) Devuelve estos comentarios si hay comentarios del tipo especificado de este elemento, de lo contrario se devuelve nulo.
parámetro:
anotationClass - objeto de clase correspondiente al tipo de anotación
devolver:
Si los comentarios del tipo de comentario especificado del elemento existen en este objeto, estos comentarios se devuelven, de lo contrario nulo
Tirar:
NullpointerException: si la clase de anotación dada es nula
Comience con la siguiente versión:
1.5
getAnnotations
Anotación [] getAnnotations () Devuelve todos los comentarios que existen en este elemento. (Si no se comenta este elemento, se devuelve una matriz de longitud cero.) El llamado del método puede modificar la matriz devuelta a voluntad; Esto no tendrá ningún efecto en la matriz devuelta por otras personas que llaman.
devolver:
Todos los comentarios que existen en este elemento
Comience con la siguiente versión:
1.5
getDeclaredannotations
Anotación [] getDeclaredAnnotations () Devuelve todos los comentarios que existen directamente en este elemento. A diferencia de otros métodos en esta interfaz, este método ignora las anotaciones hereditarias. (Si no existe ningún comentario directamente en este elemento, se devuelve una matriz de longitud cero). El llamado del método puede modificar la matriz devuelta a voluntad; Esto no tendrá ningún efecto en la matriz devuelta por otras personas que llaman.
devolver:
Todos los comentarios que existen directamente en este elemento
Comience con la siguiente versión:
1.5
Aquí hay un ejemplo de uso de reflexión para leer la información de anotación de la política de retención de tiempo de ejecución:
Anotaciones personalizadas:
@Retention (retenciónPolicy.Runtime) public @Interface MyAnnotation {String [] value1 () predeterminado "ABC";} Use anotaciones personalizadas:
public class AnnotationTest2 {@myannotation (value1 = {"A", "b"}) @deprecated public void ejecutute () {System.out.println ("método"); }} Lea la información en la anotación:
Public static void main (String [] args) lanza SecurityException, nosuchmethodexception, ilegalargumentException, ilegalAccessException, invocationTargetException {AnnotationTest2 AnnotationTest2 = New AnnotationTest2 (); // Instancia GetClass de AnnotationTest2Class <AnnotationTest2> C = AnnotationTest2.Class; // getMethodinStance Method Method Method = C.getMethod ("Ejecutar", nueva clase [] {}); // Determinar si el método contiene anotación de myAnnotation if (método.isannotationPresent (myAnnotation.class)) {// Obtener la instancia de anotación de myAnnotation de este método myAnnotation myAnnotation = método.getAnnotation (myAnnotation.class); // Ejecutar el método Method.Invoke (AnnotationTest2, New Object [] {}); // Get MyAnnotation String [] value1 = myAnnotation.Value1 (); System.out.println (valor1 [0]); } // Obtenga todas las anotaciones en la anotación del método [] anotaciones = método.getAnnotations (); para (anotación de anotación: anotaciones) {system.out.println (anotación); }}8. Uso de anotaciones limitadas:
Anotaciones limitadas usan @Target.
@Documented
@Retention (valor = tiempo de ejecución)
@Target (valor = Annotation_Type)
Public @Interface Target indica el tipo de elementos del programa a los que se aplica el tipo de anotación. Si no existe un meta comentario objetivo en la declaración de tipo de comentarios, el tipo declarado se puede usar en cualquier elemento de programa. Si existe dicho comentario, el compilador aplica el límite de uso especificado. Por ejemplo, este meta comentario indica que el tipo de declaración es en sí mismo, es decir, el tipo de meta comentario. Solo se puede usar en declaraciones de tipo de comentarios:
@Target (elementType.annotation_type) public @Interface MetaAnnotationType {...} Este meta comentario indica que el tipo de declaración solo puede usarse como tipos de miembros en declaraciones de tipo de anotación compleja. No se puede usar directamente para comentarios:
@Target ({}) public @Interface MemberType {...} Este es un error de tiempo de compilación que indica que una constante de ElementType aparece más de una vez en el comentario objetivo. Por ejemplo, los siguientes meta comentarios son ilegales:
@Target ({elementtype.field, elementtype.method, elementtype.field}) public @interface bogus {...} public enum ElementTypeExtiende el tipo de elemento de programa enum <ememantType>. Las constantes de este tipo enum proporcionan una clasificación simple de elementos declarados en un programa Java.
Estas constantes se usan con el tipo de meta comentario objetivo para especificar en qué circunstancias es legal usar el tipo de comentario.
Anotación_type
Declaración de tipo de comentarios
CONSTRUCTOR
Declaración del método del constructor
CAMPO
Declaración de campo (incluidas las constantes de enumeración)
Local_variable
Declaración de variables locales
MÉTODO
Declaración de método
PAQUETE
Declaración de paquete
PARÁMETRO
Declaración de parámetros
TIPO
Clase, interfaz (incluidos tipos de comentarios) o declaración de enumeración
Ejemplos de limitaciones sobre el uso de anotaciones:
@Target (elementType.method) public @Interface MyAnnotation {String [] value1 () predeterminado "ABC";}9. Agregue notas al documento de ayuda:
Para agregar información de anotación al archivo API al crear un archivo javadoc, puede usar java.lang.annotation.documented.
Declare el documento de anotación de compilación en una anotación personalizada:
@DocumentedPublic @Interface MyAnnotation {String [] value1 () predeterminado "ABC";} Use anotaciones personalizadas:
public class AnnotationTest2 {@myannotation (value1 = {"A", "b"}) public void ejecutute () {System.out.println ("método"); }}10. Use la herencia en anotaciones:
Por defecto, las anotaciones no se heredan en subclases. Puede agregar java.lang.annotation.altation Declaración de anotaciones cuando se usan anotaciones personalizadas.
@Documented
@Retention (valor = tiempo de ejecución)
@Target (valor = Annotation_Type)
public @Interface Herherited indica que el tipo de anotación se hereda automáticamente. Si existe una meta anotación hereditaria en la declaración de tipo de comentarios y el usuario consulta el tipo de comentario en una declaración de clase, y no hay comentarios de este tipo en la declaración de clase, el tipo de comentario se consultará automáticamente en la superclase de la clase. Este proceso se repite hasta que se encuentra este tipo de comentario o se alcanza el nivel superior de la jerarquía de clases. Si ninguna superclase tiene una anotación de ese tipo, la consulta indicará que la clase actual no tiene tal anotación.
Tenga en cuenta que si usa el tipo de anotación para comentar algo más que la clase, este tipo de comentario meta no es válido. También tenga en cuenta que este meta comentario solo facilita la herencia de los comentarios de las superclase; No es válido para los comentarios a las interfaces implementadas.
El artículo anterior habla brevemente sobre las anotaciones personalizadas de Java y el uso de la reflexión para obtener anotaciones durante el tiempo de ejecución es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.