constructorresolver.java

spring api 源代码

/*
 * Copyright 2002-2007 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.support;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.BeanMetadataElement;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.BeansException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.UnsatisfiedDependencyException;
import org.springframework.beans.factory.config.ConstructorArgumentValues;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.config.TypedStringValue;
import org.springframework.core.MethodParameter;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;

/**
 * Helper class for resolving constructors and factory methods.
 * Performs constructor resolution through argument matching.
 *
 * <p>Operates on an {@link AbstractBeanFactory} and an {@link InstantiationStrategy}.
 * Used by {@link AbstractAutowireCapableBeanFactory}.
 *
 * @author Juergen Hoeller
 * @author Rob Harrop
 * @since 2.0
 * @see #autowireConstructor
 * @see #instantiateUsingFactoryMethod
 * @see AbstractAutowireCapableBeanFactory
 */
abstract class ConstructorResolver {

	private final AbstractBeanFactory beanFactory;

	private final InstantiationStrategy instantiationStrategy;


	/**
	 * Create a new ConstructorResolver for the given factory and instantiation strategy.
	 * @param beanFactory the BeanFactory to work with
	 * @param instantiationStrategy the instantiate strategy for creating bean instances
	 */
	public ConstructorResolver(AbstractBeanFactory beanFactory, InstantiationStrategy instantiationStrategy) {
		this.beanFactory = beanFactory;
		this.instantiationStrategy = instantiationStrategy;
	}


