获取bean（doCreateBean）有四步：

  • createBeanInstance，创建BeanWrapper
  • 属性填充
  • bean初始化

1、属性填充逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
//用bean定义中的属性值填充给定BeanWrapper中的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;

        //这个bean定义不是“合成的”且持有InstantiationAwareBeanPostProcessors
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            //迭代所有BeanPostProcessor
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                //实例化前后的回调
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    //通过构造函数或工厂方法实例化bean之后，但在Spring属性填充(来自显式属性或自动装配)发生之前执行操作。
                    // postProcessAfterInstantiation：如果应该在 bean上面设置属性则返回true，否则返回false
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }
        // 如果后续处理器发出停止填充命令，则终止后续操作
        if (!continueWithPropertyPopulation) {
            return;
        }

        //获取属性
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        //已解析的自动装配代码，
        // autowire： byName 或者 byType
        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
            //深拷贝构造函数。确保PropertyValue引用是独立的，
            // 不能深度复制当前由单个PropertyValue对象引用的对象。
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // Add property values based on autowire by name if applicable.
            // byName
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // Add property values based on autowire by type if applicable.
            // byType
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }

        //是否注册了 InstantiationAwareBeanPostProcessors
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        //是否有依赖检查
        boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);


        PropertyDescriptor[] filteredPds = null;
        //如果注册了InstantiationAwareBeanPostProcessors
        if (hasInstAwareBpps) {
            //属性值确认
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            //迭代应用于此工厂创建的bean的BeanPostProcessor列表。
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                //如果属于InstantiationAwareBeanPostProcessor
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 对所有需要依赖检查的属性进行后处理
                    PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        if (filteredPds == null) {
                            //从给定的BeanWrapper中提取一组经过过滤的属性描述符，
                            // 排除被忽略的依赖项类型或在被忽略的依赖项接口上定义的属性。
                            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                        }
                        //从5.1开始，支持{@link #postProcessProperties(PropertyValues, Object, String)}
                        pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            return;
                        }
                    }
                    pvs = pvsToUse;
                }
            }
        }
        //确认依赖检查
        if (needsDepCheck) {
            //PropertyDescriptor为空
            if (filteredPds == null) {
                //从给定的BeanWrapper中提取一组经过过滤的属性描述符，
                // 排除被忽略的依赖项类型或在被忽略的依赖项接口上定义的属性。
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            // 依赖检查，对应 depends-on 属性
            // depends-on是指指定Bean初始化及销毁时的顺序，
            // 使用depends-on属性指定的Bean要先初始化完毕后才初始化当前Bean,
            // 由于只有"singleton"Bean才能被Spring管理销毁，
            // 所以当指定的Bean都是"singleton"时，
            // 使用depends-on属性指定的Bean要在指定的Bean之后销毁。
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }

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

主要流程：

  • 确认是否需要用InstantiationAwareBeanPostProcessors处理bean,可以改变bean,并且可以终止属性的填充。
  • 自动注入，byType或者byName,最后将属性存储到PropertyValues中。
  • InstantiationAwareBeanPostProcessor，对所有需要依赖检查的属性进行后处理。
  • 依赖检查，对应depends-on，指定Bean初始化及销毁时的顺序
  • 将PropertyValues应用到BeanWrapper

2、自动注入

涉及到两种：byType与byName注入。

2.1、autowireByName

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//如果autowire被设置为“byName”，则使用对该工厂中其他bean的引用填充任何缺失的属性值。
    protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        //返回复杂bean属性数组。
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        //迭代复杂bean属性
        for (String propertyName : propertyNames) {
            // 如果容器中包含指定名称的 bean，则将该 bean 注入到 bean中
            if (containsBean(propertyName)) {
                //初始化指定bean
                Object bean = getBean(propertyName);
                // 属性名称赋值
                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");
                }
            }
        }
    }

通过unsatisfiedNonSimpleProperties过滤：有可写方法、依赖检测中没有被忽略、不是简单属性类型。这里获取的就是需要依赖注入的属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//返回不满足的不是简单bean属性数组。这些可能是对工厂中其他bean的不满意引用。不包括基本类型或字符串等简单属性。
    protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
        Set<String> result = new TreeSet<>();
        //属性值
        PropertyValues pvs = mbd.getPropertyValues();
        //属性描述
        PropertyDescriptor[] pds = bw.getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            //获取应用于编写属性值的方法不为null
            //确定给定bean属性是否被排除在依赖项检查之外。
            //确定属性值中是否有pd.getName()
            //检查给定类型是否代表“简单”属性:
            // a primitive, a String or other CharSequence, a Number, a Date,
            // a URI, a URL, a Locale, a Class, or a corresponding array.
            if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
                    !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
                //满足上述条件，入集合
                result.add(pd.getName());
            }
        }
        return StringUtils.toStringArray(result);
    }

最后调用registerDependentBean完成注册依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void registerDependentBean(String beanName, String dependentBeanName) {
	String canonicalName = canonicalName(beanName);
	synchronized (this.dependentBeanMap) {
		Set<String> dependentBeans =
				this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
		if (!dependentBeans.add(dependentBeanName)) {
			return;
		}
	}

	synchronized (this.dependenciesForBeanMap) {
		Set<String> dependenciesForBean =
				this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
		dependenciesForBean.add(canonicalName);
	}
}

