UNIVERSIDAD DE ORIENTE

NÚCLEO DE MONAGAS

ESCUELA DE INGENIERIA Y CIENCIAS APLICADAS

CURSO ESPECIAL DE GRADO

Annotations

Profesor: Ing. Jhonatan Vasquez

Maturín, Mayo del 2015

Bachilleres:Centeno G. Renny J. C.I. 21.350.253Fernández G. Ana B. C.I. 21.329.313

Índice1. Introducción.....................................................................................................................2

2. Marco teórico.......................................................................................................................4

2.1 ¿Qué es una anotación?..............................................................................................4

2.2 ¿Por qué fueron creadas las anotaciones?..............................................................4

2.3 Usos de las anotaciones..............................................................................................5

2.4 Anotaciones en la ingeniería de software.................................................................5

2.5 Anotaciones en Java....................................................................................................6

2.5.1 Historia.....................................................................................................................6

2.5.2 Formato de una anotación en Java.....................................................................6

2.5.3 Anotaciones predefinidas.....................................................................................6

2.5.4 Definiendo un tipo de anotación..........................................................................8

3. Discusión.............................................................................................................................9

4. Conclusión.........................................................................................................................11

5. Bibliografía.........................................................................................................................12

1. Introducción

La programación siempre se ha superado a si misma con el pasar de los años en pro de facilitarle a los programadores su trabajo y que esto se refleje en el producto final que ofrecen a sus clientes, en los inicios de la programación se utilizaba el código binario como método de programación, desde ese momento se fue evolucionando hasta obtener lenguajes de alto nivel que fueran muchos más entendibles para las personas, y poco a poco se fueron dando pasos agigantados hasta llegar a nuestros tiempos donde se cuenta con una gran variedad de técnicas y herramientas para lograr productos de calidad.

Hoy en día con la magnitud que ha alcanzado la tecnología en la sociedad, son cada vez más grandes la cantidad de datos que deben manejar los sistemas informáticos, obviamente los datos son la fuente que genera la información y sin estos sería imposible para un software cumplir su cometido, debido a este inconveniente nacen los metadatos como una manera clara y ágil de organizar los diferentes datos que se manejen, de esta forma se logra clasifica la gran cantidad de datos dependiendo del cometido que tenga cada uno dentro de la aplicación, esto a priori ofrece diferentes ventajas.

Para gestionar estos metadatos existen diferentes técnicas, una de estas son las anotaciones, con las anotaciones se busca señalar en diferentes partes del código fuente(las que se requieran) un metadato determinado, de forma que sea utilizado por el compilador para el propio beneficio del programa, ya que las anotaciones pueden manejar diferentes tipos de metadatos que podrían tener información crucial, información que permita saber si un objeto esta obsoleto o si se declaró un parámetro de manera indebida, todo va a depender de la anotación que se use.

Resulta importante y hasta crucial conocer y comprender la importancia de los metadatos dentro de una aplicación, y aún más importante saber que técnica nos conviene para gestionar estos metadatos, las anotaciones son aplicadas en diferentes contextos dentro de la comunidad de la programación, sus usos y ventajas están más que comprobados, es cuestión de conocerla mejor y saber exactamente como debe ser usada y que posibilidades ofrece no solo en lenguajes de programación sino en otros ámbitos.

2. Marco teórico

2.1 ¿Qué es una anotación?Según Wikipedia (2015) la definición de anotación es que es un “metadato

adjunto a texto, una imagen u otro dato. A menudo las anotaciones se refieren a una parte específica de los datos originales”. Con respecto a esto, el sitio Oracle (1995) define una anotación como “una forma de metadatos, que proveen información con respecto a un programa que no es parte del programa en sí misma. Las anotaciones no tienen efectos directos sobre la operación o el funcionamiento del código al que hacen referencia”. Otro autor que hace referencia a las anotaciones, pero refiriéndose más específicamente a anotaciones dentro de códigos de programación, es el sitio Kotlin (2000), este especifica que “las anotaciones son formas de adjuntar metadatos a código”.

2.2 ¿Por qué fueron creadas las anotaciones?Con respecto a la respuesta a esta interrogante, la página Dzone (2014) explica

lo siguiente:

