org.springframework.core.annotation.MergedAnnotations.SearchStrategy Java Examples

private Stream<String> scan(AnnotatedElement element, SearchStrategy searchStrategy) {
	List<String> result = new ArrayList<>();
	AnnotationsScanner.scan(this, element, searchStrategy,
			(criteria, aggregateIndex, source, annotations) -> {
				for (Annotation annotation : annotations) {
					if (annotation != null) {
						String name = ClassUtils.getShortName(
								annotation.annotationType());
						name = name.substring(name.lastIndexOf(".") + 1);
						result.add(aggregateIndex + ":" + name);
					}
				}
				return null;
			});
	return result.stream();
}
 

@Override
@Nullable
public org.springframework.jmx.export.metadata.ManagedAttribute getManagedAttribute(Method method) throws InvalidMetadataException {
	MergedAnnotation<ManagedAttribute> ann = MergedAnnotations.from(method, SearchStrategy.EXHAUSTIVE)
			.get(ManagedAttribute.class).withNonMergedAttributes();
	if (!ann.isPresent()) {
		return null;
	}

	org.springframework.jmx.export.metadata.ManagedAttribute bean = new org.springframework.jmx.export.metadata.ManagedAttribute();
	Map<String, Object> map = ann.asMap();
	MutablePropertyValues pvs = new MutablePropertyValues(map);
	pvs.removePropertyValue("defaultValue");
	PropertyAccessorFactory.forBeanPropertyAccess(bean).setPropertyValues(pvs);
	String defaultValue = (String) map.get("defaultValue");
	if (defaultValue.length() > 0) {
		bean.setDefaultValue(defaultValue);
	}
	return bean;
}
 

@Test
public void getWithInheritedAnnotationsFromNonInheritedAnnotationInterface() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			NonInheritedAnnotationInterface.class,
			SearchStrategy.INHERITED_ANNOTATIONS).get(Order.class);
	assertThat(annotation.isPresent()).isTrue();
}
 

@Test
public void getDirectRepeatablesDeclaredOnClass() {
	Class<?> element = MyRepeatableClass.class;
	String[] expectedValuesJava = { "A", "B", "C" };
	String[] expectedValuesSpring = { "A", "B", "C", "meta1" };
	testRepeatables(SearchStrategy.DIRECT, element, expectedValuesJava,
			expectedValuesSpring);
}
 

@Test
public void inheritedAnnotationsWhenComposedMixedWithContainerOnClassReturnsAnnotations() {
	Set<PeteRepeat> annotations = getAnnotations(null, PeteRepeat.class,
			SearchStrategy.INHERITED_ANNOTATIONS,
			ComposedRepeatableMixedWithContainerClass.class);
	assertThat(annotations.stream().map(PeteRepeat::value)).containsExactly("A", "B",
			"C");
}
 

@Test
public void getWithExhaustiveInheritedFromAbstractMethod()
		throws NoSuchMethodException {
	Method method = ConcreteClassWithInheritedAnnotation.class.getMethod("handle");
	MergedAnnotation<?> annotation = MergedAnnotations.from(method,
			SearchStrategy.EXHAUSTIVE).get(Transactional.class);
	assertThat(annotation.isPresent()).isTrue();
	assertThat(annotation.getAggregateIndex()).isEqualTo(1);
}
 

private <A extends Annotation> Set<A> getAnnotations(
		Class<? extends Annotation> container, Class<A> repeatable,
		SearchStrategy searchStrategy, AnnotatedElement element) {
	RepeatableContainers containers = RepeatableContainers.of(repeatable, container);
	MergedAnnotations annotations = MergedAnnotations.from(element,
			searchStrategy, containers, AnnotationFilter.PLAIN);
	return annotations.stream(repeatable).collect(
			MergedAnnotationCollectors.toAnnotationSet());
}
 

@Test
public void inheritedAnnotationsStrategyOnClassWhenHasAnnotationOnBothClassesIncudesOnlyOne() {
	Class<?> source = WithSingleSuperclassAndDoubleInherited.class;
	assertThat(Arrays.stream(source.getAnnotations()).map(
			Annotation::annotationType).map(Class::getName)).containsExactly(
					TestInheritedAnnotation2.class.getName());
	assertThat(scan(source, SearchStrategy.INHERITED_ANNOTATIONS)).containsOnly(
			"0:TestInheritedAnnotation2");
}
 

@Test
public void getWithInheritedAnnotationsFavorsLocalComposedAnnotationOverInheritedAnnotation() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			SubClassWithInheritedAnnotation.class,
			SearchStrategy.INHERITED_ANNOTATIONS).get(Transactional.class);
	assertThat(annotation.getBoolean("readOnly")).isTrue();
}
 

