Spring 4.x 源码系列3-bean创建

一、前沿

在上节文章 bean加载 中我们学习了Sprin加载bean的整个过程，其中对于如何创建bean的我们没有讲解，本节将从 createBean 方法开始，阅读源码来了解bean的创建的整个过程，bean的创建是Spring中非常重要的模块，通过它可以了解Spring容器是怎么将bean创建出来的

二、bean创建前奏

bean 的创建是从 AbstractAutowireCapableBeanFactory（BeanFactory） 的 createBean 方法开始的，源码如下：

	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		// 根据设置的class属性或者className来解析成Class，以防 BeanDefinition 中的 BeanClass 之前没有被解析成 Class
		Class resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			// Override 方法校验和标记，对于只有一个 Override 标记的同名方法标记为未重载，以避免参数类型检查的开销
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			// InstantiationAwareBeanPostProcessor 的实例化前置处理和 BeanPostProcessor 的初始化后置处理，
			// 实例化前置和初始化后置正是生成代理bean的好时机，如果需要生成代理类则需要在此处理，直接返回代理bean
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				// 如果这里已经生成好了代理bean，则直接返回代理bean即可，无需再创建bean了
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		try {
			// doCreateBean 方法是真正创建bean逻辑
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

createBean 方法实现了如下逻辑：

1）、根据设置的class属性或者className来解析成Class，并设置到 BeanDefinition 中

2）、 Override 方法校验和标记

3）、InstantiationAwareBeanPostProcessor 的实例化前置处理和 BeanPostProcessor 的初始化后置处理，实例化前置正好是生成代理bean的最好时机，如果生成了代理bean则可以调用 BeanPostProcessor 的初始化后置处理对bean做进一步的修改

4）、如果生成了代理类bean，则创建bean结束，无需调用后续的 doCreateBean 方法再创建bean了，我们熟知的AOP就是在此实现的

5）、调用 doCreateBean 方法创建bean

2.1  根据设置的class属性或者className来解析成Class（resolveBeanClass 方法）

为防 BeanDefinition 中的 BeanClass 之前没有被解析成 Class，故这边解析一下，入口在 AbstractBeanFactory 的 resolveBeanClass 方法，源码如下：

	// 1、AbstractBeanFactory 的 resolveBeanClass
	@Nullable
	protected Class resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class... typesToMatch)
			throws CannotLoadBeanClassException {

		try {
			if (mbd.hasBeanClass()) {
				// 已经解析好了 BeanClass，则直接返回
				return mbd.getBeanClass();
			}
			if (System.getSecurityManager() != null) {
				return AccessController.doPrivileged((PrivilegedExceptionAction>) () ->
					doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
			}
			else {
				// doResolveBeanClass 方法真正解析 BeanClass
				return doResolveBeanClass(mbd, typesToMatch);
			}
		}
		catch (PrivilegedActionException pae) {
			ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
		}
		catch (ClassNotFoundException ex) {
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
		}
		catch (LinkageError err) {
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
		}
	}

	// 2、AbstractBeanFactory 的 doResolveBeanClass
	@Nullable
	private Class doResolveBeanClass(RootBeanDefinition mbd, Class... typesToMatch)
			throws ClassNotFoundException {

		ClassLoader beanClassLoader = getBeanClassLoader();
		ClassLoader dynamicLoader = beanClassLoader;
		boolean freshResolve = false;

		if (!ObjectUtils.isEmpty(typesToMatch)) {
			// When just doing type checks (i.e. not creating an actual instance yet),
			// use the specified temporary class loader (e.g. in a weaving scenario).
			ClassLoader tempClassLoader = getTempClassLoader();
			if (tempClassLoader != null) {
				dynamicLoader = tempClassLoader;
				freshResolve = true;
				if (tempClassLoader instanceof DecoratingClassLoader) {
					DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
					for (Class typeToMatch : typesToMatch) {
						dcl.excludeClass(typeToMatch.getName());
					}
				}
			}
		}

		// 获取 BeanDefinition 的 beanClassName
		String className = mbd.getBeanClassName();
		if (className != null) {
			// 根据 className 动态解析成表达式
			Object evaluated = evaluateBeanDefinitionString(className, mbd);
			if (!className.equals(evaluated)) {
				// A dynamically resolved expression, supported as of 4.2...
				if (evaluated instanceof Class) {
					// 如果解析后的表达式是 Class，则直接返回
					return (Class) evaluated;
				}
				else if (evaluated instanceof String) {
					className = (String) evaluated;
					freshResolve = true;
				}
				else {
					throw new IllegalStateException("Invalid class name expression result: " + evaluated);
				}
			}
			if (freshResolve) {
				// When resolving against a temporary class loader, exit early in order
				// to avoid storing the resolved Class in the bean definition.
				if (dynamicLoader != null) {
					try {
						// 使用ClassLoader动态加载类
						return dynamicLoader.loadClass(className);
					}
					catch (ClassNotFoundException ex) {
						if (logger.isTraceEnabled()) {
							logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
						}
					}
				}
				// 反射方法加载类
				return ClassUtils.forName(className, dynamicLoader);
			}
		}

		// Resolve regularly, caching the result in the BeanDefinition...
		// className 不存在，则使用 ClassLoader 加载类
		return mbd.resolveBeanClass(beanClassLoader);
	}

2.2 Override 方法校验和标记（prepareMethodOverrides 方法）

对 Override 方法的预处理入口在 AbstractBeanDefinition 的 prepareMethodOverrides 方法，源码如下：

	// 1、AbstractBeanDefinition 的 prepareMethodOverrides 方法
	public void prepareMethodOverrides() throws BeanDefinitionValidationException {
		// Check that lookup methods exists.
		// 校验是否存在 Override 方法
		if (hasMethodOverrides()) {
			Set overrides = getMethodOverrides().getOverrides();
			synchronized (overrides) {
				for (MethodOverride mo : overrides) {
					// 遍历所有的 Override 方法处理
					prepareMethodOverride(mo);
				}
			}
		}
	}


	// 2、AbstractBeanDefinition 的 prepareMethodOverride 方法
	protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
		// 获取同名 Override 方法的个数
		int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
		if (count == 0) {
			// 不存在的话抛出异常
			throw new BeanDefinitionValidationException(
					"Invalid method override: no method with name '" + mo.getMethodName() +
					"' on class [" + getBeanClassName() + "]");
		}
		else if (count == 1) {
			// Mark override as not overloaded, to avoid the overhead of arg type checking.
			// 只有一个同名 Override 方法，则overloaded属性标记为false
			mo.setOverloaded(false);
		}
	}

