[系统运维]SpringloC容器的依赖注入源码解析（9）—— populateBean

站在设计者的角度设计populateBean：

• 调用Bean的Setter方法实例去给Bean设置上属性值

• 变量类型的转换，同时还要考虑处理集合类型的情况

  • 配置的时候都是以字符串的形式来配置的

• 处理显式自动装配的逻辑（autowire = byName或byType）

用两个类来做测试，GirlFriend类中注入了BoyFriend的实例，BoyFriend中注入了自己的实例：

package com.wjw.dao.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class BoyFriend {
   @Autowired
   private BoyFriend boyFriend;
}

package com.wjw.dao.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class GirlFriend {
   @Autowired
   private BoyFriend boyFriend;
}

从AbstractAutowireCapableBeanFactory的doCreateBean方法中进入

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.
		boolean continueWithPropertyPopulation = true;

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		// 如果上面设置continueWithPropertyPopulation = false，表明用户可能已经自己填充了
		// bean的属性，不需要Spring帮忙填充了。此时直接返回即可
		if (!continueWithPropertyPopulation) {
			return;
		}
		// pvs是一个MutablePropertyValues实例，里面实现了PropertyValues接口，
		// 提供属性的读写操作实现，同时可以通过调用构造函数实现深拷贝
		// 获取BeanDefinition里面为Bean设置上的属性值
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// 在这里会对@Autowired标记的属性进行依赖注入
					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;
				}
			}
		}
		// 依赖检查，对应depend-on属性，3.0已经弃用此属性
		if (needsDepCheck) {
			// 过滤出所有需要进行依赖检查的属性编辑器
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			// 最终将属性注入到Bean的Wrapper实例里，这里的注入主要是供
			// 显式配置了autowiredbyName或者ByType的属性注入，
			// 针对注解来讲，由于在AutowiredAnnotationBeanPostProcessor已经完成了注入，
			// 所以此处不执行
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

最开始是一些判空逻辑：

接下来的逻辑就是脑图里的第一步了：

boolean continueWithPropertyPopulation = true;

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            continueWithPropertyPopulation = false;
            break;
         }
      }
   }
}

首先判断出boyfriend不是spring内部特殊的bean

!mbd.isSynthetic()

再看下容器里是否已经注册了InstantiationAwareBeanPostProcessors级别的后置处理器，如果有则通过责任链模式调用这些后置处理器的postProcessAfterInstantiation方法

这里InstantiationAwareBeanPostProcessor会在属性注入之前，有最后一次机会去修改bean的属性值，此处也可以决定是否后续的填充步骤

continueWithPropertyPopulation = false;

// 如果上面设置continueWithPropertyPopulation = false，表明用户可能已经自己填充了
// bean的属性，不需要Spring帮忙填充了。此时直接返回即可
if (!continueWithPropertyPopulation) {
   return;
}

接下来来到：

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

pvs是一个MutablePropertyValues实例，里面实现了PropertyValues接口，提供属性的读写操作实现，同时可以通过调用构造函数实现深拷贝，获取BeanDefinition里面为Bean设置上的属性值

返回给pvs的是mbd.getPropertyValues()方法的返回值，

public MutablePropertyValues getPropertyValues() {
   if (this.propertyValues == null) {
      this.propertyValues = new MutablePropertyValues();
   }
   return this.propertyValues;
}

MutablePropertyValues类

bean的属性解析主要就是和这个类打交道的

回到populateBean方法里，第一次解析 pvs 值为空，此时就来到脑图中的第二步，按照名字 or 类型对bean进行自动装配

int resolvedAutowireMode = mbd.getResolvedAutowireMode();

返回结果是0，表示没有配置上自动装配模式，意味着会跳过populateBean的自动装配逻辑。

之前介绍postProcessMergedBeanDefinition方法时，被@Value和@Autowired标记的成员变量已经被标记出来了，只差将其注入到bean实例里了，因此就没必要再走一遍解析了，所以就没必要执行if中的逻辑了。

if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
   MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
   // Add property values based on autowire by name if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
      autowireByName(beanName, mbd, bw, newPvs);
   }
   // Add property values based on autowire by type if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      autowireByType(beanName, mbd, bw, newPvs);
   }
   pvs = newPvs;
}

可以看一看上面两种注入方法的逻辑。

autowireByName：

protected void autowireByName(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
   // 获取要注入的非简单类型的属性名称
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      // 检测是否存在与propertyName相关的bean或BeanDefinition.
      // 若存在，则调用BeanFactory.getBean方法获取bean实例
      if (containsBean(propertyName)) {
         // 从容器中获取相应的bean实例
         Object bean = getBean(propertyName);
         // 将解析出的bean存入到属性值列表pvs中
         pvs.add(propertyName, bean);
         // 注册依赖关系
         registerDependentBean(propertyName, beanName);
         if (logger.isTraceEnabled()) {
            logger.trace("Added autowiring by name from bean name '" + beanName +
                  "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
         }
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                  "' by name: no matching bean found");
         }
      }
   }
}