2.2、autowireByType

定义“按类型自动装配”(按类型定义bean属性)行为的抽象方法。这类似于PicoContainer缺省值，其中bean工厂中必须恰好有一个属性类型的bean。这使得bean工厂很容易配置为较小的名称空间，但对于较大的应用程序，它的工作效果不如标准Spring行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
protected void autowireByType(
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    // 获取 TypeConverter 实例
    // 使用自定义的 TypeConverter，用于取代默认的 PropertyEditor 机制
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
    //复杂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);
                // 针对此工厂中定义的bean解析指定的依赖项。
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                //迭代的方式注入bean
                for (String autowiredBeanName : autowiredBeanNames) {
                    //为给定bean注册一个依赖bean，在销毁给定bean之前销毁它。
                    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);
        }
    }
}

首先要找到依赖的属性，之后通过迭代根据类型获取匹配的bean，最后注册依赖。resolveDependency:针对工厂中定义的bean解析指定的依赖项。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
@Override
   @Nullable
   public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
                                   @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

       //ParameterNameDiscoverer:用于解析方法参数名
       //初始化底层方法参数的参数名称发现
       descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());

       //如果为Optional类型，则创建为一个Optional包装器。
       if (Optional.class == descriptor.getDependencyType()) {
           return createOptionalDependency(descriptor, requestingBeanName);
       } else if (ObjectFactory.class == descriptor.getDependencyType() ||
               ObjectProvider.class == descriptor.getDependencyType()) {
           //如果是ObjectFactory或者ObjectProvider类型，返回可序列化的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;
       }
   }

   @Nullable
   public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
                                     @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

       //注入点
       InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
       try {
           //针对给定的工厂解析此依赖项的快捷方式，例如考虑一些预先解析的信息。
           //在进入所有bean的常规类型匹配算法之前，解析算法将首先尝试通过此方法解析快捷方式。
           //子类可以覆盖此方法，以提高基于预缓存信息的分辨率性能，同时仍然接收InjectionPoint暴露等。
           Object shortcut = descriptor.resolveShortcut(this);
           if (shortcut != null) {
               return shortcut;
           }

           //获取依赖的类型
           Class<?> type = descriptor.getDependencyType();
           //AutowireCandidateResolver解析器，用于检查bean定义是否是自动装配候选项。
           //确定是否为给定依赖项建议默认值。默认实现只返回null
           //支持 Spring 的注解 @value
           Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
           if (value != null) {
               //如果是String类型
               if (value instanceof String) {
                   String strVal = resolveEmbeddedValue((String) value);
                   BeanDefinition bd = (beanName != null && containsBean(beanName) ?
                           getMergedBeanDefinition(beanName) : null);
                   //计算bean定义中包含的给定字符串，
                   value = evaluateBeanDefinitionString(strVal, bd);
               }
               TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
               try {
                   return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
               } catch (UnsupportedOperationException ex) {
                   // A custom TypeConverter which does not support TypeDescriptor resolution...
                   return (descriptor.getField() != null ?
                           converter.convertIfNecessary(value, type, descriptor.getField()) :
                           converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
               }
           }

           //解析复杂类型StreamDependencyDescriptor、数组、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);
           if (matchingBeans.isEmpty()) {
               //校验@autowire的require属性为true
               if (isRequired(descriptor)) {
                   //为无法解决的依赖项引发NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException。
                   raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
               }
               return null;
           }

           String autowiredBeanName;
           Object instanceCandidate;

           if (matchingBeans.size() > 1) {
               //确定给定bean集中的自动装配候选对象。查找@Primary和@Priority(按此顺序)。
               autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
               if (autowiredBeanName == null) {
                   if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
                       //解决指定的非惟一场景:默认情况下，抛出一个NoUniqueBeanDefinitionException。
                       return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
                   } else {
                       //如果是可选的Collection/Map，则忽略非唯一的情况:
                       // 它可能是多个常规bean的空集合
                       // (特别是在4.3之前，我们甚至没有寻找集合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);
       }
   }

至此，完成了所以注入属性的获取，但是并没有应用到实例化的bean中，方法applyPropertyValues则完成这一步：

3、applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)

应用给定的属性值，解析此bean工厂中对其他bean的任何运行时引用。必须使用深度复制，因此我们不会永久修改此属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
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;
        if (mpvs.isConverted()) {
            // Shortcut: use the pre-converted values as-is.
            try {
                //执行批处理更新的首选方法。属性设置到BeanWrapper中去
                bw.setPropertyValues(mpvs);
                return;
            } catch (BeansException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Error setting property values", ex);
            }
        }
        original = mpvs.getPropertyValueList();
    } else {
        //直接使用原始类型
        original = Arrays.asList(pvs.getPropertyValues());
    }

    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

    // 创建一个深度副本，解析值的任何引用。
    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);
            }
            //可能在合并bean定义中存储转换后的值，
            //以避免对每个创建的bean实例进行重新转换。
            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) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

分析到这里，即属性已经填充到了BeanWrapper中了，之后分析bean初始化。

tencent.jpg