Spring Bean的实例化源码解析

• 实例化入口：createBeanInstance()
• 实例化Bean的方式
• • 回调函数实例化Bean
  • • 配置回调函数的示例
  • 工厂方法实例化Bean
  • • 方法参数解析
    • 执行工厂方法，实例化Bean
  • 指定构造函数实例化Bean
  • • 构造函数参数解析
    • 执行构造函数，实例化Bean
  • 默认无参构造函数实例化Bean

Spring中提供了多种实例化Bean的方式，例如Supplier回调函数、静态工厂、实例工厂、构造函数、FactoryBean等。
Supplier回调函数是从Spring5开始提供的一种实例化方式。通过工厂、构造函数实例化对象时，Spring使用的都是反射，而反射的性能相对较差。Supplier回调函数可以自定义实例化过程，无须通过反射调用，直接执行函数即可。
Spring实例化Bean的时机，请参考 Spring Bean的生命周期

说明：我的源码是 v5.2.4.RELEASE 版本，因为几年前看过，有一些相关的注释在上面，所以就没有拉取最新的源码，有可能最新的代码与这个版本有一些差异，但是整体思路应该不差多。

FactoryBean 的过程相对麻烦一些，有时间单独写一个吧。

Spring实例化Bean的入口是AbstractAutowireCapableBeanFactory.createBeanInstance()，该方法在AbstractAutowireCapableBeanFactory.doCreateBean()中被调用。

// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {
	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); // 从FactoryBean缓存列表中移除
	}
	
	if (instanceWrapper == null) { // 为null，说明不是FactoryBean，那么调用工厂或者构造函数实例化Bean
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 省略掉大量代码，这些代码用于初始化Bean、属性赋值、循环依赖处理等
	return exposedObject;
}

这个方法中的代码，是Spring实例化Bean的核心代码

// AbstractAutowireCapableBeanFactory
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// Make sure bean class is actually resolved at this point.
	// 从bean定义中解析出当前bean的class对象
	Class beanClass = resolveBeanClass(mbd, beanName);

	// 检测类的访问权限。对于非public类，默认是允许访问的；若被设置为禁止访问非public的类，则这里会抛出异常
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

	
	Supplier instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
	    // 这里的代码很简单，就是执行回调函数获取Bean的实例
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// Shortcut when re-creating the same bean...
	// Spring的注释说，这是重复实例化相同Bean时的快捷方式
	boolean resolved = false; // 判断Bean定义中的构造函数或者工厂方法是否已被解析过
	boolean autowireNecessary = false; // 有没有必要进行依赖注入
	if (args == null) { // getBean方法传入的参数为null
		synchronized (mbd.constructorArgumentLock) {
			
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true; // 标记构造函数已被解析过了，原型等非单例模式的Bean，从第二次实例化开始就会进入这里
				// 构造函数参数是否被解析过？当使用有参构造函数或者工厂方法实例化Bean时，该属性会被设置为true
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) { // 已经解析过了，直接实例化Bean即可
		if (autowireNecessary) {
			// 使用有参构造函数实例化对象
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			// 使用无参构造函数实例化对象
			return instantiateBean(beanName, mbd);
		}
	}

	// Candidate constructors for autowiring?
	// 调用Bean后置处理器，获取用于实例化Bean的构造函数，这里的返回值一般都是null
	Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		// 使用指定的构造函数实例化对象
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// Preferred constructors for default construction?
	
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		// 实例化Bean
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// No special handling: simply use no-arg constructor.
	// 如果前面的条件都不匹配，则使用无参构造函数实例化对象
	return instantiateBean(beanName, mbd);
}

从上面的源码和注释可以看出，通过Java配置类配置的Bean，使用的是实例工厂方式进行实例化，且实例工厂是Java配置类的代理对象，这个代理对象是在Spring解析Java配置类时创建的。
对于非单例模式的Bean，Spring做了一些性能优化，只有第一次实例化Bean时，才需要解析Bean定义中的构造函数或者工厂方法，然后将构造函数或者工厂方法、参数信息等数据回写到Bean定义对象的对应属性。

