spring源码学习之bean的加载（二）

　　这是接着上篇继续写bean的加载过程，好像是有点太多了，因为bean的加载过程是很复杂的，要处理的情况有很多，继续。。。

7、创建bean

常规的bean的创建时通过doCreateBean方法来实现的
这个方法在org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下

 /**
  * Actually create the specified bean. Pre-creation processing has already happened
  * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
  * <p>Differentiates between default bean instantiation, use of a
  * factory method, and autowiring a constructor.
  * @param beanName the name of the bean
  * @param mbd the merged bean definition for the bean
  * @param args explicit arguments to use for constructor or factory method invocation
  * @return a new instance of the bean
  * @throws BeanCreationException if the bean could not be created
  * @see #instantiateBean
  * @see #instantiateUsingFactoryMethod
  * @see #autowireConstructor
  */
 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
         throws BeanCreationException {

     // Instantiate the bean.
     BeanWrapper instanceWrapper = null;
     if (mbd.isSingleton()) {
         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
     }
     // 根据指定bean使用对应的策略创建新的实例，如：工厂方法、构造函数自动注入、简单初始化
     if (instanceWrapper == null) {
         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.
     synchronized (mbd.postProcessingLock) {
         if (!mbd.postProcessed) {
             try {
                 // 应用MergedBeanDefinitionPostProcessors
                 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.isDebugEnabled()) {
             logger.debug("Eagerly caching bean '" + beanName +
                     "' to allow for resolving potential circular references");
         }
         //为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
     }

     // Initialize the bean instance.
     Object exposedObject = bean;
     try {
         // 对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始依赖bean
         populateBean(beanName, mbd, instanceWrapper);
         // 初始化bean
         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) {
         Object earlySingletonReference = getSingleton(beanName, false);
         // earlySingletonReference只有在检测到有循环依赖的情况下才会不为空
         if (earlySingletonReference != null) {
             // 如果exposedObject没有在初始化方法中被改变，也就是没有被增强
             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);
                     }
                 }
                 // 因为bean创建后其所依赖的bean一定已经创建的
                 // actualDependentBeans不为空则表示当前bean创建后其依赖的bean却没有被全部创建完，存在循环依赖
                 if (!actualDependentBeans.isEmpty()) {
                     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 {
         // 根据scope注册bean
         registerDisposableBeanIfNecessary(beanName, bean, mbd);
     }
     catch (BeanDefinitionValidationException ex) {
         throw new BeanCreationException(
                 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
     }

     return exposedObject;
 }

（1）如果是单例，则需要首先清除缓存
（2）实例化bean，将BeanDefinition转换成BeanWrapper，转化是一个复杂过程，大致思路如下
如果存在工厂方法则使用工厂方法进行初始化
一个类有多个构造函数，每个构造函数都有不同的参数，所以需要根据参数锁定构造函数并进行初始化
如果即不存在工厂方法，也没有指定构造方法，则使用指定的构造方法初始化bean
（3）MergedBeanDefinitionPostProcessors的应用
bean合并后处理，autowire注解正是通过此方法实现注入类型的预解析
（4）依赖处理
（5）属性填充。将所有属性填充到bean的实例中
（6）循环依赖检查
之前提到过，在spring中解决循环依赖只对单例有效，而对于prototype的bean，spring没有更好的解决办法，唯一要做的是抛出异常。
（7）注册DisposableBean
如果配置了destroy-method，这里需要注册以便于在销毁时候调用
（8）完成创建并返回

来吧，中间还有大量的源码来实现每一部分的功能，这个是挺复杂的，开始吧，一个一个的来探索
7.1 创建bean实例

首先从createBeanInstance()方法开始，这个方法在org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下

 /**
  * Create a new instance for the specified bean, using an appropriate instantiation strategy:
  * factory method, constructor autowiring, or simple instantiation.
  * @param beanName the name of the bean
  * @param mbd the bean definition for the bean
  * @param args explicit arguments to use for constructor or factory method invocation
  * @return a BeanWrapper for the new instance
  * @see #obtainFromSupplier
  * @see #instantiateUsingFactoryMethod
  * @see #autowireConstructor
  * @see #instantiateBean
  */
 protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
     // Make sure bean class is actually resolved at this point.
     // 解析Class
     Class<?> beanClass = resolveBeanClass(mbd, beanName);

     if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                 "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
     }

     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
     if (instanceSupplier != null) {
         return obtainFromSupplier(instanceSupplier, beanName);
     }

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

     // Shortcut when re-creating the same bean...
     boolean resolved = false;
     boolean autowireNecessary = false;
     if (args == null) {
         synchronized (mbd.constructorArgumentLock) {
             // 一个类有多个构造函数，每个构造函数都有不同的参数，所以调用钱需要先根据参数锁定构造函数或者是工厂方法
             if (mbd.resolvedConstructorOrFactoryMethod != null) {
                 resolved = true;
                 autowireNecessary = mbd.constructorArgumentsResolved;
             }
         }
     }
     // 如果已经解析过则使用解析好的构造函数不需要再次锁定
     if (resolved) {
         if (autowireNecessary) {
             // 构造函数自动注入
             return autowireConstructor(beanName, mbd, null, null);
         }
         else {
             // 使用默认的构造函数
             return instantiateBean(beanName, mbd);
         }
     }

     // Candidate constructors for autowiring?
     // 需要根据参数解析构造函数
     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
     if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
             mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
         // 构造函数自动注入
         return autowireConstructor(beanName, mbd, ctors, args);
     }

     // No special handling: simply use no-arg constructor.
     // 使用默认构造函数构造
     return instantiateBean(beanName, mbd);
 }