Override 方法校验和标记意义重大，主要表现了如下方面：

1）、MethodOverride 的 overloaded 属性标记，为了避免参数类型检查的开销。如果一个类中有多个重载方法，那么在方法调用或者方法增强的时候还需要根据参数类型进行匹配，以确定当前调用的或者增强的到底是哪一个方法

2）、Spring 的一部分匹配工作在这里完成了，如果当前类中的方法只有一个的话，那么就设置该方法没有被重载，这样在后续调用的时候不仅可以直接找到该方法而不需要进行方法参数匹配确认了，而且还提前对方法做了存在性验证

2.3 实例化前置处理和初始化后置处理（resolveBeforeInstantiation 方法）

实例化前置正是生成代理bean的最好时机，生成代理类bean之后还可以调用 BeanPostProcessor 的初始化后置处理，对bean做进一步的修改，这里如果生成了bean则直接返回bean，无需再调用 doCreateBean 方法创建bean了，入口在 AbstractAutowireCapableBeanFactory 的 resolveBeforeInstantiation 方法，源码如下：

	// AbstractAutowireCapableBeanFactory 的 resolveBeforeInstantiation 方法
	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		// bean已经被解析过了
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			// bean 是非自定义的 && BeanFactory 中存在 InstantiationAwareBeanPostProcessor 类型的bean
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				// 获取bean的目标类型
				Class targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					// InstantiationAwareBeanPostProcessor 的实例化前置处理
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						// 如果bean已经生成了，则可以调用 BeanPostProcessor 的初始化后置处理，对bean做进一步的修改
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

2.3.1 实例化前置处理

