Anotación JavaDe Wikipedia, la enciclopedia libreSaltar a navegación, búsqueda

En programación, una Anotación Java es una forma de añadir metadatos al código fuente Java que están disponibles para la aplicación en tiempo de ejecución. Muchas veces se usa como una alternativa a la tecnología XML.

Las Anotaciones Java pueden añadirse a los elementos de programa tales como clases, métodos, campos, parámetros, variables locales, y paquetes. Al contrario que las etiquetas añadidas a la documentación Java y procesadas con las herramientas tales como XDoclet, las Anotaciones Java son completamente accesibles al programador mientras que el software se ejecuta usando reflexión.

Contenido

[ocultar] 1 Historia 2 Procesamiento

3 Sintaxis

4 Ventajas

5 Desventajas

6 Véase también

7 Referencias externas

[editar] Historia

Las Anotaciones Java fueron presentadas al Java Community Process como la especificación JSR-175 en 2002 y aprobadas en septiembre de 2004. Las Anotaciones empezaron a estar disponibles a partir de la versión 1.5 del JDK. La característica fue añadida al Lenguaje de programación Java a través de dicha especificación.

[editar] Procesamiento

Cuando se compila el código fuente de Java, el compilador Java almacena los metadatos de la Anotación en los ficheros/archivos de clases. Posteriormente, la JVM u otros programas pueden buscar los metadatos para determinar como interactuar con los elementos del programa o cambiar su comportamiento.

[editar] Sintaxis

Declarar una Anotación es una variación de las etiquetas que han sido añadidas anteriormente a las secciones de comentarios.

Las Anotaciones toman la forma de una declaración de interfaz con un caracter @ precediéndola, y marcada opcionalmente con meta-anotaciones, como se ve debajo:

@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD})

En el ejemplo anterior, tanto Retention como Target son ejemplos de Anotaciones.

Ventajas

Las Anotaciones permiten al programador declarar en su código fuente cómo debe comportarse el software. Esto es un ejemplo de cómo las construcciones de la Programación declarativa pueden añadirse al lenguaje procedimental.

Desventajas

Añadir metadatos en tiempo de ejecución puede causar sobrecarga adicional de memoria.

Hay pocos estándares que indiquen cómo usar las etiquetas de metadatos.

Las anotaciones son sólo metadatos (o DecorativeData, como algunos pueden preferir), información adicional sobre el código que está escrito. Normalmente siempre se hace una analogía con el Post-it colgado en la mitad de su código fuente: las anotaciones no ejecutan código.

El uso adecuado de las anotaciones sigue el estilo "Enabling". ¿No direccionan en ningún camino, no indican la ejecución de ningún código. Por el contrario, como metadatos, sólo permiten diferentes usos de esta información adicional. Un buen ejemplo sería la anotación @Entity, de la API de Java Persistencia:

@Entity

public class Vehiculo {

  // …

}

Varios frameworks, e incluso otras partes de su sistema puede utilizar esta información adicional si así lo desean. El propio Hibernate utiliza esta información para saber que esta es una clase persistente, que debe tener representación en la base de datos, un validador puede utilizar esta información para determinar qué objetos deben ser validados en esta clase, un framework de aspectos podría decidir aplicar un aspecto en esta Clase utilizando esta información adicional, entre muchas otras posibilidades. Otro ejemplo interesante podría ser la anotación @transient, de la propia especificación JPA:

public class Bicicleta {

  @Transient

  private double velocidad;

}

Se podría utilizar esta información para decidir no mostrar este campo en la interfaz gráfica de usuario (web o de escritorio). Puede utilizar esta información extra incluso para decidir que este campo no será enviado en mensajes de correo electrónico o incluso en logs. Framework de ORM como Hibernate aprovechan esta información para ignorar el atributo y no incluirlo en ninguna tarea de persistencia.

¿Se podrían dar muchos más ejemplos de buenas prácticas de anotaciones. Lo más importante es la idea de que la anotación permite múltiples usos, y no direcciona - no fuerza - ningún camino. La anotación no está asociada a ninguna ejecución de código. Funciona incluso como un simple post-it.

