Lookup methods can support arguments, find a target bean based on the return type, and be identified by an @lookup annotation

Issue: SPR-7431
Issue: SPR-5192

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java

@@ -170,8 +170,7 @@ public interface BeanFactory {
 	 * <p>Allows for specifying explicit constructor arguments / factory method arguments,
 	 * overriding the specified default arguments (if any) in the bean definition.
 	 * @param name the name of the bean to retrieve
-	 * @param args arguments to use if creating a prototype using explicit arguments to a
-	 * static factory method. It is invalid to use a non-null args value in any other case.
+	 * @param args arguments to use if creating a prototype using explicit arguments
 	 * @return an instance of the bean
 	 * @throws NoSuchBeanDefinitionException if there is no such bean definition
 	 * @throws BeanDefinitionStoreException if arguments have been given but

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

@@ -25,6 +25,7 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
@@ -44,10 +45,12 @@
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.BeanFactoryUtils;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.config.DependencyDescriptor;
 import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
 import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.LookupOverride;
 import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.BridgeMethodResolver;
@@ -96,6 +99,12 @@
  * thus the latter configuration will override the former for properties wired through
  * both approaches.
  *
+ * <p>In addition to regular injection points as discussed above, this post-processor
+ * also handles Spring's {@link Lookup @Lookup} annotation which identifies lookup
+ * methods to be replaced by the container at runtime. This is essentially a type-safe
+ * version of {@code getBean(Class, args)} and {@code getBean(String, args)},
+ * See {@link Lookup @Lookup's javadoc} for details.
+ *
  * @author Juergen Hoeller
  * @author Mark Fisher
  * @since 2.5
@@ -119,6 +128,9 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 
 	private ConfigurableListableBeanFactory beanFactory;
 
+	private final Set<String> lookupMethodsChecked =
+			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(64));
+
 	private final Map<Class<?>, Constructor<?>[]> candidateConstructorsCache =
 			new ConcurrentHashMap<Class<?>, Constructor<?>[]>(64);
 
@@ -224,7 +236,28 @@ public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, C
 	}
 
 	@Override
