fork download
copy 
  1. import java.lang.annotation.*;
  2. import java.lang.reflect.*;
  3. import java.util.*;
  4.  
  5. @Retention(RetentionPolicy.RUNTIME)
  6. @interface Handler {}
  7. interface A<T> {
  8.     @Handler
  9.     void a(T data);
  10. }
  11.  
  12. abstract class B<V> implements A<Integer> {
  13.     @Override
  14.     public void a(Integer data) {
  15.         // implementation
  16.     }
  17.  
  18.     @Handler
  19.     public abstract void b(V data);
  20. }
  21.  
  22. class C extends B<String> {
  23.     @Override
  24.     public void b(String data) {
  25.         // implementation
  26.     }
  27. }
  28. /* Name of the class has to be "Main" only if the class is public. */
  29. class Ideone
  30. {
  31.     public static void main(String[] args)
  32.     {
  33.         Set<Method> methods = getAnnotatedMethods(C.class, Handler.class);
  34.         methods.forEach(System.out::println);
  35.     }
  36.     public static Set<Method> getAnnotatedMethods(
  37.                   Class<?> actualClass, Class<? extends Annotation> a) {
  38.         Set<Method> raw = getRawAnnotatedMethods(actualClass, a);
  39.         if(raw.isEmpty()) return raw;
  40.         Set<Method> resolved = new HashSet<>();
  41.         for(Method m: raw) {
  42.             if(m.getDeclaringClass()==actualClass) resolved.add(m);
  43.             else {
  44.                 Method x = getMoreSpecific(actualClass, m);
  45.                 resolved.add(!x.isBridge()? x: resolveGeneric(x, m));
  46.             }
  47.         }
  48.         return resolved;
  49.     }
  50.     private static Method resolveGeneric(Method x, Method m) {
  51.         final Class<?> decl = m.getDeclaringClass();
  52.         Map<Type,Type> translate = new HashMap<>();
  53.         up: for(Class<?> c=x.getDeclaringClass(); c!=decl; ) {
  54.             if(decl.isInterface()) {
  55.                 for(Type t: c.getGenericInterfaces()) {
  56.                     Class<?> e = erased(t);
  57.                     if(updateMap(decl, e, t, translate)) continue;
  58.                     c = e;
  59.                     continue up;
  60.                 }
  61.             }
  62.             Type t = c.getGenericSuperclass();
  63.             c = erased(t);
  64.             updateMap(decl, c, t, translate);
  65.         }
  66.         Class<?>[] raw = m.getParameterTypes();
  67.         Type[] generic = m.getGenericParameterTypes();
  68.         for(int ix = 0; ix<raw.length; ix++)
  69.             raw[ix] = erased(translate.getOrDefault(generic[ix], raw[ix]));
  70.         return getMoreSpecific(x.getDeclaringClass(), x, raw);
  71.     }
  72.     private static Method getMoreSpecific(Class<?> actual, Method inherited) {
  73.         return getMoreSpecific(actual, inherited, inherited.getParameterTypes());
  74.     }
  75.     private static Method getMoreSpecific(
  76.                    Class<?> actual, Method inherited, Class<?>[] pTypes) {
  77.         try {
  78.             final String name = inherited.getName();
  79.             if(inherited.getDeclaringClass().isInterface()
  80.             || Modifier.isPublic(inherited.getModifiers())) {
  81.                 return actual.getMethod(name, pTypes);
  82.             }
  83.             for(;;) try {
  84.                 return actual.getDeclaredMethod(name, pTypes);
  85.             }
  86.             catch(NoSuchMethodException ex) {
  87.                 actual = actual.getSuperclass();
  88.                 if(actual == null) throw ex;
  89.             }
  90.         }
  91.         catch(NoSuchMethodException ex) {
  92.             throw new IllegalStateException(ex);
  93.         }
  94.     }
  95.  
  96.     private static boolean updateMap(Class<?> decl, Class<?> e, Type t, Map<Type, Type> m) {
  97.         if (!decl.isAssignableFrom(e)) {
  98.             return true;
  99.         }
  100.         if(t!=e) {
  101.             TypeVariable<?>[] tp = e.getTypeParameters();
  102.             if(tp.length>0) {
  103.                 Type[] arg = ((ParameterizedType)t).getActualTypeArguments();
  104.                 for(int ix=0; ix<arg.length; ix++)
  105.                     m.put(tp[ix], erased(m.getOrDefault(arg[ix], arg[ix])));
  106.             }
  107.         }
  108.         return false;
  109.     }
  110.     private static Class<?> erased(Type t) {
  111.         if(t instanceof Class<?>) return (Class<?>)t;
  112.         if(t instanceof ParameterizedType)
  113.             return (Class<?>)((ParameterizedType)t).getRawType();
  114.         if(t instanceof TypeVariable<?>) return erased(((TypeVariable<?>)t).getBounds()[0]);
  115.         if(t instanceof GenericArrayType) return Array.newInstance(
  116.                 erased(((GenericArrayType)t).getGenericComponentType()), 0).getClass();
  117.         return erased(((WildcardType)t).getUpperBounds()[0]);
  118.     }
  119.     /**
  120.      * You may replace this with the MethodUtils.getMethodsListWithAnnotation()
  121.      * you were already using.
  122.      */
  123.     private static Set<Method> getRawAnnotatedMethods(
  124.                    Class<?> c, Class<? extends Annotation> a) {
  125.         Set<Method> s = new HashSet<>();
  126.         for(; c!=null; c=c.getSuperclass()) {
  127.             for(Method m: c.getDeclaredMethods()) {
  128.                 if(m.isAnnotationPresent(a)) s.add(m);
  129.             }
  130.             for(Class<?> ifC: c.getInterfaces()) {
  131.                 for(Method m: ifC.getMethods()) {
  132.                     if(m.isAnnotationPresent(a)) s.add(m);
  133.                 }
  134.             }
  135.         }
  136.         return s;
  137.     }
  138. }
  139.  
  140.  
Success #stdin #stdout 0.22s 2841600KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
public void C.b(java.lang.String)
public void B.a(java.lang.Integer)
https://ideone.com/fpTWfz
language:
Java (HotSpot 12)
created:
8 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!