@Test
public void getDirectFromClassgetDirectFromClassMetaMetaAnnotatedClass() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			MetaMetaAnnotatedClass.class, SearchStrategy.EXHAUSTIVE).get(
					Component.class);
	assertThat(annotation.getString("value")).isEqualTo("meta2");
}
 

@Test
public void getWithExhaustiveFromInheritedAnnotationInterface() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			InheritedAnnotationInterface.class, SearchStrategy.EXHAUSTIVE).get(
					Transactional.class);
	assertThat(annotation.isPresent()).isTrue();
	assertThat(annotation.getAggregateIndex()).isEqualTo(0);
}
 

@Test
public void WithInheritedAnnotationsFromAliasedComposedAnnotation() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			AliasedComposedContextConfigurationClass.class,
			SearchStrategy.INHERITED_ANNOTATIONS).get(ContextConfiguration.class);
	assertThat(annotation.getStringArray("value")).containsExactly("test.xml");
	assertThat(annotation.getStringArray("locations")).containsExactly("test.xml");
}
 

@Test
public void WithInheritedAnnotationsFromAliasedValueComposedAnnotation() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			AliasedValueComposedContextConfigurationClass.class,
			SearchStrategy.INHERITED_ANNOTATIONS).get(ContextConfiguration.class);
	assertThat(annotation.getStringArray("value")).containsExactly("test.xml");
	assertThat(annotation.getStringArray("locations")).containsExactly("test.xml");
}
 

@Test
public void exhaustiveAnnotationsWhenNoninheritedComposedRepeatableOnClassReturnsAnnotations() {
	Set<Noninherited> annotations = getAnnotations(null, Noninherited.class,
			SearchStrategy.EXHAUSTIVE, NoninheritedRepeatableClass.class);
	assertThat(annotations.stream().map(Noninherited::value)).containsExactly("A",
			"B", "C");
}
 

private void testGetWithInherited(Class<?> element, String... expected) {
	MergedAnnotation<?> annotation = MergedAnnotations.from(element,
			SearchStrategy.INHERITED_ANNOTATIONS).get(ContextConfiguration.class);
	assertThat(annotation.getStringArray("locations")).isEqualTo(expected);
	assertThat(annotation.getStringArray("value")).isEqualTo(expected);
	assertThat(annotation.getClassArray("classes")).isEmpty();
}
 

@Test
public void getDirectFromClassWithSubSubNonInheritedAnnotationInterface() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			SubSubNonInheritedAnnotationInterface.class,
			SearchStrategy.EXHAUSTIVE).get(Order.class);
	assertThat(annotation.getAggregateIndex()).isEqualTo(2);
}
 

@Test
public void getWithInheritedAnnotationsFromHalfConventionBasedAndHalfAliasedComposedAnnotation1() {
	// SPR-13554: convention mapping mixed with AlaisFor annotations
	// xmlConfigFiles can be used because it has an AlaisFor annotation
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			HalfConventionBasedAndHalfAliasedComposedContextConfigurationClass1.class,
			SearchStrategy.INHERITED_ANNOTATIONS).get(ContextConfiguration.class);
	assertThat(annotation.getStringArray("locations")).containsExactly(
			"explicitDeclaration");
	assertThat(annotation.getStringArray("value")).containsExactly(
			"explicitDeclaration");
}
 

@Test // SPR-16060
public void getFromMethodWithGenericInterface() throws Exception {
	Method method = ImplementsInterfaceWithGenericAnnotatedMethod.class.getMethod(
			"foo", String.class);
	assertThat(MergedAnnotations.from(method, SearchStrategy.EXHAUSTIVE).get(
			Order.class).getDepth()).isEqualTo(0);
}
 

@Test
public void getWithAnnotationOnRoot() throws Exception {
	Method method = Leaf.class.getMethod("annotatedOnRoot");
	assertThat(method.getAnnotation(Order.class)).isNotNull();
	assertThat(MergedAnnotations.from(method).get(Order.class).getDepth()).isEqualTo(
			0);
	assertThat(MergedAnnotations.from(method, SearchStrategy.EXHAUSTIVE).get(
			Order.class).getDepth()).isEqualTo(0);
}
 

@Test
public void getDirectFromClassWithInheritedAnnotationInterface() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			InheritedAnnotationInterface.class, SearchStrategy.EXHAUSTIVE).get(
					Transactional.class);
	assertThat(annotation.getAggregateIndex()).isEqualTo(0);
}
 

