Java 类java.lang.annotation.Repeatable 实例源码

private <T extends Annotation> Stream<Label> getLabels(final Description result, final Class<T> labelAnnotation,
                                                       final Function<T, Label> extractor) {

    final List<Label> labels = getAnnotationsOnMethod(result, labelAnnotation).stream()
            .map(extractor)
            .collect(Collectors.toList());

    if (labelAnnotation.isAnnotationPresent(Repeatable.class) || labels.isEmpty()) {
        final Stream<Label> onClassLabels = getAnnotationsOnClass(result, labelAnnotation).stream()
                .map(extractor);
        labels.addAll(onClassLabels.collect(Collectors.toList()));
    }

    return labels.stream();
}

/**
 * Get all the annotations of given <code>annotationType</code> present in given <code>element</code>, including any
 * meta-annotation and supporting repeatable annotations.
 * @param <A> Annotation type
 * @param element Annotated element to inspect (not null)
 * @param annotationType Annotation type to lookup
 * @return List of detected annotation of given <code>annotationType</code>, an empty List if none found
 */
public static <A extends Annotation> List<A> getAnnotations(AnnotatedElement element, Class<A> annotationType) {
    ObjectUtils.argumentNotNull(element, "AnnotatedElement must be not null");
    ObjectUtils.argumentNotNull(annotationType, "Annotation type must be not null");

    Class<? extends Annotation> repeatableContainerType = null;
    if (annotationType.isAnnotationPresent(Repeatable.class)) {
        repeatableContainerType = annotationType.getAnnotation(Repeatable.class).value();
    }

    List<A> annotations = new LinkedList<>();
    findAnnotations(annotations, element, annotationType, repeatableContainerType);
    return annotations;
}

/**
 * Get all the annotations of given <code>annotationType</code> present in given annotations list, including any
 * meta-annotation and supporting repeatable annotations.
 * @param <A> Annotation type
 * @param annotations Annotation list element to inspect
 * @param annotationType Annotation type to lookup
 * @return List of detected annotation of given <code>annotationType</code>, an empty List if none found
 */
@SuppressWarnings("unchecked")
public static <A extends Annotation> List<A> getAnnotations(List<Annotation> annotations, Class<A> annotationType) {
    ObjectUtils.argumentNotNull(annotationType, "Annotation type must be not null");

    if (annotations == null || annotations.isEmpty()) {
        return Collections.emptyList();
    }

    Class<? extends Annotation> repeatableContainerType = null;
    if (annotationType.isAnnotationPresent(Repeatable.class)) {
        repeatableContainerType = annotationType.getAnnotation(Repeatable.class).value();
    }

    List<A> ans = new LinkedList<>();
    for (Annotation annotation : annotations) {
        if (annotationType.equals(annotation.annotationType())) {
            ans.add((A) annotation);
        }
        if (!isInJavaLangAnnotationPackage(annotation) && !annotation.annotationType().equals(annotationType)
                && (repeatableContainerType == null
                        || !annotation.annotationType().equals(repeatableContainerType))) {
            findAnnotations(ans, annotation.annotationType(), annotationType, repeatableContainerType);
        }
    }
    return ans;
}

/**
 * Return the annotations present by type. Repeated annotations are taken
 * into account
 */
public static List<AnnotationNode> getAnnotationsByType(List<AnnotationNode> annotations,
        Class<? extends Annotation> annotation) {
    Repeatable repeatable = annotation.getAnnotation(Repeatable.class);
    return getAnnotationsByType(annotations, Type.getInternalName(annotation),
            repeatable != null ? Type.getInternalName(repeatable.value()) : null);
}

/**
 * 繰り返されたアノテーションかどうか判定する。
 * <p>属性「value」に、繰り返しのアノテーション{@link Repeatable}が付与されている
 *    アノテーションの配列を保持しているかどうかで判定する。</p>
 * @param targetAnno
 * @return
 */
private boolean isRepeated(final Annotation targetAnno) {

    try {
        final Method method = targetAnno.getClass().getMethod("value");

        // 値のクラスタイプがアノテーションの配列かどうかのチェック
        final Class<?> returnType = method.getReturnType();
        if(!(returnType.isArray() && Annotation.class.isAssignableFrom(returnType.getComponentType()))) {
            return false;
        }

        final Annotation[] annos = (Annotation[]) method.invoke(targetAnno);
        if(annos.length == 0) {
            return false;
        }

        // @Repetableアノテーションが付与されているかどうか
        if(annos[0].annotationType().getAnnotation(Repeatable.class) != null) {
            return true;
        }

    } catch (Exception e) {

    }

    return false;

}

private static Class<? extends Annotation> getContainer(Class<? extends Annotation> annoType) {
    Repeatable repeatable = annoType.getAnnotation(Repeatable.class);
    return (repeatable == null) ? null : repeatable.value();
}

private static Class<? extends Annotation> getContainer(Class<? extends Annotation> annoType) {
    Repeatable repeatable = annoType.getAnnotation(Repeatable.class);
    return (repeatable == null) ? null : repeatable.value();
}

@Test
public void findRepeatableAnnotationOnComposedAnnotation() {
    Repeatable repeatable = findAnnotation(MyRepeatableMeta1.class, Repeatable.class);
    assertNotNull(repeatable);
    assertEquals(MyRepeatableContainer.class, repeatable.value());
}

private boolean isRepeatableAnnotation() {
    return annotationClass.isAnnotationPresent(Repeatable.class);
}