Anotación Java

De Wikipedia, la enciclopedia libre

Saltar 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 SQL
la 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.