¿Cómo y dónde se usan las anotaciones en Java?

¿Cuáles son las áreas principales en las que podemos usar Anotaciones? ¿Es la característica un reemplazo para la configuración basada en XML?

Las anotaciones son meta-metaobjetos que se pueden usar para describir otros metaobjetos . Los metaobjetos son clases, campos y métodos. Preguntar a un objeto por su metaobjeto (p anObj.getClass(). Ej. ) Se llama introspección . La introspección puede ir más allá y podemos preguntarle a un metaobjeto cuáles son sus anotaciones (por ejemplo aClass.getAnnotations). La introspección y las anotaciones pertenecen a lo que se llama reflexión y metaprogramación .

Una anotación debe interpretarse de una forma u otra para que sea útil. Las anotaciones pueden ser interpretadas en tiempo de desarrollo por el IDE o el compilador, o en tiempo de ejecución por un marco.

El procesamiento de anotaciones es un mecanismo muy poderoso y puede usarse de muchas maneras diferentes:

• para describir las restricciones o el uso de un elemento: por ejemplo @Deprecated, @Override, o@NotNull
• para describir la "naturaleza" de un elemento, p. ej. @Entity, @TestCase, @WebService
• para describir el comportamiento de un elemento: @Statefull, @Transaction
• para describir cómo procesar el elemento: @Column, @XmlElement

En todos los casos, se usa una anotación para describir el elemento y aclarar su significado .

Antes de JDK5, la información que ahora se expresa con anotaciones tenía que almacenarse en otro lugar, y los archivos XML se usaban con frecuencia. Pero es más conveniente usar anotaciones porque pertenecerán al código Java en sí mismo y, por lo tanto, son mucho más fáciles de manipular que XML.

Uso de anotaciones:

• Documentación, por ejemplo, XDoclet
• Compilacion
• IDE
• Marco de prueba, por ejemplo, JUnit
• Contenedor de IoC, por ejemplo, como Spring
• Serialización, p. Ej. XML
• Programación orientada a aspectos (AOP), por ejemplo, Spring AOP
• Servidores de aplicaciones, por ejemplo, contenedor EJB, servicio web
• Mapeo relacional de objetos (ORM), por ejemplo, Hibernate, JPA
• y muchos más...

... eche un vistazo, por ejemplo, al proyecto Lombok , que utiliza anotaciones para definir cómo generar equalso hashCodemétodos.

Existen múltiples aplicaciones para las anotaciones de Java. En primer lugar, pueden ser utilizados por el compilador (o extensiones del compilador). Considere, por ejemplo, la anotación de anulación :

class Foo {

    @Override public boolean equals(Object other) {
        return ...;
    }
}

Este está realmente integrado en Java JDK. El compilador señalará un error, si algún método está etiquetado con él, lo que no anula un método heredado de una clase base. Esta anotación puede ser útil para evitar el error común, donde realmente tiene la intención de anular un método, pero no lo hace, porque la firma dada en su método no coincide con la firma del método que se anula:

class Foo {

    @Override public boolean equals(Foo other) {  // Compiler signals an error for this one
        return ...;
    }
}

A partir de JDK7, se permiten anotaciones en cualquier tipo. Esta característica ahora se puede usar para anotaciones del compilador como NotNull , como en:

public void processSomething(@NotNull String text) {
    ...
}

lo que permite que el compilador le advierta sobre usos indebidos / no verificados de variables y valores nulos .

Otra aplicación más avanzada para anotaciones implica el procesamiento de reflexión y anotación en tiempo de ejecución. Esto es (creo) lo que tenía en mente cuando habla de anotaciones como "reemplazo de la configuración basada en XML". Este es el tipo de procesamiento de anotaciones utilizado, por ejemplo, por varios marcos y estándares JCP (persistencia, inyección de dependencia, lo que sea) para proporcionar los metadatos y la información de configuración necesarios.