大致梳理一下这个createBeanInstance()方法中的思路：
（1）如果在RootBeanDefinition中存在factoryMethodName属性，或者说是在配置文件中配置了factory-method，那么spring会尝试使用
instantiateUsingFactoryMethod(beanName, mbd, args)方法根据RootBeanDefiniton中配置生成bean的实例
（2）解析构造函数并进行构造函数的实例化，因为一个bean对应的类中可能会有多个构造函数，而每个构造函数的参数不同，spring会根据参数以及类型
去判断最终会使用哪个构造函数进行实例化。但是，判断过程是比较消耗性能的，所以采用缓存机制，如果已经解析过了，则不需要重复解析，而是直接从
RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值去取，否则需要再次解析，并将结果添加至RootBeanDefinition中的属性
resolvedConstructorOrFactoryMethod中

1、autowireConstructor

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

org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下createBeanInstance()方法
从这段代码继续向下寻找，找到真正的逻辑代码

// 构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, args);

org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类

 protected BeanWrapper autowireConstructor(
         String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {

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

真正的代码其实在这个方法中
org.springframework.beans.factory.support包下ConstructorResolver类下的autowireConstructor方法

 public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
         @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {

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

     Constructor<?> constructorToUse = null;
     ArgumentsHolder argsHolderToUse = null;
     Object[] argsToUse = null;

     // explicitArgs通过getBean方法传入，如果getBean方法调用的时候指定方法参数那么直接使用
     if (explicitArgs != null) {
         argsToUse = explicitArgs;
     }
     else {
         // 如果在getBean方法时候没有指定则尝试从配置文件中解析
         Object[] argsToResolve = null;
         synchronized (mbd.constructorArgumentLock) {
             constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
             if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                 // Found a cached constructor...
                 // 尝试从缓存中获取
                 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() == AutowireCapableBeanFactory.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) {
                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                         "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                         "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", 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) {
                 // Already found greedy constructor that can be satisfied ->
                 // do not look any further, there are only less greedy constructors left.
                 // 如果已经找到选用的构造参数或者需要的参数个数小于当前构造参数个数则终止
                 // 因为已经按照参数个数降序排列
                 break;
             }
             if (paramTypes.length < minNrOfArgs) {
                 // 参数个数不相等
                 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()) {
                         logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                     }
                     // 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));
             // Choose this constructor if it represents the closest match.
             // 如果它代表着当前最接近的匹配则选择作为构造函数
             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;
             }
             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                     "Could not resolve matching constructor " +
                     "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
         }
         else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                     "Ambiguous constructor matches found in bean '" + beanName + "' " +
                     "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                     ambiguousConstructors);
         }

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

     try {
         final InstantiationStrategy strategy = 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, beanFactory, ctorToUse, argumentsToUse),
                     beanFactory.getAccessControlContext());
         }
         else {
             beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
         }

         // 将构造函数的实例加入BeanInstance中
         bw.setBeanInstance(beanInstance);
         return bw;
     }
     catch (Throwable ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                 "Bean instantiation via constructor failed", ex);
     }
 }

