本文主要基于 Spring 5.0.6.RELEASE
摘要: 原创出处 http://cmsblogs.com/?p=todo 「小明哥」，谢谢！
作为「小明哥」的忠实读者，「老艿艿」略作修改，记录在理解过程中，参考的资料。
#doCreateBean(...) 方法，主要用于完成 bean 的创建和初始化工作，我们可以将其分为四个过程：
#createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args)方法，实例化 bean 。- 循环依赖的处理。
#populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw)方法，进行属性填充。#initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)方法，初始化 Bean 。
第一个过程，实例化 bean 已经在前面两篇博客分析完毕了。
这篇博客开始，分析属性填充，也就是 #populateBean(...) 方法。该函数的作用是将 BeanDefinition 中的属性值赋值给 BeanWrapper 实例对象(对于 BeanWrapper ，我们后续专门写文分析)。
1. populateBean
// AbstractAutowireCapableBeanFactory.java |
处理流程如下：
<1>，根据hasInstantiationAwareBeanPostProcessors属性来判断，是否需要在注入属性之前给 InstantiationAwareBeanPostProcessors 最后一次改变 bean 的机会。此过程可以控制 Spring 是否继续进行属性填充。- 统一存入到 PropertyValues 中，PropertyValues 用于描述 bean 的属性。
<2>，根据注入类型(AbstractBeanDefinition#getResolvedAutowireMode()方法的返回值 )的不同来判断：- 是根据名称来自动注入（
#autowireByName(...)） - 还是根据类型来自动注入（
#autowireByType(...)） - 详细解析，见 「1.1 自动注入」 。
- 是根据名称来自动注入（
<3>，进行 BeanPostProcessor 处理。<4>，依赖检测。
<5>，将所有 PropertyValues 中的属性，填充到 BeanWrapper 中。
1.1 自动注入
Spring 会根据注入类型（ byName / byType ）的不同，调用不同的方法来注入属性值。代码如下：
// AbstractBeanDefinition.java |
1.1.1 autowireByName
#autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) 方法，是根据属性名称，完成自动依赖注入的。代码如下：
// AbstractAutowireCapableBeanFactory.java |
<1>处，该方法逻辑很简单，获取该 bean 的非简单属性。什么叫做非简单属性呢？就是类型为对象类型的属性，但是这里并不是将所有的对象类型都都会找到，比如 8 个原始类型，String 类型 ，Number类型、Date类型、URL类型、URI类型等都会被忽略。代码如下：// AbstractAutowireCapableBeanFactory.java
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
// 创建 result 集合
Set<String> result = new TreeSet<>();
PropertyValues pvs = mbd.getPropertyValues();
// 遍历 PropertyDescriptor 数组
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
if (pd.getWriteMethod() != null // 有可写方法
&& !isExcludedFromDependencyCheck(pd) // 依赖检测中没有被忽略
&& !pvs.contains(pd.getName()) // pvs 不包含该属性名
&& !BeanUtils.isSimpleProperty(pd.getPropertyType())) { // 不是简单属性类型
result.add(pd.getName()); // 添加到 result 中
}
}
return StringUtils.toStringArray(result);
}- 过滤条件为：有可写方法、依赖检测中没有被忽略、不是简单属性类型。
- 过滤结果为：其实这里获取的就是需要依赖注入的属性。
获取需要依赖注入的属性后，通过迭代、递归的方式初始化相关的 bean ，然后调用
#registerDependentBean(String beanName, String dependentBeanName)方法，完成注册依赖。代码如下：// DefaultSingletonBeanRegistry.java
/**
* Map between dependent bean names: bean name to Set of dependent bean names.
*
* 保存的是依赖 beanName 之间的映射关系：beanName - > 依赖 beanName 的集合
*/
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
/**
* Map between depending bean names: bean name to Set of bean names for the bean's dependencies.
*
* 保存的是依赖 beanName 之间的映射关系：依赖 beanName - > beanName 的集合
*/
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
public void registerDependentBean(String beanName, String dependentBeanName) {
// 获取 beanName
String canonicalName = canonicalName(beanName);
// 添加 <canonicalName, <dependentBeanName>> 到 dependentBeanMap 中
synchronized (this.dependentBeanMap) {
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
// 添加 <dependentBeanName, <canonicalName>> 到 dependenciesForBeanMap 中
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
1.1.2 autowireByType
#autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) 方法，是根据属性类型，完成自动依赖注入的。代码如下：
// AbstractAutowireCapableBeanFactory.java |
- 其实主要过程和根据名称自动注入差不多，都是找到需要依赖注入的属性，然后通过迭代的方式寻找所匹配的 bean，最后调用
#registerDependentBean(...)方法，来注册依赖。不过相对于#autowireByName(...)方法而言，根据类型寻找相匹配的 bean 过程比较复杂。
1.1.2.1 resolveDependency
下面我们就分析这个复杂的过程，代码如下：
// DefaultListableBeanFactory.java |
这里我们关注通用处理逻辑
#doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)方法，代码如下：// DefaultListableBeanFactory.java
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
// 注入点
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
// 针对给定的工厂给定一个快捷实现的方式，例如考虑一些预先解析的信息
// 在进入所有bean的常规类型匹配算法之前，解析算法将首先尝试通过此方法解析快捷方式。
// 子类可以覆盖此方法
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()));
}
// 解析复合 bean，其实就是对 bean 的属性进行解析
// 包括：数组、Collection 、Map 类型
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
// 查找与类型相匹配的 bean
// 返回值构成为：key = 匹配的 beanName，value = beanName 对应的实例化 bean
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
// 没有找到，检验 @autowire 的 require 是否为 true
if (matchingBeans.isEmpty()) {
// 如果 @autowire 的 require 属性为 true ，但是没有找到相应的匹配项，则抛出异常
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
if (matchingBeans.size() > 1) {
// 确认给定 bean autowire 的候选者
// 按照 @Primary 和 @Priority 的顺序
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
// 唯一性处理
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
// 在可选的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);
}
}- 代码比较多，胖友调试看看。看懂大体逻辑即可。
到这里就已经完成了所有属性的注入了。populateBean() 该方法就已经完成了一大半工作了：
- 下一步，则是对依赖 bean 的依赖检测和 PostProcessor 处理，这个我们后面分析。
- 下面，分析该方法的最后一步：
#applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)方法。
1.2 applyPropertyValues
其实，上面只是完成了所有注入属性的获取，将获取的属性封装在 PropertyValues 的实例对象 pvs 中，并没有应用到已经实例化的 bean 中。而 #applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) 方法，则是完成这一步骤的。代码如下：
// AbstractAutowireCapableBeanFactory.java |
总结 #applyPropertyValues(...) 方法（完成属性转换）：
- 属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。
- 属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。
而且，我们看到调用了 #resolveValueIfNecessary(...)方法对属性值的解析。详细解析，可见 《Spring应用、原理以及粗读源码系列（一）–框架总述、以Bean为核心的机制（IoC容器初始化以及依赖注入）》 的 「7. 追踪 resolveValueIfNecessary ，发现是在 BeanDefinitionValueResolver 类」 。
2. 小结
至此，#doCreateBean(...) 方法的第二个过程：属性填充已经分析完成了，下篇分析第三个过程：循环依赖的处理。其实，循环依赖并不仅仅只是在 #doCreateBean(...) 方法中处理，在整个加载 bean 的过程中都有涉及。所以下篇内容并不仅仅只局限于 #doCreateBean(...) 方法。