// AbstractAutowireCapableBeanFactory
protected BeanWrapper obtainFromSupplier(Supplier instanceSupplier, String beanName) {
	Object instance;

	// 设置当前正在实例化的Bean的名称到ThreadLocal
	String outerBean = this.currentlyCreatedBean.get();
	this.currentlyCreatedBean.set(beanName);
	try {
		instance = instanceSupplier.get(); // 调用函数，拿到Bean实例
	}
	finally {
		// 重置ThreadLocal
		if (outerBean != null) {
			this.currentlyCreatedBean.set(outerBean);
		}
		else {
			this.currentlyCreatedBean.remove();
		}
	}

	if (instance == null) {
		instance = new NullBean();
	}

	// BeanWrapper接口提供了一些操作目标对象属性值的方法
	BeanWrapper bw = new BeanWrapperImpl(instance);
	initBeanWrapper(bw);
	return bw;
}

可以看到，通过回调函数实例化Bean的代码非常简单，直接执行回调函数，无须解析参数，也不需要进行反射调用。

提供一个简单的回调函数配置示例

public class MemberRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		RootBeanDefinition bd = new RootBeanDefinition();
		bd.setBeanClass(Member.class);
		bd.setInstanceSupplier(Member::new); // 这里注册一个回调函数
		registry.registerBeanDefinition("member", bd);
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

	}
}

Java配置类中的Bean是通过实例工厂方法实例化的，实例工厂是Java配置类的代理对象。
无论是静态工厂方法还是实例工厂方法，亦或者是Java配置类()，都是走相同的代码。

