Anotación (Java)

En relación con el Java de programación del lenguaje, la anotación es un elemento de lenguaje que permite a los metadatos a ser incorporados en el texto original . Este elemento se definió en JSR 175 y se introdujo con la versión Java 5.0.

Las anotaciones comienzan con un signo @. A esto le sigue su nombre. Opcionalmente, puede seguir una lista de parámetros separados por comas, que se incluye entre corchetes. Por ejemplo, en el siguiente extracto del código fuente, la anotación marca la clase A como obsoleta :

@Deprecated
public class A {}

Un procesador de anotaciones es un complemento del compilador que puede evaluar las anotaciones durante la compilación para suprimir o activar advertencias y mensajes de error o para generar código fuente adicional u otros archivos. Sin embargo, no puede cambiar el código anotado. Las anotaciones para las que está destinado también se pueden evaluar en tiempo de ejecución mediante la reflexión .

Las anotaciones se utilizan, entre otras cosas, en el entorno de Jakarta EE para agregar información a las clases que tenían que almacenarse en archivos separados antes de Java 5. Ejemplos destacados son las interfaces locales y domésticas, así como los descriptores de implementación.

Una técnica anterior para incrustar metadatos en el código fuente de Java es el uso de comentarios especiales de Javadoc . Estos fueron evaluados con la ayuda de los llamados doclets . Una herramienta ampliamente utilizada para este método es XDoclet . Esta técnica aún se puede utilizar después de la introducción de las anotaciones.

Tipos de anotaciones predefinidos

En Java SE 5.0 hay siete tipos de anotaciones predefinidas disponibles, en los paquetes ( paquete ) java.lango java.lang.annotationmentira. A diferencia de la mayoría de las anotaciones, el compilador las evalúa. Los programadores pueden crear más.

/**
 * @deprecated  Die Klasse A wurde mit Version 10.3 durch die Klasse ANeu ersetzt.
 */
@Deprecated
public class A {}

public class A {
    public void eineMethode() {}
}
 
public class B extends A {
    @Override
    public void eineMethode() {}
}

public class A {
    @SuppressWarnings({"deprecation"})
    public void eineMethode() {
        EineDeprecatedKlasse b = new EineDeprecatedKlasse();
    }
}

Definición de sus propias anotaciones

Las anotaciones son interfaces especiales; Por tanto, según la convención, sus nombres se escriben con mayúscula. En su acuerdo está interfaceel signo @. Extienden implícitamente la interfaz java.lang.annotation.Annotation. No deben extender (es decir, extendsestán prohibidas) otras interfaces y no son genéricas. Sus métodos son sin parámetros y no genéricos. Solo se permiten los siguientes tipos como tipos de resultado (tipo de retorno):

• tipos primitivos
• Tipos de enumeración ( enum)
• Tipos de anotaciones
• String
• Class
• Campos (matrices) de estos tipos

Tampoco lanzan excepciones y no se les permite usar la recursividad.

Muchas anotaciones no contienen ningún método. Un ejemplo sería:

@interface Vorlaeufig { }

Otras anotaciones contienen métodos (como es habitual para las interfaces), pero solo con los tipos de resultados enumerados anteriormente. Por convención, si una anotación contiene solo un método, su nombre es value:

@interface Test {
	boolean value(); // true solange nicht freigegeben
}

o

@interface Autoren {
	String[] value(); // Namen der Autoren
}

o

@interface Kunden {
	Person[] value();
}

donde Persona enumdebe definirse como tipo de enumeración ( ) o anotación, p. ej. B .:

@interface Person {
	String name();
	int alter();
}

Al acordar las anotaciones, a menudo se java.lang.annotationutilizan las anotaciones estándar del paquete . En particular, debe @Retentionespecificarse cuánto tiempo debe mantenerse la anotación: solo en el código fuente ( SOURCE), en el archivo de clase guardado ( CLASS) o también en la clase cargada ( RUNTIME). @Targetdescribe para qué elementos del programa se puede utilizar la anotación. Por ejemplo, todos los acuerdos de anotaciones se incluyen java.lang.annotationcon las anotaciones.