先获取非简单类型的属性名称，再根据获取出来的属性名称去依次调用容器的getBean方法获取属性名对应的bean实例，最后将获取到的bean实例连同属性的名称添加到属性列表pvs中，再将bean的依赖关系通过registerDependentBean方法给注册起来。

进入unsatisfiedNonSimpleProperties方法里：

/**
 * 获取非简单类型属性的名称，且该属性未被配置在配置文件中，如下例：将属性明确写在bean里面了，就不算自动装配
 * <bean class="org.springframework.aop.framework.ProxyFactoryBean">
 *        <property name="target">
 *            <ref parent="accountService"/>
 *         </property>
 * </bean>
 *
 * Spring认为的“简单类型“属性有哪些，如下：
 * 1. CharSequence接口的实现类，比如String
 * 2. Enum
 * 3. Date
 * 4. URI/URL
 * 5. Number的继承类，比如Integer/Long
 * 6. byte/short/int...等基本类型
 * 7. Locale
 * 8．以上所有类型的数组形式
 *
 * 
 * @param mbd
 * @param bw
 * @return
 */
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
   Set<String> result = new TreeSet<>();
   PropertyValues pvs = mbd.getPropertyValues();
   PropertyDescriptor[] pds = bw.getPropertyDescriptors();
   for (PropertyDescriptor pd : pds) {
      if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
            !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
         result.add(pd.getName());
      }
   }
   return StringUtils.toStringArray(result);
}

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);
   // 获取要注入的属性名称（非简单属性（8种原始类型、字符、URL等都是简单属性））
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      try {
         // 获取指定属性名称的属性Descriptor（Descriptor用来记载属性的getter setter type等情况）
         PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
         // Don't try autowiring by type for type Object: never makes sense,
         // even if it technically is a unsatisfied, non-simple property.
         // 不对Object类型的属性进行装配注入，技术上没法实现，并且没有意义
         // 即如果属性类型为Object，则忽略，不做解析
         if (Object.class != pd.getPropertyType()) {
            // 获取属性的setter方法
            MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
            // Do not allow eager init for type matching in case of a prioritized post-processor.
            // 对于继承了PriorityOrdered的post-processor，不允许立即初始化（热加载）
            boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
            // 创建一个要被注入的依赖描述，方便提供统一的访问
            DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
            // 根据容器的BeanDefinition解析依赖关系，返回所有要被注入的Bean实例
            Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
            if (autowiredArgument != null) {
               // 将解析出的bean存入到属性值列表pvs中
               pvs.add(propertyName, autowiredArgument);
            }
            for (String autowiredBeanName : autowiredBeanNames) {
               // 注册依赖关系
               registerDependentBean(autowiredBeanName, beanName);
               if (logger.isTraceEnabled()) {
                  logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
                        propertyName + "' to bean named '" + autowiredBeanName + "'");
               }
            }
            // 清除已注入属性的记录
            autowiredBeanNames.clear();
         }
      }
      catch (BeansException ex) {
         throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
      }
   }
}

首先也是获得非简单类型属性名称：

 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);

然后再根据属性名获取属性描述符PropertyDescriptor：

PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);

然后根据属性描述符去获取方法参数对象MethodParameter：

MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);

之后再根据方法参数对象去获取依赖描述符对象DependencyDescriptor：

DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);

进入PropertyDescriptor：

主要就是用来描述bean里的主要属性，可以通过它获取到该属性的getter或setter

回到autowireByType，

MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);

就是获得属性setter方法实例，保存到MethodParameter实例中，该实例是封装setter的，方便后续注入，DependencyDescriptor描述要注入的依赖

InjectionPoint是用来描述注入点的，比如boyfriend中的girlfriend就是一个注入点，girlfriend的类型、setter、注解标签这些信息都可以通过InjectionPoint来获取，DependencyDescriptor除了上述的功能外，还保存了一些额外的信息，比如：依赖是否必要

public boolean isRequired() {
   if (!this.required) {
      return false;
   }

   if (this.field != null) {
      return !(this.field.getType() == Optional.class || hasNullableAnnotation() ||
            (KotlinDetector.isKotlinReflectPresent() &&
                  KotlinDetector.isKotlinType(this.field.getDeclaringClass()) &&
                  KotlinDelegate.isNullable(this.field)));
   }
   else {
      return !obtainMethodParameter().isOptional();
   }
}

是否是延迟加载的：

public boolean isEager() {
   return this.eager;
}

相关的一些嵌套级别：

public void increaseNestingLevel() {
   this.nestingLevel ++;
   this.resolvableType = null;
   if (this.methodParameter != null) {
      this.methodParameter = this.methodParameter.nested();
   }
}

回到autowireByType，获取到DependencyDescriptor之后就可以进行属性对应的值的解析了

// 根据容器的BeanDefinition解析依赖关系，返回所有要被注入的Bean实例
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);

autowiredArgument是属性的值，并将其与属性名一起添加到属性列表中

pvs.add(propertyName, autowiredArgument);

之后再注册一下bean之间的依赖关系

registerDependentBean(autowiredBeanName, beanName);

毕竟不是所有的依赖关系都是在配置里显式标注的。注册完成后就完成了该方法