// AbstractAutowireCapableBeanFactory
protected BeanWrapper instantiateUsingFactoryMethod(
	String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

// ConstructorResolver
public BeanWrapper instantiateUsingFactoryMethod(
		String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

	BeanWrapperImpl bw = new BeanWrapperImpl();
	this.beanFactory.initBeanWrapper(bw);

	// 实例工厂Bean对象，如果是静态工厂，值为null
	Object factoryBean;
	// 工厂的类型
	Class factoryClass;
	// 是否静态工厂
	boolean isStatic;

	// 实例工厂的BeanName，如果是静态工厂，则值为null
	String factoryBeanName = mbd.getFactoryBeanName();
	if (factoryBeanName != null) {
		// 如果是实例工厂，进入这个分支
		// 实例工厂的Bean名称和需要使用工厂实例化的Bean对象的名称相同，则抛出异常
		if (factoryBeanName.equals(beanName)) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
					"factory-bean reference points back to the same bean definition");
		}
		// 从IoC容器中获取实例工厂对象
		factoryBean = this.beanFactory.getBean(factoryBeanName);
		// 单例Bean，并且在IoC容器的一级缓存中已存在，说明这个Bean已经被创建过了，不能再次创建，抛出异常
		if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
			throw new ImplicitlyAppearedSingletonException();
		}
		factoryClass = factoryBean.getClass(); // 实例工厂的类名，这里可能得到CGLIB生成的子类名称
		isStatic = false;
	}
	else {
		// It's a static factory method on the bean class.
		// 如果是静态工厂，则进入这个分支
		if (!mbd.hasBeanClass()) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
					"bean definition declares neither a bean class nor a factory-bean reference");
		}
		factoryBean = null;
		factoryClass = mbd.getBeanClass(); // 静态工厂的类名
		isStatic = true;
	}

	Method factoryMethodToUse = null; // 用于实例化Bean的工厂方法
	ArgumentsHolder argsHolderToUse = null; // 持有 用于实例化Bean的参数 对象
	Object[] argsToUse = null; // 用于实例化Bean的参数

	if (explicitArgs != null) {
		argsToUse = explicitArgs;
	}
	else {
		Object[] argsToResolve = null;
		synchronized (mbd.constructorArgumentLock) {
			
			factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
			if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
				// Found a cached factory method...
				argsToUse = mbd.resolvedConstructorArguments;
				if (argsToUse == null) {
					argsToResolve = mbd.preparedConstructorArguments;
				}
			}
		}
		if (argsToResolve != null) {
			argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
		}
	}

	if (factoryMethodToUse == null || argsToUse == null) {
		// 获取工厂的实际类型，如果是CGLIB生成的子类，则返回原始类；否则返回的就是参数值
		factoryClass = ClassUtils.getUserClass(factoryClass);

		List candidates = null; // 可用于实例化Bean的工厂方法
		if (mbd.isFactoryMethodUnique) { // 如果是通过Java配置类配置的Bean，会走这块代码
			if (factoryMethodToUse == null) {
				factoryMethodToUse = mbd.getResolvedFactoryMethod();
			}
			if (factoryMethodToUse != null) {
				candidates = Collections.singletonList(factoryMethodToUse);
			}
		}
		if (candidates == null) { // 如果是静态工厂或者实例工厂，会走块代码
			candidates = new ArrayList<>();
			Method[] rawCandidates = getCandidateMethods(factoryClass, mbd); // 获取工厂类的所有方法
			
			for (Method candidate : rawCandidates) {
				if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
					candidates.add(candidate);
				}
			}
		}

		// 只有一个符合条件的工厂方法，并且方法没有参数，则走这一块代码
		if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
			Method uniqueCandidate = candidates.get(0); // 唯一可以用来实例化Bean的工厂方法
			if (uniqueCandidate.getParameterCount() == 0) { // 方法的参数个数为0
				mbd.factoryMethodToIntrospect = uniqueCandidate;
				synchronized (mbd.constructorArgumentLock) {
					
					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
					mbd.constructorArgumentsResolved = true;
					mbd.resolvedConstructorArguments = EMPTY_ARGS;
				}

				// instantiate：通过反射的方式执行工厂方法实例化Bean，Method.invoke()
				bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
				return bw;
			}
		}

		// 有多个工厂方法，则根据方法参数的个数进行排序，参数多的在前面
		if (candidates.size() > 1) {  // explicitly skip immutable singletonList
			candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
		}

		ConstructorArgumentValues resolvedValues = null; // 已转换的参数值
		// 是否是构造函数注入
		boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
		int minTypeDiffWeight = Integer.MAX_VALUE;
		Set ambiguousFactoryMethods = null;

		int minNrOfArgs; // 参数个数
		if (explicitArgs != null) {
			minNrOfArgs = explicitArgs.length;
		}
		else {
			if (mbd.hasConstructorArgumentValues()) { // 是否需要参数
			    // 获取Bean定义中的参数信息，例如 有多少个参数，参数是什么类型、名称等，就是Bean定义的参数信息
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				// 根据Bean定义时使用的索引、类型、名称等方式解析参数，如果引用了其它Bean，在这里会被创建
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
			else {
				minNrOfArgs = 0;
			}
		}

        // 该变量用于缓存解析方法参数过程中出现的异常，方法可能被重载，当被解析的方法与Bean定义中的方法无法匹配时，就会抛出异常
		LinkedList causes = null;
		for (Method candidate : candidates) {
			int parameterCount = candidate.getParameterCount(); // 方法的参数个数
			if (parameterCount >= minNrOfArgs) {
				ArgumentsHolder argsHolder;
                // 方法的参数类型
				Class[] paramTypes = candidate.getParameterTypes();
				if (explicitArgs != null) {
					// Explicit arguments given -> arguments length must match exactly.
					if (paramTypes.length != explicitArgs.length) {
						continue;
					}
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
				else {
					// Resolved constructor arguments: type conversion and/or autowiring necessary.
					try {
						String[] paramNames = null; // 方法参数的名称
						ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
						if (pnd != null) {
						    // 解析方法参数的名称
							paramNames = pnd.getParameterNames(candidate);
						}
						// 解析方法的参数值
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
								paramTypes, paramNames, candidate, autowiring, candidates.size() == 1);
					}
					catch (UnsatisfiedDependencyException ex) {
						// 省略了异常处理的代码，这里并不会直接抛出异常，只是将异常缓存到 causes 变量
						// 如果所有方法都无法匹配Bean定义中的方法，在后面的代码中才抛出异常
						continue;
					}
				}

				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
				// Choose this factory method if it represents the closest match.
				if (typeDiffWeight < minTypeDiffWeight) {
					factoryMethodToUse = candidate; // 实例化Bean的工厂方法
					argsHolderToUse = argsHolder; // 持有工厂方法参数的对象
					argsToUse = argsHolder.arguments; // 工厂方法需要的参数
					minTypeDiffWeight = typeDiffWeight;
					ambiguousFactoryMethods = null;
				} else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
						!mbd.isLenientConstructorResolution() &&
						paramTypes.length == factoryMethodToUse.getParameterCount() &&
						!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
					if (ambiguousFactoryMethods == null) {
						ambiguousFactoryMethods = new LinkedHashSet<>();
						ambiguousFactoryMethods.add(factoryMethodToUse);
					}
					ambiguousFactoryMethods.add(candidate);
				}
			}
		}
        // ......
		// 这里省略了一块代码，这些主要用来处理由于Bean定义错误，导致无法实例化Bean的异常情况
        // ......
		if (explicitArgs == null && argsHolderToUse != null) {
			mbd.factoryMethodToIntrospect = factoryMethodToUse; // 回写工厂方法到Bean定义的属性
			argsHolderToUse.storeCache(mbd, factoryMethodToUse); // 回写相关信息到Bean定义中，例如上面提到的resolvedConstructorOrFactoryMethod、constructorArgumentsResolved等属性
		}
	}

	// 通过反射实例化Bean
	bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
	return bw;
}