Las anotaciones son una forma de metadatos (datos sobre datos) agregados a un archivo fuente Java. Los marcos los utilizan en gran medida para simplificar la integración del código del cliente. Un par de ejemplos del mundo real fuera de mi cabeza:

• JUnit 4: agrega la @Testanotación a cada método de prueba que desea que ejecute el corredor JUnit. También hay anotaciones adicionales relacionadas con la configuración de pruebas (como @Beforey @BeforeClass). Todos estos son procesados ​​por el corredor JUnit, que ejecuta las pruebas en consecuencia. Se podría decir que es un reemplazo para la configuración XML, pero las anotaciones a veces son más potentes (pueden usar la reflexión, por ejemplo) y también están más cerca del código al que hacen referencia (la @Testanotación está justo antes del método de prueba, por lo que el propósito de ese método es claro, sirve como documentación también). La configuración XML, por otro lado, puede ser más compleja y puede incluir muchos más datos que las anotaciones.

• Terracota: utiliza anotaciones y archivos de configuración XML. Por ejemplo, la @Rootanotación le dice al tiempo de ejecución de Terracota que el campo anotado es una raíz y que su memoria debe compartirse entre las instancias de VM. El archivo de configuración XML se usa para configurar el servidor y decirle qué clases instrumentar.

• Google Guice: un ejemplo sería la @Injectanotación, que cuando se aplica a un constructor hace que el tiempo de ejecución de Guice busque valores para cada parámetro, en función de los inyectores definidos. La @Injectanotación sería bastante difícil de replicar utilizando archivos de configuración XML, y su proximidad al constructor al que hace referencia es bastante útil (imagine tener que buscar en un gran archivo XML para encontrar todas las inyecciones de dependencia que ha configurado).

Espero haberle dado una idea de cómo se usan las anotaciones en diferentes marcos.

Las anotaciones en Java proporcionan un medio para describir clases, campos y métodos. Esencialmente, son una forma de metadatos agregados a un archivo fuente Java, no pueden afectar la semántica de un programa directamente. Sin embargo, las anotaciones se pueden leer en tiempo de ejecución utilizando Reflection y este proceso se conoce como Introspección. Entonces podría usarse para modificar clases, campos o métodos.

Las bibliotecas y los SDK (hibernate, JUnit, Spring Framework) a menudo explotan esta característica para simplificar o reducir la cantidad de código que un programador haría a menos que haga un trabajo para trabajar con estas bibliotecas o SDK. Por lo tanto, es justo decir Anotaciones y Trabajo de reflexión de la mano en Java.

También podemos limitar la disponibilidad de una anotación ya sea en tiempo de compilación o en tiempo de ejecución. A continuación se muestra un ejemplo simple de cómo crear una anotación personalizada

Driver.java

package io.hamzeen;

import java.lang.annotation.Annotation;

public class Driver {

    public static void main(String[] args) {
        Class<TestAlpha> obj = TestAlpha.class;
        if (obj.isAnnotationPresent(IssueInfo.class)) {

            Annotation annotation = obj.getAnnotation(IssueInfo.class);
            IssueInfo testerInfo = (IssueInfo) annotation;

            System.out.printf("%nType: %s", testerInfo.type());
            System.out.printf("%nReporter: %s", testerInfo.reporter());
            System.out.printf("%nCreated On: %s%n%n",
                    testerInfo.created());
        }
    }
}

TestAlpha.java

package io.hamzeen;

import io.hamzeen.IssueInfo;
import io.hamzeen.IssueInfo.Type;

@IssueInfo(type = Type.IMPROVEMENT, reporter = "Hamzeen. H.")
public class TestAlpha {

}

IssueInfo.java

package io.hamzeen;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author Hamzeen. H.
 * @created 10/01/2015
 * 
 * IssueInfo annotation definition
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface IssueInfo {

    public enum Type {
        BUG, IMPROVEMENT, FEATURE
    }

    Type type() default Type.BUG;

    String reporter() default "Vimesh";

    String created() default "10/01/2015";
}

