Allow meta-annotations to override attributes from their parent

Issue: SPR-10181

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java

@@ -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");
  * you may not use this file except in compliance with the License.
@@ -55,7 +55,8 @@
 import org.springframework.core.MethodParameter;
 import org.springframework.core.Ordered;
 import org.springframework.core.PriorityOrdered;
-import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
@@ -235,7 +236,7 @@ public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, Strin
 					Constructor<?> requiredConstructor = null;
 					Constructor<?> defaultConstructor = null;
 					for (Constructor<?> candidate : rawCandidates) {
-						Annotation annotation = findAutowiredAnnotation(candidate);
+						AnnotationAttributes annotation = findAutowiredAnnotation(candidate);
 						if (annotation != null) {
 							if (requiredConstructor != null) {
 								throw new BeanCreationException("Invalid autowire-marked constructor: " + candidate +
@@ -333,7 +334,7 @@ private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
 		do {
 			LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>();
 			for (Field field : targetClass.getDeclaredFields()) {
-				Annotation annotation = findAutowiredAnnotation(field);
+				AnnotationAttributes annotation = findAutowiredAnnotation(field);
 				if (annotation != null) {
 					if (Modifier.isStatic(field.getModifiers())) {
 						if (logger.isWarnEnabled()) {
@@ -347,7 +348,7 @@ private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
 			}
 			for (Method method : targetClass.getDeclaredMethods()) {
 				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
-				Annotation annotation = BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod) ?
+				AnnotationAttributes annotation = BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod) ?
 						findAutowiredAnnotation(bridgedMethod) : findAutowiredAnnotation(method);
 				if (annotation != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
 					if (Modifier.isStatic(method.getModifiers())) {
@@ -374,16 +375,29 @@ private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
 		return new InjectionMetadata(clazz, elements);
 	}
 
-	private Annotation findAutowiredAnnotation(AccessibleObject ao) {
+	private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
 		for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
-			Annotation annotation = AnnotationUtils.getAnnotation(ao, type);
+			AnnotationAttributes annotation = AnnotatedElementUtils.getAnnotationAttributes(ao, type.getName());
 			if (annotation != null) {
 				return annotation;
 			}
 		}
 		return null;
 	}
 
+	/**
+	 * Determine if the annotated field or method requires its dependency.
+	 * <p>A 'required' dependency means that autowiring should fail when no beans
+	 * are found. Otherwise, the autowiring process will simply bypass the field
+	 * or method when no beans are found.
+	 * @param annotation the Autowired annotation
+	 * @return whether the annotation indicates that a dependency is required
+	 */
+	protected boolean determineRequiredStatus(AnnotationAttributes annotation) {
+		return (!annotation.containsKey(this.requiredParameterName) ||
+				this.requiredParameterValue == annotation.getBoolean(this.requiredParameterName));
+	}
+
 	/**
 	 * Obtain all beans of the given type as autowire candidates.
 	 * @param type the type of the bean
@@ -398,31 +412,6 @@ protected <T> Map<String, T> findAutowireCandidates(Class<T> type) throws BeansE
 		return BeanFactoryUtils.beansOfTypeIncludingAncestors(this.beanFactory, type);
 	}
 
-	/**
-	 * Determine if the annotated field or method requires its dependency.
-	 * <p>A 'required' dependency means that autowiring should fail when no beans
-	 * are found. Otherwise, the autowiring process will simply bypass the field
-	 * or method when no beans are found.
-	 * @param annotation the Autowired annotation
-	 * @return whether the annotation indicates that a dependency is required
-	 */
-	protected boolean determineRequiredStatus(Annotation annotation) {
-		try {
-			Method method = ReflectionUtils.findMethod(annotation.annotationType(), this.requiredParameterName);
-			if (method == null) {
-				// annotations like @Inject and @Value don't have a method (attribute) named "required"
-				// -> default to required status
-				return true;
-			}
-			return (this.requiredParameterValue == (Boolean) ReflectionUtils.invokeMethod(method, annotation));
-		}
-		catch (Exception ex) {
-			// an exception was thrown during reflective invocation of the required attribute
-			// -> default to required status
-			return true;
-		}
-	}
-
 	/**
 	 * Register the specified bean as dependent on the autowired beans.
 	 */

spring-context/src/test/java/org/springframework/context/annotation/AnnotationScopeMetadataResolverTests.java

@@ -16,19 +16,20 @@
 
 package org.springframework.context.annotation;
 
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Retention;
 import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import static org.junit.Assert.*;
 import org.junit.Before;
 import org.junit.Test;
 
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
 
+import static org.junit.Assert.*;
+
 /**
  * @author Rick Evans
  * @author Chris Beams
@@ -83,6 +84,15 @@ public void testCustomRequestScope() {
 		assertEquals(ScopedProxyMode.NO, scopeMetadata.getScopedProxyMode());
 	}
 
+	@Test
+	public void testCustomRequestScopeWithAttribute() {
+		AnnotatedBeanDefinition bd = new AnnotatedGenericBeanDefinition(AnnotatedWithCustomRequestScopeWithAttribute.class);
+		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(bd);
+		assertNotNull("resolveScopeMetadata(..) must *never* return null.", scopeMetadata);
+		assertEquals("request", scopeMetadata.getScopeName());
+		assertEquals(ScopedProxyMode.TARGET_CLASS, scopeMetadata.getScopedProxyMode());
+	}
+
 	@Test(expected=IllegalArgumentException.class)
 	public void testCtorWithNullScopedProxyMode() {
 		new AnnotationScopeMetadataResolver(null);
@@ -98,17 +108,21 @@ public void testSetScopeAnnotationTypeWithNullType() {
 	private static final class AnnotatedWithSingletonScope {
 	}
 
-
 	@Scope("prototype")
 	private static final class AnnotatedWithPrototypeScope {
 	}
 
-
 	@Scope(value="request", proxyMode = ScopedProxyMode.TARGET_CLASS)
 	private static final class AnnotatedWithScopedProxy {
 	}
 
 
+	@Target({ElementType.TYPE, ElementType.METHOD})
+	@Retention(RetentionPolicy.RUNTIME)
+	@Scope("request")
+	public @interface CustomRequestScope {
+	}
+
 	@CustomRequestScope
 	private static final class AnnotatedWithCustomRequestScope {
 	}
@@ -117,8 +131,13 @@ private static final class AnnotatedWithCustomRequestScope {
 	@Target({ElementType.TYPE, ElementType.METHOD})
 	@Retention(RetentionPolicy.RUNTIME)
 	@Scope("request")
-	public @interface CustomRequestScope {
+	public @interface CustomRequestScopeWithAttribute {
+
+		ScopedProxyMode proxyMode();
+	}
 
+	@CustomRequestScopeWithAttribute(proxyMode = ScopedProxyMode.TARGET_CLASS)
+	private static final class AnnotatedWithCustomRequestScopeWithAttribute {
 	}
 
 }

spring-context/src/test/java/org/springframework/context/annotation/configuration/BeanMethodQualificationTests.java

@@ -20,6 +20,8 @@
 import java.lang.annotation.RetentionPolicy;
 
 import org.junit.Test;
+
+import org.springframework.tests.sample.beans.NestedTestBean;
 import org.springframework.tests.sample.beans.TestBean;
 
 import org.springframework.beans.factory.annotation.Autowired;
@@ -60,9 +62,19 @@ public void testCustom() {
 		assertThat(pojo.testBean.getName(), equalTo("interesting"));
 	}
 
+	@Test
+	public void testCustomWithAttributeOverride() {
+		AnnotationConfigApplicationContext ctx =
+				new AnnotationConfigApplicationContext(CustomConfigWithAttributeOverride.class, CustomPojo.class);
+		assertFalse(ctx.getBeanFactory().containsSingleton("testBeanX"));
+		CustomPojo pojo = ctx.getBean(CustomPojo.class);
+		assertThat(pojo.testBean.getName(), equalTo("interesting"));
+	}
+
 
 	@Configuration
 	static class StandardConfig {
+
 		@Bean @Lazy @Qualifier("interesting")
 		public TestBean testBean1() {
 			return new TestBean("interesting");
@@ -76,11 +88,13 @@ public TestBean testBean2() {
 
 	@Component @Lazy
 	static class StandardPojo {
+
 		@Autowired @Qualifier("interesting") TestBean testBean;
 	}
 
 	@Configuration
 	static class CustomConfig {
+
 		@InterestingBean
 		public TestBean testBean1() {
 			return new TestBean("interesting");
@@ -92,21 +106,52 @@ public TestBean testBean2() {
 		}
 	}
 
+	@Configuration
+	static class CustomConfigWithAttributeOverride {
+
+		@InterestingBeanWithName(name="testBeanX")
+		public TestBean testBean1() {
+			return new TestBean("interesting");
+		}
+
+		@Bean @Qualifier("boring")
+		public TestBean testBean2() {
+			return new TestBean("boring");
+		}
+	}
+
 	@InterestingPojo
 	static class CustomPojo {
+
 		@InterestingNeed TestBean testBean;
+
+		@InterestingNeedWithRequiredOverride(required=false) NestedTestBean nestedTestBean;
 	}
 
 	@Bean @Lazy @Qualifier("interesting")
 	@Retention(RetentionPolicy.RUNTIME)
 	public @interface InterestingBean {
 	}
 
+	@Bean @Lazy @Qualifier("interesting")
+	@Retention(RetentionPolicy.RUNTIME)
+	public @interface InterestingBeanWithName {
+
+		String name();
+	}
+
 	@Autowired @Qualifier("interesting")
 	@Retention(RetentionPolicy.RUNTIME)
 	public @interface InterestingNeed {
 	}
 
+	@Autowired @Qualifier("interesting")
+	@Retention(RetentionPolicy.RUNTIME)
+	public @interface InterestingNeedWithRequiredOverride {
+
+		boolean required();
+	}
+
 	@Component @Lazy
 	@Retention(RetentionPolicy.RUNTIME)
 	public @interface InterestingPojo {