Antes de las anotaciones (e incluso después) los archivos XML eran ampliamente usados para metadatos y, de alguna manera, un grupo particular de desarrolladores de aplicaciones y arquitectos de software pensó que el mantenimiento de XML se estaba volviendo problemático. El grupo entonces quiso crear algo que pudiera ser fuertemente ligado con el código, en lugar de los archivos XML, que casi no están agrupados con el código (y en algunos casos simplemente están separados). Si se realiza una búsqueda en google acerca de “XML contra anotaciones” se encontrarán una serie de interesantes debates. Un punto interesante es que las configuraciones XML fueron creadas para separar la configuración del código. Esto es más fácil de entender con un ejemplo:

Supóngase que se quieren establecer algunas constantes o parámetros para una aplicación. En este escenario, XML sería la mejor opción porque esto no está relacionado con ninguna pieza de código específica. Si se quiere exponer algún método como servicio, una anotación sería la mejor opción, tomando en cuenta que la anotación debe estar más fuertemente agrupada con ese método, y el desarrollador debe estar consciente de esto.

Otro factor importante es que la anotación representa una manera estándar de definir metadatos en el código. Antes de las anotaciones, las personas usaban sus propias maneras de definir metadatos. Algunos ejemplos de esto son: usando interfaces de marcado, comentarios, entre otros. Cada desarrollador decidía su propia manera de definir los metadatos, pero las anotaciones sirvieron para estandarizar las cosas. Actualmente, casi todos los frameworks utilizan una combinación de XML y anotaciones para nivelar los aspectos positivos de ambos.

2.3 Usos de las anotaciones.La misma página Oracle (1995) indica que “las anotaciones tienen una gran

cantidad de usos”. Este mismo autor especifica que entre los usos de las anotaciones se encuentran:

Información para el compilador: las anotaciones pueden ser usadas por el compilador para detectar errores o contener alertas.

Procesamiento en tiempo de compilación y tiempo de despliegue: las herramientas de software pueden procesar la información de las anotaciones para generar código, archivos XML, entre otros.

Procesamiento en tiempo de ejecución: algunas anotaciones tienen la capacidad de ser examinadas en tiempo de ejecución.

2.4 Anotaciones en la ingeniería de software.Con respecto al uso de las notaciones en la ingeniería de software, Wikipedia

(2015) señala tres grandes aplicaciones que tienen las mismas, describiendo dichas aplicaciones de la siguiente manera:

Documentos de texto: lenguajes de marcado como XML y HTML realizan anotaciones de texto en una forma que es sintácticamente distinguible de ese texto. Las anotaciones pueden ser usadas para agregar información acerca de la presentación visual deseada, o información semántica que pueda ser leída por las máquinas.

Control de fuentes: la función de anotación usada en el sistemas de control de fuentes tales como “sevidor del equipo de fundación” y “subversión” determina quien realizó cambios en el código fuente en el repositorio. Esta función imprime una copia del código fuente donde cada línea contiene una anotación con el nombre del último en contribuir para editar esa línea (y posiblemente un número de revisión). Esto puede ayudar a establecer responsabilidades en caso de que algún cambio causara un mal funcionamiento, o simplemente para identificar al autor de un código muy útil.

Anotaciones en Java: un caso especial de las anotaciones, se da en el lenguaje de programación Java, donde las anotaciones pueden ser usadas como una forma especial de metadatos sintácticos en el código fuente. Clases, métodos, variables, parámetros y paquetes pueden estar anotados. Las anotaciones pueden ser incrustadas en archivos de clase generados por el compilador y pueden ser retenidas por la máquina virtual de Java y así influenciar el comportamiento en el tiempo de ejecución de una aplicación. Es posible crear meta-anotaciones aparte de las que ya existen en Java.

2.5 Anotaciones en Java

2.5.1 HistoriaLa fuente Wikipedia, explica respecto a la historia de las anotaciones en Java

que:

La plataforma Java cuenta con varios mecanismos de anotación. Por ejemplo, el modificador transitorio, o la etiqueta @deprecated (@obsoleta). JSR-175 introdujo el propósito general de una anotación (también conocida como metadato) a la comunidad de Java en el 2002, pero ganó cierta aprobación hasta septiembre del 2004. Las anotaciones estuvieron disponibles en Java a partir de la versión 1.5 del kit de desarrollo java o JDK. La herramienta de procesamiento de anotaciones proveyó de una interfaz provisional para anotaciones en tiempo de compilación que pudieran ser procesadas en la versión 1.5 de JDK. JSR-269 formalizó esto y las anotaciones se integraron al compilador javac en su versión 1.6.