¿Es un reemplazo para la configuración basada en XML?

No del todo, pero la configuración que corresponde estrechamente a las estructuras de código (como los mapeos de JPA o la inyección de dependencia en Spring) a menudo se puede reemplazar con anotaciones y, por lo general, es mucho menos detallada, molesta y dolorosa. Casi todos los marcos notables han hecho este cambio, aunque la configuración XML anterior generalmente permanece como una opción.

Hay 2 vistas de anotaciones

1. la vista del usuario, la mayoría de las veces, las anotaciones funcionan como un atajo, le permiten presionar algunas teclas o hacen que su programa sea más legible

2. vista del proveedor, la vista de anotación del procesador es más bien una 'interfaz' ligera, su programa se enfrenta a ALGO pero sin "implementar" explícitamente la interfaz particular (aquí también conocida como la anotación)

por ejemplo, en jpa define algo como

@Entity class Foo {...}

en vez de

class Foo implements Entity {...}

ambos hablan lo mismo "Foo es una clase de entidad"

Dónde se pueden usar las anotaciones

Las anotaciones se pueden aplicar a declaraciones: declaraciones de clases, campos, métodos y otros elementos del programa. Cuando se usa en una declaración, cada anotación a menudo aparece, por convención, en su propia línea.

Actualización de Java SE 8: las anotaciones también se pueden aplicar al uso de tipos. Aquí hay unos ejemplos:

• Expresión de creación de instancia de clase:

  nuevo @Interned MyObject ();

• Tipo de reparto:

  myString = (@NonNull String) str;

• implementa la cláusula:

  class UnmodifiableList implementa @Readonly List <@Readonly T> {...}

• Declaración de excepción lanzada:

  vacío monitorTemperature () arroja @Critical TemperatureException {...}

Los marcos como Hibernate donde se requiere mucha configuración / mapeo usan Anotaciones en gran medida.

Echa un vistazo a las anotaciones de Hibernate

JPA (de Java EE 5) es un excelente ejemplo del uso (excesivo) de anotaciones. Java EE 6 también introducirá anotaciones en muchas áreas nuevas, como los servicios web RESTful y nuevas anotaciones para cada una de las API de Servlet.

Aquí hay varios recursos:

• Sun - La API de persistencia de Java
• Tutorial de Java EE 5 - JPA
• Presentamos la plataforma Java EE 6 (consulte las tres páginas).

No son solo los detalles de configuración los que se deben / pueden tomar por anotaciones, sino que también se pueden usar para controlar el comportamiento. Ves esto bien en los ejemplos JAX-RS de Java EE 6.

Es útil para anotar sus clases, ya sea a nivel de método, clase o campo, algo sobre esa clase que no está muy relacionado con la clase.

Puede tener sus propias anotaciones, que se usan para marcar ciertas clases como uso de prueba solamente. Podría ser simplemente para fines de documentación, o podría aplicarlo filtrándolo durante la compilación de un candidato de lanzamiento de producción.

Puede usar anotaciones para almacenar algunos metadatos, como en un marco de complemento, por ejemplo, el nombre del complemento.

Es solo otra herramienta, tiene muchos propósitos.

Adjunta información adicional sobre el código mediante (a) verificación del compilador o (b) análisis de código

** **

• Las siguientes son las anotaciones incorporadas :: 2 tipos

** **

Tipo 1) Anotaciones aplicadas al código java:

@Override // gives error if signature is wrong while overriding.
Public boolean equals (Object Obj) 

@Deprecated // indicates the deprecated method
Public doSomething()....

@SuppressWarnings() // stops the warnings from printing while compiling.
SuppressWarnings({"unchecked","fallthrough"})

Tipo 2) Anotaciones aplicadas a otras anotaciones:

@Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at run-time through reflection.

@Documented - Marks another annotation for inclusion in the documentation.

@Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to

@Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

** **

• Anotaciones personalizadas ::

