处理注释的最佳方法

Question

I have 3 different kinds of custom annotations. Assume those are Annotation1,Annotation2,Annotation3.

I was applied these 3 annotations to some of the fields in my class. Now I am extracting/getting all the fields which are assigned these 3 annotations. So for that I wrote a method like

public List<Field> getAnnotation1Fields(Annotation1 argAnnotation1){
     // Code to extract those fields...
}

So for my 3 annotations I need to write 3 different methods like

public List<Field> getAnnotation2Fields(Annotation2 argAnnotation2){
     // Code to extract those fields...
}

public List<Field> getAnnotation3Fields(Annotation3 argAnnotation3){
     // Code to extract those fields...
}

In the above methods the Extraction logic is same but the parameter type is different (Argument). Here my question is how can I call these three methods on single annotation...? So that one common method can be called for any type of annotation (Including our custom annotations).

Answer 1

Use method generics - You can define a variable type parameter for methods, as well as classes, like so:

public <T> List<Field> getAnnotationFields(T argAnnotation) {
  // Get fields with annotation type T
}

And then you can call it as easily as:

Annotation3 thingy = ...;
getAnnotationFields(thingy); // Extracts fields for Annotation3

Answer 2

public List<Field> getAnnotatedFields(java.lang.annotation.Annotation annotation)

or

public List<Field> getAnnotatedFields(Class<? extends Annotation> annotationType)

depending on what you have instance (first) or type (second).

Answer 3

You could do it with this simple method:

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

public static List<Field> getAnnotatedFields(Class<?> clazz, Class<? extends Annotation> annotationType) {
    Field[] declaredFields = clazz.getDeclaredFields();
    List<Field> annotatedFields = new LinkedList<>();
    for(Field field : declaredFields) {
        if(field.getAnnotation(annotationType) != null)
            annotatedFields.add(field);
    }
    return annotatedFields;
}

Usage example:

getAnnotatedFields(TestClass.class, Deprecated.class);

Answer 4

I hope that's closer to your needs:

static <A extends Annotation> Map<String,A> getField2Annotation(
  Class<?> declaringClass, Class<A> annotationType) {

  Field[] fields=declaringClass.getDeclaredFields();
  Map<String, A> map=Collections.emptyMap();
  for(Field f:fields) {
    A anno=f.getAnnotation(annotationType);
    if(anno!=null) {
      if(map.isEmpty()) map=new HashMap<String, A>();
      map.put(f.getName(), anno);
    }
  }
  return map;
}

Then you can do something like this:

public class Example {
  @Retention(RetentionPolicy.RUNTIME)
  @interface Foo { String value() default "bar"; }

  @Foo static String X;
  @Foo("baz") String Y;

  public static void main(String[] args) {
    Map<String, Foo> map = getField2Annotation(Example.class, Foo.class);
    for(Map.Entry<String,Foo> e:map.entrySet()) {
      System.out.println(e.getKey()+": "+e.getValue().value());
    }
  }
}