Comprender la anotación en Java

Question

Estaba intentando buscar material en línea para aprender a anotar en Java.

En el siguiente código, ¿qué pasó con mi querido "Hello world" cadena que pasé en esta línea: @Test_Target(doTestTarget="Hello World !")?

@Target(ElementType.METHOD) 
public @interface Test_Target { 
    public String doTestTarget(); 
} 

anterior es la anotación definida y por debajo es su uso

public class TestAnnotations { 
    @Test_Target(doTestTarget="Hello World !") 
    private String str; 
    public static void main(String arg[]) { 
     new TestAnnotations().doTestTarget(); 
    } 
    public void doTestTarget() { 
     System.out.printf("Testing Target annotation"); 
    } 
} 

Cuando ejecuto el código que sólo se imprime Testing Target annotation

por favor me ayude, estoy completamente nueva a la anotación.

Answer 1

anotaciones son básicamente bits de datos que se puede unir a los campos, métodos, clases, etc.

La sintaxis para declarar anotaciones en Java es un poco incómodo . Se parecen un poco a las interfaces (son, después de todo, declaradas con @interface), pero en realidad no son interfaces. Creo que podría haber puesto el método doTestTarget() en su clase TestAnnotations porque pensó que su anotación era una interfaz y que necesitaba implementarla. Esto no es cierto: puede eliminar este método y la llamada desde su código, si lo desea y no le causará ningún problema.

Además, es posible que no haya pensado poner la anotación en el campo str. Las anotaciones se aplican solo a lo que les sigue inmediatamente. Como resultado, su código no se compila, porque ha aplicado su anotación a un campo pero ha declarado que su anotación solo se puede aplicar a los métodos. Cambie @Target(ElementType.METHOD) a @Target(ElementType.FIELD) y su código debe compilarse.

En cuanto a lo que sucede con la cadena Hello World !, se escribe en el archivo .class y está disponible para cualquier herramienta que lea en las clases de Java. Sin embargo, no estaría necesariamente disponible en la JVM en tiempo de ejecución. Esto sucede porque no especificó un @Retention para su anotación @Test_Target. El valor predeterminado para @Retention es RetentionPolicy.CLASS, lo que significa que la JVM podría no molestarse en cargarlos fuera del archivo de clase. (Consulte Javadoc for the RetentionPolicy enum.)

Imagino que desea ver alguna forma de leer el valor de esta anotación en tiempo de ejecución.Si es así, recomiendo agregar @Retention(RetentionPolicy.RUNTIME) a su anotación para asegurarse de que estará disponible en tiempo de ejecución.

Para acceder a su anotación y el valor que contiene en tiempo de ejecución, debe usar la reflexión. He reescrito la clase TestAnnotations de la siguiente manera para dar una rápida demostración:

import java.lang.reflect.Field; 

public class TestAnnotations { 

    @Test_Target(doTestTarget="Hello World !") 
    private String str; 

    public static void main(String[] args) throws Exception { 
     // We need to use getDeclaredField here since the field is private. 
     Field field = TestAnnotations.class.getDeclaredField("str"); 
     Test_Target ann = field.getAnnotation(Test_Target.class); 
     if (ann != null) { 
     System.out.println(ann.doTestTarget()); 
     } 
    } 
} 

Cuando ejecuto el código, me da el siguiente resultado:

 
Hello World ! 

Answer 2

En principio, agregar una anotación por sí solo no altera fundamentalmente el comportamiento de los programas.

En su caso, ha creado una nueva anotación tipo @Test_Target, que se puede utilizar en cualquier método (como lo indica su anotación @Target).

Luego aplicó esto no a un método, sino al campo str (que debería dar un error de compilación, creo).

Independientemente de esto, está creando un objeto con un método doTestTarget, y lo invoca, y obtiene el resultado esperado (es decir, se ejecuta el método).

Si desea que su anotación haga algo más que simplemente estar allí y proporcionar cierta información para el lector de la fuente, debe usarla, ya sea con un procesador de anotación en tiempo de compilación o utilizando el tiempo de ejecución (entonces sería necesario también @Retention(RUNTIME) como una anotación en Test_Target.)

Answer 3

En el espíritu de aprendizaje, de otro modo es utilizar la clase anotada sin orientar un método o campo. En primer lugar declarar su interfaz con el método que necesita y directiva de retención a Tiempo de ejecución

import java.lang.annotation.*; 

@Retention(RetentionPolicy.RUNTIME) 
public @interface Test_Target { 
    public String doTestTarget() default "default string"; 
} 

continuación, realizar anotaciones en el interfaz creada a su clase. De su clase, encuentre la clase anotada y luego llame al método con ella.

import java.lang.annotation.Annotation; 
import java.lang.reflect.AnnotatedElement; 

@Test_Target(doTestTarget="Hello World !") 
public class TestAnnotations { 

public static void main(String[] args) throws Exception 
{  
    AnnotatedElement c = TestAnnotations.class; 
    if(c.isAnnotationPresent(Test_Target.class)) 
    { 
     Annotation singleAnnotation = c.getAnnotation(Test_Target.class); 
     Test_Target tt = (Test_Target) singleAnnotation; 
     System.out.println(tt.doTestTarget()); 
    }  
} 

}

el resultado es: Hello World!