Spring源码解析4.createBean()方法解析

shstart7

已于 2022-05-26 11:43:01 修改

阅读量284

点赞数

分类专栏： Spring 文章标签： spring java ioc 源码

于 2021-12-15 17:39:03 首次发布

本文链接：https://blog.csdn.net/qq_46312987/article/details/121957813

版权

Spring 专栏收录该内容

12 篇文章 3 订阅

订阅专栏

createBeanInstance()

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {

		//获取bd内部的Class对象。
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		//这里判断当前bean是非公开类型的无法被创建，直接抛出异常即可。
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			//抛出异常。。
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
		//这里是一个FactoryBean创建的逻辑，
		if (mbd.getFactoryMethodName() != null) {
            //走FactoryBean创建对象的逻辑
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		//表示bd对应的构造信息是否已经解析成可以反射调用的构造方法method了
		boolean resolved = false;
		//是否自动匹配构造方法
		boolean autowireNecessary = false;
		//args一般都为NULL
		if (args == null) {
			//加锁
			synchronized (mbd.constructorArgumentLock) {
				//条件成立：表示bd的构造信息已经转化成了可以反射调用的method了
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					/*
					 *  当resolvedConstructorOrFactoryMethod有值时，且构造方法有参					   *  数，那么可以认为这个字段值就是true
					 *  只有什么情况下这个字段是false？
					 *  1.resolvedConstructorOrFactoryMethod == NULL
					 *  2.当resolvedConstructorOrFactoryMethod表示的是默认的构造方					    *  法，无参构造方法
					 * */
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			//bd中含有非默认(无参)的构造方法
			if (autowireNecessary) {
				//有参数，那么就需要根据参数 去匹配最合适的构造方法去执行反射创建对象
				return autowireConstructor(beanName, mbd, null, null);
			}
			//bd中只有默认的无参构造方法
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// 典型的应用: @Autowired注解标在了构造器方法上 这里使用后处理器寻找合适的构造器
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		/*
		*  条件一：成立，后处理器指定了构造方法数组
		*  条件二：mbd autowiredMode一般是no
		*  条件三：条件成立，说明bd中配置了构造参数信息
		*  条件四：getBean时 args。有参数
		* */
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			//使用获取的构造器去构造对象
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		//这里一般不会执行
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		//未指定构造参数，未设定偏好，，， 使用默认无参的构造器创建对象
		return instantiateBean(beanName, mbd);
	}

1. doCreateBean方法解析

还是一样的步骤，先来整体分析一下doGreateBean方法，后面再详细分步骤解析：

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

		/*
		*  BeanWrapper 内部包装了最核心的就是创建出来的实例对象，还提供了一些额外的接口方		*  法 比如属性访问器等
		* */
		BeanWrapper instanceWrapper = null;

		/*
		 * mbd是单例的，先将缓存中的实例干掉
		 * factoryBeanInstanceCache (ConcurrentHashMap<String, BeanWrapper>)
		 */
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		
    	//缓存中没有找到
		if (instanceWrapper == null) {
			/*
			 * 到这里会创建出来真实的bean实例，并且将其包装成BeanWrapper
			 */
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
        
        //获取wrapper内部封装的创建出来的bean对象
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
                    //后处理器调用点：合并BD信息，接下来就是处理依赖了。
                    
                    /*
                     * 提取出当前beanTypeClass类型整个继承体系内的
                     * @Autowired @Value @Inject信息 并且包装成一个									 *	InjectionMetadata，存放到												 *	AutowiredAnnotationBeanPostProcessor的缓存中，key是						 *	beanName
                     */
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					//抛异常
				}
				mbd.postProcessed = true;
			}
		}

		/*
		 * 这里判断是否需要提前暴露一个对象到三级缓存：条件：单例 && 正在创建 &&允许循环引		   * 用
		 * 这里为了解决循环依赖。
		 */
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
    
		if (earlySingletonExposure) {
			//打印日志
			}
			
    		/*
    		 * 为了检测并处理循环依赖(单实例set注入循环依赖可以处理)，
    		 * 这里提前将未初始化完毕的实例加入三级缓存中。
    		 */
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		
		/*
		 * 下面就是完善bean的生命周期的过程，(进行依赖注入，调用init-method等。。)
		 */		
		Object exposedObject = bean;
		try {
			/*
			 * 对bean进行填充，将各个属性值注入，
			 * 处理当前实例的依赖数据。。。依赖注入就是在这一步完成的。
			 */
			populateBean(beanName, mbd, instanceWrapper);
			
            /*
             * 调用初始化方法，比如init-method
             * 生命周期中初始化方法的调用。
             */
            exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			//抛异常
			}
			else {
				//抛异常
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						//抛出异常
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			 //抛出异常
		}
		return exposedObject;
	}

上面代码中，我们整体串了一遍doCreateBean方法的整体流程，为了减少代码量和文章篇幅，代码中省略了错误日志打印和异常抛出。

我们来总结一下上面代码的执行过程：

获取BeanWrapper：如果是单例模式，首先从缓存中尝试 remove 移除对应的 Bean 对象，移除后该方法返回 BeanWrapper对象。

// Instantiate the bean.实例化bean。
// BeanWrapper：包装对象，内部最核心的字段就是咱们的真实实例。它提供了一些额外的接口方法，比如 属性访问器
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}

获取BeanWrapper：如果缓存中没有找到目标结果，则通过createBeanInstance方法创建 Bean 实例（根据 BeanDefinition 最终结果转换为 BeanWrapper对象）

// 如果缓存中没有找到对应的结果：
if (instanceWrapper == null) {
	// 则创建Bean实例，并将其包装到BeanWrapper实例中
	// createBeanInstance方法创建出来真实的bean实例：
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

对Bean 的依赖进行处理、填充、属性注入，并进行循环依赖检查，检测已经加载的 bean 是否已经出现了依赖循环，并判断是否要抛出异常：

// 是否需要提早曝光：单例&允许循环依赖&当前bean正在创建中，检测循环依赖
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
		isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
	if (logger.isTraceEnabled()) {
		//打印日志
	}
	// 为避免后期循环依赖，可以在bean初始化完成之前将创建实例的ObjectFactory加入工厂
	// 对bean再一次依赖引用，主要应用SmartInstantiationAware BeanPostProcessor
   // 其中我们熟知的AOP就是这样将advice动态织入bean中，若没有则直接返回bean，不做任何处理
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
	// 依赖注入在这一步完成：对bean进行填充，将各个属性值注入，
    // 其中，可能存在依赖于其他bean的属性，则会递归初始依赖bean
	populateBean(beanName, mbd, instanceWrapper);
	// 调用初始化方法，比如init-method
	// 生命周期中的初始化方法的调用：
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
	if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
		... // 抛异常
	}
	else {
		... // 抛异常
	}
}