2.5.2 Formato de una anotación en JavaSegún Oracle (1996), “en su forma más simple, una anotación se ve como lo

siguiente: @Entidad. El símbolo (@) indica al compilador que lo que le sigue es una anotación”. La misma fuente muestra un ejemplo con una anotación cuyo nombre es “Override”.

@Override

void mySuperMethod() { ... }

Las anotaciones pueden incluir elementos, que pueden tener nombre o no. Y esos elementos pueden tener ciertos valores. Por ejemplo:

@Author(

name = "Benjamin Franklin",

date = "3/27/2003"

)

class MyClass() { ... }

2.5.3 Anotaciones predefinidasDe acuerdo a la fuente Oracle (1995) “un conjunto de anotaciones están

predefinidas en Java. Algunos tipos de anotaciones son usados por el compilador de Java, y otros son aplicados a otras anotaciones”.

La misma fuente menciona entre estos tipos de anotaciones a las siguientes:

Anotaciones usadas por el lenguaje Java

@Deprecated: esta anotación indica que el elemento señalado está obsoleto y no debería seguir en uso. El compilador genera una alerta cuando el programa quiera usar un método, clase o archivo que esté marcado con la anotación

@Deprecated. Cuando un elemento está obsoleto, esto debe ser documentado usando la etiqueta javadoc @deprecated. Esto se hace de la siguiente manera:

// Javadoc comment follows

/**

* @deprecated

* explanation of why it was deprecated

*/

@Deprecated

static void deprecatedMethod() { }

}

@Override: esta anotación informa al compilador que el elemento debe anular o invalidar otro elemento declarado en una superclase. Esto ayuda a prevenir errores. Se hace de la siguiente manera:

// mark method as a superclass method

// that has been overridden

@Override

int overriddenMethod() { }

@SuppressWarnings: como su nombre lo indica, esta anotación indica al compilador que debe suprimir determinadas alertas que de otra forma se generarían. En este ejemplo, se está usando una anotación @Deprecated que en la mayoría de los casos genera una alerta. En este caso, sin embargo, la anotación suprimirá la alerta:

// use a deprecated method and tell

// compiler not to generate a warning

@SuppressWarnings("deprecation")

void useDeprecatedMethod() {

// deprecation warning

// - suppressed

objectOne.deprecatedMethod();

}

@SafeVarargs: cuando esta aplicación es usada en un método o un constructor afirma que el código no realiza una serie de operaciones potencialmente inseguras, declaradas en este parámetro varargs. Cuando este tipo de anotación es usado, las alertas relacionadas con su uso son suprimidas.

@FunctionallInterface indica que el tipo de declaración está diseñada para trabajar como una interfaz funcional, tal y como está definido en las especificaciones del lenguaje Java.

Anotaciones que se aplican a otras anotaciones

Estas son llamadas meta-anotaciones. Hay muchas meta-anotaciones definidas en la librería de anotaciones Java.

@Retention: esta anotación especifica cómo está almacenada cierta anotación.

@Documented: esta anotación indica que cuando la anotación especificada sea usada en un elemento, ese elemento debe ser documentado usando la herramienta Javadoc.

@Target: marca otra anotación para restringir a qué tipo de elementos de Java puede ser aplicada la anotación.

@Inherited: indica que el tipo de anotación puede heredar de una superclase. Cuando el usuario instancia un tipo de anotación y la clase no tiene anotación para este tipo, la superclase es instanciada para el tipo de anotación inicial. Esta anotación aplica sólo para las declaraciones de clase.

@Repeatable: indica que la anotación marcada puede ser aplicada más de una vez para la misma declaración o el mismo tipo de uso.

2.5.4 Definiendo un tipo de anotación Muchas anotaciones reemplazan comentarios en el código. Supóngase que un grupo de software comienza tradicionalmente el cuerpo de cada clase con comentarios que proveen información muy importante. Esa información puede ser agregada con metadatos definiendo un tipo de anotación, usando la sintaxis:

@interface ClassPreamble {

String author();

String date();

int currentRevision() default 1;

String lastModified() default "N/A";

String lastModifiedBy() default "N/A";

// Note use of array

String[] reviewers();

}

