Java seek a method with specific annotation and its annotation element

前端 未结 2 1631
臣服心动
臣服心动 2020-11-30 02:07

Suppose I have this annotation class


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodXY {
    public int x();
    pu         


        
相关标签:
2条回答
  • 2020-11-30 03:02

    try this code sample:

    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import java.lang.annotation.ElementType;
    import java.lang.reflect.InvocationTargetException;
    
    class AnotTest {
        public static void main(String... args) {
            AnnotationTest at = new AnnotationTest();
            for (Method m : at.getClass().getMethods()) {
               MethodXY mXY = (MethodXY)m.getAnnotation(MethodXY.class);
               if (mXY != null) {
                   if (mXY.x() == 3 && mXY.y() == 2){
                       try {
                           m.invoke(at);
                       } catch (IllegalAccessException e) {
                           //do nothing;
                       } catch (InvocationTargetException o) {
                           //do nothing;
                       }
                   }
               }
            }
        }
        @Retention(RetentionPolicy.RUNTIME)
        @Target(ElementType.METHOD)
        static public @interface MethodXY {
            public int x();
            public int y();
        }
    
        static class AnnotationTest {
            @MethodXY(x=5, y=5)
            public void myMethodA() {
                System.out.println("boo");
            }
    
            @MethodXY(x=3, y=2)
            public void myMethodB() {
                System.out.println("foo");
            }
        }
    }
    
    0 讨论(0)
  • 2020-11-30 03:10

    Here is a method, which returns methods with specific annotations:

    public static List<Method> getMethodsAnnotatedWith(final Class<?> type, final Class<? extends Annotation> annotation) {
        final List<Method> methods = new ArrayList<Method>();
        Class<?> klass = type;
        while (klass != Object.class) { // need to iterated thought hierarchy in order to retrieve methods from above the current instance
            // iterate though the list of methods declared in the class represented by klass variable, and add those annotated with the specified annotation
            for (final Method method : klass.getDeclaredMethods()) {
                if (method.isAnnotationPresent(annotation)) {
                    Annotation annotInstance = method.getAnnotation(annotation);
                    // TODO process annotInstance
                    methods.add(method);
                }
            }
            // move to the upper class in the hierarchy in search for more methods
            klass = klass.getSuperclass();
        }
        return methods;
    }
    

    It can be easily modified to your specific needs. Pls note that the provided method traverses class hierarchy in order to find methods with required annotations.

    Here is a method for your specific needs:

    public static List<Method> getMethodsAnnotatedWithMethodXY(final Class<?> type) {
        final List<Method> methods = new ArrayList<Method>();
        Class<?> klass = type;
        while (klass != Object.class) { // need to iterated thought hierarchy in order to retrieve methods from above the current instance
            // iterate though the list of methods declared in the class represented by klass variable, and add those annotated with the specified annotation
            for (final Method method : klass.getDeclaredMethods()) {
                if (method.isAnnotationPresent(MethodXY.class)) {
                    MethodXY annotInstance = method.getAnnotation(MethodXY.class);
                    if (annotInstance.x() == 3 && annotInstance.y() == 2) {         
                        methods.add(method);
                    }
                }
            }
            // move to the upper class in the hierarchy in search for more methods
            klass = klass.getSuperclass();
        }
        return methods;
    }
    

    For invocation of the found method(s) pls refer a tutorial. One of the potential difficulties here is the number of method arguments, which could vary between found methods and thus requiring some additional processing.

    0 讨论(0)
提交回复
热议问题