if (earlySingletonExposure) {
	Object earlySingletonReference = getSingleton(beanName, false);
	// earlySingletonReference只有在检测到有循环依赖的情况下才会不为空
	if (earlySingletonReference != null) {
		// 条件成立有几种情况？
		// 1.当前“真实实例”不需要被代理
		// 2.当前“实例”已经被代理过了...是在ObjectFactory.getObject() 方法调用时 实现的增强代理。
		if (exposedObject == bean) {
			exposedObject = earlySingletonReference;
		}
		else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
			// 获取依赖当前bean的 其它beanName
			String[] dependentBeans = getDependentBeans(beanName);
			Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
			for (String dependentBean : dependentBeans) {
				// 检测依赖
				if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
					actualDependentBeans.add(dependentBean);
				}
			}
			// 为什么有问题？
			// 因为咱们当前对象的AOP操作是在 当前方法的 initializeBean 这个方法完成的。
			// 在这之前 外部其它bean持有到的当前的 “bean实例” 都是尚未增强的。
			if (!actualDependentBeans.isEmpty()) {
				... // 抛异常
			}
		}
	}
}

// 判断当前bean实例是否需要注册 析构回调。当容器销毁时，会给当前bean的析构方法进行回调。
// 根据scope注册bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);

完成创建并返回
```
return exposedObject;
```
接下来一步一步的详细分析

2.获取BeanWrapper

在分析createBeanInstance方法之前，先来了解一下 BeanWrapper 类以及它的作用：

在Spring框架中，数据的提供是由BeanDefinition个类来负责，而依赖的注入就需要通过 BeanWrapper。
可以把BeanWrapper 理解为是一个代理器，Spring框架会委托 BeanWrapper 去完成 Bean 属性的填充工作。
BeanWrapper 是一个接口，因此Bean 属性的填充工作实际上是交给其实现类 BeanWrapperImpl 去完成！

在doCreateBean方法中，调用createBeanInstance()创建BeanWrapper实例之前，会先尝试从缓存中获取BeanWrapper对象（从factoryBeanInstanceCache中进行 remove，并获取该方法的返回值，返回的结果就是BeanWrapper实例。

如果缓存中没有，我们需要调用 createBeanInstance() 方法根据指定 Bean 使用对应的策略创建新的 BeanWrapper 实例。

// Instantiate the bean.实例化bean。
// BeanWrapper：包装对象，内部最核心的字段就是咱们的真实实例。它提供了一些额外的接口方法，比如 属性访问器
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}

// 如果缓存中没有找到对应的结果：
if (instanceWrapper == null) {
	// 则创建Bean实例，并将其包装到BeanWrapper实例中
	// createBeanInstance方法创建出来真实的bean实例：
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

下面就来分析，创建BeanWrapper实例的方法：createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)：

/**
 * 创建beanWrapper的实例
 * Create a new instance for the specified bean, using an appropriate instantiation strategy:
 * factory method, constructor autowiring, or simple instantiation.
 * @param beanName
 * @param mbd RootBeanDefinition
 * @param args
 * @return 返回一个BeanWrapper对象
 */
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // 解析bean对象的class类型
   Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
   // 三个条件： 
   // beanClass != null --> bean对象的class类型不为null
   // !Modifier.isPublic(beanClass.getModifiers() ---> 表示class是非public类型的
   // !mbd.isNonPublicAccessAllowed() ---> bd中nonPublicAccessAllowed字段值为false
   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
       // 上述三个条件均成立，就抛异常
       ... // 抛异常
   }

   // 通过指定的Supplier获取bean（JDK8 Spring5）
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

   // 如果mbd中factoryMethodName不为空，则使用工厂方法初始化策略
   if (mbd.getFactoryMethodName() != null)  {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // 表示bd对应的构造信息是否已经解析成可以反射调用的构造方法method信息了...
   boolean resolved = false;
   // 是否自动匹配构造方法..
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         // 一个类有多个构造函数，每个构造函数都有不同的参数，所以调用前需要先根据参数锁定构造函数和对应的工厂方法
         // resolvedConstructorOrFactoryMethod缓存这构造函数或工厂方法
         // 如果条件成立：说明bd的构造信息已经转化成可以反射调用的method了...
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            // 当resolvedConstructorOrFactoryMethod 有值时，且构造方法有参数，那么可以认为这个字段值就是true。
		   // 只有什么情况下这个字段是false呢？
		   // 1.resolvedConstructorOrFactoryMethod == null
		   // 2.当resolvedConstructorOrFactoryMethod 表示的是默认的构造方法，无参构造方法。
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   // 如果已经解析过则使用缓存中已经解析好的构造函数方法不需要再次锁定
   if (resolved) {
      if (autowireNecessary) {
         // 构造函数自动注入
         // 如果有参数，那么就需要根据参数 去匹配合适的构造方法了...
         // 拿出当前Class的所有构造器，然后根据参数信息去匹配出一个最优的选项，然后执行最优的构造器创建出实例。
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         // 使用默认构造函数构造（无参构造方法处理）
         return instantiateBean(beanName, mbd);
      }
   }

   // 典型的应用：@Autowired 注解打在了构造器方法上（需要根据参数解析构造函数...）
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   // 条件一：成立，后处理指定了构造方法数组
   // 条件二：mbd autowiredMode 一般情况是no
   // 条件三：条件成立，说明bean信息中配置了 构造参数信息。
   // 条件四：getBean时，args有参数..
   if (ctors != null ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
      // 构造函数自动注入
      return autowireConstructor(beanName, mbd, ctors, args);
   }
   // 未指定构造参数，未设定偏好...则使用默认的无参数的构造方法进行创建实例
   return instantiateBean(beanName, mbd);
}

下面我们重点分析一下autowireConstructor()

2.1autowireConstructor

