È ansible leggere il valore di un’annotazione in java?

questo è il mio codice:

@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; } 

è ansible leggere il valore della mia annotazione @Column ( columnName = “xyz123”) in un’altra class?

Sì, se l’annotazione della colonna ha la conservazione del runtime

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

puoi fare qualcosa di simile

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

Ovviamente è. Ecco un’annotazione di esempio:

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

E un esempio di metodo annotato:

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

E un metodo di esempio in un’altra class che stampa il valore del 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()); } } 

Non molto diverso per le annotazioni sul campo come il tuo.

Cheerz!

Non l’ho mai fatto, ma sembra che Reflection fornisca questo. Field è un AnnotatedElement e quindi ha getAnnotation . Questa pagina ha un esempio (copiato sotto); abbastanza semplice se si conosce la class dell’annotazione e se il criterio di annotazione mantiene l’annotazione in fase di esecuzione. Naturalmente se il criterio di conservazione non mantiene l’annotazione in fase di esecuzione, non sarà ansible interrogarlo in fase di runtime.

Una risposta che è stata eliminata (?) Ha fornito un utile collegamento a un tutorial di annotazioni che potresti trovare utile; Ho copiato il link qui così le persone possono usarlo.

Esempio da questa pagina :

 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); } } 

Mentre tutte le risposte date finora sono perfettamente valide, si dovrebbe anche tenere a mente la libreria di google reflections per un approccio più generico e facile alla scansione delle annotazioni, ad es.

  Reflections reflections = new Reflections("my.project.prefix"); Set ids = reflections.getFieldsAnnotatedWith(javax.persistence.Id.class); 

Elaborando la risposta di @ Cefalopode, se si desidera che tutti i nomi di colonna in un elenco si possa utilizzare questo oneliner:

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

Puoi anche usare tipi generici, nel mio caso, tenendo conto di tutto ciò che è stato detto prima di poter fare qualcosa del tipo:

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

Ricorda che questo non sarà equivalente al 100% a SomeClass.class.get (…) ();

Ma può fare il trucco …

Nel caso comune hai accesso privato per i campi, quindi NON puoi usare getFields in reflection. Invece di questo dovresti usare getDeclaredFields

Quindi, in primo luogo, dovresti sapere se l’annotazione della colonna ha la conservazione del runtime:

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

Dopo di che puoi fare qualcosa del genere:

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

Ovviamente, ti piacerebbe fare qualcosa con il campo – impostare un nuovo valore usando il valore di annotazione:

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

Quindi, il codice completo può essere simile a questo:

 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() ) ); }