这个方法代码量很大，感觉很乱，自己读这个源码肯定要掉的坑里了，看看作者是如何解析的：
（1）构造函数参数的确定

根据explicitArgs参数确定
如果传入的参数explicitArgs不为空，那边可以直接确定参数，因为explicitArgs参数是在调用bean的时候用户指定的，在BeanFactory中存在这个代码：
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
在获取bean的时候，用户不但可以指定bean名称还可以指定bean所对应的类的构造函数或者工厂方法的方法参数，主要用于静态工厂方法的调用，而这里
是需要给定完全匹配的参数，所以，便可判断，如果传入参数explicitArgs不为空，则可以确定构造参数就是它。

缓存中获取
除此之外，确定参数的办法如果之前已经分析过了，也就是说构造函数参数已经记录在缓存中，那么便可以直接拿来使用，而且，在缓存中缓存的可能是参数
的最终类型也可能是参数的初始类型，所以，即使在缓存中得到了参数，也需要经过类型转换器的过滤以确保参数类型与对应的构造函数参数类型完全对应

配置文件中获取
如果不能根据传入的参数explicitArgs确定构造函数的参数，也无法在缓存中获取相关信息，只能另辟蹊径
分析从获取配置文件中配置的构造函数信息开始，spring中配置文件中的信息经过转换会通过BeanDefinition实例承载，也就是参数mbd中包含，那么可以通过
mbd.getConstructorArgumentValues()来获取构造函数的信息，有了配置的信息便可以获取对应的参数值信息了，获取参数值的信息包括直接指定值，如：直接
指定构造函数中某个值为原始类型String类型，或者是一个对其他bean的引用，而这一处理委托给resolveConstructorArguments方法，并返回解析到参数个数

（2）构造函数的确定
已经确定构造函数的参数，接下来就是根据构造函数参数在所有的构造函数中锁定构造函数，而匹配的方法就是根据参数的个数，所以匹配之前需要先将构造函数
按照public构造函数优先参数数量降序，非public构造函数参数数量降序，这样可以在遍历的情况下迅速判断排在后面的构造函数参数个数是够符合条件
由于在配置文件中并不是唯一限制使用参数位置索引的方式去创建，同样还支持指定参数名称进行设定参数值的情况，那么就需要确定构造函数中参数名称
获取参数名称可以有两种方式：一种是通过注解的方式直接获取，另一种是使用spring中提供的工具类ParameterNameDiscoverer来获取，构造函数，参数名称
参数类型、参数值都确定后就可以锁定构造函数以及转换对应的参数类型了

（3）根据确定的构造函数转换对应的参数类型
主要是使用spring中提供的类型转换器或者用户提供的自定义的类型转换器

（4）构造函数不确定性的验证
spring在这里又做了一次验证

（5）根据实例化策略以及得到的构造函数以及构造函数参数实例化bean

2、instantiateBean
这个就是默认的无参数的构造方法，并没有什么处理逻辑，直接调用实例化策略进行实例化就可以了
此方法在org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下

 /**
  * Instantiate the given bean using its default constructor.
  * @param beanName the name of the bean
  * @param mbd the bean definition for the bean
  * @return a BeanWrapper for the new instance
  */
 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) {
         throw new BeanCreationException(
                 mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
     }
 }

3、实例化策略
其实，经过前面的分析，我们已经得到了实例化所需的相关信息，完全可以使用最简单的反射方法直接反射来构造实例对象，spring没有这么做，找到实例化方法
instantiateBean()方法中的这行代码：
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
中instantiate方法，然后找到此方法的实现类SimpleInstantiationStrategy中的方法的重写，这里有代码实现

 @Override
 public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
     // Don't override the class with CGLIB if no overrides.
     // 如果有需要覆盖或者动态替换的方法则当然需要使用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);
     }
 }