Esta definición se asemeja a una definición de interfaz, donde la palabra “interface” es precedida por el símbolo (@). Los tipos de anotaciones son formas de interfaces. El cuerpo de la definición de anotación antes mencionada contiene declaraciones de elementos bastante parecidos a métodos. Es de destacar que cada uno de estos elementos puede definir ciertos valores opcionales por defecto.

3. Discusión

A medida que la programación fue evolucionando se fue haciendo más y más fuerte este campo debido al desarrollo constante de nuevas técnicas que les permitiera a los programadores ofrecerle solución a cualquier problemática que se quisiera solventar, estas técnicas o herramientas fueron permitiendo la creación de programa, aplicaciones o sistemas informáticos cada vez más complejos que lograran satisfacer las necesidades de los clientes, por supuesto que mientras más grande es un sistema más información este debe manejar, lo que hacía un poco tedioso y desorganizada la manera de manejar los diferentes datos del sistema informático, por ello es que nacen los metadatos como una manera de clasificar los datos a conveniencia y de esta forma los programadores pudieran trabajar más tranquilos y lograr acceder a los datos de manera sencilla.

Existen diversas maneras de utilizar los metadatos y resulta que una que ha cobrado mucho auge en los últimos años son las anotaciones, una anotación se puede definir como un metadato adjunto a texto, una imagen u otro dato, frecuentemente las anotaciones refieren a una parte especifica de los datos, es decir, adjunta una parte de los datos a el código que se esté trabajando, viene siendo como un gestor de metadatos que permite hacer referencia de unos ciertos datos pertenecientes a un conjunto más grande(concepto de metadatos), pero las anotaciones no son la única técnica que se utiliza para manejar metadatos, también esta xml, y siempre se hacen comparaciones entre estas 2 técnicas, las comparaciones son odiosas ya que las ambas son diferentes.

Xml es un lenguaje de marcas que permite almacenar datos de forma legible, su mayor uso está en los metadatos, desde su creación ha sido la manera más popular de manejar los metadatos dentro de un software y de esta forma tener perfectamente ordenada y clasificada los datos, a pesar de su popularidad comenzaron a surgir ciertos malestares por parte de la comunidad de programadores que hacía uso de xml, ellos decían que se volvía cada vez más problemático realizarle mantenimiento al lenguaje xml debido al crecimiento exponencial de datos dentro de las aplicaciones, y desde ahí surgió la iniciativa de crear una herramienta para gestionar metadatos que estuviera más ligada al código de la aplicación, así fue como nacieron las anotaciones.

Una de las principales diferencias entre las anotaciones y xml viene dada por el rango de aplicación que se le puede dar a cada una de ellas debido a sus características, xml se instancia de forma totalmente independiente del código fuente lo que la hace un método complicado si se desea realizar alguna actualización, porque se debe compilar todo el código, además xml debe ser usado para casos donde se desee definir ciertos parámetros para toda la aplicación y no en casos donde se deba realizar conexión de datos con ciertas partes del código como un método por ejemplo, en esos casos el uso de anotaciones resulta fundamental, le saca una ventaja significativa a xml.

Otro aspecto que hay que resaltar de las anotaciones es que es una manera rápida de definir metadatos en una aplicación, no es que con xml no se haga pero

con las anotaciones se obtiene una manera más sencilla y rápida de realizarlo, y ya que de ventajas significativas de las anotaciones hablamos, es necesario tocar las más importantes, primero esta que pueden ser de gran ayuda para detectar errores o inconvenientes en el código fuente de las aplicaciones, esto lo logran ya que le proporcionan información relevante al compilador y este a la hora de realizar una compilación puede darse cuenta de incongruencias presentes, lo segundo es que durante el tiempo de compilación se puede usar las anotaciones para crear nuevos códigos e incluso archivos xml de ser necesario, ya por ultimo una ventaja importante del uso de anotaciones se presenta en el tiempo de ejecución, durante este tiempo el programa está en la capacidad de verificar las anotaciones en caso de que exista una contradicción o error en estas.