El enfoque alternativo sería el pensamiento "Directing". En este caso, la anotación está directamente relacionada con la ejecución del código y sólo sirve para este fin. Ejemplo:

public class Sistema {

  @EnviaEmail(Emails.CONFIRMACION)

  public void registro(Usuario usuario) {

    //…

  }

}

En este caso no hay ningún otro uso para esta anotación. Tenga en cuenta que ella ya presupone una ejecución del código para el envío de mensajes de correo electrónico. Limita a un pensamiento particular, para un uso específico. Tal vez un caso exagerado, mas no hay diferencia alguna con el llamado al método directo que envía el e-mail:

public class Sistema {

 

  public void registro(Usuario usuario) {

    mensajero.enviaEmail(Emails.CONFIRMACION, usuario);

    // …

  }

 

}

En algunos casos puede ser muy difícil, o demasiado subjetiva para decidir si el uso de una anotación es "Directing" (Directivo) o es "Enabling" (habilitante). No creo que deberíamos tomar nada como la verdad absoluta, lo importante es ser consciente de varios puntos de vista diferentes. Así, podemos tomar nuestras decisiones, siempre pesando ventajas y desventajas.

@Anotaciones(“java”)

Las anotaciones son un mecanismo para dotar a las clases de Meta información o auto información. Estas ya existían en versiones de java anteriores y de hecho se usaban, por ejemplo para generar el javaDoc (@Deprecated). Pero desde la versión 1.5 (Tiger! oh yeah) se han convertido en una parte Tipada del lenguaje y podemos trabajar con ellas tanto en tiempo de compilación como en tiempo de ejecución.

Anotar una porción de código nos sirve para procesarla de alguna manera en algún script, herramienta de despliegue o de diseño, para hacer uso de ellas en un framework, para trabajarlas distintas por un compilador…

Decía que las anotaciones se pueden trabajar en tiempo de ejecución. La forma de hacerlo sería usando el API de reflection, que se ha completado en Java 5 para tener acceso a las anotaciones.

Por ejemplo en la clase Class tenemos:

<A extends Annotation> A getAnnotation(Class<A> annotationClass)

Annotation[] getDeclaredAnnotations()

boolean isAnnotation()

Tenemos métodos similares en las clases de reflexión java.lang.reflect.Field, java.lang.reflect.Method… Puesto que las anotaciones pueden ir a cada uno de estos niveles.

Además la plataforma java incluye un herramienta apt para trabajar con anotaciones. %JAVA_HOME%/bin/apt

Para distinguir las anotaciones, estas vienen precedidas siempre de una arroba (@ Toma!). Y se pueden clasificar en 3 tipos:

Marker annotations: Anotaciones que no reciben ningún parámetro. Marcan algún elemento. La única información que nos da esta anotación es que se tiene o no se tiene.

Normal annotations: Anotaciones que reciben argumentos en forma de pares nombreParametro=valorParametro

Single member annotations: Anotaciones que sólo tienen un miembro y este se llama value, no necesitan indicar el nombreParametro, solo el valorParametro.

Además estan las built in annnotations, es decir, las que ya forman parte del lenguaje, que en la versión java SE5 son 3:

Overrides: Indica que el método esta siendo sobreescrito, tenemos un error de compilación si el método no es sobreescrito. (Si nos equivocamos al teclearlo).

Deprecated: Indica que el método esta deprecado y no debería usarse y nos genera un warning en compilación.

SupressWarnings: Recibe una lista de argumentos y le indican al compilador que no muestre los warnings de los tipos pasados como argumento. (“all”,”checked”,”finally”).

Las anotaciones pueden a su vez estar anotadas, es decir, en la definición de una anotación podemos anotarlas usando meta-anotaciones.

Estas son:

Target: Indica sobre que elementos puede usarse la anotación. Recibe un array de argumentos y las posibilidades son: TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE.

Retention: Indica el alcance de la anotación. Las posibilidades son:

o SOURCE: La anotación sólo existe en el fuente, no en la clase compilada.

o CLASS: Por defecto. La anotación existe en la clase pero la maquina virtual la ignora en ejecución.

o RUNTIME: La máquina virtual tiene acceso a ella y es necesaria si queremos acceder reflexivamente a ella.