instantiateWithMethodInjection()方法最终调用的是下面这个方法
这个方法是在org.springframework.beans.factory.support包下CglibSubclassingInstantiationStrategy类中

 /**
  * Create a new instance of a dynamically generated subclass implementing the
  * required lookups.
  * @param ctor constructor to use. If this is {@code null}, use the
  * no-arg constructor (no parameterization, or Setter Injection)
  * @param args arguments to use for the constructor.
  * Ignored if the {@code ctor} parameter is {@code null}.
  * @return new instance of the dynamically generated subclass
  */
 public Object instantiate(@Nullable Constructor<?> ctor, @Nullable Object... args) {
     Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
     Object instance;
     if (ctor == null) {
         instance = BeanUtils.instantiateClass(subclass);
     }
     else {
         try {
             Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
             // 这里用到了反射
             instance = enhancedSubclassConstructor.newInstance(args);
         }
         catch (Exception ex) {
             throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
                     "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
         }
     }
     // SPR-10785: set callbacks directly on the instance instead of in the
     // enhanced class (via the Enhancer) in order to avoid memory leaks.
     Factory factory = (Factory) instance;
     factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
             new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
             new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
     return instance;
 }

程序中，首先判断如果!bd.hasMethodOverrides()为空，也就是用户没有使用replace或者lookup的配置方法，那么直接使用反射的方式，但是如果使用了这两个
特性，则需要将这两个配置提供的功能切入进去，所以必须使用动态代理的方式将包含两个特性所对应的逻辑拦截增强器设置进去，这样才可以保证在调用方法
的时候会被相应的拦截器增强，返回值为包含拦截器的代理实例

7.2记录创建bean的ObjectFactory

org.springframework.beans.factory.support包下的AbstractAutowireCapableBeanFactory类中的doCreateBean()方法中有这样一段代码，作者书中写错了！

 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
         isSingletonCurrentlyInCreation(beanName));
 if (earlySingletonExposure) {
     if (logger.isDebugEnabled()) {
         logger.debug("Eagerly caching bean '" + beanName +
                 "' to allow for resolving potential circular references");
     }
     //为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
     addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 }

这一个小内容是来解释spring中处理依赖的方法的，我真的不想去记录了，哈，解释一下代码
（1）earlySingletonExposure，字面意思是提早曝光，哪些条件可以影响这个值呢？
（2）mbd.isSingleton()：此RootBeanDefinition代表的是是否是单例
（3）this.allowCircularReferences：是否允许循环依赖
（4）isSingletonCurrentlyInCreation(beanName)：该bean是否在创建中

看一下代码中getEarlyBeanReference(beanName, mbd, bean)方法
org.springframework.beans.factory.support包下的AbstractAutowireCapableBeanFactory类中

 /**
  * 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()方法中，没有太多的逻辑处理，除了后处理器的调用时，没有别的处理工作，根据以上分析，基本可以清理spring处理循环依赖
的解决办法，在B中创建依赖A时通过ObjectFactory提供的实例方法来判断A中的属性填充，使B中持有A仅仅是刚刚初始化并没有填充任何属性A，而这正初始化
A的步骤还是最开始创建A的时候进行的，但是因为A和B中的A所表示的属性地址是一样的，所以在A中创建好的属性填充自然可以通过B中的A获取，这样就解决了循环
依赖问题

7.3 属性注入

属性注入的功能，主要是使用的populateBean()方法，看一下属性是如何注入
org.springframework.beans.factory.support包下的AbstractAutowireCapableBeanFactory类中

 /**
  * Populate the bean instance in the given BeanWrapper with the property values
  * from the bean definition.
  * @param beanName the name of the bean
  * @param mbd the bean definition for the bean
  * @param bw the BeanWrapper with bean instance
  */
 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.
     // 给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() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
         // Add property values based on autowire by name if applicable.
         // 根据名称自动注入
         if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
             autowireByName(beanName, mbd, bw, newPvs);
         }
         // Add property values based on autowire by type if applicable.
         // 根据类型自动注入
         if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
             autowireByType(beanName, mbd, bw, newPvs);
         }
         pvs = newPvs;
     }

     // 后处理器已经初始化
     boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
     // 需要依赖检查
     boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

     if (hasInstAwareBpps || needsDepCheck) {
         if (pvs == null) {
             pvs = mbd.getPropertyValues();
         }
         PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
         if (hasInstAwareBpps) {
             for (BeanPostProcessor bp : getBeanPostProcessors()) {
                 if (bp instanceof InstantiationAwareBeanPostProcessor) {
                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                     // 对所有需要依赖的属性进行后处理
                     pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                     if (pvs == null) {
                         return;
                     }
                 }
             }
         }
         if (needsDepCheck) {
             // 依赖检查，对应depend-on属性 spring3.0废弃
             checkDependencies(beanName, mbd, filteredPds, pvs);
         }
     }

     if (pvs != null) {
         // 将属性应用到bean中
         applyPropertyValues(beanName, mbd, bw, pvs);
     }
 }