Un entorno donde el uso de anotaciones es bastante frecuente es en el lenguaje de programación java, este lenguaje bastante popular que es utilizado por una gran cantidad de programadores no deja de lado esta herramienta, aunque en principio no fue considerada prioridad de la plataforma de programación de sunsystem el uso de anotaciones, debido a su considerable aceptación en la comunidad del software tuvo que ser incluida de forma que viniera a reforzar aún más el lenguaje y dejara satisfecho a todos los usuarios de java, así fue como en 2004 oficialmente las anotaciones eran por así decirlo como un caso especial de metadatos en java, estas serían usadas como una forma especial de crear metadatos en el código fuente del programa, así clases, métodos, variables, etc., lograrían ser anotados, dichas anotaciones serian incrustadas en el código fuente y ser procesadas por la máquina de virtual de java lo que permitiría afectar el comportamiento del programa en si a la hora de que fuera compilado.

Existen diversas anotaciones en java, cada una con sus características únicas, por ejemplo la anotación “Deprecated” le indica al compilador que un objeto en específico está obsoleto y que debería ser sustituido, de esta forma el compilador genera una alerta cuando se quiere hacer uso de un objeto que posea esta anotación, otra anotación muy usada es la “Override”, esta anotación advierte que se debe anular o eliminar un elemento declarado en una súper clase ya que dicho elemento podría generar errores, siguiendo con las anotaciones en java esta la “SafeVarargs”, esta anotación le permite saber al programa que un método o constructor podría ejecutar una serie de códigos que se consideran inseguros para el bienestar del programa, y para terminar este recorrido de anotaciones tenemos la “Target”, esta marca otra anotación y así restringir a qué tipo de elementos en java se aplicara dicha anotación.

Como se pudo observar las aplicaciones de las anotaciones son variadas y sumamente importantes en la programación, facilitan enormemente el trabajo de organizar los datos y son punto de referencia cuando de proteger la integridad del programa se refiere.

4. Conclusión

Resulta crucial en cualquier aspecto de nuestras vidas que nos mantengamos organizados, que podamos tener todo en su lugar y de esta forma ser más eficiente a la hora de trabajar ya que podríamos acceder a todas nuestras herramientas o técnicas de manera rápida y cómoda, si por ejemplo tenemos nuestro cuarto ordenado y estamos estudiando se nos facilitara enormemente la tarea de conseguir cuadernos, lápices, libros o cualquier otro instrumento que nos facilite la tarea del estudio, imagínense llevar a cabo la tarea de estudiar si no sabemos dónde halla cada cosa, perderíamos tiempo y esfuerzo que se podría dedicar a cosas más importantes.

De igual forma pasa en la programación, cada vez son más y más grandes las cantidades de datos que debe manejar un programa para poder cumplir con sus objetivos, si se tuviera semejante cantidad de información de manera desorganizada sería un total caos para el programa acceder de manera eficiente a la información, he allí la importancia de los metadatos para ofrecer soluciones a este inconveniente, ya que es una manera sencilla de clasificar y agrupar los datos con respecto a cada categoría u asunto en concreto, de esta forma se puede tener acceso a los datos de manera fluida en los momentos que se le necesite y así agilizar la ejecución del programa.

Una de las formas de manejar los metadatos son las anotaciones, esta importante herramienta se popularizo debido a los inconvenientes que presentaba xml, ya que xml se ajustaba más a programas que enfocaron sus parámetros de manera global y no existiera conexión de los metadatos de forma directa con el código fuente del programa en sí, incluso xml se instancia de manera independiente, en contrario a lo que sucede con las anotaciones que están incrustadas en partes especificas del código fuente donde se les requiera, permitiendo gestionar metadatos de manera óptima.

Cabe destacar que aunque las anotaciones son usadas en una cantidad amplia de contextos, tienen una importante utilidad en un lenguaje muy conocido como java, aquí se pueden incrustar anotaciones en el código fuente y dichas anotaciones serán reconocidas por la máquina virtual de java para que el programa reconozca la información que se está aportando, de esta forma se pueden resaltar diferentes ventajas del uso de anotaciones en java, que van desde detectar objetos obsoletos en el código fuente como la de advertir potenciales errores por la creación indebida de elementos, sin duda alguna las anotaciones resultan ser una técnica que todo buen programador debe tener en su repertorio si desea un mecanismo que le facilite el manejo de metadatos y procure velar por el bienestar y correcto funcionamiento del software.

5. Bibliografía