sirven - notacion en java
¿Cómo y dónde se utilizan las anotaciones en Java? (14)
¿Es un reemplazo para la configuración basada en XML?
No completamente, pero la configuración que se corresponde estrechamente con las estructuras de código (como las asignaciones de JPA o la inyección de dependencia en Spring) a menudo se puede reemplazar con anotaciones y, por lo general, es mucho menos prolija, molesta y dolorosa. Prácticamente todos los frameworks notables han hecho este cambio, aunque la configuración XML anterior usualmente permanece como una opción.
¿Cuáles son las principales áreas en las que podemos usar Anotaciones? ¿Es la característica un reemplazo para la configuración basada en XML?
Adjunta información adicional sobre el código mediante (a) verificación de compilador o (b) análisis de código
**
- A continuación se muestran las anotaciones incorporadas :: 2 tipos
**
Tipo 1) Anotaciones aplicadas al código de 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 UNA MEJOR COMPRENSIÓN PRUEBA ABAJO LINK: ELABORAR CON EJEMPLOS
El propósito de una anotación Java es simplemente asociar información con el elemento de programa anotado. Las anotaciones Java se pueden usar como modificadores en cualquier declaración, ya sea paquete, clase (incluidas enumeraciones), interfaz (incluidos tipos de anotación), campo, método, parámetro formal, constructor o variable local.
Las anotaciones Java también se pueden usar en constantes de enum. Tales anotaciones se colocan inmediatamente antes de la constante de enumeración que anotan. Las anotaciones 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 .
Es útil para anotar sus clases, ya sea en el método, clase o nivel de campo, algo sobre esa clase que no está muy relacionado con la clase.
Puede tener sus propias anotaciones, que se utilizan para marcar ciertas clases solo como uso de prueba. Simplemente podría ser 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 plugin, por ejemplo, el nombre del plugin.
Es solo otra herramienta, tiene muchos propósitos.
Hay 2 vistas de anotaciones
la vista del usuario, la mayoría de las veces, las anotaciones funcionan como un acceso directo, le ahorran algunas pulsaciones de tecla o hacen que su programa sea más legible
vista de proveedor, la vista de anotación del procesador es más de ''interfaz'' ponderada, su programa FRENTE a ALGO pero sin implementar explícitamente la interfaz particular (aquí también la anotación)
por ejemplo, en jpa se define algo así como
@Entity class Foo {...}
en lugar de
class Foo implements Entity {...}
ambos hablan lo mismo "Foo es una clase de Entidad"
Hay varias aplicaciones para las anotaciones de Java. En primer lugar, pueden ser utilizados por el compilador (o extensiones del compilador). Considere por ejemplo la anulación de Anular :
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, en el que tiene la intención de anular un método, pero no lo hace, porque la firma proporcionada 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 ...;
}
}
El próximo JDK7 permitirá anotaciones de cualquier tipo. Ya hay propuestas para usar esta característica para anotaciones de compilación como NotNull , como en:
public void processSomething(@NotNull String text) {
...
}
lo que podría permitirle al compilador advertirle sobre los usos incorrectos / 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ías en mente cuando hablas de anotaciones como "reemplazo de la configuración basada en XML". Este es el tipo de procesamiento de anotación utilizado, por ejemplo, por varios marcos y estándares JCP (persistencia, inyección de dependencia, lo que sea) para proporcionar la información de metadatos y configuración necesaria.
JPA (de Java EE 5) es un excelente ejemplo del (sobre) uso de anotaciones. Java EE 6 también introducirá anotaciones en muchas áreas nuevas, como RESTful webservices y nuevas anotaciones para cada una de las antiguas API de Servlet.
Aquí hay varios recursos:
- Sun - La API de Java Persistence
- Tutorial de Java EE 5 - JPA
- Presentamos la plataforma Java EE 6 (verifique las tres páginas).
No solo son los detalles de la configuración los que deben ser controlados por las anotaciones, sino que también se pueden usar para controlar el comportamiento. Usted ve esto bien en los ejemplos JAX-RS de Java EE 6.
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 usando 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 esa implementación de una interfaz.
Las anotaciones en Java proporcionan un medio para describir clases, campos y métodos. Básicamente, son una forma de metadatos añadidos 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 usando Reflection y este proceso se conoce como Introspection. Luego podría usarse para modificar clases, campos o métodos.
Esta característica, a menudo es explotada por Bibliotecas y SDK (hibernación, JUnit, Spring Framework) para simplificar o reducir la cantidad de código que un programador haría a menos que trabaje con estas bibliotecas o SDK. Por lo tanto, es justo decir Anotaciones y Trabajo de reflexión mano a mano en Java.
También podemos limitar la disponibilidad de una anotación en tiempo de compilación o en tiempo de ejecución. A continuación, se muestra un ejemplo simple al 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";
}
Las anotaciones se pueden usar como una alternativa a los archivos de configuración externos, pero no se pueden considerar como un reemplazo completo. Puede encontrar muchos ejemplos donde las anotaciones se han utilizado para reemplazar archivos de configuración, como Hibernate, JPA, EJB 3 y casi todas las tecnologías incluidas en Java EE.
De todos modos, esta no es siempre una buena elección. El propósito de usar archivos de configuración suele ser separar el código de los detalles del entorno en el que se ejecuta la aplicación. En tales situaciones, y sobre todo 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 como 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 ordena a las herramientas de procesamiento, tanto en tiempo de compilación como en tiempo de ejecución, manejar las clases y las estructuras de clase de manera especial. @Override y JUnit''s @Test son buenos ejemplos de dicho uso, que ya se explicaron 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.
Las anotaciones son una forma de metadatos (datos sobre datos) agregados a un archivo fuente Java. Son ampliamente utilizados por los marcos para simplificar la integración del código del cliente. Un par de ejemplos del mundo real en la cima de mi cabeza:
JUnit 4: agrega la anotación
@Testa cada método de prueba que desee que ejecute el corredor JUnit. También hay anotaciones adicionales relacionadas con la configuración de las 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 son a veces más potentes (pueden usar el reflejo, por ejemplo) y también están más cerca del código al que hacen referencia (la anotación@Testestá justo antes del método de prueba, entonces el propósito de ese método es claro, también sirve como documentació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 anotación
@Rootle dice al tiempo de ejecución de Terracotta que el campo anotado es una raíz y que su memoria se debe compartir entre las instancias de VM. El archivo de configuración XML se utiliza para configurar el servidor y decirle qué clases instrumentar.Google Guice: un ejemplo sería la anotación
@Inject, 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 anotación@Injectserí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 enorme archivo XML para encontrar todas las inyecciones de dependencia que haya configurado).
Espero haberles dado una idea de cómo se usan las anotaciones en diferentes marcos.
Los marcos como Hibernate fueron muchos de configuración / mapeo necesarios para usar Anotaciones en gran medida.
Eche un vistazo a las anotaciones de Hibernate
Donde las anotaciones se pueden usar
Las anotaciones se pueden aplicar a las declaraciones: declaraciones de clases, campos, métodos y otros elementos del programa. Cuando se utiliza en una declaración, cada anotación a menudo aparece, por convención, en su propia línea.
Actualización 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 @ MyObject Intermedio ();
Tipo de elenco:
myString = (@NonNull String) str;
cláusula de implementaciones:
class UnmodifiableList implementa @Readonly List <@Readonly T> {...}
Declaración de excepción lanzada:
void monitorTemperature () arroja @Critical TemperatureException {...}
Las anotaciones son meta metaobjetos que se pueden usar para describir otros metaobjetos . Los meta-objetos son clases, campos y métodos. Pedir un objeto para su metaobjeto (por ejemplo, anObj.getClass() ) 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 necesita ser interpretada de una forma u otra para ser ú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 se puede usar de muchas maneras diferentes:
- para describir las restricciones o el uso de un elemento: por ejemplo
@Deprecated, @Override,@NotNullo@NotNull - para describir la "naturaleza" de un elemento, por ejemplo
@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 necesitaba 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, p. Ej. JUnit
- Contenedor de IoC, por ejemplo, como Spring
- Serialización, por ejemplo, XML
- La programación orientada a aspectos (AOP), por ejemplo, Spring AOP
- Servidores de aplicaciones, por ejemplo, contenedor EJB, servicio web
- Mapeo objeto-relacional (ORM), p. Ej., Hibernate, JPA
- y muchos más...
... busque, por ejemplo, en el proyecto Lombok , que utiliza anotaciones para definir cómo generar métodos equals o hashCode .