It seems like getAnnotatedParameterTypes() returns an array of AnnotatedTypes holding raw, rather than generic, types. For example:
public void genericMethod(T t) {
}
@Test
public void testAnnotatedTypes() throws ReflectiveOperationException {
Method method = getClass().getMethod("genericMethod", Object.class);
Type type = method.getGenericParameterTypes()[0];
assertTrue(type instanceof TypeVariable);
AnnotatedType annotatedType = method.getAnnotatedParameterTypes()[0];
// This fails; annotatedType implements only AnnotatedType
assertTrue(annotatedType instanceof AnnotatedTypeVariable);
// This fails too; type is a TypeVariable while annotatedType.getType() is
// Object.class
assertEquals(type, annotatedType.getType());
}
What's the reason for the disagreement with getGenericParameterTypes()?
解决方案
There's a bug report about this, and it has since been fixed.
There's a difference between Method#getGenericParameterTypes() and Method#getAnnotatedParameterTypes().
The former makes guarantees about the types it returns
If a formal parameter type is a parameterized type, the Type object
returned for it must accurately reflect the actual type parameters
used in the source code.
If a formal parameter type is a type variable or a parameterized type,
it is created. Otherwise, it is resolved.
while the latter doesn't, not clearly at least:
Returns an array of AnnotatedType objects that represent the use of
types to specify formal parameter types of the method/constructor
represented by this Executable.
We have to assume that getAnnotatedParameterTypes() returns the erased types (although it may not have been intended that way). The unbounded type variable T is erased to Object. If you had , it would be erased to Foo.
As for the comments, about getting the annotation from a type argument in a method parameter, there's no way given the above. One would think it works as it does for fields.
public static void main(String[] args) throws Exception {
Field field = Example.class.getField("field");
AnnotatedParameterizedType annotatedParameterizedType = (AnnotatedParameterizedType) field
.getAnnotatedType();
System.out.println(annotatedParameterizedType
.getAnnotatedActualTypeArguments()[0].getType());
System.out.println(Arrays.toString(annotatedParameterizedType
.getAnnotatedActualTypeArguments()[0].getAnnotations()));
}
@Retention(RetentionPolicy.RUNTIME)
@Target(value = { ElementType.TYPE_USE })
@interface Bar {
}
public List field;
which prints
class java.lang.String
[@com.example.Example$Bar()]
I very much think it's a bug that needs fixing and will be following the bug report linked above.