-	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
+	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName) throws BeansException {
+		if (!this.lookupMethodsChecked.contains(beanName)) {
+			ReflectionUtils.doWithMethods(beanClass, new ReflectionUtils.MethodCallback() {
+				@Override
+				public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
+					Lookup lookup = method.getAnnotation(Lookup.class);
+					if (lookup != null) {
+						LookupOverride override = new LookupOverride(method, lookup.value());
+						try {
+							RootBeanDefinition mbd = (RootBeanDefinition) beanFactory.getMergedBeanDefinition(beanName);
+							mbd.getMethodOverrides().addOverride(override);
+						}
+						catch (NoSuchBeanDefinitionException ex) {
+							throw new BeanCreationException(beanName,
+									"Cannot apply @Lookup to beans without corresponding bean definition");
+						}
+					}
+				}
+			});
+			this.lookupMethodsChecked.add(beanName);
+		}
+
 		// Quick check on the concurrent map first, with minimal locking.
 		Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
 		if (candidateConstructors == null) {
@@ -239,7 +272,8 @@ public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, Strin
 						AnnotationAttributes annotation = findAutowiredAnnotation(candidate);
 						if (annotation != null) {
 							if (requiredConstructor != null) {
-								throw new BeanCreationException("Invalid autowire-marked constructor: " + candidate +
+								throw new BeanCreationException(beanName,
+										"Invalid autowire-marked constructor: " + candidate +
 										". Found another constructor with 'required' Autowired annotation: " +
 										requiredConstructor);
 							}
@@ -250,10 +284,10 @@ public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, Strin
 							boolean required = determineRequiredStatus(annotation);
 							if (required) {
 								if (!candidates.isEmpty()) {
-									throw new BeanCreationException(
+									throw new BeanCreationException(beanName,
 											"Invalid autowire-marked constructors: " + candidates +
 											". Found another constructor with 'required' Autowired annotation: " +
-											requiredConstructor);
+											candidate);
 								}
 								requiredConstructor = candidate;
 							}

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2002-2014 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 org.springframework.beans.factory.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that indicates 'lookup' methods, to be overridden by the container
+ * to redirect them back to the {@link org.springframework.beans.factory.BeanFactory}
+ * for a {@code getBean} call. This is essentially an annotation-based version of the
+ * XML {@code lookup-method} attribute, resulting in the same runtime arrangement.
+ *
+ * <p>The resolution of the target bean can either be based on the return type
+ * ({@code getBean(Class)}) or on a suggested bean name ({@code getBean(String)}),
+ * in both cases passing the method's arguments to the {@code getBean} call
+ * for applying them as target factory method arguments or constructor arguments.
+ *
+ * <p>Such lookup methods can have default (stub) implementations that will simply
+ * get replaced by the container, or they can be declared as abstract - for the
+ * container to fill them in at runtime. In both cases, the container will generate
+ * runtime subclasses of the method's containing class via CGLIB, which is why such
+ * lookup methods can only work on beans that the container instantiates through
+ * regular constructors (i.e. lookup methods cannot get replaced on beans returned
+ * from factory methods where we can't dynamically provide a subclass for them).
+ *
+ * <p>Note: When used with component scanning or any other mechanism that filters
+ * out abstract beans, provide stub implementations of your lookup methods to be
+ * able to declare them as concrete classes.
+ *
+ * @author Juergen Hoeller
+ * @since 4.1
+ * @see org.springframework.beans.factory.BeanFactory#getBean(Class, Object...)
+ * @see org.springframework.beans.factory.BeanFactory#getBean(String, Object...)
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Lookup {
+
+	/**
+	 * This annotation attribute may suggest a target bean name to look up.
+	 * If not specified, the target bean will be resolved based on the
+	 * annotated method's return type declaration.
+	 */
+	String value() default "";
+
+}

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java

@@ -285,8 +285,8 @@ protected <T> T doGetBean(
 				if (dependsOn != null) {
 					for (String dependsOnBean : dependsOn) {
 						if (isDependent(beanName, dependsOnBean)) {
-							throw new BeanCreationException("Circular depends-on relationship between '" +
-									beanName + "' and '" + dependsOnBean + "'");
+							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
+									"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
 						}
 						registerDependentBean(dependsOnBean, beanName);
 						getBean(dependsOnBean);
@@ -1274,7 +1274,7 @@ protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName
 		// Check validity of the usage of the args parameter. This can
 		// only be used for prototypes constructed via a factory method.
 		if (args != null && !mbd.isPrototype()) {
-			throw new BeanDefinitionStoreException(
+			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
 					"Can only specify arguments for the getBean method when referring to a prototype bean definition");
 		}
 	}
@@ -1625,8 +1625,7 @@ protected void registerDisposableBeanIfNecessary(String beanName, Object bean, R
 	 * instantiation within this class is performed by this method.
 	 * @param beanName the name of the bean
 	 * @param mbd the merged bean definition for the bean
-	 * @param args arguments to use if creating a prototype using explicit arguments to a
-	 * static factory method. This parameter must be {@code null} except in this case.
+	 * @param args arguments to use if creating a prototype using explicit arguments
 	 * @return a new instance of the bean
 	 * @throws BeanCreationException if the bean could not be created
 	 */

spring-beans/src/main/java/org/springframework/beans/factory/support/CglibSubclassingInstantiationStrategy.java

@@ -25,7 +25,6 @@
 import org.springframework.beans.BeanInstantiationException;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.BeanFactory;
-
 import org.springframework.cglib.core.SpringNamingPolicy;
 import org.springframework.cglib.proxy.Callback;
 import org.springframework.cglib.proxy.CallbackFilter;
@@ -34,6 +33,7 @@
 import org.springframework.cglib.proxy.MethodInterceptor;
 import org.springframework.cglib.proxy.MethodProxy;
 import org.springframework.cglib.proxy.NoOp;
+import org.springframework.util.StringUtils;
 
 /**
  * Default object instantiation strategy for use in BeanFactories.
@@ -89,14 +89,13 @@ protected Object instantiateWithMethodInjection(RootBeanDefinition beanDefinitio
 	 */
 	private static class CglibSubclassCreator {
 
-		private static final Class<?>[] CALLBACK_TYPES = new Class<?>[] { NoOp.class,
-			LookupOverrideMethodInterceptor.class, ReplaceOverrideMethodInterceptor.class };
+		private static final Class<?>[] CALLBACK_TYPES = new Class<?>[]
+				{NoOp.class, LookupOverrideMethodInterceptor.class, ReplaceOverrideMethodInterceptor.class};
 
 		private final RootBeanDefinition beanDefinition;
 
 		private final BeanFactory owner;
 
-
 		CglibSubclassCreator(RootBeanDefinition beanDefinition, BeanFactory owner) {
 			this.beanDefinition = beanDefinition;
 			this.owner = owner;
@@ -113,7 +112,6 @@ private static class CglibSubclassCreator {
 		 */
 		Object instantiate(Constructor<?> ctor, Object[] args) {
 			Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
-
 			Object instance;
 			if (ctor == null) {
 				instance = BeanUtils.instantiate(subclass);
@@ -123,19 +121,17 @@ Object instantiate(Constructor<?> ctor, Object[] args) {
 					Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
 					instance = enhancedSubclassConstructor.newInstance(args);
 				}
-				catch (Exception e) {
+				catch (Exception ex) {
 					throw new BeanInstantiationException(this.beanDefinition.getBeanClass(), String.format(
-						"Failed to invoke construcor for CGLIB enhanced subclass [%s]", subclass.getName()), e);
+							"Failed to invoke constructor for CGLIB enhanced subclass [%s]", subclass.getName()), ex);
 				}
 			}
-
 			// SPR-10785: set callbacks directly on the instance instead of in the
 			// enhanced class (via the Enhancer) in order to avoid memory leaks.
 			Factory factory = (Factory) instance;
-			factory.setCallbacks(new Callback[] { NoOp.INSTANCE,//
-				new LookupOverrideMethodInterceptor(beanDefinition, owner),//
-				new ReplaceOverrideMethodInterceptor(beanDefinition, owner) });
-
+			factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
+					new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
+					new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
 			return instance;
 		}
 
@@ -153,6 +149,7 @@ private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
 		}
 	}
 
+
 	/**
 	 * Class providing hashCode and equals methods required by CGLIB to
 	 * ensure that CGLIB doesn't generate a distinct class per bean.
@@ -162,7 +159,6 @@ private static class CglibIdentitySupport {
 
 		private final RootBeanDefinition beanDefinition;
 
-
 		CglibIdentitySupport(RootBeanDefinition beanDefinition) {
 			this.beanDefinition = beanDefinition;
 		}
@@ -173,8 +169,8 @@ RootBeanDefinition getBeanDefinition() {
 
 		@Override
 		public boolean equals(Object other) {
-			return other.getClass().equals(this.getClass())
-					&& ((CglibIdentitySupport) other).getBeanDefinition().equals(this.getBeanDefinition());
+			return (getClass().equals(other.getClass()) &&
+					this.beanDefinition.equals(((CglibIdentitySupport) other).beanDefinition));
 		}
 
 		@Override
@@ -183,14 +179,14 @@ public int hashCode() {
 		}
 	}
 
+
 	/**
 	 * CGLIB callback for filtering method interception behavior.
 	 */
 	private static class MethodOverrideCallbackFilter extends CglibIdentitySupport implements CallbackFilter {
 
 		private static final Log logger = LogFactory.getLog(MethodOverrideCallbackFilter.class);
 
-
 		MethodOverrideCallbackFilter(RootBeanDefinition beanDefinition) {
 			super(beanDefinition);
 		}
@@ -210,11 +206,12 @@ else if (methodOverride instanceof LookupOverride) {
 			else if (methodOverride instanceof ReplaceOverride) {
 				return METHOD_REPLACER;
 			}
-			throw new UnsupportedOperationException("Unexpected MethodOverride subclass: "
-					+ methodOverride.getClass().getName());
+			throw new UnsupportedOperationException("Unexpected MethodOverride subclass: " +
+					methodOverride.getClass().getName());
 		}
 	}
 
+
 	/**
 	 * CGLIB MethodInterceptor to override methods, replacing them with an
 	 * implementation that returns a bean looked up in the container.
@@ -223,7 +220,6 @@ private static class LookupOverrideMethodInterceptor extends CglibIdentitySuppor
 
 		private final BeanFactory owner;
 
-
 		LookupOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
 			super(beanDefinition);
 			this.owner = owner;
@@ -233,10 +229,17 @@ private static class LookupOverrideMethodInterceptor extends CglibIdentitySuppor
 		public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
 			// Cast is safe, as CallbackFilter filters are used selectively.
 			LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
-			return this.owner.getBean(lo.getBeanName());
+			Object[] argsToUse = (args.length > 0 ? args : null);  // if no-arg, don't insist on args at all
+			if (StringUtils.hasText(lo.getBeanName())) {
+				return this.owner.getBean(lo.getBeanName(), argsToUse);
+			}
+			else {
+				return this.owner.getBean(method.getReturnType(), argsToUse);
+			}
 		}
 	}
 
+
 	/**
 	 * CGLIB MethodInterceptor to override methods, replacing them with a call
 	 * to a generic MethodReplacer.
@@ -245,7 +248,6 @@ private static class ReplaceOverrideMethodInterceptor extends CglibIdentitySuppo
 
 		private final BeanFactory owner;
 
-
 		ReplaceOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
 			super(beanDefinition);
 			this.owner = owner;
@@ -255,7 +257,7 @@ private static class ReplaceOverrideMethodInterceptor extends CglibIdentitySuppo
 		public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
 			ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
 			// TODO could cache if a singleton for minor performance optimization
-			MethodReplacer mr = owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
+			MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
 			return mr.reimplement(obj, method, args);
 		}
 	}