** http://en.wikipedia.org/wiki/Java_annotation#Custom_annotations

PARA MEJOR INTENTAR INTENTAR ABAJO DEL ENLACE: ELABORAR CON EJEMPLOS

http://www.javabeat.net/2007/08/annotations-in-java-5-0/

Las anotaciones pueden usarse como una alternativa a los archivos de configuración externos, pero no pueden considerarse un reemplazo completo. Puede encontrar muchos ejemplos en los que se han utilizado anotaciones para reemplazar archivos de configuración, como Hibernate, JPA, EJB 3 y casi todas las tecnologías incluidas en Java EE.

De todos modos, esto no siempre es una buena opción. El propósito de usar archivos de configuración es generalmente separar el código de los detalles del entorno donde se ejecuta la aplicación. En tales situaciones, y principalmente cuando la configuración se utiliza para asignar la aplicación a la estructura de un sistema externo, las anotaciones no son un buen reemplazo para el archivo de configuración, ya que le permiten incluir los detalles del sistema externo dentro del código fuente de su aplicación. Aquí los archivos externos deben considerarse la mejor opción, de lo contrario, deberá modificar el código fuente y volver a compilar cada vez que cambie un detalle relevante en el entorno de ejecución.

Las anotaciones son mucho más adecuadas para decorar el código fuente con información adicional que instruye a las herramientas de procesamiento, tanto en tiempo de compilación como en tiempo de ejecución, para manejar clases y estructuras de clase de manera especial. @Overridey JUnit @Testson buenos ejemplos de tal uso, ya explicados en detalle en otras respuestas.

Al final, la regla es siempre la misma: mantener dentro de la fuente las cosas que cambian con la fuente, y mantener fuera de la fuente las cosas que cambian independientemente de la fuente.

Java EE 5 favorece el uso de anotaciones sobre la configuración XML. Por ejemplo, en EJB3, los atributos de transacción en un método EJB se especifican mediante anotaciones. Incluso usan anotaciones para marcar POJO como EJB y para especificar métodos particulares como métodos de ciclo de vida en lugar de requerir la implementación de una interfaz.

El propósito de una anotación Java es simplemente asociar información con el elemento anotado del programa. Las anotaciones de Java se pueden usar como modificadores en cualquier declaración, ya sea paquete, clase (incluidas las enumeraciones), interfaz (incluidos los tipos de anotación), campo, método, parámetro formal, constructor o variable local.

Las anotaciones de Java también se pueden usar en constantes enum. Dichas anotaciones se colocan inmediatamente antes de la constante enum que anotan. Las anotaciones de Java se colocan convencionalmente antes que todos los demás modificadores, pero esto no es un requisito; pueden mezclarse libremente con otros modificadores.

Lea en detalle las anotaciones de Java .

Los siguientes son algunos de los lugares donde puede usar anotaciones.

a. Annotations can be used by compiler to detect errors and suppress warnings
b. Software tools can use annotations to generate code, xml files, documentation etc., For example, Javadoc use annotations while generating java documentation for your class.
c. Runtime processing of the application can be possible via annotations.
d. You can use annotations to describe the constraints (Ex: @Null, @NotNull, @Max, @Min, @Email).
e. Annotations can be used to describe type of an element. Ex: @Entity, @Repository, @Service, @Controller, @RestController, @Resource etc.,
f. Annotation can be used to specify the behaviour. Ex: @Transactional, @Stateful
g. Annotation are used to specify how to process an element. Ex: @Column, @Embeddable, @EmbeddedId
h. Test frameworks like junit and testing use annotations to define test cases (@Test), define test suites (@Suite) etc.,
i. AOP (Aspect Oriented programming) use annotations (@Before, @After, @Around etc.,)
j. ORM tools like Hibernate, Eclipselink use annotations

Puede consultar este enlace para obtener más detalles sobre anotaciones.

Puede consultar este enlace para ver cómo se usan las anotaciones para crear un conjunto de pruebas simple.