对于实例的创建Spring中分成了两种情况，一种是通用的实例化，另一种是带有参数的实例化。带有参数的实例化过程相当复杂，因为存在着不确定性，所以在判断对应参数上做了大量工作。

	/*
	 * 带有参数的构造方法实例化
	 * @param chosenCtors 候选的构造方法
	 * @return 返回一个BeanWrapper对象
	 */
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
		
    	//先创建一个BeanWrapper(接口)实例(BeanWrapperImpl是其实现类)对象。
		BeanWrapperImpl bw = new BeanWrapperImpl();
    	//为bw设置一些转换器等
		this.beanFactory.initBeanWrapper(bw);
		
    	//最终筛选出来的构造器
		Constructor<?> constructorToUse = null;
		ArgumentsHolder argsHolderToUse = null;
    	//参数
		Object[] argsToUse = null;
		
    	//explicitArgs通过getBean()方法传入，如果getBean()方法调用
        //的时候指定了方法参数那么可以直接使用
		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
        //getBean()方法调用时没有指定方法参数则尝试从缓存中解析
		else {
			Object[] argsToResolve = null;
            //尝试从缓存中获取
			synchronized (mbd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse != null && mbd.constructorArgumentsResolved) {
					//从缓存中获取
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
                        //配置的构造函数参数
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
	  // 如果缓存中存在
      if (argsToResolve != null) {
         // 解析参数类型，如给定方法的构造函数A(int, int)则通过此方法后就会把配置中的("1", "1")转换为(1, 1)
         // 缓存中的值可能是原始值也可能是最终值
         argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
      }
 // 如果没有被缓存，则从配置文件的配置下手
   if (constructorToUse == null) {
      // Need to resolve the constructor.
      boolean autowiring = (chosenCtors != null ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
      ConstructorArgumentValues resolvedValues = null;

      int minNrOfArgs;
      if (explicitArgs != null) {
         minNrOfArgs = explicitArgs.length;
      }
      else {
         // 提取配置文件中的配置的构造函数参数
         ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
         // 用于承载解析后的构造函数参数的值
         resolvedValues = new ConstructorArgumentValues();
         // 能解析到的参数个数
         minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
      }

      // Take specified constructors, if any.
      Constructor<?>[] candidates = chosenCtors;
      if (candidates == null) {
         Class<?> beanClass = mbd.getBeanClass();
         try {
            candidates = (mbd.isNonPublicAccessAllowed() ?
                  beanClass.getDeclaredConstructors() : beanClass.getConstructors());
         }
         catch (Throwable ex) {
            // 抛出异常
         }
      }
      // 排序给定的构造函数，public构造函数优先参数数量降序、非public构造函数参数数量降序
      AutowireUtils.sortConstructors(candidates);
      
      int minTypeDiffWeight = Integer.MAX_VALUE;
      Set<Constructor<?>> ambiguousConstructors = null;
      LinkedList<UnsatisfiedDependencyException> causes = null;

      for (Constructor<?> candidate : candidates) {
         // 获取每个构造函数其所有的参数类型组成数组（不去重）
         Class<?>[] paramTypes = candidate.getParameterTypes();

         if (constructorToUse != null && argsToUse.length > paramTypes.length) {
            // 如果已经找到该用的构造函数并且用的参数大于构造函数可以传入的，因为降序排序，所以一旦大于，后面都会大于
            break;
         }
         if (paramTypes.length < minNrOfArgs) {
            // 文件配置的参数多于构造函数可以传入的，则进行下一个尝试
            continue;
         }

         ArgumentsHolder argsHolder;
         if (resolvedValues != null) {
            // 有参数则根据值构造对应参数类型的参数
            try {
               // 注解上获取参数名称
               String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
               if (paramNames == null) {
                  // 获取参数名称探索器
                  ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                  if (pnd != null) {
                     // 获取指定构造函数的参数名称
                     paramNames = pnd.getParameterNames(candidate);
                  }
               }
               // 根据名称和数据类型创建参数持有者
               argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                     getUserDeclaredConstructor(candidate), autowiring);
            }
            catch (UnsatisfiedDependencyException ex) {
               if (logger.isTraceEnabled()) {
                  ... // 日志打印
               }
               // Swallow and try next constructor.
               if (causes == null) {
                  causes = new LinkedList<>();
               }
               causes.add(ex);
               continue;
            }
         }
         else {
            // Explicit arguments given -> arguments length must match exactly.
            if (paramTypes.length != explicitArgs.length) {
               continue;
            }
            // 构造函数没有参数的情况
            argsHolder = new ArgumentsHolder(explicitArgs);
         }

         // 探测是否有不确定的构造函数存在，例如不同构造函数的参数为父子关系
         int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
               argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
         // 如果他代表着当前最接近的匹配则选择作为构造函数
         if (typeDiffWeight < minTypeDiffWeight) {
            //进行赋值
            constructorToUse = candidate;
            argsHolderToUse = argsHolder;
            argsToUse = argsHolder.arguments;
            minTypeDiffWeight = typeDiffWeight;
            ambiguousConstructors = null;
         }
         else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
            if (ambiguousConstructors == null) {
               ambiguousConstructors = new LinkedHashSet<>();
               ambiguousConstructors.add(constructorToUse);
            }
            ambiguousConstructors.add(candidate);
         }
      }

      if (constructorToUse == null) {
         if (causes != null) {
            UnsatisfiedDependencyException ex = causes.removeLast();
            for (Exception cause : causes) {
               this.beanFactory.onSuppressedException(cause);
            }
            throw ex;
         }
         ... // 抛异常
      }
      else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
         ... // 抛异常
      }

      if (explicitArgs == null) {
         // 将解析的构造函数加入缓存
         argsHolderToUse.storeCache(mbd, constructorToUse);
      }
   }

   try {
      final InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
      Object beanInstance;

      if (System.getSecurityManager() != null) {
         final Constructor<?> ctorToUse = constructorToUse;
         final Object[] argumentsToUse = argsToUse;
         beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
               strategy.instantiate(mbd, beanName, this.beanFactory, ctorToUse, argumentsToUse),
               this.beanFactory.getAccessControlContext());
      }
      else {
         beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
      }
      // 将构建的实例加入BeanWrapper中
      bw.setBeanInstance(beanInstance);
      return bw;
   }
   catch (Throwable ex) {
      ... // 抛异常
   }
}

代码量很多，我们整体过一遍整个方法逻辑，其实现的功能考虑了一下几个方面

2.1.1 构造函数参数的确定

根据 explicitArgs 参数判断

如果调用函数时传入的 explicitArgs 参数不为空，那么可以直接确认构造函数的参数就是这个。我们回溯一下 explicitArgs 参数的来源：

Object getBean(String name, Object... args) throws BeansException;

在获取 bean 的时候，用户不但可以指定 bean 的名称还可以指定 bean 所对应的构造函数或者工厂方法的方法参数，主要用于静态工厂方法的调用，而这里是需要给定完全匹配的参数的。所以，只要传入了 explicitArgs 参数，就是构造函数的参数了。

缓存中获取

如果 explicitArgs 参数为空，便可以先尝试从缓存中获取。缓存中缓存了构造函数的参数，但是参数可能是最终类型，也可能是初始类型。比如：构造函数参数要求的是 int 类型，但初始的参数值可能是 String 类型的 “1”，那么即使从缓存中获取到参数，也需要进行类型转换器的过滤确保参数类型完全对应上。

从代码上来看，argsToResolve 则是保存最后类型对应上的参数，它可能来自于 mbd.resolvedConstructorArguments，但是如果没有，则需要从缓存保存的初始参数 mbd.preparedConstructorArguments 通过 resolvePreparedArguments() 方法来进行转换。

// 如果getBean方法调用的时候没有指定方法参数则尝试从缓存中解析
else {
   Object[] argsToResolve = null;
   // 尝试从缓存中获取
   synchronized (mbd.constructorArgumentLock) {
      constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
      if (constructorToUse != null && mbd.constructorArgumentsResolved) {
         // 从缓存中获取已解析好的构造函数参数
         argsToUse = mbd.resolvedConstructorArguments;
         if (argsToUse == null) {
            // 如果缓存中没有，则通过配置的（准备）构造函数参数来生成
            argsToResolve = mbd.preparedConstructorArguments;
         }
      }
   }
   // 如果缓存中存在
   if (argsToResolve != null) {
      // 解析参数类型，如给定方法的构造函数A(int, int)则通过此方法后就会把配置中的("1", "1")转换为(1, 1)
      // 缓存中的值可能是原始值也可能是最终值
      argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
   }
}