@Documented
@Retention(value=RUNTIME)
@Target(value=ANNOTATION_TYPE)

Error. Como resultado, todos son evaluados por javadoc, cargados en el código de bytes y, por lo tanto, pueden evaluarse en tiempo de ejecución; además, solo se pueden utilizar para tipos de anotaciones.

Uso de sus propias anotaciones

Una anotación sin métodos, como @Vorlaeufig, por ejemplo, puede B. ser colocado frente a una clase:

@Vorlaeufig
class Klasse {
	void methode();
}

Una anotación con un solo método con el nombre valuedebe recibir un valor constante del tipo de resultado de este método entre paréntesis:

@Test(true)
public void methode() { ... }

Si el tipo de resultado es una matriz, se debe utilizar un literal de matriz:

@Autoren({"Solymosi", "Grude"})
String buch = "Algorithmen und Datenstrukturen mit Java"

Si la matriz no contiene ningún elemento, también debe ({})especificarse. Sin embargo, si la matriz contiene solo un elemento, se pueden omitir las llaves:

@Autoren("Solymosi")
String anderesBuch = "Programmieren in Scala"

A una anotación con varios métodos se le debe asignar un valor constante entre paréntesis a cada uno de sus métodos:

@Person(name = "Andreas Solymosi", alter = 56)
Konto konto = new Konto();

La opción de especificar el valor por nombre también está disponible para las anotaciones con un método (sin embargo, es superfluo, como máximo para facilitar la lectura):

@Test(value = true)

Se debe aplicar una anotación compleja (anidada) anidada:

@Kunden(@Person(name = "Andreas Solymosi", alter = 56))
class Unternehmen { … }

Se pueden definir valores estándar para los métodos en el acuerdo de anotación; entonces el valor correspondiente se puede omitir cuando se usa. Dado que las anotaciones son interfaces, puede marcarlas usted mismo con anotaciones:

@Autoren("Solymosi")
public @interface Test {
	boolean wert() default false; // muss nicht unbedingt wert heißen
}

Evaluación de anotaciones

Si las anotaciones se cargan con el código de bytes de la clase, se pueden evaluar con la ayuda de la reflexión. Por ejemplo, puede determinar si se ha especificado una anotación o no:

boolean vorlaeufig = Klasse.class.isAnnotationPresent(Vorlaeufig.class);

Cuando haya determinado que la anotación está allí, también puede leer su valor, p. Ej. B. si el método todavía está en el estado de prueba o no:

boolean imTestzustand = Klasse.class.getMethod("methode", new Class[]{}).getAnnotation(Test.class).value();

Si la anotación no existe aquí, getAnnotation()se NullPointerExceptionlanza la excepción . Sus elementos deben seleccionarse individualmente a partir de una anotación compleja:

Person kunden = Unternehmen.class.getAnnotation(Kunden.class).value()[0];

Anotación de paquetes

La especificación del lenguaje Java también permite anotar paquetes, por ejemplo, para proporcionar documentación para un paquete. Se puede packageanotar un máximo de una declaración por paquete . Si un paquete va a recibir anotaciones, la Especificación del lenguaje Java recomienda crear un archivo separado package-info.javaen el directorio de este paquete. Este archivo luego contiene la packagedeclaración con las anotaciones.

enlaces web

• Anotaciones en Java
• Anotaciones en el tutorial de Java de Sun
• Herramienta de procesamiento de anotaciones (apt )
• La función de anotaciones de J2SE 5.0 en Sun
• JSR 175: una función de metadatos para el lenguaje de programación JavaTM (inglés)
• Anotaciones en la especificación del lenguaje Java (inglés)
• Anotaciones en "Java también es una isla"