Java Repeatable类代码示例

import java.lang.annotation.Repeatable; //导入依赖的package包/类
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();
}
 

import java.lang.annotation.Repeatable; //导入依赖的package包/类
/**
 * 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;
}
 

import java.lang.annotation.Repeatable; //导入依赖的package包/类
/**
 * 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);
}
 

import java.lang.annotation.Repeatable; //导入依赖的package包/类
/**
 * 繰り返されたアノテーションかどうか判定する。
 * <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;
    
}
 

import java.lang.annotation.Repeatable; //导入依赖的package包/类
private static Class<? extends Annotation> getContainer(Class<? extends Annotation> annoType) {
    Repeatable repeatable = annoType.getAnnotation(Repeatable.class);
    return (repeatable == null) ? null : repeatable.value();
}
 

import java.lang.annotation.Repeatable; //导入依赖的package包/类
@Test
public void findRepeatableAnnotationOnComposedAnnotation() {
	Repeatable repeatable = findAnnotation(MyRepeatableMeta1.class, Repeatable.class);
	assertNotNull(repeatable);
	assertEquals(MyRepeatableContainer.class, repeatable.value());
}
 

import java.lang.annotation.Repeatable; //导入依赖的package包/类
private boolean isRepeatableAnnotation() {
    return annotationClass.isAnnotationPresent(Repeatable.class);
}