配置文件获取

如果缓存中也没有，那么只能从 BeanDefinition 中去下手，也就是 mbd 参数，从中去解析出我们需要的参数信息。通过 mbd.getConstructorArgumentValues() 能够获取配置的构造函数信息。有了配置的信息便可以解析对应的参数值信息了，resolveConstructorArguments() 方法获取参数值的信息包括直接指定值，如：直接指定构造函数中的某个值为原始类型 String 类型，或者是一个对其他 bean 的引用。

// 如果没有被缓存，则从配置文件的配置下手
if (constructorToUse == null) {
   // Need to resolve the constructor.
   boolean autowiring = (chosenCtors != null ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
   ConstructorArgumentValues resolvedValues = null;

   int minNrOfArgs;
   if (explicitArgs != null) {
      minNrOfArgs = explicitArgs.length;
   }
   else {
      // 提取配置文件中的配置的构造函数参数
      ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
      // 用于承载解析后的构造函数参数的值
      resolvedValues = new ConstructorArgumentValues();
      // 能解析到的参数个数
      minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
   }
}

具体看看 resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues) 的方法。该方法五个参数具体见注释，函数内部主要对参数个数的统计以及将 cargs 解析保存至 resolvedValues 中

/**
 * 确定构造函数参数，并保存到resolvedValues中
 * @param beanName bean名称
 * @param mbd 配置文件信息
 * @param bw beanwrapper
 * @param cargs 配置文件中解析出的构造函数信息
 * @param resolvedValues 保存解析出的参数值信息
 * @return 解析到参数的个数
 */
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
      ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {

   TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
   TypeConverter converter = (customConverter != null ? customConverter : bw);
   BeanDefinitionValueResolver valueResolver =
         new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);

   int minNrOfArgs = cargs.getArgumentCount();

   for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> 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();
      if (valueHolder.isConverted()) {
         resolvedValues.addIndexedArgumentValue(index, valueHolder);
      }
      else {
         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 {
         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;
}

2.1.2 构造函数的确定

经过上面构造函数参数的确定，我们可以依据参数来锁定构造函数。我们需要先获取所有的候选的构造函数，如果用户传入构造函数那么直接确定为候选集合，否则需要我们根据 bean 的类型获取其所有的构造函数：

// 获取所有的构造函数
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
   Class<?> beanClass = mbd.getBeanClass();
   try {
      // 是否包含非public的构造函数
      candidates = (mbd.isNonPublicAccessAllowed() ?
            beanClass.getDeclaredConstructors() : beanClass.getConstructors());
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Resolution of declared constructors on bean Class [" + beanClass.getName() +
            "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
   }
}

匹配构造函数的方法是根据参数个数进行匹配，所以匹配前需要先对构造函数按照 public 构造函数优先参数数量降序、非 public 构造函数参数数量降序。这样可以在遍历的情况下迅速判断排在后面的构造函数参数个数是否符合条件。

// 排序给定的构造函数，public构造函数优先参数数量降序、非public构造函数参数数量降序
AutowireUtils.sortConstructors(candidates);

public static void sortConstructors(Constructor<?>[] constructors) {
    Arrays.sort(constructors, (c1, c2) -> {
        boolean p1 = Modifier.isPublic(c1.getModifiers());
        boolean p2 = Modifier.isPublic(c2.getModifiers());
        if (p1 != p2) {
            return (p1 ? -1 : 1);
        }
        int c1pl = c1.getParameterCount();
        int c2pl = c2.getParameterCount();
        return (c1pl < c2pl ? 1 : (c1pl > c2pl ? -1 : 0));
    });
}

由于在配置文件中并不限制只能用参数位置索引的方式去创建，同样支持指定参数名称进行设定参数值的情况，例如，那么这种情况就需要首先确定构造函数中的参数名称。

获取参数名称有两种方式，一种是注解的方式直接获取，另一种是使用Spring提供的工具类 ParamterNameDiscover 来获取。注解的方式如下：

@Nullable
public static String[] evaluate(Constructor<?> candidate, int paramCount) {
   ConstructorProperties cp = candidate.getAnnotation(ConstructorProperties.class);
   if (cp != null) {
      String[] names = cp.value();
      if (names.length != paramCount) {
         throw new IllegalStateException("Constructor annotated with @ConstructorProperties but not " +
               "corresponding to actual number of parameters (" + paramCount + "): " + candidate);
      }
      return names;
   }
   else {
      return null;
   }
}

如果注解获取不到，则需要借助 ParamterNameDiscover 来获取。

// 注解上获取参数名称
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
if (paramNames == null) {
   // 获取参数名称探索器
   ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
   if (pnd != null) {
      // 获取指定构造函数的参数名称
      paramNames = pnd.getParameterNames(candidate);
   }
}

构造函数、参数名称、参数类型、参数值都确定后就可以锁定构造函数以及转换对应的参数类型了。

2.1.3 根据确定的构造函数转换对应的参数类型

主要使用Spring中提供的类型转换器或者用户提供的自定义类型转换器进行转换。

/*
 * 将确定的构造函数转换为对应的参数类型
 */
private ArgumentsHolder createArgumentArray(
      String beanName, RootBeanDefinition mbd, @Nullable ConstructorArgumentValues resolvedValues,
      BeanWrapper bw, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable,
      boolean autowiring) throws UnsatisfiedDependencyException {

   TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
   TypeConverter converter = (customConverter != null ? customConverter : bw);

   ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
   Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
   Set<String> autowiredBeanNames = new LinkedHashSet<>(4);

   for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
      Class<?> paramType = paramTypes[paramIndex];
      String paramName = (paramNames != null ? paramNames[paramIndex] : "");
      // Try to find matching constructor argument value, either indexed or generic.
      ConstructorArgumentValues.ValueHolder valueHolder = null;
      if (resolvedValues != null) {
         valueHolder = resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
        
         if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
            valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
         }
      }
      if (valueHolder != null) {
         // We found a potential match - let's give it a try.
         // Do not consider the same value definition multiple times!
         usedValueHolders.add(valueHolder);
         Object originalValue = valueHolder.getValue();
         Object convertedValue;
         if (valueHolder.isConverted()) {
            convertedValue = valueHolder.getConvertedValue();
            args.preparedArguments[paramIndex] = convertedValue;
         }
         else {
            MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
            try {
               convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
            }
            catch (TypeMismatchException ex) {
              //跑异常
            Object sourceHolder = valueHolder.getSource();
            if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) {
               Object sourceValue = ((ConstructorArgumentValues.ValueHolder) sourceHolder).getValue();
               args.resolveNecessary = true;
               args.preparedArguments[paramIndex] = sourceValue;
            }
         }
         args.arguments[paramIndex] = convertedValue;
         args.rawArguments[paramIndex] = originalValue;
      }
      else {
         MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
         // No explicit match found: we're either supposed to autowire or
         // have to fail creating an argument array for the given constructor.
         if (!autowiring) {
            //抛异常
         }
         try {
            Object autowiredArgument =
                  resolveAutowiredArgument(methodParam, beanName, autowiredBeanNames, converter);
            args.rawArguments[paramIndex] = autowiredArgument;
            args.arguments[paramIndex] = autowiredArgument;
            args.preparedArguments[paramIndex] = new AutowiredArgumentMarker();
            args.resolveNecessary = true;
         }
         catch (BeansException ex) {
           //抛异常
      }
   }

   for (String autowiredBeanName : autowiredBeanNames) {
      this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
      if (logger.isDebugEnabled()) {
         //日志
   }
   return args;
}

2.1.4 构造函数不确定的验证

虽然构造函数、参数名称、参数类型、参数值都确定后也不一定会直接锁定构造函数，不同构造函数的参数为父子关系，所以Spring在最后又做了一次验证。定义了一个最小的差异权重 minTypeDiffWeight，下面这段代码由于在循环体内，所以每次都会检查新的构造函数其差异权重是否更小，如果是则更新需要使用的构造函数 constructorToUse 等。

// 探测是否有不确定的构造函数存在，例如不同构造函数的参数为父子关系
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
      argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// 如果他代表着当前最接近的匹配则选择作为构造函数
if (typeDiffWeight < minTypeDiffWeight) {
   // 更新
   constructorToUse = candidate;
   argsHolderToUse = argsHolder;
   argsToUse = argsHolder.arguments;
   minTypeDiffWeight = typeDiffWeight;
   ambiguousConstructors = null;
}
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
   if (ambiguousConstructors == null) {
      ambiguousConstructors = new LinkedHashSet<>();
      ambiguousConstructors.add(constructorToUse);
   }
   ambiguousConstructors.add(candidate);
}