使用工厂方法实例化Bean，主要有如下几个步骤：

1. 如果是实例工厂，则先获取实例工厂对象。
2. 找到用于创建Bean的工厂方法，工厂方法可能被重载，那么就会找到多个名字相同的方法，此时需要根据方法的参数进行查找。
3. 根据参数索引、类型或者名称等解析方法参数，例如参数是其它Bean，则会创建这个Bean。
4. 将解析得到的方法、参数等数据回写到Bean定义对象的相关属性上，再次创建相同的Bean时，就无需解析，直接从Bean定义中取即可。
5. 使用反射的方式执行方法，实例化Bean。

定义Bean时，指定工厂方法的参数可以使用索引位置、参数类型、参数名称、或者什么都不指定直接设值 多种方式。
解析参数时，通过索引位置配置的方式是单独的解析方式，其它几种使用的是同一种解析方式。

// ConstructorResolver
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
		ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
    // 自定义的参数类型解析器，一般都没有指定，所以返回值是null
	TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
	// 如果没有自定义解析器，则使用BeanWrapper
	TypeConverter converter = (customConverter != null ? customConverter : bw);
	// Bean定义值解析器
	BeanDefinitionValueResolver valueResolver =
			new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);

	int minNrOfArgs = cargs.getArgumentCount(); // 参数的数量
    // 通过索引位置配置的参数，走这里
	for (Map.Entry entry : cargs.getIndexedArgumentValues().entrySet()) {
		int index = entry.getKey(); // 索引
		if (index < 0) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Invalid constructor argument index: " + index);
		}
		if (index > minNrOfArgs) {
			minNrOfArgs = index + 1;
		}
		ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue(); // 参数值
		// 参数值是否已经转换，例如参数引用了一个Bean，这个Bean是否已经被创建出来
		if (valueHolder.isConverted()) {
			resolvedValues.addIndexedArgumentValue(index, valueHolder); // 回写方法参数，在外层再取出来
		}
		else {
		    // 参数转换后的值，例如参数是一个Bean，则此处会将Bean创建出来，如果Bean已经创建了，则直接从IoC容器中拿到这个Bean。
			Object resolvedValue =
					valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
			// 保存参数值的对象
			ConstructorArgumentValues.ValueHolder resolvedValueHolder =
					new ConstructorArgumentValues.ValueHolder(resolvedValue, valueHolder.getType(), valueHolder.getName());
			resolvedValueHolder.setSource(valueHolder);
			resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder); // 回写方法参数
		}
	}
    // 通过类型、名称或者什么都没有指定的方式配置的参数，走这里
	for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
		if (valueHolder.isConverted()) {
			resolvedValues.addGenericArgumentValue(valueHolder);
		}
		else {
		    // 参数值解析，如果引用了其它Bean，这里会将Bean创建出来
			Object resolvedValue =
					valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
			// 保存参数值的对象
			ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
					resolvedValue, valueHolder.getType(), valueHolder.getName()); 
			resolvedValueHolder.setSource(valueHolder);
			resolvedValues.addGenericArgumentValue(resolvedValueHolder); // 回写方法参数
		}
	}

	return minNrOfArgs;
}

直接通过反射的方式Method.invoke()执行工厂方法，实例化Bean。

// ConstructorResolver
private Object instantiate(String beanName, RootBeanDefinition mbd,
		@Nullable Object factoryBean, Method factoryMethod, Object[] args) {

	try {
		if (System.getSecurityManager() != null) {
			return AccessController.doPrivileged((PrivilegedAction