root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Component scanning ignores attributes and meta-annotations on non-public annotations 

Issue: SPR-11091
This commit is contained in:
Juergen Hoeller 2013-12-11 15:29:55 +01:00
parent a223e247c2
commit 161819f141
4 changed files with 76 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
spring-context/src/test/java/example/scannable/CustomAnnotations.java Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright 2002-2013 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package example.scannable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
public class CustomAnnotations {
@Retention(RetentionPolicy.RUNTIME)
private @interface PrivateAnnotation {
String value();
}
@Retention(RetentionPolicy.RUNTIME)
@PrivateAnnotation("special")
public @interface SpecialAnnotation {
}
}

3
spring-context/src/test/java/example/scannable/CustomComponent.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2007 the original author or authors. * Copyright 2002-2013 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -28,6 +28,7 @@ import java.lang.annotation.Target;
@Target(ElementType.TYPE) @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@Inherited @Inherited
@CustomAnnotations.SpecialAnnotation
public @interface CustomComponent { public @interface CustomComponent {
} }

4
spring-context/src/test/java/example/scannable/MessageBean.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2012 the original author or authors. * Copyright 2002-2013 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -20,6 +20,7 @@ package example.scannable;
* @author Mark Fisher * @author Mark Fisher
*/ */
@CustomComponent @CustomComponent
@CustomAnnotations.SpecialAnnotation
public class MessageBean { public class MessageBean {
private String message; private String message;
@ -32,6 +33,7 @@ public class MessageBean {
this.message = message; this.message = message;
} }
@CustomAnnotations.SpecialAnnotation
public String getMessage() { public String getMessage() {
return this.message; return this.message;
} }

71
spring-core/src/main/java/org/springframework/core/type/classreading/AnnotationAttributesReadingVisitor.java
View File

@ -20,6 +20,7 @@ import java.lang.annotation.Annotation;
import java.lang.reflect.Array; import java.lang.reflect.Array;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.LinkedHashSet; import java.util.LinkedHashSet;
import java.util.List; import java.util.List;
@ -28,6 +29,7 @@ import java.util.Set;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.springframework.asm.AnnotationVisitor; import org.springframework.asm.AnnotationVisitor;
import org.springframework.asm.SpringAsmInfo; import org.springframework.asm.SpringAsmInfo;
import org.springframework.asm.Type; import org.springframework.asm.Type;
@ -51,14 +53,12 @@ abstract class AbstractRecursiveAnnotationVisitor extends AnnotationVisitor {
protected final ClassLoader classLoader; protected final ClassLoader classLoader;
public AbstractRecursiveAnnotationVisitor(ClassLoader classLoader, AnnotationAttributes attributes) { public AbstractRecursiveAnnotationVisitor(ClassLoader classLoader, AnnotationAttributes attributes) {
super(SpringAsmInfo.ASM_VERSION); super(SpringAsmInfo.ASM_VERSION);
this.classLoader = classLoader; this.classLoader = classLoader;
this.attributes = attributes; this.attributes = attributes;
} }
@Override @Override
public void visit(String attributeName, Object attributeValue) { public void visit(String attributeName, Object attributeValue) {
this.attributes.put(attributeName, attributeValue); this.attributes.put(attributeName, attributeValue);
@ -114,14 +114,12 @@ final class RecursiveAnnotationArrayVisitor extends AbstractRecursiveAnnotationV
private final List<AnnotationAttributes> allNestedAttributes = new ArrayList<AnnotationAttributes>(); private final List<AnnotationAttributes> allNestedAttributes = new ArrayList<AnnotationAttributes>();
public RecursiveAnnotationArrayVisitor( public RecursiveAnnotationArrayVisitor(
String attributeName, AnnotationAttributes attributes, ClassLoader classLoader) { String attributeName, AnnotationAttributes attributes, ClassLoader classLoader) {
super(classLoader, attributes); super(classLoader, attributes);
this.attributeName = attributeName; this.attributeName = attributeName;
} }
@Override @Override
public void visit(String attributeName, Object attributeValue) { public void visit(String attributeName, Object attributeValue) {
Object newValue = attributeValue; Object newValue = attributeValue;
@ -170,24 +168,21 @@ class RecursiveAnnotationAttributesVisitor extends AbstractRecursiveAnnotationVi
private final String annotationType; private final String annotationType;
public RecursiveAnnotationAttributesVisitor( public RecursiveAnnotationAttributesVisitor(
String annotationType, AnnotationAttributes attributes, ClassLoader classLoader) { String annotationType, AnnotationAttributes attributes, ClassLoader classLoader) {
super(classLoader, attributes); super(classLoader, attributes);
this.annotationType = annotationType; this.annotationType = annotationType;
} }
@Override @Override
public final void visitEnd() { public final void visitEnd() {
try { try {
Class<?> annotationClass = this.classLoader.loadClass(this.annotationType); Class<?> annotationClass = this.classLoader.loadClass(this.annotationType);
this.doVisitEnd(annotationClass); doVisitEnd(annotationClass);
} }
catch (ClassNotFoundException ex) { catch (ClassNotFoundException ex) {
this.logger.debug("Failed to classload type while reading annotation " + this.logger.debug("Failed to class-load type while reading annotation metadata. " +
"metadata. This is a non-fatal error, but certain annotation " + "This is a non-fatal error, but certain annotation metadata may be unavailable.", ex);
"metadata may be unavailable.", ex);
} }
} }
@ -196,26 +191,30 @@ class RecursiveAnnotationAttributesVisitor extends AbstractRecursiveAnnotationVi
} }
private void registerDefaultValues(Class<?> annotationClass) { private void registerDefaultValues(Class<?> annotationClass) {
// Check declared default values of attributes in the annotation type. // Only do further scanning for public annotations; we'd run into IllegalAccessExceptions
Method[] annotationAttributes = annotationClass.getMethods(); // otherwise, and don't want to mess with accessibility in a SecurityManager environment.
for (Method annotationAttribute : annotationAttributes) { if (Modifier.isPublic(annotationClass.getModifiers())) {
String attributeName = annotationAttribute.getName(); // Check declared default values of attributes in the annotation type.
Object defaultValue = annotationAttribute.getDefaultValue(); Method[] annotationAttributes = annotationClass.getMethods();
if (defaultValue != null && !this.attributes.containsKey(attributeName)) { for (Method annotationAttribute : annotationAttributes) {
if (defaultValue instanceof Annotation) { String attributeName = annotationAttribute.getName();
defaultValue = AnnotationAttributes.fromMap( Object defaultValue = annotationAttribute.getDefaultValue();
AnnotationUtils.getAnnotationAttributes((Annotation)defaultValue, false, true)); if (defaultValue != null && !this.attributes.containsKey(attributeName)) {
} if (defaultValue instanceof Annotation) {
else if (defaultValue instanceof Annotation[]) { defaultValue = AnnotationAttributes.fromMap(
Annotation[] realAnnotations = (Annotation[]) defaultValue; AnnotationUtils.getAnnotationAttributes((Annotation) defaultValue, false, true));
AnnotationAttributes[] mappedAnnotations = new AnnotationAttributes[realAnnotations.length];
for (int i = 0; i < realAnnotations.length; i++) {
mappedAnnotations[i] = AnnotationAttributes.fromMap(
AnnotationUtils.getAnnotationAttributes(realAnnotations[i], false, true));
} }
defaultValue = mappedAnnotations; else if (defaultValue instanceof Annotation[]) {
Annotation[] realAnnotations = (Annotation[]) defaultValue;
AnnotationAttributes[] mappedAnnotations = new AnnotationAttributes[realAnnotations.length];
for (int i = 0; i < realAnnotations.length; i++) {
mappedAnnotations[i] = AnnotationAttributes.fromMap(
AnnotationUtils.getAnnotationAttributes(realAnnotations[i], false, true));
}
defaultValue = mappedAnnotations;
}
this.attributes.put(attributeName, defaultValue);
} }
this.attributes.put(attributeName, defaultValue);
} }
} }
} }
@ -267,19 +266,23 @@ final class AnnotationAttributesReadingVisitor extends RecursiveAnnotationAttrib
} }
Set<String> metaAnnotationTypeNames = new LinkedHashSet<String>(); Set<String> metaAnnotationTypeNames = new LinkedHashSet<String>();
for (Annotation metaAnnotation : annotationClass.getAnnotations()) { for (Annotation metaAnnotation : annotationClass.getAnnotations()) {
recusivelyCollectMetaAnnotations(metaAnnotationTypeNames, metaAnnotation); recursivelyCollectMetaAnnotations(metaAnnotationTypeNames, metaAnnotation);
} }
if (this.metaAnnotationMap != null) { if (this.metaAnnotationMap != null) {
this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames); this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames);
} }
} }
private void recusivelyCollectMetaAnnotations(Set<String> visited, Annotation annotation) { private void recursivelyCollectMetaAnnotations(Set<String> visited, Annotation annotation) {
if (visited.add(annotation.annotationType().getName())) { if (visited.add(annotation.annotationType().getName())) {
this.attributesMap.add(annotation.annotationType().getName(), // Only do further scanning for public annotations; we'd run into IllegalAccessExceptions
AnnotationUtils.getAnnotationAttributes(annotation, true, true)); // otherwise, and don't want to mess with accessibility in a SecurityManager environment.
for (Annotation metaMetaAnnotation : annotation.annotationType().getAnnotations()) { if (Modifier.isPublic(annotation.annotationType().getModifiers())) {
recusivelyCollectMetaAnnotations(visited, metaMetaAnnotation); this.attributesMap.add(annotation.annotationType().getName(),
AnnotationUtils.getAnnotationAttributes(annotation, true, true));
for (Annotation metaMetaAnnotation : annotation.annotationType().getAnnotations()) {
recursivelyCollectMetaAnnotations(visited, metaMetaAnnotation);
}
} }
} }
} }