2.1.5 实例化bean

根据实例化策略，通过得到的构造函数以及构造函数参数实例化 Bean 得到 beanInstance，将其设置到 bw 中进行返回。核心代码主要就是strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse)，之后文章我们会再详细介绍这里

try {
   final InstantiationStrategy strategy = this.beanFactory.getInsta	ntiationStrategy();
   Object beanInstance;

   if (System.getSecurityManager() != null) {
      final Constructor<?> ctorToUse = constructorToUse;
      final Object[] argumentsToUse = argsToUse;
      beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
            strategy.instantiate(mbd, beanName, this.beanFactory, ctorToUse, argumentsToUse),
            this.beanFactory.getAccessControlContext());
   }
   else {
      beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
   }
   // 将构建的实例加入BeanWrapper中
   bw.setBeanInstance(beanInstance);
   return bw;
}

2.2 instantiateBean

上面讲完带参数的构造函数的实例构造，我们继续看无参的默认构造函数构造 beanInstance 返回出 beanWrapper。

/**
 * 无参的实例化bean
 */
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
         beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
               getInstantiationStrategy().instantiate(mbd, beanName, parent),
               getAccessControlContext());
      }
      else {
         //直接创建
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
   }
   catch (Throwable ex) {
      //抛出异常
   }
}

可以看到，无参的根本不需要像之前那样花太多精力来确认参数、匹配构造函数，只需要直接通过实例化策略进行实例化即可

2.3 实例化策略

在上面说到有参与无参的两种讨论中，最后都是通过实例化策略构造出实例。理论上，我们已经得到足以实例化的所有相关信息，完全可以使用最简单的反射方法直接反射来构造实例化对象。我们看看Spring如何实现。

有参的实例化过程：

/**
 * 有参实例化策略
 */
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
      final Constructor<?> ctor, @Nullable Object... args) {
   // 如果有需要覆盖或者动态替换的方法当然需要使用cglib进行动态代理，因为可以在创建代理的同时将动态方法织入类中
   // 但是如果没有需要动态改变的方法，为了方便直接反射就可以了
   if (!bd.hasMethodOverrides()) {
      if (System.getSecurityManager() != null) {
         // use own privileged to change accessibility (when security is on)
         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            ReflectionUtils.makeAccessible(ctor);
            return null;
         });
      }
      return (args != null ? BeanUtils.instantiateClass(ctor, args) : BeanUtils.instantiateClass(ctor));
   }
   else {
      return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
   }
}

无参的实例化过程：

/**
 * 无参实例化策略
 */
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
   // 如果有需要覆盖或者动态替换的方法当然需要使用cglib进行动态代理，因为可以在创建代理的同时将动态方法织入类中
   // 但是如果没有需要动态改变的方法，为了方便直接反射就可以了
   if (!bd.hasMethodOverrides()) {
      Constructor<?> constructorToUse;
      synchronized (bd.constructorArgumentLock) {
         constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
         if (constructorToUse == null) {
            final Class<?> clazz = bd.getBeanClass();
            if (clazz.isInterface()) {
               throw new BeanInstantiationException(clazz, "Specified class is an interface");
            }
            try {
               if (System.getSecurityManager() != null) {
                  constructorToUse = AccessController.doPrivileged(
                        (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
               }
               else {
                  constructorToUse = clazz.getDeclaredConstructor();
               }
               bd.resolvedConstructorOrFactoryMethod = constructorToUse;
            }
            catch (Throwable ex) {
               throw new BeanInstantiationException(clazz, "No default constructor found", ex);
            }
         }
      }
      return BeanUtils.instantiateClass(constructorToUse);
   }
   else {
      // Must generate CGLIB subclass.
      return instantiateWithMethodInjection(bd, beanName, owner);
   }
}

无论哪种，都分为 if-else 两大块。如果用户在配置文件中没有配置 replace 或者 lookup 的配置方法，那么直接使用反射方式，简单快捷。如果使用了这两个配置，再直接使用反射的方式创建实例就不妥了，因为需要将这两个配置提供的功能切入进去，所以必须保证使用动态代理的方式将两个特性所对应的逻辑的拦截增强器设置进去，这样才能保证在调用方法的时候会被相应的拦截器增强，返回值为包含拦截器的代理实例。

3. 记录bean的ObjectFactory

我们回到本部分最开始，通过上一小节的讨论，我们已经成功获取了 BeanWrapper。我们继续查看 doCreateBean() 中的逻辑：

final Object bean = instanceWrapper.getWrappedInstance();
····

// 是否需要提早曝光：单例&允许循环依赖&当前bean正在创建中，检测循环依赖
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   if (logger.isDebugEnabled()) {
      //打印日志
   }
   // 为避免后期循环依赖，可以在bean初始化完成之前将创建实例的ObjectFactory加入工厂
   addSingletonFactory(beanName,
         // 对bean再一次依赖引用，主要应用SmartInstantiationAware BeanPostProcessor
         // 其中我们熟知的AOP就是这样将advice动态织入bean中，若没有则直接返回bean，不做任何处理
         () -> getEarlyBeanReference(beanName, mbd, bean));
}

