--- old/src/share/classes/java/lang/reflect/AnnotatedElement.java 2013-10-24 00:20:04.000000000 -0700 +++ new/src/share/classes/java/lang/reflect/AnnotatedElement.java 2013-10-24 00:20:04.000000000 -0700 @@ -27,6 +27,8 @@ import java.lang.annotation.Annotation; import java.lang.annotation.AnnotationFormatError; +import java.lang.annotation.Repeatable; +import java.util.Objects; /** * Represents an annotated element of the program currently running in this @@ -222,6 +224,15 @@ * 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 + * #getAnnotation(Class)} on the argument type. If the annotation + * is directly or indirectly present, it is returned in an + * one-element array. Otherwise, if the argument annotation type + * is repeatable and an annotation of the container type is + * directly or indirectly present, then the returned result is + * equal to the result of calling the {@code value} method on the + * container annotation. + * * @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 +241,10 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T[] getAnnotationsByType(Class annotationClass); - + default T[] getAnnotationsByType(Class annotationClass) { + return AnnotatedElementSupport.getAnnotationsByTypeDeclaredOrNot(this, annotationClass, false); + } + /** * Returns this element's annotation for the specified type if * such an annotation is directly present, else null. @@ -239,6 +252,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 +265,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); + Annotation[] annotations = getDeclaredAnnotations(); // All directly-present annotations + for (Annotation annotation : annotations) { + if (annotationClass.equals(annotation.annotationType())) { + // More robust to do a 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 +297,15 @@ * 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 + * #getDeclaredAnnotation(Class)} on the argument type. If the + * annotation is directly present, it is returned in an + * one-element array. Otherwise, if the argument annotation type + * is repeatable and an annotation of the container type is + * directly present, then the returned result is equal to the + * result of calling the {@code value} method on the container + * annotation. + * * @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 +315,9 @@ * @throws NullPointerException if the given annotation class is null * @since 1.8 */ - T[] getDeclaredAnnotationsByType(Class annotationClass); + default T[] getDeclaredAnnotationsByType(Class annotationClass) { + return AnnotatedElementSupport.getAnnotationsByTypeDeclaredOrNot(this, annotationClass, true); + } /** * Returns annotations that are directly present on this element. --- old/src/share/classes/sun/reflect/annotation/AnnotationSupport.java 2013-10-24 00:20:05.000000000 -0700 +++ new/src/share/classes/sun/reflect/annotation/AnnotationSupport.java 2013-10-24 00:20:05.000000000 -0700 @@ -187,10 +187,12 @@ } - /* Reflectively invoke the values-method of the given annotation - * (container), cast it to an array of annotations and return the result. + /* + * Reflectively invoke the values-method of the given annotation + * (container), cast it to an array of annotations and return the + * result. */ - private static A[] getValueArray(Annotation container) { + public static A[] getValueArray(Annotation container) { try { // According to JLS the container must have an array-valued value // method. Get the AnnotationType, get the "value" method and invoke @@ -211,16 +213,12 @@ // return-value in the method that call this method. @SuppressWarnings("unchecked") A[] values = (A[]) m.invoke(container); - return values; - } catch (IllegalAccessException | // couldn't loosen security IllegalArgumentException | // parameters doesn't match InvocationTargetException | // the value method threw an exception ClassCastException e) { - throw invalidContainerException(container, e); - } } --- /dev/null 2013-10-23 13:21:49.554975487 -0700 +++ new/src/share/classes/java/lang/reflect/AnnotatedElementSupport.java 2013-10-24 00:20:05.000000000 -0700 @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package java.lang.reflect; + +import java.lang.annotation.*; +import java.util.Objects; +import sun.reflect.annotation.AnnotationSupport; +import sun.reflect.annotation.AnnotationType; + +/** + * This class provides static utility methods to be called by + * implementations of {@link AnnotatedElement}, including the default + * methods in that interface. + */ +class AnnotatedElementSupport { + public static T[] getAnnotationsByTypeDeclaredOrNot(AnnotatedElement element, + Class annotationClass, + boolean declared) { + Objects.requireNonNull(annotationClass); + T annotation = (declared ? + element.getDeclaredAnnotation(annotationClass): + element.getAnnotation(annotationClass)); + @SuppressWarnings("unchecked") + T[] annotations = (T[]) Array.newInstance(annotationClass, 0); + int resultSize = 0; + + // If the annotation type is directly present, return it boxed + // in an array. + if (annotation != null) { + resultSize = 1; + } else { // Otherwise, if the annotation type is repeatable, + // look through a container if one is present + Repeatable repeatable = annotationClass.getAnnotation(Repeatable.class); + if (repeatable != null) { // T is a repeatable annotation type + Class containerType = repeatable.value(); + Annotation container = (declared ? + element.getDeclaredAnnotation(containerType): + element.getAnnotation(containerType)); + if (container != null) { + annotations = AnnotationSupport.getValueArray(container); + resultSize = annotations.length; + if (resultSize == 1) + annotation = annotations[0]; + } + } + } + + @SuppressWarnings("unchecked") + T[] returnValue = (T[]) Array.newInstance(annotationClass, resultSize); + switch (resultSize) { + case 0: + break; // Nothing else do to + case 1: + returnValue[0] = annotation; + break; + default: + for (int i = 0; i < resultSize; i++) { + returnValue[i] = annotations[i]; + } + break; + } + return returnValue; + } +}