bean的实例化前置处理，也就是将 BeanDefinition 转换为 BeanWrapper 前的处理。给子类一个修改 BeanDefinition 的机会，也就是说当程序经过这个方法后，bean 可能已经不是我们认为的bean了，而是或许成为了一个经过处理的代理bean，即可能是通过 JDK动态代理或者CGLIB生成的，也可能是其他技术生成的，入口在 AbstractAutowireCapableBeanFactory 的 applyBeanPostProcessorsBeforeInstantiation 方法，源码如下：

	// AbstractAutowireCapableBeanFactory 的 applyBeanPostProcessorsBeforeInstantiation
	@Nullable
	protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
		//  遍历所有的 BeanPostProcessor
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			// InstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 模板方法，调用具体的 InstantiationAwareBeanPostProcessor 实现类的 postProcessBeforeInstantiation 方法
				// 这里可以根据自己的业务做处理，比如通过 JDK 动态代理或者CGLIB 生成代理类，AOP 的代理类创建就是在这里实现的
				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
				if (result != null) {
					// 如果有一个生成了bean，就立即返回该bean，即后续的 InstantiationAwareBeanPostProcessor 都不会处理了
					return result;
				}
			}
		}
		// 没有生成任何bean
		return null;
	}

2.3.2 初始化后置处理

在分析从缓存中获取单例bean的时候就提到过，Spring 中的规则是在 bean 的初始化后尽可能保证将注册的后处理器的 postProcessAfterInitialization 方法应用到该 bean中。因为这里创建好了bean，即返回结果不为空，那么便不会再次经历普通 bean 的创建过程了，所以只能在这里调用 BeanPostProcessor 后处理器的 postProcessAfterInitialization 初始化后置处理方法了，入口在 AbstractAutowireCapableBeanFactory 的 applyBeanPostProcessorsAfterInitialization 方法，源码如下：

	// AbstractAutowireCapableBeanFactory 的 applyBeanPostProcessorsAfterInitialization 方法
	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		// 遍历所有的 BeanPostProcessor
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			// 模板方法，这里调用具体的实现类 BeanPostProcessorpost 的 postProcessAfterInitialization 方法做初始化后置处理
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				// 没有返回处理后的新的bean，则直接返回原bean即可
				return result;
			}
			// 初始化后置处理后返回的新bean赋值给 result
			result = current;
		}
		return result;
	}

在真正调用 doCreate 方法创建bean之前调用了 resolveBeforeInstantiation 方法对 BeanDefinition 的属性做些实例化前置处理和初始化后置处理。当然无论是否有相应的逻辑实现我们都可以理解，因为真正逻辑实现前后留有处理方法也是可扩展的一种体现，当经过 resolveBeforeInstantiation 处理后返回结果不为空，那么会直接略过后续的 Bean 创建（doCreateBean 方法）而直接返回结果。这一特性起着至关重要的作用，我们熟知的 AOP 功能就是基于这里实现的

下面开始分析常规bean的真正创建过程，即 doCreateBean 方法

三、bean真正创建