之前在循环依赖部分已经介绍过相关概念，earlySingletonExposure 就是为了解决循环依赖而准备的。它由三部分组成，首先是是否单例模式 mbd.isSingleton()，其次是是否允许循环依赖 this.allowCircularReferences 以及 bean 是否正在创建中 isSingletonCurrentlyInCreation(beanName) 。当这三个条件都满足时，会执行 addSingletonFactory() 方法。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
			//放到三级缓存中
            this.singletonFactories.put(beanName, singletonFactory);
            //从二级缓存中删除
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

可以看到，在 singletonFactories 中添加了传入的 singletonFactory，singletonFactory 是我们创建的 ObjectFactory 实例，并重写了其中的 getObject() 方法：

/**
 * Obtain a reference for early access to the specified bean,
 * typically for the purpose of resolving a circular reference.
 * @param beanName the name of the bean (for error handling purposes)
 * @param mbd the merged bean definition for the bean
 * @param bean the raw bean instance
 * @return the object to expose as bean reference
 */
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
         }
      }
   }
   return exposedObject;
}

getEarlyBeanReference() 方法中没有太多处理的逻辑，除了后处理器的调用没有别的处理工作。

4. 属性注入

提前暴露完仅仅实现构造函数完毕的 bean 的 ObjectFactory 后，紧接着可以进行属性的填充，也就是本部分内容的第五步。属性注入是通过 populateBean 完成的，instanceWrapper 就是通过构造函数创建出的 beanWrapper。

// 对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始依赖bean
populateBean(beanName, mbd, instanceWrapper);

进入函数体：

/**
 * 对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始依赖bean
 */
@SuppressWarnings("deprecation")  // for postProcessPropertyValues
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 {
         // 没有可填充的属性
         return;
      }
   }

   // 给InstantiationAwareBeanPostProcessors最后一次机会在属性设置前改变bean,
   // 如：可以用来支持属性注入的类型
   boolean continueWithPropertyPopulation = true;

   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            // 返回值为是否继续填充bean
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               continueWithPropertyPopulation = false;
               break;
            }
         }
      }
   }

   // 如果后处理器发出停止填充命令则终止后续的执行
   if (!continueWithPropertyPopulation) {
      return;
   }

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

   if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

      // Add property values based on autowire by name if applicable.
      // 根据名称自动注入
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
      }

      // Add property values based on autowire by type if applicable.
      // 根据类型自动注入
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
      }

      pvs = newPvs;
   }

   // 后处理器已经初始化
   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   // 需要依赖检查
   boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.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;
            PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               if (filteredPds == null) {
                  filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
               }
               // 对所有需要依赖检查的属性进行后处理
               pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
               if (pvsToUse == null) {
                  return;
               }
            }
            pvs = pvsToUse;
         }
      }
   }
   if (needsDepCheck) {
      // 依赖检查，对应depends-on属性，3.0已经弃用此属性
      if (filteredPds == null) {
         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      }
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }

   // 将属性应用到bean中
   // 将所有ProtertyValues中的属性填充至BeanWrapper中
   if (pvs != null) {
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}

又是很长的一大串！看一下代码逻辑：

（1）InstantiationAwareBeanPostProcessor 的 postProcessAfterInstantiation 方法的调用，可以控制程序是否继续属性填充；

（2）根据注入类型 (byName/byType) 提取依赖的 bean，并统一存入PropertyValues 中；

（3）应用 InstantiationAwareBeanPostProcessor 的 postProcessPropertyValues() 方法，对属性获取完毕填充前的再次处理。典型的应用是 RequiredAnnotationBeanPostProcesser 类中对属性的验证；
（4）将所有 ProtertyValues 中的属性填充至 BeanWrapper 中。

我们着重研究依赖注入(autowireByName/autowireByType)以及属性填充部分。

4.1 autowireByName

/**
 * 在传入的参数bw中，找出已经加载的bean,并递归实例化，进而加入到pvs中
 */
protected void autowireByName(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

   // 寻找bw中需要依赖注入的属性
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      if (containsBean(propertyName)) {
         // 递归初始化相关的bean
         Object bean = getBean(propertyName);
         pvs.add(propertyName, bean);
         // 注册依赖
         registerDependentBean(propertyName, beanName);
         if (logger.isDebugEnabled()) {
            //打印日志
      }
      else {
         if (logger.isTraceEnabled()) {
                //打印日志
         }
      }
   }
}

除去日志等代码，逻辑较为清晰。先通过 unsatisfiedNonSimpleProperties() 找到需要填充的所有属性 name，根据传入的参数 pvs 中找出已经加载的 bean，并递归实例化，然后再加入到 pvs 中。

4.2 autowireByType

protected void autowireByType(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }

   Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
   // 寻找bw中需要依赖注入的属性，然后遍历这些属性去寻找类型匹配的bean
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      try {
         PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);

         if (Object.class != pd.getPropertyType()) {
            // 探测指定属性的set方法
            MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
            
            boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
            DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
            // 解析指定beanName的属性所匹配的值，并把解析到的属性名称存储在autowiredBeanNames中，当属性存在多个封装bean时，如:
            // @Autowired private List<A> aList; 将会找到所有匹配A类型的bean并将其注入
            Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
            if (autowiredArgument != null) {
               pvs.add(propertyName, autowiredArgument);
            }
            for (String autowiredBeanName : autowiredBeanNames) {
               // 注册依赖
               registerDependentBean(autowiredBeanName, beanName);
               if (logger.isDebugEnabled()) {
                 //打印日志
            }
            autowiredBeanNames.clear();
         }
      }
      catch (BeansException ex) {
         //抛异常
   }
}

根据属性与根据名称两种自动注入属性第一步都是寻找 bw 中需要依赖注入的属性，然后遍历这些属性并寻找类型匹配的 bean，其中最复杂就是寻找类型匹配的 bean。Spring中提供了对集合的类型注入的支持，如使用注解的方式：

@Autowired
private List<Test> tests;

Spring会把所有与 Test 匹配的类型找出来并注入到 tests 属性中，正因如此，所以才创建了局部遍历autowiredBeanNames，用于存储所有依赖的 bean。如果只是对非集合类的属性注入来说，该属性没有用处。

对于寻找类型匹配的逻辑实现由 resolveDependency(desc, beanName, autowiredBeanNames, converter)

/**
 * 寻找类型匹配
 */
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

   descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
   if (Optional.class == descriptor.getDependencyType()) {
      // Optional类注入的特殊处理
      return createOptionalDependency(descriptor, requestingBeanName);
   }
   else if (ObjectFactory.class == descriptor.getDependencyType() ||
         ObjectProvider.class == descriptor.getDependencyType()) {
      // ObjectFactory、ObjectProvider类注入的特殊处理
      return new DependencyObjectProvider(descriptor, requestingBeanName);
   }
   else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
      // javaxInjectProviderClass类注入的特殊处理
      return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
   }
   else {
      // 通用处理逻辑
      Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
            descriptor, requestingBeanName);
      if (result == null) {
         result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
      }
      return result;
   }
}

Spring在寻找匹配类型时，对于 Optional 类型、ObjectFactory 类型、ObjectProvider 类型和 javaxInjectProviderClass 类型依赖进行单独的处理。而正常类型的依赖委托 doResolveDependency() 方法去完成。

