Las anotaciones de Java proporcionan información sobre el código, pero no afectan directamente el contenido del código que anota. En este tutorial, aprenderemos sobre las anotaciones de Java, cómo personalizar las anotaciones, el uso de anotaciones y cómo analizar las anotaciones a través de la reflexión.
Java 1.5 presenta anotaciones, y muchos marcos de Java actualmente utilizan anotaciones ampliamente, como Hibernate, Jersey y Spring. Las anotaciones están integradas en el programa como metadatos del programa. Las anotaciones pueden ser analizadas por algunas herramientas de análisis o herramientas de compilación. También podemos declarar que las anotaciones tienen un efecto durante la compilación o ejecución.
Antes de usar anotaciones, los datos de la fuente del programa solo pasan por anotaciones de Java y Javadoc, pero las anotaciones proporcionan mucho más que estas. Las anotaciones no solo contienen metadatos, sino que también pueden actuar sobre la secuencia de ejecución del programa. El intérprete de anotación puede resolver la orden de ejecución del programa a través de la anotación. Por ejemplo, en Jersey Webservice agregamos una ruta ** ** Anotación en forma de una cadena URI al método, luego, durante el programa en ejecución, el intérprete Jerser determinará que el método llamará al URI dado.
Crear anotaciones personalizadas Java
Crear una anotación personalizada es similar a la creación de una interfaz, pero la palabra clave de la interfaz anotada debe comenzar con el símbolo @. Podemos declarar métodos para la anotación. Primero veamos el ejemplo de anotación, y luego discutiremos algunas de sus características.
paquete 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)@herhherited@retención (retenciónPolicy.Runtime) public @Interface MethodInfo {String Autor () predeterminado 'Pankaj'; Date de cadena (); int revisión () predeterminado 1; Comentarios de cadena ();} El método de anotación no puede transportar parámetros;
Los tipos de valor de retorno del método de anotación se limitan a: tipos básicos, cadenas, enumines, anotaciones o matrices de estos tipos;
Los métodos de anotación pueden tener valores predeterminados;
Las anotaciones en sí mismas pueden contener meta anotaciones, que se utilizan para anotar otras anotaciones.
Aquí hay cuatro tipos de meta anotaciones :
1. @Documented : indica que los elementos que tienen esta anotación pueden ser documentados por herramientas como Javadoc. Este tipo debe usarse para anotar aquellos tipos que afectan la declaración del cliente de usar elementos anotados. Si una declaración se anota utilizando documentado, este tipo de anotación anotada se usa como API pública para el miembro del programa anotado.
2. @Target : indica el alcance de los elementos del programa que las anotaciones de este tipo pueden anotar. Los valores de esta meta anotación pueden ser tipo, método, constructor, campo, etc. Si la meta anotación objetivo no aparece, la anotación definida se puede aplicar a cualquier elemento del programa.
3. @Inherited : indica que el tipo de anotación se hereda automáticamente. Si el usuario consulta este tipo de meta anotación en la clase actual y la declaración de la clase actual no contiene este tipo de meta anotación, también consultará automáticamente si la clase principal de la clase actual tiene una meta anotación hereditaria. Esta acción se repetirá para saber que se ha encontrado el tipo de anotación o se consulta la clase principal en el nivel superior.
4.@Retención : especifica el tiempo que se retiene la anotación. Los valores de retención de retención son fuente, clase, tiempo de ejecución.
Anotaciones incorporadas de Java
Java proporciona tres anotaciones incorporadas.
1. @Override : cuando queremos reescribir el método en la clase principal, debemos usar esta anotación para informar al compilador que queremos reescribir este método. De esta manera, el compilador solicitará un mensaje de error cuando se elimine el método en la clase principal o se produzcan cambios.
2. @Depreced : cuando queremos que el compilador sepa que no se recomienda un método, debemos usar esta anotación. Java recomienda esta anotación en Javadoc, debemos proporcionar por qué no se recomienda este método y los métodos alternativos.
3. @Suppleswarnings : esto es solo para decirle al compilador que ignore mensajes de advertencia específicos, como usar tipos de datos nativos en genéricos. Su política de retención es fuente (nota del traductor: válida en el archivo de origen) y el compilador lo descarta.
Echemos un vistazo a un ejemplo de anotaciones incorporadas en Java, consulte las anotaciones personalizadas mencionadas anteriormente.
paquete 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 @metodInfo (autor = 'Pankaj', comentarios = 'método principal', fecha = 'nov 17 2012', revisión = 1) public string toString () {return 'anversoin toString método';} @desordenado @método (comentarios = 'Métode deprecado', date 17 2012) void Oldmethod () {System.out.println ('Método antiguo, no lo use.');} @SupplesWarnings ({'Unchecked', 'Deprecation'}) @MethodInfo (autor = 'Pankaj', Comentarios = 'Método principal', fecha = '17 2012', revisión = 10) Public StattatS void void Void Void Void () shole nuevo ArrayList (); L.Add ('ABC'); Oldmethod ();}}Creo que este ejemplo puede explicarse por sí mismo y se puede mostrar en diferentes escenarios.
Análisis de anotación de Java
Utilizaremos la tecnología de reflexión para analizar las anotaciones de las clases de Java. Luego, la capacidad de retención de anotación debe establecerse en tiempo de ejecución, de lo contrario, la información de anotación de la clase Java no estará disponible durante la ejecución, por lo que no podemos obtener ningún dato relacionado con la anotación de él.
paquete com.journaldev.annotations; import java.lang.annotation.annotation; import java.lang.reflect.method; public class AnnotationParsing {public static void main (string [] args) {try {for (método método: annotationParsing.Class .getClassLoader () .loadClass (('com.journaldev.annotations.annotationExample') .getMethods ()) {// verificaciones if MethodInfo annotation está presente para el método si el método si el método si el método)). (Method.isannotationPresent (com.journaldev.annotations.methodinfo.class)) {try {// itera todas las anotaciones disponibles en el método para (anno anno: método.getDeClaredAnnotations ()) {System.out.println ('Annotation in Method' '' + Method + ':' + annO); } MethodInfo MethodAnno = Method.getAnnotation (MethodInfo.class); if (Methodanno.revision () == 1) {System.out.println ('Método con la revisión no 1 ='+ método); }} catch (showable Ex) {Ex.PrintStackTrace (); }}}} Catch (SecurityException | ClassNotFoundException e) {E.PrintStackTrace (); }}} Ejecutar el programa anterior saldrá:
Anotación en el método 'public java.lang.string com.journaldev.annotations.annotationExample.ToString ()': @com.journaldev.annotations.methodinfo (autor = Pankaj, revisión = 1, comentarios = método principal, fecha = 17 de noviembre de 2012) Método con revisión no 1 = público java.lang.string com.journaldev.annotations.annotationExample.ToString () Annotation in Method 'Public static void com.journaldev.annotations.annotationExample.oldmethod ()': @java.lang.Depreced () anotación en el método 'público estatic void com.JournalDev.annotations.annotationExample.oldmethod ()' '' @com.journalaldev.annotations.methodinfo (autor = Pankaj, revision = 1, comentarios = método depreciado, fecha = 17 de noviembre de 2012) Método con revisión no 1 = public static void com.journaldev.annotations.annotationExample.oldMethod () Annotation en el método 'pública estábelada java.io.filenotfoundexception ': @com.journaldev.annotations.methodinfo (autor = Pankaj, revisión = 10, comentarios = método principal, fecha = 17 de noviembre de 2012)
Eso se trata de este tutorial, y espero que puedas aprender algo de él.