在 Spring 中一般真正实现业务的方法都是以 do 开头的，创建bean也不例外，bean真正创建始于 AbstractAutowireCapableBeanFactory（BeanFactory） 的 doCreateBean 方法，源码如下：

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// 如果是单例，则清除未完成的实例化bean的缓存，并返回 BeanWrapper
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// bean实例为空时，创建bean实例，根据指定的bean使用对应的策略创建bean的实例，例如工厂方法、构造方法自动注入、简单初始化等
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		// 加锁做 MergedBeanDefinitionPostProcessor 的 postProcessMergedBeanDefinition 方法处理
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				// 没有应用过 MergedBeanDefinitionPostProcessor
				try {
					// MergedBeanDefinitionPostProcessor 的应用，bean合并后的处理，Autowired 注解正是通过此方法实现诸如类型的预解析
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 是否允许提早曝光：单例 && 允许循环依赖 && 当前bean在创建中
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			// 允许提前曝光
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			// 为解决循环依赖问题，在bean初始化完成前将创建实例bean的 ObjectFactory 加入 singletonFactories 缓存中
			// ObjectFactory 的 getObject 方法调用 getEarlyBeanReference 方法，
			// 具体调用 SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference 方法再次对bean获取依赖，我们熟知的AOP就是在这里将Advice动态织入bean中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		// 开始初始化bean
		Object exposedObject = bean;
		try {
			// 初始化bean的属性值，其中属性可以依赖于其他bean，则会递归初始化依赖bean的属性
			populateBean(beanName, mbd, instanceWrapper);
			// 初始化bean方法调用，按照顺序调用如下：
			// 1、xxxAware 的 setXXX 方法
			// 2、BeanPostProcessor 的初始化前置处理
			// 3、InitializingBean 的 afterPropertiesSet 方法
			// 4、bean 的 init-method 方法
			// 5、BeanPostProcessor 的初始化后置处理
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			// 缓存中获取单例bean
			Object earlySingletonReference = getSingleton(beanName, false);
			// 存在循环依赖
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					// exposedObject 和 bean 相等，说明经过bean初始化后，bean没有被增强
					exposedObject = earlySingletonReference;
				}
				// 在循环引用的情况下，不允许注入一个原始的bean实例 && 存在bean依赖
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					// 遍历bean依赖处理
					for (String dependentBean : dependentBeans) {
						// 从缓存中移除仅仅是为了类型检查创建的单例bean
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							// 如果依赖的bean还没有创建好，则加入actualDependentBeans
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						// bean 创建好之后其依赖的所有bean一定也是创建好的，这里 actualDependentBeans 不为空，则说明当前bean创建后其依赖的bean却没有全部创建完，也就是说存在循环依赖
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			// 注册 DisposableBean，即将单例bean注册到 disposableBeans 中去，暴露 Bean（DisposableBean） 的 destroy 方法（配置了 destroy-method 方法），
			// 以便销毁时 BeanFactory 调用bean的此方法销毁bean
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

doCreateBean 方法主要实现了以下核心逻辑：

1）、创建bean实例

2）、MergedBeanDefinitionPostProcessor 的应用，bean合并后的处理

3）、记录创建bean的 ObjectFactory ，解决循环依赖问题

4）、初始化bean的属性

5）、初始化bean的方法

6）、注册 DisposableBean

下面分别对这6个核心逻辑作详细的源码分析

3.1 创建bean实例（createBeanInstance 方法）

创建bean实例 过程复杂，这里使用单独一篇文章来分析，这里不在赘述

3.2 MergedBeanDefinitionPostProcessor 的应用（applyMergedBeanDefinitionPostProcessors 方法）

MergedBeanDefinitionPostProcessor 的应用，即bean合并后的处理，Autowired 注解正是通过此方法实现诸如类型的预解析，入口在 AbstractAutowireCapableBeanFactory 的 applyMergedBeanDefinitionPostProcessors 方法，源码如下：

	// AbstractAutowireCapableBeanFactory 的 applyMergedBeanDefinitionPostProcessors 方法
	protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				// MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				// 模板方法，调用具体的实现类 MergedBeanDefinitionPostProcessor 的 postProcessMergedBeanDefinition 方法
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

3.3 记录创建bean的 ObjectFactory（addSingletonFactory 方法）

在分析记录创建bean的 ObjectFactory 源码前，我们先梳理一下几个重要参数的作用，分别如下：

earlySingletonExposure：是否允许提早曝光的单例

allowCircularReferences：是否允许循环依赖，配置文件中木有这个属性的配置，但是在 AbstractRefreshableApplicationContext 中存在 setAllowCircularReferences 方法，可以通过硬编码的方式或者自定义命名空间进行设置此参数

isSingletonCurrentlyInCreation（baneName）：该bean是否在创建中，在Spring中默认使用 DefaultSingletonBeanRegistry 的属性 singletonsCurrentlyInCreation 来记录 bean 的加载状态。在bean开始创建前会将 beanName 记录在属性中，在bean创建结束后就移除 beanName，不同scope的bean记录的位置不一样

那么 addSingletonFactory 的作用是什么呢，又会在什么时候调用呢？我们以最简单的AB循环依赖为例，类A中有属性类B，类B中有属性类A，那么创建Bean A 的过程如下图所示：

解决循环依赖的我关键就是如上图所示的 getBean（A）的时候，根据之前我们分析的代码可知，并不是直接去实例化 A ，而是先去检测缓存中是否有已经创建好的对应的bean，或者是否存在已经创建好的 ObjectFactory ，而此时对于 A 的 ObjectFactory 早已从创建好，所以程序便不会向后执行，而是直接调用 ObjectFactory 去创建 A ，源码如下：

	// 1、DefaultSingletonBeanRegistry 的 addSingletonFactory 方法
	protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			// beanName 对应的 bean 没有被缓存
			if (!this.singletonObjects.containsKey(beanName)) {
				// 增加 beanName 对应的 ObjectFactory 缓存
				this.singletonFactories.put(beanName, singletonFactory);
				// 移除 beanName 对应的早期缓存
				this.earlySingletonObjects.remove(beanName);
				// registeredSingletons 也增加 beanName 对应的缓存
				this.registeredSingletons.add(beanName);
			}
		}
	}


	// 2、AbstractAutowireCapableBeanFactory 的 getEarlyBeanReference 方法
	// 调用 ObjectFactory 的 getObject 方法时便会调用此方法
	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				// 循环处理 SmartInstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					// 模板方法，调用 SmartInstantiationAwareBeanPostProcessor 实现类的 getEarlyBeanReference 方法
					// 我们熟知的AOP就是在这里将advice动态织入bean中，不需要处理时则直接返回bean即可
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
				}
			}
		}
		return exposedObject;
	}