在这个处理方法中populateBean，主要处理流程是这样的：
（1）InstantiationAwareBeanPostProcessor处理器的postProcessAfterInstantiation来控制是否进行属性的填充
（2）根据注入类型（byName/byType）,提取依赖的bean，并统一存入PropertyValues
（3）应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法，对属性获取完毕填充前对属性再次处理，典型应用是
org.springframework.beans.factory.annotation包下的RequiredAnnotationBeanPostProcessor
（4）将所有的PropertyValues中的属性填充至BeanWrapper中

其中的有几个方法来看一下源码：
1、根据名称依赖注入 autowireByName
org.springframework.beans.factory.support包下的AbstractAutowireCapableBeanFactory类中

 /**
  * Fill in any missing property values with references to
  * other beans in this factory if autowire is set to "byName".
  * @param beanName the name of the bean we're wiring up.
  * Useful for debugging messages; not used functionally.
  * @param mbd bean definition to update through autowiring
  * @param bw the BeanWrapper from which we can obtain information about the bean
  * @param pvs the PropertyValues to register wired objects with
  */
 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()) {
                 logger.debug("Added autowiring by name from bean name '" + beanName +
                         "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
             }
         }
         else {
             if (logger.isTraceEnabled()) {
                 logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                         "' by name: no matching bean found");
             }
         }
     }
 }

如果之前了解过autowire的使用方法，我也没有理解清楚这段代码，传入的参数pvs中找到已经加载的bean，并且递归实例化，进而加入到pvs中

2、根据类型自动注入 autowireByType
autowireByType和autowireByName对于我们理解与使用来说，复杂程度不会太困难，但是其实现功能的复杂程度完全不一样

 /**
  * Abstract method defining "autowire by type" (bean properties by type) behavior.
  * <p>This is like PicoContainer default, in which there must be exactly one bean
  * of the property type in the bean factory. This makes bean factories simple to
  * configure for small namespaces, but doesn't work as well as standard Spring
  * behavior for bigger applications.
  * @param beanName the name of the bean to autowire by type
  * @param mbd the merged bean definition to update through autowiring
  * @param bw the BeanWrapper from which we can obtain information about the bean
  * @param pvs the PropertyValues to register wired objects with
  */
 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中需要依赖注入的属性
     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.
             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.
                 boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());

                 DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                 // 解析指定beanName的属性所匹配的值，并把解析到的属性名称存储在autowiredBeanNames中
                 // 当属性存在多个封装bean时，如：@Autowire 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()) {
                         logger.debug("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);
         }
     }
 }

