--- old/src/share/classes/java/lang/reflect/AnnotatedElement.java 2013-10-30 16:55:50.000000000 -0700 +++ new/src/share/classes/java/lang/reflect/AnnotatedElement.java 2013-10-30 16:55:50.000000000 -0700 @@ -27,6 +27,15 @@ import java.lang.annotation.Annotation; import java.lang.annotation.AnnotationFormatError; +import java.lang.annotation.Repeatable; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Objects; +import java.util.function.Function; +import java.util.stream.Collectors; +import sun.reflect.annotation.AnnotationSupport; +import sun.reflect.annotation.AnnotationType; /** * Represents an annotated element of the program currently running in this @@ -222,6 +231,18 @@ * The caller of this method is free to modify the returned array; it will * have no effect on the arrays returned to other callers. * + * @implSpec The default implementation first calls {@link + * #getDeclaredAnnotationsByType(Class)} passing {@code + * annotationClass} as the argument. If the returned array has + * length greater than zero, the array is returned. If the returned + * array is zero-length and this {@code AnnotatedElement} is a + * class and the argument type is an inheritable annotation type, + * and the superclass of this {@code AnnotatedElement} is non-null, + * then the returned result is the result of calling {@link + * #getAnnotationsByType(Class)} on the superclass with {@code + * annotationClass} as the argument. Otherwise, a zero-length + * array is returned. + * * @param the type of the annotation to query for and return if present * @param annotationClass the Class object corresponding to the * annotation type @@ -230,8 +251,30 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T[] getAnnotationsByType(Class annotationClass); + default T[] getAnnotationsByType(Class annotationClass) { + /* + * Definition of associated: directly or indirectly present OR + * neither directly nor indirectly present AND the element is + * a Class, the annotation type is inheritable, and the + * annotation type is associated with the superclass of the + * element. + */ + T[] result = getDeclaredAnnotationsByType(annotationClass); + + if (result.length == 0 && // Neither directly nor indirectly present + this instanceof Class && // the element is a class + AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable + Class superClass = ((Class) this).getSuperclass(); + if (superClass != null) { + // Determine if the annotation is associated with the + // superclass + result = superClass.getAnnotationsByType(annotationClass); + } + } + return result; + } + /** * Returns this element's annotation for the specified type if * such an annotation is directly present, else null. @@ -239,6 +282,11 @@ * This method ignores inherited annotations. (Returns null if no * annotations are directly present on this element.) * + * @implSpec The default implementation first performs a null check + * and then loops over the results of {@link + * #getDeclaredAnnotations} returning the first annotation whose + * annotation type matches the argument type. + * * @param the type of the annotation to query for and return if directly present * @param annotationClass the Class object corresponding to the * annotation type @@ -247,7 +295,18 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T getDeclaredAnnotation(Class annotationClass); + default T getDeclaredAnnotation(Class annotationClass) { + Objects.requireNonNull(annotationClass); + // Loop over all directly-present annotations looking for a matching one + for (Annotation annotation : getDeclaredAnnotations()) { + if (annotationClass.equals(annotation.annotationType())) { + // More robust to do a dynamic cast at runtime instead + // of compile-time only. + return annotationClass.cast(annotation); + } + } + return null; + } /** * Returns this element's annotation(s) for the specified type if @@ -268,6 +327,22 @@ * The caller of this method is free to modify the returned array; it will * have no effect on the arrays returned to other callers. * + * @implSpec The default implementation may call {@link + * #getDeclaredAnnotation(Class)} one or more times to find a + * directly present annotation and, if the annotation type is + * repeatable, to find a container annotation. If annotations of + * the annotation type {@code annotationClass} are found to be both + * directly and indirectly present, then {@link + * #getDeclaredAnnotations()} will get called to determine the + * order of the elements in the returned array. + * + *

Alternatively, the default implementation may call {@link + * #getDeclaredAnnotations()} a single time and the returned array + * examined for both directly and indirectly present + * annotations. The results of calling {@link + * #getDeclaredAnnotations()} are assumed to be consistent with the + * results of calling {@link #getDeclaredAnnotation(Class)}. + * * @param the type of the annotation to query for and return * if directly or indirectly present * @param annotationClass the Class object corresponding to the @@ -277,7 +352,16 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T[] getDeclaredAnnotationsByType(Class annotationClass); + default T[] getDeclaredAnnotationsByType(Class annotationClass) { + Objects.requireNonNull(annotationClass); + return AnnotationSupport. + getDirectlyAndIndirectlyPresent(Arrays.stream(getDeclaredAnnotations()). + collect(Collectors.toMap(Annotation::annotationType, + Function.identity(), + ((first,second) -> first), + LinkedHashMap::new)), + annotationClass); + } /** * Returns annotations that are directly present on this element.