Inherited: Indica que la anotación la heredan las subclases.

Documented: Indica que las herramientas de documentacion tipo javaDoc tienen que documentarla.

Así pues la forma de crear un Annotation Type (Lo que sería la Clase de los objetos anotación) utilizaremos la sintaxis:

@Meta-anotacion1(miembros)

@Meta-anotacion2(miembros)

…..

modificadores @interface NombreTipoAnotación{

TipoMiembro1 nombreMiembro1();

TipoMiembro2 nombreMiembro2() default valorPorDefecto;

…

}

Más claro lo tenemos en el ejemplo de la anotación built-in SupressWarnings:

package java.lang;

import java.lang.annotation.*;

import java.lang.annotation.ElementType;

import static java.lang.annotation.ElementType.*;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR,

LOCAL_VARIABLE})

@Retention(RetentionPolicy.SOURCE)

public @interface SuppressWarnings {

String[] value();

}

Como cosa curiosa, al construir tipos de anotaciones estamos usando la notacion @interface aunque en realidad lo que ocurre es que estamos extendiendo de la intefaz java.lang.annotation.Annotation, Pero si la extendieramos directamente NO conseguiríamos una anotación.

Anotación de Java

anotación, en Lenguaje de programación de la computadora de Java, es una forma especial de sintáctico meta datos eso se puede agregar al código de fuente de Java.[1] Las clases, los métodos, las variables, los parámetros y los paquetes pueden ser anotados. Desemejante Javadoc las etiquetas, anotaciones de Java son reflexivo en ése se encajan adentro archivos de la clase generado por el recopilador y puede ser conservado por la Java VM que se hará recuperable en tiempo de pasada.[2]

@Twizzle palanca vacía del público () {}el @Twizzle de // es una anotación a la palanca del método ().

público @interface Twizzle {}// declara la anotación Twizzle.

Las anotaciones pueden incluir una lista opcional de los pares del llave-valor:

// iguales que: @Edible(el valor = verdad)@Edibleartículo (verdadero) del artículo = zanahoria nueva ();público @interface Comestible {defecto boleano del valor () falso; }

@Author(primero = “Oompah”, pasados = “Loompah”) reserve el libro = libro nuevo ();público @interface Autor {secuencia primero (); Último de la secuencia (); }

Las anotaciones ellos mismos se anotan para indicar donde y cuando pueden ser utilizadas:

@Retention(RetentionPolicy.RUNTIME) // conserva esta anotación en la VM para el uso en el tiempo de pasada.@Target({ElementType.METHOD}) // esta anotación se puede aplicar solamente a los métodos de la clase.público @interface Tweezable {}

El recopilador reserva un sistema de anotaciones especiales (que incluyen @Deprecated, @Override y @SuppressWarnings) para los propósitos sintácticos.

Las anotaciones son de uso frecuente cerca armazones como manera convenientemente de asociar comportamientos a las clases y a los métodos definidos por el usario que se deben declarar de otra manera en una cierta fuente externa (como un archivo de la configuración de XML) o programmatically (con llamadas del API). Lo que sigue, por ejemplo, es anotado EJB 3.0 clase de datos:

@Entity // declara esto haba de la entidad@Table(nombre = “gente”) // traz la haba a la tabla “gente” del SQLla persona de la clase pone Serializable en ejecución {@Id Mapa de // esto a la columna dominante primaria.@GeneratedValue(estrategia = GenerationType.AUTO) La base de datos de // generará las nuevas llaves primarias, no nosotros.identificación privada del número entero;

@Column(longitud = 32) Valores truncados de la columna de // a 32 caracteres.nombre privado de la secuencia;

getId público del número entero () {identificación de vuelta;}

setId vacío del público (identificación del número entero) {this.id = identificación;}

getName público de la secuencia () {nombre de vuelta;}

setName vacío del público (nombre de la secuencia) {this.name = nombre;}}

Las anotaciones no son llamadas del método y no, por sí mismos, hacer cualquier cosa. Algo, el objeto de la clase se pasa a la puesta en práctica de EJB en el tiempo de pasada, que entonces extrae las anotaciones para generar ORM.