AbstractAutowireCapableBeanFactory 的 getEarlyBeanReference 方法中除了后处理器的调用外并没有太多的逻辑，根据以上分析，我们得出了Spring处理循环依赖的解决方法：

在B中创建依赖A时通过 ObjectFactory 提供的实例化方法来中断 A 中的属性填充，使B中持有的 A 仅仅是刚刚初始化并没有填充任何属性的 A，而真正初始化 A 的步骤还是在最开始创建 A 的时候进行的，但是因为 A 与 B 中的属性 A 所表示的属性地址是一样的，所以在 A 中创建好的属性填充自然可以通过B中的 A 获取，这样就解决了循环依赖问题

3.4 初始化bean的属性（populateBean 方法）

创建好bean实例之后，就需要对bean进行初始化了，即属性填充，而在属性填充的时候会出现本文 3.3 中讲到的循环依赖问题，不过Spring很好的解决了循环依赖的矛盾问题，属性填充的入口在 AbstractAutowireCapableBeanFactory 的 populateBean 方法，源码如下：

	@SuppressWarnings("deprecation")  // for postProcessPropertyValues
	// AbstractAutowireCapableBeanFactory 的 populateBean 方法
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				// 如果空实例 && 有属性，则抛出异常
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		// 给 InstantiationAwareBeanPostProcessor 最后一次机会在属性填充前修改bean，比如：可以用来支持属性注入的类型
		boolean continueWithPropertyPopulation = true;

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// InstantiationAwareBeanPostProcessor 的实例化后置处理
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						// 一个实例化后置处理失败，则将终止该bean的属性填充，这里可以控制bean是否需要继续属性填充
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			// 不需要属性填充，直接返回
			return;
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		// 根据依赖注入的类型（byName或者byType）获取依赖的bean，并将依赖bean和本bean属性一起存入 MutablePropertyValues 对象中
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				// 根据名称注入bean
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				// 根据类型注入bean
				autowireByType(beanName, mbd, bw, newPvs);
			}
			// 更新后的属性赋值给 pvs
			pvs = newPvs;
		}

		// 是否有实例化处理器，这里是对属性值应用之前的处理
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		// 是否需要依赖检查
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// InstantiationAwareBeanPostProcessor 的 postProcessProperties 方法，对属性值应用之前的处理
					// 获取属性完之后属性填充前的再次处理，比如：AutowiredAnnotationBeanPostProcessor 的依赖注入对象 Metadata 数据预处理
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							// 为依赖检查过滤掉不需要的属性 Descriptor
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				// 为依赖检查过滤掉不需要的属性 Descriptor
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			// 依赖检查
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			// 应用所有的bean属性
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

上述代码中主要实现了以下逻辑：

1）、byName 根据名称自动注入

2）、byType 根据类型自动注入

3）、属性应用

下面分别对这三个逻辑通过源码来做具体分析

3.4.1 根据名称自动注入（autowireByName 方法）

根据名称自动注入的入口在 AbstractAutowireCapableBeanFactory 的 autowireByName 方法，源码如下：

	// AbstractAutowireCapableBeanFactory 的 autowireByName 方法
	protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		// 获取非简单bean属性名称，即所有需要依赖注入的属性
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			// BeanFactory 缓存中是否有 propertyName 对应的bean定义
			if (containsBean(propertyName)) {
				// 根据名称获取bean实例，递归获取bean的所有依赖
				Object bean = getBean(propertyName);
				// 将依赖的bean加入本bean的属性中去
				pvs.add(propertyName, bean);
				// 注册依赖bean的映射关系
				registerDependentBean(propertyName, beanName);
				if (logger.isTraceEnabled()) {
					logger.trace("Added autowiring by name from bean name '" + beanName +
							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
				}
			}
			else {
				// 依赖的bean不存在bean定义，则抛出异常
				if (logger.isTraceEnabled()) {
					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
							"' by name: no matching bean found");
				}
			}
		}
	}