@Test
public void collectMultiValueMapFavorsInheritedComposedAnnotationsOverMoreLocallyDeclaredComposedAnnotations() {
	MultiValueMap<String, Object> map = MergedAnnotations.from(
			SubSubClassWithInheritedComposedAnnotation.class,
			SearchStrategy.INHERITED_ANNOTATIONS).stream(Transactional.class).collect(
					MergedAnnotationCollectors.toMultiValueMap());
	assertThat(map).contains(entry("qualifier", Arrays.asList("composed1")));
}
 

@Test
public void collectMultiValueMapFavorsInheritedAnnotationsOverMoreLocallyDeclaredComposedAnnotations() {
	MultiValueMap<String, Object> map = MergedAnnotations.from(
			SubSubClassWithInheritedAnnotation.class,
			SearchStrategy.INHERITED_ANNOTATIONS).stream(Transactional.class).collect(
					MergedAnnotationCollectors.toMultiValueMap());
	assertThat(map).contains(entry("qualifier", Arrays.asList("transactionManager")));
}
 

private void testJavaRepeatables(SearchStrategy searchStrategy, Class<?> element,
		String[] expected) {
	MyRepeatable[] annotations = searchStrategy == SearchStrategy.DIRECT
			? element.getDeclaredAnnotationsByType(MyRepeatable.class)
			: element.getAnnotationsByType(MyRepeatable.class);
	assertThat(Arrays.stream(annotations).map(MyRepeatable::value)).containsExactly(
			expected);
}
 

@Test
public void exhaustiveStrategyOnBridgedMethodScansAnnotations() throws Exception {
	Method source = BridgedMethod.class.getDeclaredMethod("method", String.class);
	assertThat(source.isBridge()).isFalse();
	assertThat(scan(source, SearchStrategy.EXHAUSTIVE)).containsExactly(
			"0:TestAnnotation1", "1:TestAnnotation2");
}
 

@Test
public void exhaustiveStrategyMultipleNoninheritedComposedAnnotationsOnSuperclass() {
	MergedAnnotations annotations = MergedAnnotations.from(
			SubMultipleNoninheritedComposedCachesClass.class,
			SearchStrategy.EXHAUSTIVE);
	assertThat(stream(annotations, "value")).containsExactly("noninheritedCache1",
			"noninheritedCache2");
}
 

@Test
public void getRepeatableDeclaredOnClassWithMissingAttributeAliasDeclaration() {
	RepeatableContainers containers = RepeatableContainers.of(
			BrokenContextConfiguration.class, BrokenHierarchy.class);
	assertThatExceptionOfType(AnnotationConfigurationException.class).isThrownBy(() ->
			MergedAnnotations.from(BrokenHierarchyClass.class, SearchStrategy.EXHAUSTIVE, containers,
					AnnotationFilter.PLAIN).get(BrokenHierarchy.class))
		.withMessageStartingWith("Attribute 'value' in")
		.withMessageContaining(BrokenContextConfiguration.class.getName())
		.withMessageContaining("@AliasFor 'location'");
}
 

@Test
public void getWithExhaustiveFromSubSubNonInheritedAnnotationInterface() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			SubSubNonInheritedAnnotationInterface.class,
			SearchStrategy.EXHAUSTIVE).get(Order.class);
	assertThat(annotation.isPresent()).isTrue();
	assertThat(annotation.getAggregateIndex()).isEqualTo(2);
}
 

@Test
public void getWithExhaustiveInheritedFromInterfaceMethod()
		throws NoSuchMethodException {
	Method method = ConcreteClassWithInheritedAnnotation.class.getMethod(
			"handleFromInterface");
	MergedAnnotation<?> annotation = MergedAnnotations.from(method,
			SearchStrategy.EXHAUSTIVE).get(Order.class);
	assertThat(annotation.isPresent()).isTrue();
	assertThat(annotation.getAggregateIndex()).isEqualTo(1);
}
 

@Test
public void getDirectFromClassWithMetaCycleAnnotatedClassWithMissingTargetMetaAnnotation() {
	MergedAnnotation<?> annotation = MergedAnnotations.from(
			MetaCycleAnnotatedClass.class, SearchStrategy.EXHAUSTIVE).get(
					Component.class);
	assertThat(annotation.isPresent()).isFalse();
}
 

@Test
public void inheritedStrategyMultipleNoninheritedComposedAnnotationsOnClass() {
	MergedAnnotations annotations = MergedAnnotations.from(
			MultipleNoninheritedComposedCachesClass.class,
			SearchStrategy.INHERITED_ANNOTATIONS);
	assertThat(stream(annotations, "value")).containsExactly("noninheritedCache1",
			"noninheritedCache2");
}