/**
 * 正常类型的依赖处理
 * @param descriptor
 * @param beanName
 * @param autowiredBeanNames
 * @param typeConverter
 * @return
 * @throws BeansException
 */
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

   InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
   try {
      Object shortcut = descriptor.resolveShortcut(this);
      if (shortcut != null) {
         return shortcut;
      }

      Class<?> type = descriptor.getDependencyType();
      // 用于支持Spring中新增的注解@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 = evaluateBeanDefinitionString(strVal, bd);
         }
         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
         return (descriptor.getField() != null ?
               converter.convertIfNecessary(value, type, descriptor.getField()) :
               converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
      }

      // 如果解析器没有成功解析，则需要考虑各种情况
      Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
      if (multipleBeans != null) {
         return multipleBeans;
      }

      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
      if (matchingBeans.isEmpty()) {
         // 如果找到的匹配类型的bean为空，同时autowire的require属性为true，需要抛出异常
         if (isRequired(descriptor)) {
            raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
         }
         return null;
      }

      String autowiredBeanName;
      Object instanceCandidate;

      if (matchingBeans.size() > 1) {
         // 当集合或者数组中类型匹配到的bean不止一个
         autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
         
         if (autowiredBeanName == null) {
            if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
               return descriptor.resolveNotUnique(type, 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;
            }
         }
         instanceCandidate = matchingBeans.get(autowiredBeanName);
      }
      else {
         // 已经确定只有一个匹配项，集合或数组中只有一个bean
         Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
         autowiredBeanName = entry.getKey(); // beanName
         instanceCandidate = entry.getValue(); // bean
      }

      if (autowiredBeanNames != null) {
         autowiredBeanNames.add(autowiredBeanName);
      }
      if (instanceCandidate instanceof Class) {
         instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
      }
      Object result = instanceCandidate;
      
      // 再次check解析到的依赖bean是否有以及类型是否正确
      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);
   }
}

寻找类型的匹配时，首先尝试使用解析器进行解析。如果解析器没有解析成功，那么可能是使用默认的解析器没有做出任何处理，或者是使用了自定义的解析器，但是对于数组、集合等类型来说并不在解析范围之内，所以针对他们需要再次对不同的类型进行不同的处理。具体是委托 resolveMultipleBeans() 方法去处理：

/**
 * 处理类型为数组、集合类型的
 * @param descriptor
 * @param beanName
 * @param autowiredBeanNames
 * @param typeConverter
 * @return
 */
@Nullable
private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

   Class<?> type = descriptor.getDependencyType();
   // 如果解析器没有成功解析，则需要考虑各种情况
   // 属性是数组类型
   if (type.isArray()) {
      // 获取数组中元素类型
      Class<?> componentType = type.getComponentType();

      ResolvableType resolvableType = descriptor.getResolvableType();
      Class<?> resolvedArrayType = resolvableType.resolve();
      if (resolvedArrayType != null && resolvedArrayType != type) {
         type = resolvedArrayType;
         componentType = resolvableType.getComponentType().resolve();
      }
      if (componentType == null) {
         return null;
      }
      // 根据属性类型找到beanFactory中所有类型的匹配bean，
      // 返回值的构成为：key=匹配的beanName,value=beanName对应的实例化后的bean（通过getBean(beanName)返回）
      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
            new MultiElementDescriptor(descriptor));
      if (matchingBeans.isEmpty()) {
         return null;
      }
      if (autowiredBeanNames != null) {
         autowiredBeanNames.addAll(matchingBeans.keySet());
      }
      // 通过转换器将bean的值转换为对应的type类型
      TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
      Object result = converter.convertIfNecessary(matchingBeans.values(), type);
      if (getDependencyComparator() != null && result instanceof Object[]) {
         Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));
      }
      return result;
   }
   // 属性是Collection类型
   else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
      // 获取元素类型
      Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
      if (elementType == null) {
         return null;
      }
      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
            new MultiElementDescriptor(descriptor));
      if (matchingBeans.isEmpty()) {
         return null;
      }
      if (autowiredBeanNames != null) {
         autowiredBeanNames.addAll(matchingBeans.keySet());
      }
      TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
      Object result = converter.convertIfNecessary(matchingBeans.values(), type);
      if (getDependencyComparator() != null && result instanceof List) {
         ((List<?>) result).sort(adaptDependencyComparator(matchingBeans));
      }
      return result;
   }
   // 属性是Map类型
   else if (Map.class == type) {
      ResolvableType mapType = descriptor.getResolvableType().asMap();
      // 获取key的类型
      Class<?> keyType = mapType.resolveGeneric(0);
      if (String.class != keyType) {
         return null;
      }
      // 获取value类型
      Class<?> valueType = mapType.resolveGeneric(1);
      if (valueType == null) {
         return null;
      }
      Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
            new MultiElementDescriptor(descriptor));
      if (matchingBeans.isEmpty()) {
         return null;
      }
      if (autowiredBeanNames != null) {
         autowiredBeanNames.addAll(matchingBeans.keySet());
      }
      return matchingBeans;
   }
   else {
      return null;
   }
}

函数主要对数组、集合类型进行处理，主要都是根据属性类型找到 beanFactory 中所有类型的匹配 bean，将 key 为匹配的 beanName，value 为 beanName 对应的实例化后的 bean 的 map。

4.3 applyPropertyValues

经过①和②，我们已经获取到了需要注入的属性，最后这些属性的保存形式为 PropertyValues，还没有应用到已经实例化的 bean 中，所以下一步需要利用 applyPropertyValues(beanName, mbd, bw, pvs) 方法将 PropertyValues 中的属性设置到 bean 中：

