¿Es posible leer el valor de una anotación en java?

Question

este es mi código:

@Column(columnName="firstname") 


private String firstName; 

@Column(columnName="lastname") 
private String lastName; 

public String getFirstName() { 
    return firstName; 
} 

public void setFirstName(String firstName) { 
    this.firstName = firstName; 
} 

public String getLastName() { 
    return lastName; 
} 

public void setLastName(String lastName) { 
    this.lastName = lastName; 
} 

es posible leer el valor de mi @Column (columnName = "XYZ123") en otra clase?

Answer 1

Nunca lo he hecho, pero parece que Reflection proporciona esto. Field es un AnnotatedElement y entonces tiene getAnnotation. This page tiene un ejemplo (copiado a continuación); bastante sencillo si conoce la clase de la anotación y si la política de anotación retiene la anotación en tiempo de ejecución. Naturalmente, si la política de retención no mantiene la anotación en tiempo de ejecución, no podrá consultarla en tiempo de ejecución.

Una respuesta que se ha eliminado desde entonces (?) Proporcionó un enlace útil al an annotations tutorial que puede ser útil; Copié el enlace aquí para que la gente pueda usarlo.

Ejemplo de this page:

import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.reflect.Method; 

@Retention(RetentionPolicy.RUNTIME) 
@interface MyAnno { 
    String str(); 

    int val(); 
} 

class Meta { 
    @MyAnno(str = "Two Parameters", val = 19) 
    public static void myMeth(String str, int i) { 
    Meta ob = new Meta(); 

    try { 
     Class c = ob.getClass(); 

     Method m = c.getMethod("myMeth", String.class, int.class); 

     MyAnno anno = m.getAnnotation(MyAnno.class); 

     System.out.println(anno.str() + " " + anno.val()); 
    } catch (NoSuchMethodException exc) { 
     System.out.println("Method Not Found."); 
    } 
    } 

    public static void main(String args[]) { 
    myMeth("test", 10); 
    } 
} 

Answer 2

Sí, si su anotación columna tiene la retención de tiempo de ejecución

@Retention(RetentionPolicy.RUNTIME) 
@interface Column { 
    .... 
} 

que puede hacer algo como esto

for (Field f: MyClass.class.getFields()) { 
    Column column = f.getAnnotation(Column.class); 
    if (column != null) 
     System.out.println(column.columnName()); 
} 

Answer 3

Por supuesto que es. Aquí es una anotación de la muestra:

@Target(ElementType.METHOD) 
@Retention(RetentionPolicy.RUNTIME) 
public @interface TestAnnotation 
{ 
    String testText(); 
} 

y un método anotado muestra:

class TestClass 
{ 
    @TestAnnotation(testText="zyx") 
    public void doSomething(){} 
} 

Y un método de muestreo en otra clase que imprime el valor de la testText:

Method[] methods = TestClass.class.getMethods(); 
for (Method m : methods) 
{ 
     if (m.isAnnotationPresent(TestAnnotation.class)) 
    { 
     TestAnnotation ta = m.getAnnotation(TestAnnotation.class); 
     System.out.println(ta.testText()); 
    } 
} 

No

mucho diferente para las anotaciones de campo como la tuya.

Cheerz!

Answer 4

Si bien todas las respuestas dadas hasta el momento son perfectamente válidas, también se debe tener en cuenta el google reflections library para un enfoque más genérico y fácil para el escaneo de anotaciones, p.

Reflections reflections = new Reflections("my.project.prefix"); 

Set<Field> ids = reflections.getFieldsAnnotatedWith(javax.persistence.Id.class); 

Answer 5

También puede utilizar los tipos genéricos, en mi caso, teniendo en cuenta todo lo dicho antes de poder hacer algo como:

public class SomeTypeManager<T> { 

    public SomeTypeManager(T someGeneric) { 

     //That's how you can achieve all previously said, with generic types. 
     Annotation[] an = someGeneric.getClass().getAnnotations(); 

    } 

} 

Recuerde que esto no Equival al 100% a SomeClass. class.get (...)();

Pero puede hacer el truco ...

Answer 6

La elaboración de la respuesta de @Cephalopod, si desea todos los nombres de columna en una lista que podría utilizar este oneliner:

List<String> columns = 
     Arrays.asList(MyClass.class.getFields()) 
       .stream() 
       .filter(f -> f.getAnnotation(Column.class)!=null) 
       .map(f -> f.getAnnotation(Column.class).columnName()) 
       .collect(Collectors.toList()); 

Answer 7

En caso común que tiene acceso privado para los campos, para que puedas' T usa getFields en la reflexión. En lugar de esto, usted debe utilizar getDeclaredFields

Así, en primer lugar, debe tener en cuenta si su anotación columna tiene la retención de tiempo de ejecución:

@Retention(RetentionPolicy.RUNTIME) 
@interface Column { 
} 

Después de que usted puede hacer algo como esto:

for (Field f: MyClass.class.getDeclaredFields()) { 
    Column column = f.getAnnotation(Column.class); 
     // ... 
} 

Obviamente, le gustaría hacer algo con el campo - establecer un nuevo valor usando el valor de anotación:

Column annotation = f.getAnnotation(Column.class); 
if (annotation != null) { 
    new PropertyDescriptor(f.getName(), Column.class).getWriteMethod().invoke(
     object, 
     myCoolProcessing(
      annotation.value() 
     ) 
    ); 
} 

Por lo tanto, el código completo se puede veía así:

for (Field f : MyClass.class.getDeclaredFields()) { 
    Column annotation = f.getAnnotation(Column.class); 
    if (annotation != null) 
     new PropertyDescriptor(f.getName(), Column.class).getWriteMethod().invoke(
       object, 
       myCoolProcessing(
         annotation.value() 
       ) 
     ); 
}