diff --git a/spring-core/src/main/java/org/springframework/core/type/AnnotatedTypeMetadata.java b/spring-core/src/main/java/org/springframework/core/type/AnnotatedTypeMetadata.java index 07bf83141e..12bf7ed714 100644 --- a/spring-core/src/main/java/org/springframework/core/type/AnnotatedTypeMetadata.java +++ b/spring-core/src/main/java/org/springframework/core/type/AnnotatedTypeMetadata.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2019 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,8 +16,15 @@ package org.springframework.core.type; +import java.lang.annotation.Annotation; import java.util.Map; +import org.springframework.core.annotation.MergedAnnotation; +import org.springframework.core.annotation.MergedAnnotation.Adapt; +import org.springframework.core.annotation.MergedAnnotationCollectors; +import org.springframework.core.annotation.MergedAnnotationPredicates; +import org.springframework.core.annotation.MergedAnnotationSelectors; +import org.springframework.core.annotation.MergedAnnotations; import org.springframework.lang.Nullable; import org.springframework.util.MultiValueMap; @@ -38,6 +45,13 @@ import org.springframework.util.MultiValueMap; */ public interface AnnotatedTypeMetadata { + /** + * Return annotation details based on the direct annotations of the + * underlying element. + * @return merged annotations based on the direct annotations + */ + MergedAnnotations getAnnotations(); + /** * Determine whether the underlying element has an annotation or meta-annotation * of the given type defined. @@ -47,7 +61,9 @@ public interface AnnotatedTypeMetadata { * type to look for * @return whether a matching annotation is defined */ - boolean isAnnotated(String annotationName); + default boolean isAnnotated(String annotationName) { + return getAnnotations().isPresent(annotationName); + } /** * Retrieve the attributes of the annotation of the given type, if any (i.e. if @@ -78,7 +94,16 @@ public interface AnnotatedTypeMetadata { * {@code null} if no matching annotation is defined. */ @Nullable - Map getAnnotationAttributes(String annotationName, boolean classValuesAsString); + default Map getAnnotationAttributes(String annotationName, + boolean classValuesAsString) { + + MergedAnnotation annotation = getAnnotations().get(annotationName, + null, MergedAnnotationSelectors.firstDirectlyDeclared()); + if (!annotation.isPresent()) { + return null; + } + return annotation.asAnnotationAttributes(Adapt.values(classValuesAsString, true)); + } /** * Retrieve all attributes of all annotations of the given type, if any (i.e. if @@ -109,6 +134,15 @@ public interface AnnotatedTypeMetadata { * @see #getAllAnnotationAttributes(String) */ @Nullable - MultiValueMap getAllAnnotationAttributes(String annotationName, boolean classValuesAsString); + default MultiValueMap getAllAnnotationAttributes( + String annotationName, boolean classValuesAsString) { + + Adapt[] adaptations = Adapt.values(classValuesAsString, true); + return getAnnotations().stream(annotationName) + .filter(MergedAnnotationPredicates.unique(MergedAnnotation::getTypeHierarchy)) + .map(MergedAnnotation::withNonMergedAttributes) + .collect(MergedAnnotationCollectors.toMultiValueMap(map -> + map.isEmpty() ? null : map, adaptations)); + } } diff --git a/spring-core/src/main/java/org/springframework/core/type/AnnotationMetadata.java b/spring-core/src/main/java/org/springframework/core/type/AnnotationMetadata.java index f2d4ebac89..3bd7f8c6c8 100644 --- a/spring-core/src/main/java/org/springframework/core/type/AnnotationMetadata.java +++ b/spring-core/src/main/java/org/springframework/core/type/AnnotationMetadata.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2017 the original author or authors. + * Copyright 2002-2019 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,14 @@ package org.springframework.core.type; +import java.util.Collections; +import java.util.LinkedHashSet; import java.util.Set; +import java.util.stream.Collectors; + +import org.springframework.core.annotation.MergedAnnotation; +import org.springframework.core.annotation.MergedAnnotations; +import org.springframework.core.annotation.MergedAnnotations.SearchStrategy; /** * Interface that defines abstract access to the annotations of a specific @@ -38,7 +45,12 @@ public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata * are present on the underlying class. * @return the annotation type names */ - Set getAnnotationTypes(); + default Set getAnnotationTypes() { + return getAnnotations().stream() + .filter(MergedAnnotation::isDirectlyPresent) + .map(annotation -> annotation.getType().getName()) + .collect(Collectors.toCollection(LinkedHashSet::new)); + } /** * Get the fully qualified class names of all meta-annotation types that @@ -47,7 +59,15 @@ public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata * type to look for * @return the meta-annotation type names, or an empty set if none found */ - Set getMetaAnnotationTypes(String annotationName); + default Set getMetaAnnotationTypes(String annotationName) { + MergedAnnotation annotation = getAnnotations().get(annotationName, MergedAnnotation::isDirectlyPresent); + if (!annotation.isPresent()) { + return Collections.emptySet(); + } + return MergedAnnotations.from(annotation.getType(), SearchStrategy.INHERITED_ANNOTATIONS).stream() + .map(mergedAnnotation -> mergedAnnotation.getType().getName()) + .collect(Collectors.toCollection(LinkedHashSet::new)); + } /** * Determine whether an annotation of the given type is present on @@ -57,7 +77,7 @@ public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata * @return {@code true} if a matching annotation is present */ default boolean hasAnnotation(String annotationName) { - return getAnnotationTypes().contains(annotationName); + return getAnnotations().isDirectlyPresent(annotationName); } /** @@ -67,7 +87,10 @@ public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata * meta-annotation type to look for * @return {@code true} if a matching meta-annotation is present */ - boolean hasMetaAnnotation(String metaAnnotationName); + default boolean hasMetaAnnotation(String metaAnnotationName) { + return getAnnotations().get(metaAnnotationName, + MergedAnnotation::isMetaPresent).isPresent(); + } /** * Determine whether the underlying class has any methods that are @@ -75,7 +98,9 @@ public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata * @param annotationName the fully qualified class name of the annotation * type to look for */ - boolean hasAnnotatedMethods(String annotationName); + default boolean hasAnnotatedMethods(String annotationName) { + return !getAnnotatedMethods(annotationName).isEmpty(); + } /** * Retrieve the method metadata for all methods that are annotated diff --git a/spring-core/src/main/java/org/springframework/core/type/StandardAnnotationMetadata.java b/spring-core/src/main/java/org/springframework/core/type/StandardAnnotationMetadata.java index 27c00023fa..dcf4a7e9a1 100644 --- a/spring-core/src/main/java/org/springframework/core/type/StandardAnnotationMetadata.java +++ b/spring-core/src/main/java/org/springframework/core/type/StandardAnnotationMetadata.java @@ -24,7 +24,11 @@ import java.util.Map; import java.util.Set; import org.springframework.core.annotation.AnnotatedElementUtils; +import org.springframework.core.annotation.AnnotationFilter; import org.springframework.core.annotation.AnnotationUtils; +import org.springframework.core.annotation.MergedAnnotations; +import org.springframework.core.annotation.MergedAnnotations.SearchStrategy; +import org.springframework.core.annotation.RepeatableContainers; import org.springframework.lang.Nullable; import org.springframework.util.MultiValueMap; import org.springframework.util.ReflectionUtils; @@ -42,10 +46,11 @@ import org.springframework.util.ReflectionUtils; */ public class StandardAnnotationMetadata extends StandardClassMetadata implements AnnotationMetadata { - private final Annotation[] annotations; + private final MergedAnnotations mergedAnnotations; private final boolean nestedAnnotationsAsMap; + private Set annotationTypes; /** * Create a new {@code StandardAnnotationMetadata} wrapper for the given Class. @@ -69,72 +74,49 @@ public class StandardAnnotationMetadata extends StandardClassMetadata implements */ public StandardAnnotationMetadata(Class introspectedClass, boolean nestedAnnotationsAsMap) { super(introspectedClass); - this.annotations = introspectedClass.getDeclaredAnnotations(); + this.mergedAnnotations = MergedAnnotations.from(introspectedClass, + SearchStrategy.DIRECT, RepeatableContainers.none(), + AnnotationFilter.NONE); this.nestedAnnotationsAsMap = nestedAnnotationsAsMap; } @Override - public Set getAnnotationTypes() { - Set types = new LinkedHashSet<>(); - for (Annotation ann : this.annotations) { - if (!AnnotationUtils.isInJavaLangAnnotationPackage(ann.annotationType().getName())) { - types.add(ann.annotationType().getName()); - } - } - return types; - } - - @Override - public Set getMetaAnnotationTypes(String annotationName) { - if (AnnotationUtils.isInJavaLangAnnotationPackage(annotationName)) { - return Collections.emptySet(); - } - return (this.annotations.length > 0 ? - AnnotatedElementUtils.getMetaAnnotationTypes(getIntrospectedClass(), annotationName) : - Collections.emptySet()); + public MergedAnnotations getAnnotations() { + return this.mergedAnnotations; } @Override - public boolean hasAnnotation(String annotationName) { - if (AnnotationUtils.isInJavaLangAnnotationPackage(annotationName)) { - return false; - } - for (Annotation ann : this.annotations) { - if (ann.annotationType().getName().equals(annotationName)) { - return true; - } - } - return false; - } - - @Override - public boolean hasMetaAnnotation(String annotationName) { - if (AnnotationUtils.isInJavaLangAnnotationPackage(annotationName)) { - return false; + public Set getAnnotationTypes() { + Set annotationTypes = this.annotationTypes; + if (annotationTypes == null) { + annotationTypes = Collections.unmodifiableSet( + AnnotationMetadata.super.getAnnotationTypes()); + this.annotationTypes = annotationTypes; } - return (this.annotations.length > 0 && - AnnotatedElementUtils.hasMetaAnnotationTypes(getIntrospectedClass(), annotationName)); - } - - @Override - public boolean isAnnotated(String annotationName) { - return (this.annotations.length > 0 && - AnnotatedElementUtils.isAnnotated(getIntrospectedClass(), annotationName)); + return annotationTypes; } @Override @Nullable public Map getAnnotationAttributes(String annotationName, boolean classValuesAsString) { - return (this.annotations.length > 0 ? AnnotatedElementUtils.getMergedAnnotationAttributes( - getIntrospectedClass(), annotationName, classValuesAsString, this.nestedAnnotationsAsMap) : null); + if (this.nestedAnnotationsAsMap) { + return AnnotationMetadata.super.getAnnotationAttributes(annotationName, + classValuesAsString); + } + return AnnotatedElementUtils.getMergedAnnotationAttributes( + getIntrospectedClass(), annotationName, classValuesAsString, this.nestedAnnotationsAsMap); } @Override @Nullable public MultiValueMap getAllAnnotationAttributes(String annotationName, boolean classValuesAsString) { - return (this.annotations.length > 0 ? AnnotatedElementUtils.getAllAnnotationAttributes( - getIntrospectedClass(), annotationName, classValuesAsString, this.nestedAnnotationsAsMap) : null); + if (this.nestedAnnotationsAsMap) { + return AnnotationMetadata.super.getAllAnnotationAttributes(annotationName, + classValuesAsString); + } + return AnnotatedElementUtils.getAllAnnotationAttributes( + getIntrospectedClass(), annotationName, classValuesAsString, this.nestedAnnotationsAsMap); } @Override @@ -143,8 +125,7 @@ public class StandardAnnotationMetadata extends StandardClassMetadata implements try { Method[] methods = ReflectionUtils.getDeclaredMethods(getIntrospectedClass()); for (Method method : methods) { - if (!method.isBridge() && method.getAnnotations().length > 0 && - AnnotatedElementUtils.isAnnotated(method, annotationName)) { + if (isAnnotatedMethod(method, annotationName)) { return true; } } @@ -158,13 +139,15 @@ public class StandardAnnotationMetadata extends StandardClassMetadata implements @Override public Set getAnnotatedMethods(String annotationName) { - Set annotatedMethods = new LinkedHashSet<>(4); + Set annotatedMethods = null; if (AnnotationUtils.isCandidateClass(getIntrospectedClass(), annotationName)) { try { - Method[] methods = getIntrospectedClass().getDeclaredMethods(); + Method[] methods = ReflectionUtils.getDeclaredMethods(getIntrospectedClass()); for (Method method : methods) { - if (!method.isBridge() && method.getAnnotations().length > 0 && - AnnotatedElementUtils.isAnnotated(method, annotationName)) { + if (isAnnotatedMethod(method, annotationName)) { + if (annotatedMethods == null) { + annotatedMethods = new LinkedHashSet<>(4); + } annotatedMethods.add(new StandardMethodMetadata(method, this.nestedAnnotationsAsMap)); } } @@ -173,7 +156,12 @@ public class StandardAnnotationMetadata extends StandardClassMetadata implements throw new IllegalStateException("Failed to introspect annotated methods on " + getIntrospectedClass(), ex); } } - return annotatedMethods; + return annotatedMethods != null ? annotatedMethods : Collections.emptySet(); + } + + private boolean isAnnotatedMethod(Method method, String annotationName) { + return !method.isBridge() && method.getAnnotations().length > 0 && + AnnotatedElementUtils.isAnnotated(method, annotationName); } } diff --git a/spring-core/src/main/java/org/springframework/core/type/StandardMethodMetadata.java b/spring-core/src/main/java/org/springframework/core/type/StandardMethodMetadata.java index 854aff0293..42de7b6d50 100644 --- a/spring-core/src/main/java/org/springframework/core/type/StandardMethodMetadata.java +++ b/spring-core/src/main/java/org/springframework/core/type/StandardMethodMetadata.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2019 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,6 +21,10 @@ import java.lang.reflect.Modifier; import java.util.Map; import org.springframework.core.annotation.AnnotatedElementUtils; +import org.springframework.core.annotation.AnnotationFilter; +import org.springframework.core.annotation.MergedAnnotations; +import org.springframework.core.annotation.MergedAnnotations.SearchStrategy; +import org.springframework.core.annotation.RepeatableContainers; import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.MultiValueMap; @@ -41,6 +45,8 @@ public class StandardMethodMetadata implements MethodMetadata { private final boolean nestedAnnotationsAsMap; + private final MergedAnnotations mergedAnnotations; + /** * Create a new StandardMethodMetadata wrapper for the given Method. @@ -65,8 +71,15 @@ public class StandardMethodMetadata implements MethodMetadata { Assert.notNull(introspectedMethod, "Method must not be null"); this.introspectedMethod = introspectedMethod; this.nestedAnnotationsAsMap = nestedAnnotationsAsMap; + this.mergedAnnotations = MergedAnnotations.from(introspectedMethod, + SearchStrategy.DIRECT, RepeatableContainers.none(), + AnnotationFilter.PLAIN); } + @Override + public MergedAnnotations getAnnotations() { + return this.mergedAnnotations; + } /** * Return the underlying Method. @@ -107,17 +120,19 @@ public class StandardMethodMetadata implements MethodMetadata { @Override public boolean isOverridable() { - return (!isStatic() && !isFinal() && !Modifier.isPrivate(this.introspectedMethod.getModifiers())); + return !isStatic() && !isFinal() && !isPrivate(); } - @Override - public boolean isAnnotated(String annotationName) { - return AnnotatedElementUtils.isAnnotated(this.introspectedMethod, annotationName); + private boolean isPrivate() { + return Modifier.isPrivate(this.introspectedMethod.getModifiers()); } @Override @Nullable public Map getAnnotationAttributes(String annotationName, boolean classValuesAsString) { + if (this.nestedAnnotationsAsMap) { + return MethodMetadata.super.getAnnotationAttributes(annotationName, classValuesAsString); + } return AnnotatedElementUtils.getMergedAnnotationAttributes(this.introspectedMethod, annotationName, classValuesAsString, this.nestedAnnotationsAsMap); } @@ -125,6 +140,9 @@ public class StandardMethodMetadata implements MethodMetadata { @Override @Nullable public MultiValueMap getAllAnnotationAttributes(String annotationName, boolean classValuesAsString) { + if (this.nestedAnnotationsAsMap) { + return MethodMetadata.super.getAllAnnotationAttributes(annotationName, classValuesAsString); + } return AnnotatedElementUtils.getAllAnnotationAttributes(this.introspectedMethod, annotationName, classValuesAsString, this.nestedAnnotationsAsMap); } diff --git a/spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitor.java b/spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitor.java index bb342a512c..5564e83288 100644 --- a/spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitor.java +++ b/spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitor.java @@ -30,6 +30,7 @@ import org.springframework.asm.Opcodes; import org.springframework.asm.Type; import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.core.annotation.AnnotationUtils; +import org.springframework.core.annotation.MergedAnnotations; import org.springframework.core.type.AnnotationMetadata; import org.springframework.core.type.MethodMetadata; import org.springframework.lang.Nullable; @@ -72,6 +73,11 @@ public class AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisito } + @Override + public MergedAnnotations getAnnotations() { + throw new UnsupportedOperationException(); + } + @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { // Skip bridge methods - we're only interested in original annotation-defining user methods. @@ -129,6 +135,11 @@ public class AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisito this.attributesMap.containsKey(annotationName)); } + @Override + public boolean hasAnnotation(String annotationName) { + return getAnnotationTypes().contains(annotationName); + } + @Override @Nullable public AnnotationAttributes getAnnotationAttributes(String annotationName, boolean classValuesAsString) { diff --git a/spring-core/src/main/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitor.java b/spring-core/src/main/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitor.java index 1e1f0faee7..dba25e94f4 100644 --- a/spring-core/src/main/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitor.java +++ b/spring-core/src/main/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitor.java @@ -27,6 +27,7 @@ import org.springframework.asm.Opcodes; import org.springframework.asm.SpringAsmInfo; import org.springframework.asm.Type; import org.springframework.core.annotation.AnnotationAttributes; +import org.springframework.core.annotation.MergedAnnotations; import org.springframework.core.type.MethodMetadata; import org.springframework.lang.Nullable; import org.springframework.util.LinkedMultiValueMap; @@ -77,6 +78,11 @@ public class MethodMetadataReadingVisitor extends MethodVisitor implements Metho } + @Override + public MergedAnnotations getAnnotations() { + throw new UnsupportedOperationException(); + } + @Override public AnnotationVisitor visitAnnotation(final String desc, boolean visible) { if (!visible) { diff --git a/spring-core/src/test/java/org/springframework/core/type/AbstractAnnotationMetadataTests.java b/spring-core/src/test/java/org/springframework/core/type/AbstractAnnotationMetadataTests.java index c483013b61..398dc3fcb9 100644 --- a/spring-core/src/test/java/org/springframework/core/type/AbstractAnnotationMetadataTests.java +++ b/spring-core/src/test/java/org/springframework/core/type/AbstractAnnotationMetadataTests.java @@ -21,6 +21,7 @@ import java.lang.annotation.RetentionPolicy; import org.junit.Test; +import org.springframework.core.annotation.MergedAnnotation; import org.springframework.core.type.AbstractAnnotationMetadataTests.TestMemberClass.TestMemberClassInnerClass; import org.springframework.core.type.AbstractAnnotationMetadataTests.TestMemberClass.TestMemberClassInnerInterface; import org.springframework.util.MultiValueMap; @@ -137,6 +138,16 @@ public abstract class AbstractAnnotationMetadataTests { assertThat(get(TestClass.class).getMemberClassNames()).isEmpty(); } + @Test + public void getAnnotationsReturnsDirectAnnotations() { + AnnotationMetadata metadata = get(WithDirectAnnotations.class); + assertThat(metadata.getAnnotations().stream().filter( + MergedAnnotation::isDirectlyPresent).map( + a -> a.getType().getName())).containsExactlyInAnyOrder( + DirectAnnotation1.class.getName(), + DirectAnnotation2.class.getName()); + } + @Test public void isAnnotatedWhenMatchesDirectAnnotationReturnsTrue() { assertThat(get(WithDirectAnnotations.class).isAnnotated( diff --git a/spring-core/src/test/java/org/springframework/core/type/AbstractMethodMetadataTests.java b/spring-core/src/test/java/org/springframework/core/type/AbstractMethodMetadataTests.java index 8e0a3fca6a..61e99347e3 100644 --- a/spring-core/src/test/java/org/springframework/core/type/AbstractMethodMetadataTests.java +++ b/spring-core/src/test/java/org/springframework/core/type/AbstractMethodMetadataTests.java @@ -21,6 +21,7 @@ import java.lang.annotation.RetentionPolicy; import org.junit.Test; +import org.springframework.core.annotation.MergedAnnotation; import org.springframework.util.MultiValueMap; import static org.assertj.core.api.Assertions.*; @@ -91,6 +92,16 @@ public abstract class AbstractMethodMetadataTests { assertThat(getTagged(WithPrivateMethod.class).isOverridable()).isFalse(); } + @Test + public void getAnnotationsReturnsDirectAnnotations() { + MethodMetadata metadata = getTagged(WithDirectAnnotation.class); + assertThat(metadata.getAnnotations().stream().filter( + MergedAnnotation::isDirectlyPresent).map( + a -> a.getType().getName())).containsExactlyInAnyOrder( + Tag.class.getName(), + DirectAnnotation.class.getName()); + } + @Test public void isAnnotatedWhenMatchesDirectAnnotationReturnsTrue() { assertThat(getTagged(WithDirectAnnotation.class).isAnnotated( diff --git a/spring-core/src/test/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitorTests.java b/spring-core/src/test/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitorTests.java index 711f931b06..ef9832b13b 100644 --- a/spring-core/src/test/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitorTests.java +++ b/spring-core/src/test/java/org/springframework/core/type/classreading/AnnotationMetadataReadingVisitorTests.java @@ -25,8 +25,11 @@ import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; import org.springframework.core.type.AbstractAnnotationMetadataTests; import org.springframework.core.type.AnnotationMetadata; +import org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor; import org.springframework.util.ClassUtils; +import static org.assertj.core.api.Assertions.*; + /** * Tests for {@link AnnotationMetadataReadingVisitor}. * @@ -58,4 +61,10 @@ public class AnnotationMetadataReadingVisitorTests } } + @Override + public void getAnnotationsReturnsDirectAnnotations() { + assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy( + super::getAnnotationsReturnsDirectAnnotations); + } + } diff --git a/spring-core/src/test/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitorTests.java b/spring-core/src/test/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitorTests.java index f111744219..fad7baad57 100644 --- a/spring-core/src/test/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitorTests.java +++ b/spring-core/src/test/java/org/springframework/core/type/classreading/MethodMetadataReadingVisitorTests.java @@ -25,13 +25,18 @@ import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; import org.springframework.core.type.AbstractMethodMetadataTests; import org.springframework.core.type.AnnotationMetadata; +import org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor; +import org.springframework.core.type.classreading.MethodMetadataReadingVisitor; import org.springframework.util.ClassUtils; +import static org.assertj.core.api.Assertions.*; + /** * Tests for {@link MethodMetadataReadingVisitor}. * * @author Phillip Webb */ +@SuppressWarnings("deprecation") public class MethodMetadataReadingVisitorTests extends AbstractMethodMetadataTests { @Override @@ -57,4 +62,10 @@ public class MethodMetadataReadingVisitorTests extends AbstractMethodMetadataTes } } + @Override + public void getAnnotationsReturnsDirectAnnotations() { + assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy( + super::getAnnotationsReturnsDirectAnnotations); + } + }