这里面 复杂的地方是spring中提供了对集合类型的注入支持，
@Autowire
private List<Test> tests;
spring会将所有Test类型的找出来并注入到tests属性中，正式由于这一因素，所以在autowireByType函数中，新建了局部遍历autowiredBeanNames，用于
存储所有依赖的bean，如果只是对非集合类的属性注入来说，此属性并没用处
对于寻找类型匹配的逻辑实现封装在了resolveDependency函数中：
org.springframework.beans.factory.support包下DefaultListableBeanFactory类中

 @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类注入的特殊处理
         return new DependencyObjectProvider(descriptor, requestingBeanName);
     }
     else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
         // javaxInjectProviderClass类注入的特殊处理
         return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
     }
     else {
         Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
                 descriptor, requestingBeanName);
         if (result == null) {
             // 通用处理逻辑
             result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
         }
         return result;
     }
 }

org.springframework.beans.factory.support包下DefaultListableBeanFactory类中doResolveDependency函数，看一下通用处理的逻辑

 @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()));
         }

         // 如果解析器没有成功解析，则需要考虑各种情况
         // 这个处理逻辑实在resolveMultipleBeans函数中，现在这个版本的spring把这部分单独写成一个函数了
         Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
         if (multipleBeans != null) {
             return multipleBeans;
         }

         Map<String, Object> 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) {
             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).
                     // 在可选的Collection / Map的情况下，静默地忽略一个非唯一的情况：可能它是一个多个常规bean的空集合
                     return null;
                 }
             }
             instanceCandidate = matchingBeans.get(autowiredBeanName);
         }
         else {
             // We have exactly one match.
             // 已经确定只有一个匹配项
             Map.Entry<String, Object> 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);
     }
 }

看一下resolveMultipleBeans函数的处理逻辑，在解析器没有解析成功的时候，spring如何处理
org.springframework.beans.factory.support包下DefaultListableBeanFactory类中，同一个类中

 @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();
         // 根据属性类型找到beanFactory中所有类型匹配bean，返回值的构成为：
         // key=匹配的beanName value=beanName对应的实例化后的bean（通过getBean(beanName)返回）
         ResolvableType resolvableType = descriptor.getResolvableType();
         Class<?> resolvedArrayType = resolvableType.resolve();
         if (resolvedArrayType != null && resolvedArrayType != type) {
             type = resolvedArrayType;
             componentType = resolvableType.getComponentType().resolve();
         }
         if (componentType == null) {
             return null;
         }
         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
                 new MultiElementDescriptor(descriptor));
         if (matchingBeans.isEmpty()) {
             // 如果autowire属性为true而找到的匹配项却为空，则返回null
             return null;
         }
         if (autowiredBeanNames != null) {
             autowiredBeanNames.addAll(matchingBeans.keySet());
         }
         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
         // 通过转换器将bean的值转换成对应的type类型
         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();
         Class<?> keyType = mapType.resolveGeneric(0);
         if (String.class != keyType) {
             return null;
         }
         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;
     }
 }

3、applyPropertyValues
程序运行到这里，已经完成了对所有注入属性的获取，但是获取的属性是以PropertyValues形式存在的，还并没有应用到已经实例化的bean中，这一工作在
applyPropertyValues函数中实现，org.springframework.beans.factory.support包下的AbstractAutowireCapableBeanFactory类中

 /**
  * Apply the given property values, resolving any runtime references
  * to other beans in this bean factory. Must use deep copy, so we
  * don't permanently modify this property.
  * @param beanName the bean name passed for better exception information
  * @param mbd the merged bean definition
  * @param bw the BeanWrapper wrapping the target object
  * @param pvs the new property values
  */
 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;

     if (pvs instanceof MutablePropertyValues) {
         mpvs = (MutablePropertyValues) pvs;
         // 如果mpvs中的值已经被转换为对应的类型，那么可以直接设置到BeanWrapper中
         if (mpvs.isConverted()) {
             // Shortcut: use the pre-converted values as-is.
             try {
                 bw.setPropertyValues(mpvs);
                 return;
             }
             catch (BeansException ex) {
                 throw new BeanCreationException(
                         mbd.getResourceDescription(), beanName, "Error setting property values", 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 {
         // BeanWrapper中 wrapper的意思是包装纸的意思 这里大概就是bean的封装类
         bw.setPropertyValues(new MutablePropertyValues(deepCopy));
     }
     catch (BeansException ex) {
         throw new BeanCreationException(
                 mbd.getResourceDescription(), beanName, "Error setting property values", ex);
     }
 }