	/**
	 * "autowire constructor" (with constructor arguments by type) behavior.
	 * Also applied if explicit constructor argument values are specified,
	 * matching all remaining arguments with beans from the bean factory.
	 * <p>This corresponds to constructor injection: In this mode, a Spring
	 * bean factory is able to host components that expect constructor-based
	 * dependency resolution.
	 * @param beanName the name of the bean
	 * @param mbd the merged bean definition for the bean
	 * @param chosenCtor a pre-chosen Constructor (or <code>null</code> if none)
	 * @return a BeanWrapper for the new instance
	 */
	protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd, Constructor chosenCtor) {
		BeanWrapper bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);

		Constructor constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
		Object[] argsToUse = null;

		if (constructorToUse != null) {
			// Found a cached constructor...
			argsToUse = mbd.resolvedConstructorArguments;
			if (argsToUse == null) {
				Class[] paramTypes = constructorToUse.getParameterTypes();
				Object[] argsToResolve = mbd.preparedConstructorArguments;
				BeanDefinitionValueResolver valueResolver =
						new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, bw);
				argsToUse = new Object[argsToResolve.length];
				for (int i = 0; i < argsToResolve.length; i++) {
					Object argValue = argsToResolve[i];
					if (argValue instanceof BeanMetadataElement) {
						String argName = "constructor argument with index " + i;
						argValue = valueResolver.resolveValueIfNecessary(argName, argValue);
					}
					argsToUse[i] = bw.convertIfNecessary(argValue, paramTypes[i],
							new MethodParameter(constructorToUse, i));
				}
			}
		}

		else {
			// Need to resolve the constructor.
			boolean autowiring = (chosenCtor != null ||
					mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);

			ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
			ConstructorArgumentValues resolvedValues = new ConstructorArgumentValues();
			int minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);

			// Take specified constructor, if any.
			if (chosenCtor != null) {
				Class[] paramTypes = chosenCtor.getParameterTypes();
				argsToUse = createArgumentArray(
						beanName, mbd, resolvedValues, bw, paramTypes, chosenCtor, autowiring).arguments;
				constructorToUse = chosenCtor;
			}

			else {
				Constructor[] candidates = mbd.getBeanClass().getDeclaredConstructors();
				AutowireUtils.sortConstructors(candidates);
				int minTypeDiffWeight = Integer.MAX_VALUE;

				for (int i = 0; i < candidates.length; i++) {
					Constructor candidate = candidates[i];
					Class[] paramTypes = candidate.getParameterTypes();

					if (constructorToUse != null && argsToUse.length > paramTypes.length) {
						// Already found greedy constructor that can be satisfied ->
						// do not look any further, there are only less greedy constructors left.
						break;
					}
					if (paramTypes.length < minNrOfArgs) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								minNrOfArgs + " constructor arguments specified but no matching constructor found in bean '" +
								beanName + "' " +
								"(hint: specify index and/or type arguments for simple parameters to avoid type ambiguities)");
					}

					// Try to resolve arguments for current constructor.
					try {
						ArgumentsHolder args = createArgumentArray(
								beanName, mbd, resolvedValues, bw, paramTypes, candidate, autowiring);
						int typeDiffWeight = args.getTypeDifferenceWeight(paramTypes);
						// Choose this constructor if it represents the closest match.
						if (typeDiffWeight < minTypeDiffWeight) {
							constructorToUse = candidate;
							argsToUse = args.arguments;
							minTypeDiffWeight = typeDiffWeight;
						}
					}
					catch (UnsatisfiedDependencyException ex) {
						if (this.beanFactory.logger.isTraceEnabled()) {
							this.beanFactory.logger.trace(
									"Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
						}
						if (i == candidates.length - 1 && constructorToUse == null) {
							throw ex;
						}
						else {
							// Swallow and try next constructor.
						}
					}
				}

				if (constructorToUse == null) {
					throw new BeanCreationException(
							mbd.getResourceDescription(), beanName, "Could not resolve matching constructor");
				}
			}

			mbd.resolvedConstructorOrFactoryMethod = constructorToUse;
		}

		Object beanInstance = this.instantiationStrategy.instantiate(
				mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
		bw.setWrappedInstance(beanInstance);
		return bw;
	}

	/**
	 * Instantiate the bean using a named factory method. The method may be static, if the
	 * bean definition parameter specifies a class, rather than a "factory-bean", or
	 * an instance variable on a factory object itself configured using Dependency Injection.
	 * <p>Implementation requires iterating over the static or instance methods with the
	 * name specified in the RootBeanDefinition (the method may be overloaded) and trying
	 * to match with the parameters. We don't have the types attached to constructor args,
	 * so trial and error is the only way to go here. The explicitArgs array may contain
	 * argument values passed in programmatically via the corresponding getBean method.
	 * @param beanName the name of the bean
	 * @param mbd the merged bean definition for the bean
	 * @param explicitArgs argument values passed in programmatically via the getBean
	 * method, or <code>null</code> if none (-> use constructor argument values from bean definition)
	 * @return a BeanWrapper for the new instance
	 */
	public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {
		BeanWrapper bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);

		Class factoryClass = null;
		Object factoryBean = null;
		boolean isStatic = true;

		String factoryBeanName = mbd.getFactoryBeanName();
		if (factoryBeanName != null) {
			if (factoryBeanName.equals(beanName)) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"factory-bean reference points back to the same bean definition");
			}
			factoryBean = this.beanFactory.getBean(factoryBeanName);
			if (factoryBean == null) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"factory-bean '" + factoryBeanName + "' returned null");
			}
			factoryClass = factoryBean.getClass();
			isStatic = false;
		}
		else {
			// It's a static factory method on the bean class.
			factoryClass = mbd.getBeanClass();
		}

		Method factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
		Object[] argsToUse = null;

		if (factoryMethodToUse != null) {
			// Found a cached factory method...
			if (explicitArgs != null) {
				argsToUse = explicitArgs;
			}
			else {
				argsToUse = mbd.resolvedConstructorArguments;
				if (argsToUse == null) {
					Class[] paramTypes = factoryMethodToUse.getParameterTypes();
					Object[] argsToResolve = mbd.preparedConstructorArguments;
					BeanDefinitionValueResolver valueResolver =
							new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, bw);
					argsToUse = new Object[argsToResolve.length];
					for (int i = 0; i < argsToResolve.length; i++) {
						Object argValue = argsToResolve[i];
						if (argValue instanceof BeanMetadataElement) {
							String argName = "factory method argument with index " + i;
							argValue = valueResolver.resolveValueIfNecessary(argName, argValue);
						}
						argsToUse[i] = bw.convertIfNecessary(argValue, paramTypes[i],
								new MethodParameter(factoryMethodToUse, i));
					}
				}
			}
		}

		else {
			// Need to determine the factory method...
			// Try all methods with this name to see if they match the given arguments.
			Method[] candidates = ReflectionUtils.getAllDeclaredMethods(factoryClass);
			boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
			int minTypeDiffWeight = Integer.MAX_VALUE;
			ConstructorArgumentValues resolvedValues = null;

			int minNrOfArgs = 0;
			if (explicitArgs != null) {
				minNrOfArgs = explicitArgs.length;
			}
			else {
				// We don't have arguments passed in programmatically, so we need to resolve the
				// arguments specified in the constructor arguments held in the bean definition.
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}

			for (int i = 0; i < candidates.length; i++) {
				Method candidate = candidates[i];