/**
 * 将所有ProtertyValues中的属性填充至BeanWrapper中
 */
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
   if (pvs.isEmpty()) {
      return;
   }

   if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
      ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
   }

   MutablePropertyValues mpvs = null;
   List<PropertyValue> original; // 保存PropertyValue数组

   // 如果PropertyValues是MutablePropertyValues类型，那么尝试直接将PropertyValues设置到BeanWrapper中
   // 如果设置到BeanWrapper失败和或者不是MutablePropertyValues类型，都将PropertyValues转换成PropertyValue数组放到original
   // 然后再用original构造出MutablePropertyValues设置到BeanWrapper中
   if (pvs instanceof MutablePropertyValues) {
      mpvs = (MutablePropertyValues) pvs;
      // 如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanwapper中
      if (mpvs.isConverted()) {
         // Shortcut: use the pre-converted values as-is.
         try {
            bw.setPropertyValues(mpvs);
            return;
         }
         catch (BeansException ex) {
            //抛异常
         }
      }
      original = mpvs.getPropertyValueList();
   }
   else {
      // 如果pvs并不是使用MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法
      original = Arrays.asList(pvs.getPropertyValues());
   }

   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }
   // 获取对应的解析器
   BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

   // Create a deep copy, resolving any references for values.
   List<PropertyValue> deepCopy = new ArrayList<>(original.size());
   boolean resolveNecessary = false;

   // 遍历属性，将属性转换为对应类的对应属性的类型
   for (PropertyValue pv : original) {
      if (pv.isConverted()) {
         deepCopy.add(pv);
      }
      else {
         String propertyName = pv.getName();
         Object originalValue = pv.getValue();
         Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
         Object convertedValue = resolvedValue;
         boolean convertible = bw.isWritableProperty(propertyName) &&
               !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
         if (convertible) {
            convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
         }
         // Possibly store converted value in merged bean definition,
         // in order to avoid re-conversion for every created bean instance.
         if (resolvedValue == originalValue) {
            if (convertible) {
               pv.setConvertedValue(convertedValue);
            }
            deepCopy.add(pv);
         }
         else if (convertible && originalValue instanceof TypedStringValue &&
               !((TypedStringValue) originalValue).isDynamic() &&
               !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
            pv.setConvertedValue(convertedValue);
            deepCopy.add(pv);
         }
         else {
            resolveNecessary = true;
            deepCopy.add(new PropertyValue(pv, convertedValue));
         }
      }
   }
   if (mpvs != null && !resolveNecessary) {
      mpvs.setConverted();
   }

   // Set our (possibly massaged) deep copy.
   try {
      bw.setPropertyValues(new MutablePropertyValues(deepCopy));
   }
   catch (BeansException ex) {
      //抛异常
   }
}

5. 初始化bean

对 bean 属性填充完需要进行 bean 的初始化，在配置文件中可以通过 init-method 这个属性配置，在 bean 实例化前调用 init-method 指定的方法来根据用户业务进行相应的实例化。我们来看一下执行用户配置的初始化方法的方法在哪里执行。之前Spring已经执行了 bean 的实例化，紧接着又做了属性填充，随后调用了：

exposedObject = initializeBean(beanName, exposedObject, mbd)；

而用户配置的初始化就是在这里完成的。

/**
 * 初始化bean-->用户配置的init-method
 */
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      // 对特殊的bean的处理：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      // 应用后处理器
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
      // 激活用户自定义的init方法
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      // 后处理应用
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

虽然该函数主要目的是调用用户设置的初始化方法，但是仍然还有一些其他工作需要完成。

5.1 激活Aware方法

先了解一下 Aware 的使用。Spring中提供了一些 Aware 接口，比如BeanFactoryAware 、ApplicationContextAware、ResourceLoaderAware 和 ServletContextAware 等，实现这些 Aware 接口的 bean 在被初始化后，可以取得一些相对应的资源，例如实现 BeanFactoryAware 的 bean 在初始化之后，Spring容器将会注入 BeanFactory 实例，而实现 ApplicationContextAware 的 bean，在 bean 被初始化后，将会被注入 ApplicationContext 实例等。我们先通过示例方法了解下 Aware 的使用。

在 spring-mytest 模块中新建普通实体类 Hello：

public class Hello {   
  public void say() {
      System.out.println("hello");
   }
}

定义 beanFactoryAware类型的 bean：

public class TestAware implements BeanFactoryAware {
   
   private BeanFactory beanFactory;
   
   @Override
   public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
      this.beanFactory = beanFactory;
   }
   
   public void testAware() {
      Hello hello = (Hello) this.beanFactory.getBean("hello");
      hello.say();
   }
}

编写配置文件 awareTest.xml：

<?xml version='1.0' encoding='UTF-8' ?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans.xsd">
   <bean id="hello" class="guo.ping.ioc.aware.Hello" />
   <bean id="test" class="guo.ping.ioc.aware.TestAware" />
</beans>

编写测试类：

public class AwareTest {

   @Test
   public void sing() {
      ApplicationContext context = new ClassPathXmlApplicationContext("awareTest.xml");
      TestAware testAware = (TestAware) context.getBean("test");
      testAware.testAware();
   }
}

测试结果：

hello

测试代码中，TestAware 实现了 BeanFactoryAware 接口，在名为 test 的 bean 实例化的时候，该 bean 能够自动被注入 BeanFactory 的实例，从而能够在其 testAware() 方法中通过 BeanFactory 的实例进一步获取到名为 hello 的 bean。为了做到这一点，Spring实现的本质就是通过 invokeAwareMethods(beanName, bean) 方法，分别对三种 Aware 调用了 setter 方法。

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

5.2 处理器的应用

BeanPostPrecessor ——后处理器，这是Spring开放式架构的一个必不可少的亮点，给用户充足的权限去更改或者扩展Spring，而除了 BeanPostProcessor 外还有很多其他的 PostProcessor，当然大部分都以此为基础，继承自 BeanPostProcessor。BeanPostProcessor 在调用用户自定义初始化方法前或者调用自定义初始化方法后分别会调用 BeanPostProcessor 的postProcessBeforeInitialization 和 postProcessAfterinitialization 方法，使用户可以根据自己的业务需求就行相应的处理。

我们同样研究一下初始化前和初始化后后处理器应用代码

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
······
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

/**
 * 初始化后应用BeanPostProcessors后处理器
 * @param existingBean the new bean instance FactoryBean的getObject获得的对象
 */
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

5.3 激活用户自定义init方法

用户定制的初始化方法除了我们熟知的使用配置 init-method 外，还可以通过让自定义的 bean 实现 InitializingBean 接口，并在 afterPropertiesSet 中实现自己的初始化业务逻辑。

init-method 与 afterPropertiesSet 都是在初始化 bean 时执行，执行顺序是 afterPropertiesSet 先执行，而 init-method 后执行。

我们具体来看看这两个步骤的初始化调用：

/**
 * 激活用户自定义初始化方法
 */
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {

   // 首先检查bean是否是InitializingBean实例，是的话需要先调用afterPropertiesSet方法
   boolean isInitializingBean = (bean instanceof InitializingBean);
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (logger.isDebugEnabled()) {
         logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
      }
      if (System.getSecurityManager() != null) {
         try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
               ((InitializingBean) bean).afterPropertiesSet();
               return null;
            }, getAccessControlContext());
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         // 属性初始化后的处理
         ((InitializingBean) bean).afterPropertiesSet();
      }
   }

   if (mbd != null && bean.getClass() != NullBean.class) {
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
         // 调用自定义初始化方法
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}

6. 注册DisposableBean

我们来到这一部分 (do)创建bean的最后一步，如果XML配置了 destory-method，这里需要注册以便于销毁 bean 的时候调用。Spring中不仅提供了对于初始化方法的扩展入口，同样也提供了销毁方法的扩展入口。除了 destroy-method 之外，还可以注册后处理器 DestructionAwareBeanPostProcessor 来统一处理 bean 的销毁方法：

/**
 * 注册DisposableBean，销毁方法的扩展入口
 */
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
   AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
   if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
      if (mbd.isSingleton()) {
         registerDisposableBean(beanName,
               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
      else {
         // A bean with a custom scope...
         Scope scope = this.scopes.get(mbd.getScope());
         if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
         }
         scope.registerDestructionCallback(beanName,
               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
   }
}