Anotaciones de Java

Las anotaciones de Java proporcionan información sobre el código. Las anotaciones de Java no tienen un efecto directo en el código que anotan. En el tutorial de anotaciones de Java, veremos lo siguiente;

1. Anotaciones Java integradas
2. Cómo escribir anotaciones personalizadas
3. Uso de anotaciones y cómo analizar anotaciones utilizando API de Reflexión .

Anotaciones de Java

Java 1.5 introdujo anotaciones y ahora se usa ampliamente en marcos de Java EE como Hibernate, Jersey y Spring. La anotación de Java es metadatos sobre el programa incrustados en el propio programa. Puede ser analizado por la herramienta de análisis de anotaciones o por el compilador. También podemos especificar la disponibilidad de la anotación tanto para el tiempo de compilación como hasta el tiempo de ejecución. Antes de las anotaciones de Java, los metadatos del programa estaban disponibles a través de comentarios en Java o mediante Javadoc, pero la anotación ofrece más que eso. Los metadatos de las anotaciones también pueden estar disponibles en tiempo de ejecución y los analizadores de anotaciones pueden usarlo para determinar el flujo del proceso. Por ejemplo, en el servicio web de Jersey agregamos la anotación PATH con una cadena URI a un método y en tiempo de ejecución, Jersey lo analiza para determinar el método a invocar para el patrón URI dado.

Anotación Personalizada de Java

Creando una anotación personalizada es similar a escribir una interfaz, excepto que la palabra clave de la interfaz se antecede con el símbolo _@_. Podemos declarar métodos en la anotación. Veamos un ejemplo de anotación personalizada en Java y luego discutiremos sus características y puntos importantes.

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();
}

Algunos puntos importantes sobre las anotaciones en Java son:

1. Los métodos de anotación no pueden tener parámetros.
2. Los tipos de retorno de los métodos de anotación están limitados a primitivos, String, Enums, Annotation o matrices de estos.
3. Los métodos de anotación en Java pueden tener valores predeterminados.
4. Las anotaciones pueden tener metaanotaciones adjuntas a ellas. Las metaanotaciones se utilizan para proporcionar información sobre la anotación.

Metaanotaciones en Java

Existen cinco tipos de metaanotaciones:

1. @Documented – indica que los elementos que utilizan esta anotación deben ser documentados por Javadoc y herramientas similares. Este tipo debe usarse para anotar las declaraciones de tipos cuyas anotaciones afectan el uso de elementos anotados por sus clientes. Si una declaración de tipo está anotada con Documented, sus anotaciones se convierten en parte de la API pública de los elementos anotados.
2. @Objetivo – indica los tipos de elementos de programa a los que se aplica un tipo de anotación. Algunos valores posibles son TYPE, METHOD, CONSTRUCTOR, FIELD, etc. Si la meta-anotación Target no está presente, entonces la anotación se puede usar en cualquier elemento de programa.
3. @Heredado – indica que un tipo de anotación se hereda automáticamente. Si un usuario consulta el tipo de anotación en una declaración de clase y la declaración de clase no tiene ninguna anotación para este tipo, entonces se consultará automáticamente la superclase de la clase para el tipo de anotación. Este proceso se repetirá hasta que se encuentre una anotación para este tipo o se alcance la parte superior de la jerarquía de clases (Object).
4. @Retencion – indica cuánto tiempo se retendrán las anotaciones con el tipo anotado. Toma un argumento RetentionPolicy cuyos valores posibles son SOURCE, CLASS y RUNTIME
5. @Repetible – se utiliza para indicar que el tipo de anotación cuya declaración anota es repetible.

Anotaciones integradas en Java

Java proporciona cinco anotaciones integradas.

1. @Override – Cuando queremos anular un método de la superclase, debemos usar esta anotación para informar al compilador que estamos anulando un método. Así que cuando el método de la superclase se elimina o se cambia, el compilador mostrará un mensaje de error. Aprende por qué siempre debemos usar la anotación de anulación de Java al anular un método.
2. @Deprecated – cuando queremos que el compilador sepa que un método está obsoleto, debemos usar esta anotación. Java recomienda que en javadoc proporcionemos información sobre por qué este método está obsoleto y cuál es la alternativa a usar.
3. @SuppressWarnings – Esto es simplemente para indicar al compilador que ignore advertencias específicas que producen, por ejemplo, el uso de tipos sin procesar en genéricos de Java. Su política de retención es SOURCE y es descartada por el compilador.
4. @FunctionalInterface – Esta anotación fue introducida en Java 8 para indicar que la interfaz está destinada a ser una interfaz funcional.
5. @SafeVarargs – Una afirmación del programador de que el cuerpo del método o constructor anotado no realiza operaciones potencialmente inseguras en su parámetro varargs.

Ejemplo de Anotaciones en Java

Vamos a ver un ejemplo en Java que muestra el uso de anotaciones integradas en Java, así como el uso de una anotación personalizada creada por nosotros en el ejemplo anterior.

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();
	}

}

I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

Análisis de Anotaciones en Java

Utilizaremos Reflexión para analizar las anotaciones en Java desde una clase. Por favor, tenga en cuenta que la Política de Retención de Anotaciones debería ser RUNTIME de lo contrario su información no estará disponible en tiempo de ejecución y no podremos obtener ningún dato de ella.

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()) {
				// comprueba si la anotación MethodInfo está presente para el método
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// itera todas las anotaciones disponibles en el método
						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();
		}
	}

}

La salida del programa anterior es:

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)

La API de Reflexión es muy potente y se utiliza ampliamente en Java, en los frameworks J2EE como Spring, Hibernate, JUnit, echa un vistazo a Reflexión en Java. Eso es todo para el tutorial de ejemplo de anotaciones en Java, espero que hayas aprendido algo de él. Actualizaciones de Anotaciones en Java:

1. Especificaciones del Servlet 3.0 introdujeron el uso de anotaciones para la configuración de Servlet y los parámetros de inicialización, lee más en Tutorial de Java Servlet.
2. Podemos usar anotaciones en Struts 2 para configurar las clases de acción y las páginas de resultado, consulta un ejemplo funcional en Ejemplo de Anotaciones de Hola Mundo de Struts 2.

Referencia: sitio web de Oracle