Reputation: 2945
I have an interface with an annotated method. The annotation is marked with @Inherited
, so I expect an implementor to inherit it. However, it is not the case:
Code:
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.util.Arrays;
public class Example {
public static void main(String[] args) throws SecurityException, NoSuchMethodException {
TestInterface obj = new TestInterface() {
@Override
public void m() {}
};
printMethodAnnotations(TestInterface.class.getMethod("m"));
printMethodAnnotations(obj.getClass().getMethod("m"));
}
private static void printMethodAnnotations(Method m) {
System.out.println(m + ": " + Arrays.toString(m.getAnnotations()));
}
}
interface TestInterface {
@TestAnnotation
public void m();
}
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface TestAnnotation {}
The above code prints:
public abstract void annotations.TestInterface.m(): [@annotations.TestAnnotation()]
public void annotations.Example$1.m(): []
So the question is why does not the obj.m()
have @TestAnnotation
despite that it implements a method marked with @TestAnnotation
which is @Inherited
?
Upvotes: 14
Views: 13309
Reputation: 163
Alternatively, you can use reflection to derive the same information. The method printMethodAnnotations
can be rewritten as:
private static void printMethodAnnotations(Method m) {
Class<?> methodDeclaredKlass = m.getDeclaringClass();
List<Class<?>> interfases = org.apache.commons.lang3.ClassUtils.getAllInterfaces(methodDeclaredKlass);
List<Annotation> annotations = new ArrayList<>();
annotations.addAll(Arrays.asList(m.getAnnotations()));
for (Class<?> interfase : interfases) {
for (Method interfaseMethod : interfase.getMethods()) {
if (areMethodsEqual(interfaseMethod, m)) {
annotations.addAll(Arrays.asList(interfaseMethod.getAnnotations()));
continue;
}
}
}
System.out.println(m + "*: " + annotations);
}
private static boolean areMethodsEqual(Method m1, Method m2) {
// return type, Modifiers are not required to check, if they are not appropriate match then it will be a compile
// time error. This needs enhancements for Generic types parameter ?
return m1.getName().equals(m2.getName()) && Arrays.equals(m1.getParameterTypes(), m2.getParameterTypes());
}
Upvotes: 3
Reputation: 5277
From the @Inherited javadoc:
Note that this meta-annotation type has no effect if the annotated type is used to annotate anything other than a class. Note also that this meta-annotation only causes annotations to be inherited from superclasses; annotations on implemented interfaces have no effect.`
In summary, it doesn't apply to methods.
Upvotes: 23
Reputation: 23812
From the javadocs of java.lang.annotation.Inherited
:
Note that this meta-annotation type has no effect if the annotated type is used to annotate anything other than a class. Note also that this meta-annotation only causes annotations to be inherited from superclasses; annotations on implemented interfaces have no effect.
Upvotes: 33