3.4.2  根据类型自动注入（autowireByType 方法）

autowireByType 和 autowireByName 使用起来很相似，但是其实现功能的复杂度却完全不一样， 根据类型自动注入比根据名称自动注入要复杂的多，入口在 AbstractAutowireCapableBeanFactory 的 autowireByType 方法，源码如下：

	// 1、AbstractAutowireCapableBeanFactory 的 autowireByType 方法
	protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		// 类型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		Set autowiredBeanNames = new LinkedHashSet<>(4);
		// 获取非简单bean属性名称，即所有需要依赖注入的属性
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			try {
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
				// Don't try autowiring by type for type Object: never makes sense,
				// even if it technically is a unsatisfied, non-simple property.
				// 对象类型是非 Object 的
				if (Object.class != pd.getPropertyType()) {
					// 获取指定属性的set方法
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					// Do not allow eager init for type matching in case of a prioritized post-processor.
					// 非优先级 PriorityOrdered 的 bean
					boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
					// 构建 DependencyDescriptor
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					// 调用 DefaultListableBeanFactory 的 resolveDependency 方法解析依赖
					// 解析指定beanName的属性所匹配的值，并把解析到的属性名存储在autowiredBeanNames对象中，当属性存在多个封装bean时，
					// 比如： @Autowired private List list, Spring将会找到所有A类型的bean注入到 list 中
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
						// 解析好的依赖bean映射存入属性 MutablePropertyValues 中
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
						// 注册依赖关系映射到缓存中
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isTraceEnabled()) {
							logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
									propertyName + "' to bean named '" + autowiredBeanName + "'");
						}
					}
					autowiredBeanNames.clear();
				}
			}
			catch (BeansException ex) {
				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
			}
		}
	}


	// 2、DefaultListableBeanFactory 的 resolveDependency 方法
	@Override
	@Nullable
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		if (Optional.class == descriptor.getDependencyType()) {
			// Optional 类型的 bean 处理
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			// ObjectFactory 类型 或者 ObjectProvider 类型的 bean 处理
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			// javaxInjectProviderClass  类型的 bean 处理
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			// 如果需要懒加载，则获取懒加载代理bean
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				// 其他普通类型的bean处理
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}


	// 3、DefaultListableBeanFactory 的 resolveDependency 方法
	@Nullable
	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		// 当前注入点
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			// 获取 shortcut 名称的bean
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}

			Class type = descriptor.getDependencyType();
			// @Value 注解
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			if (value != null) {
				if (value instanceof String) {
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ?
							getMergedBeanDefinition(beanName) : null);
					// 解析value中的表达式
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				try {
					// 类型转换器转换成依赖bean的类型
					return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
				}
				catch (UnsupportedOperationException ex) {
					// A custom TypeConverter which does not support TypeDescriptor resolution...
					return (descriptor.getField() != null ?
							converter.convertIfNecessary(value, type, descriptor.getField()) :
							converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
				}
			}

			// 集合类型 bean 解析，比如：数组、Map、Stream 和 Collection
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}

			// 根据属性类型找到 BeanFactory 中所有类型匹配的bean，组成 beanName -> bean 实例的映射关系
			Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;

			if (matchingBeans.size() > 1) {
				// 同种类型多个bean匹配时，优先匹配 @Primary 注解的bean，其次是 @Priority（值越小优先级越高） 注解最高优先级的 bean，
				// 最后匹配已经解析过的bean或者是匹配到该名称或者别名对应的bean
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
					}
					else {
						// In case of an optional Collection/Map, silently ignore a non-unique case:
						// possibly it was meant to be an empty collection of multiple regular beans
						// (before 4.3 in particular when we didn't even look for collection beans).
						return null;
					}
				}
				// 获取最后匹配的bean实例
				instanceCandidate = matchingBeans.get(autowiredBeanName);
			}
			else {
				// We have exactly one match.
				Map.Entry entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			if (result instanceof NullBean) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				result = null;
			}
			if (!ClassUtils.isAssignableValue(type, result)) {
				// 类型不匹配
				throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
			}
			return result;
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

	// 4、DefaultListableBeanFactory 的 resolveMultipleBeans 方法
	@Nullable
	private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) {

		final Class type = descriptor.getDependencyType();

		if (descriptor instanceof StreamDependencyDescriptor) {
			// 属性是 Stream 类型的bean 集合
			Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			Stream