Spring源码解析——IOC属性填充

正文
doCreateBean() 主要用于完成 bean 的创建和初始化工作，我们可以将其分为四个过程：

最全面的Java面试网站

• createBeanInstance() 实例化 bean
  
• populateBean() 属性填充
  
• 循环依赖的处理
  
• initializeBean() 初始化 bean
  

第一个过程实例化 bean在前面一篇博客中已经分析完了，这篇博客开始分析 属性填充，也就是 populateBean()

1. protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {  
2.     PropertyValues pvs = mbd.getPropertyValues();  
4.     if (bw == null) {  
5.         if (!pvs.isEmpty()) {  
6.             throw new BeanCreationException(  
7.                     mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");  
8.         }  
9.         else {  
10.             // Skip property population phase for null instance.  
11.             return;  
12.         }  
13.     }  
15.     // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the  
16.     // state of the bean before properties are set. This can be used, for example,  
17.     // to support styles of field injection.  
18.     boolean continueWithPropertyPopulation = true;  
20.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
21.         for (BeanPostProcessor bp : getBeanPostProcessors()) {  
22.             if (bp instanceof InstantiationAwareBeanPostProcessor) {  
23.                 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
24.                 //返回值为是否继续填充bean  
25.                 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  
26.                     continueWithPropertyPopulation = false;  
27.                     break;  
28.                 }  
29.             }  
30.         }  
31.     }  
32.     //如果后处理器发出停止填充命令则终止后续的执行  
33.     if (!continueWithPropertyPopulation) {  
34.         return;  
35.     }  
37.     if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||  
38.             mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
39.         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
41.         // Add property values based on autowire by name if applicable.  
42.         //根据名称自动注入  
43.         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {  
44.             autowireByName(beanName, mbd, bw, newPvs);  
45.         }  
47.         // Add property values based on autowire by type if applicable.  
48.         //根据类型自动注入  
49.         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
50.             autowireByType(beanName, mbd, bw, newPvs);  
51.         }  
53.         pvs = newPvs;  
54.     }  
55.     //后处理器已经初始化  
56.     boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  
57.     //需要依赖检查  
58.     boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);  
60.     if (hasInstAwareBpps || needsDepCheck) {  
61.         PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);  
62.         if (hasInstAwareBpps) {  
63.             for (BeanPostProcessor bp : getBeanPostProcessors()) {  
64.                 if (bp instanceof InstantiationAwareBeanPostProcessor) {  
65.                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
66.                     //对所有需要依赖检查的属性进行后处理  
67.                     pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);  
68.                     if (pvs == null) {  
69.                         return;  
70.                     }  
71.                 }  
72.             }  
73.         }  
74.         if (needsDepCheck) {  
75.             //依赖检查，对应depends-on属性，3.0已经弃用此属性  
76.             checkDependencies(beanName, mbd, filteredPds, pvs);  
77.         }  
78.     }  
79.     //将属性应用到bean中  
80.     //将所有ProtertyValues中的属性填充至BeanWrapper中。  
81.     applyPropertyValues(beanName, mbd, bw, pvs);  
82. }

复制代码

我们来分析下populateBean的流程：
（1）首先进行属性是否为空的判断
（2）通过调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)方法来控制程序是否继续进行属性填充
（3）根据注入类型（byName/byType）提取依赖的bean，并统一存入PropertyValues中
（4）应用InstantiationAwareBeanPostProcessor的postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName)方法，对属性获取完毕填充前的再次处理，典型的应用是RequiredAnnotationBeanPostProcesser类中对属性的验证
（5）将所有的PropertyValues中的属性填充至BeanWrapper中
上面步骤中有几个地方是我们比较感兴趣的，它们分别是依赖注入（autowireByName/autowireByType）以及属性填充，接下来进一步分析这几个功能的实现细节

分享一份大彬精心整理的大厂面试手册，包含计算机基础、Java基础、多线程、JVM、数据库、Redis、Spring、Mybatis、SpringMVC、SpringBoot、分布式、微服务、设计模式、架构、校招社招分享等高频面试题，非常实用，有小伙伴靠着这份手册拿过字节offer~


需要的小伙伴可以自行下载：
http://mp.weixin.qq.com/s?__biz=Mzg2OTY1NzY0MQ==&mid=2247485445&idx=1&sn=1c6e224b9bb3da457f5ee03894493dbc&chksm=ce98f543f9ef7c55325e3bf336607a370935a6c78dbb68cf86e59f5d68f4c51d175365a189f8#rd

自动注入

Spring 会根据注入类型（ byName / byType ）的不同，调用不同的方法（autowireByName() / autowireByType()）来注入属性值。
autowireByName()

1. protected void autowireByName(
2.         String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
4.     // 获取 Bean 对象中非简单属性
5.     String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
6.     for (String propertyName : propertyNames) {
7.         // 如果容器中包含指定名称的 bean，则将该 bean 注入到 bean中
8.         if (containsBean(propertyName)) {
9.             // 递归初始化相关 bean
10.             Object bean = getBean(propertyName);
11.             // 为指定名称的属性赋予属性值  
12.             pvs.add(propertyName, bean);
13.             // 属性依赖注入
14.             registerDependentBean(propertyName, beanName);
15.             if (logger.isDebugEnabled()) {
16.                 logger.debug("Added autowiring by name from bean name '" + beanName +
17.                         "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
18.             }
19.         }
20.         else {
21.             if (logger.isTraceEnabled()) {
22.                 logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
23.                         "' by name: no matching bean found");
24.             }
25.         }
26.     }
27. }

复制代码

该方法逻辑很简单，获取该 bean 的非简单属性，什么叫做非简单属性呢？就是类型为对象类型的属性，但是这里并不是将所有的对象类型都都会找到，比如 8 个原始类型，String 类型 ，Number类型、Date类型、URL类型、URI类型等都会被忽略，如下：

1. protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
2.     Set<String> result = new TreeSet<>();
3.     PropertyValues pvs = mbd.getPropertyValues();
4.     PropertyDescriptor[] pds = bw.getPropertyDescriptors();
5.     for (PropertyDescriptor pd : pds) {
6.         if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
7.                 !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
8.             result.add(pd.getName());
9.         }
10.     }
11.     return StringUtils.toStringArray(result);
12. }

复制代码

这里获取的就是需要依赖注入的属性。
autowireByName()函数的功能就是根据传入的参数中的pvs中找出已经加载的bean，并递归实例化，然后加入到pvs中
autowireByType

autowireByType与autowireByName对于我们理解与使用来说复杂程度相似，但是实现功能的复杂度却不一样，我们看下方法代码：

1. protected void autowireByType(  
2.         String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {  
4.     TypeConverter converter = getCustomTypeConverter();  
5.     if (converter == null) {  
6.         converter = bw;  
7.     }  
9.     Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);  
10.     //寻找bw中需要依赖注入的属性  
11.     String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);  
12.     for (String propertyName : propertyNames) {  
13.         try {  
14.             PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);  
15.             // Don't try autowiring by type for type Object: never makes sense,  
16.             // even if it technically is a unsatisfied, non-simple property.  
17.             if (!Object.class.equals(pd.getPropertyType())) {  
18.                 //探测指定属性的set方法  
19.                 MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);  
20.                 // Do not allow eager init for type matching in case of a prioritized post-processor.  
21.                 boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());  
22.                 DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);  
23.                 //解析指定beanName的属性所匹配的值，并把解析到的属性名称存储在autowiredBeanNames中，  
24.                 Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);  
25.                 if (autowiredArgument != null) {  
26.                     pvs.add(propertyName, autowiredArgument);  
27.                 }  
28.                 for (String autowiredBeanName : autowiredBeanNames) {  
29.                     //注册依赖  
30.                     registerDependentBean(autowiredBeanName, beanName);  
31.                     if (logger.isDebugEnabled()) {  
32.                         logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +  
33.                                 propertyName + "' to bean named '" + autowiredBeanName + "'");  
34.                     }  
35.                 }  
36.                 autowiredBeanNames.clear();  
37.             }  
38.         }  
39.         catch (BeansException ex) {  
40.             throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);  
41.         }  
42.     }  
43. }

复制代码

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

1. @Autowired
2. private List<Test> tests;

复制代码

这种方式spring会把所有与Test匹配的类型找出来并注入到tests属性中，正是由于这一因素，所以在autowireByType函数，新建了局部遍历autowireBeanNames，用于存储所有依赖的bean，如果只是对非集合类的属性注入来说，此属性并无用处。
对于寻找类型匹配的逻辑实现是封装在了resolveDependency函数中，其实现如下：

1. public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
2.     descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());  
3.     if (descriptor.getDependencyType().equals(ObjectFactory.class)) {  
4.         //ObjectFactory类注入的特殊处理  
5.         return new DependencyObjectFactory(descriptor, beanName);  
6.     }  
7.     else if (descriptor.getDependencyType().equals(javaxInjectProviderClass)) {  
8.         //javaxInjectProviderClass类注入的特殊处理  
9.         return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName);  
10.     }  
11.     else {  
12.         //通用处理逻辑  
13.         return doResolveDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter);  
14.     }  
15. }  
17. protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName,  
18.         Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {  
19.     /*
20.      * 用于支持Spring中新增的注解@Value
21.      */  
22.     Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);  
23.     if (value != null) {  
24.         if (value instanceof String) {  
25.             String strVal = resolveEmbeddedValue((String) value);  
26.             BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);  
27.             value = evaluateBeanDefinitionString(strVal, bd);  
28.         }  
29.         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  
30.         return (descriptor.getField() != null ?  
31.                 converter.convertIfNecessary(value, type, descriptor.getField()) :  
32.                 converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));  
33.     }  
34.     //如果解析器没有成功解析，则需要考虑各种情况  
35.     //属性是数组类型  
36.     if (type.isArray()) {  
37.         Class<?> componentType = type.getComponentType();  
38.         //根据属性类型找到beanFactory中所有类型的匹配bean，  
39.         //返回值的构成为：key=匹配的beanName,value=beanName对应的实例化后的bean（通过getBean(beanName)返回）  
40.         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);  
41.         if (matchingBeans.isEmpty()) {  
42.             //如果autowire的require属性为true而找到的匹配项却为空则只能抛出异常  
43.             if (descriptor.isRequired()) {  
44.                 raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);  
45.             }  
46.             return null;  
47.         }  
48.         if (autowiredBeanNames != null) {  
49.             autowiredBeanNames.addAll(matchingBeans.keySet());  
50.         }  
51.         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  
52.         //通过转换器将bean的值转换为对应的type类型  
53.         return converter.convertIfNecessary(matchingBeans.values(), type);  
54.     }  
55.     //属性是Collection类型  
56.     else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {  
57.         Class<?> elementType = descriptor.getCollectionType();  
58.         if (elementType == null) {  
59.             if (descriptor.isRequired()) {  
60.                 throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");  
61.             }  
62.             return null;  
63.         }  
64.         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, descriptor);  
65.         if (matchingBeans.isEmpty()) {  
66.             if (descriptor.isRequired()) {  
67.                 raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);  
68.             }  
69.             return null;  
70.         }  
71.         if (autowiredBeanNames != null) {  
72.             autowiredBeanNames.addAll(matchingBeans.keySet());  
73.         }  
74.         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  
75.         return converter.convertIfNecessary(matchingBeans.values(), type);  
76.     }  
77.     //属性是Map类型  
78.     else if (Map.class.isAssignableFrom(type) && type.isInterface()) {  
79.         Class<?> keyType = descriptor.getMapKeyType();  
80.         if (keyType == null || !String.class.isAssignableFrom(keyType)) {  
81.             if (descriptor.isRequired()) {  
82.                 throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +  
83.                         "] must be assignable to [java.lang.String]");  
84.             }  
85.             return null;  
86.         }  
87.         Class<?> valueType = descriptor.getMapValueType();  
88.         if (valueType == null) {  
89.             if (descriptor.isRequired()) {  
90.                 throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");  
91.             }  
92.             return null;  
93.         }  
94.         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, descriptor);  
95.         if (matchingBeans.isEmpty()) {  
96.             if (descriptor.isRequired()) {  
97.                 raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);  
98.             }  
99.             return null;  
100.         }  
101.         if (autowiredBeanNames != null) {  
102.             autowiredBeanNames.addAll(matchingBeans.keySet());  
103.         }  
104.         return matchingBeans;  
105.     }  
106.     else {  
107.         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);  
108.         if (matchingBeans.isEmpty()) {  
109.             if (descriptor.isRequired()) {  
110.                 raiseNoSuchBeanDefinitionException(type, "", descriptor);  
111.             }  
112.             return null;  
113.         }  
114.         if (matchingBeans.size() > 1) {  
115.             String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);  
116.             if (primaryBeanName == null) {  
117.                 throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());  
118.             }  
119.             if (autowiredBeanNames != null) {  
120.                 autowiredBeanNames.add(primaryBeanName);  
121.             }  
122.             return matchingBeans.get(primaryBeanName);  
123.         }  
124.         // We have exactly one match.  
125.         Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();  
126.         if (autowiredBeanNames != null) {  
127.             autowiredBeanNames.add(entry.getKey());  
128.         }  
129.         //已经确定只有一个匹配项  
130.         return entry.getValue();  
131.     }  
132. }

复制代码

主要就是通过Type从BeanFactory中找到对应的benaName，然后通过getBean获取实例

1. protected Map<String, Object> findAutowireCandidates(
2.         @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
3.     //在BeanFactory找到所有Type类型的beanName
4.     String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
5.             this, requiredType, true, descriptor.isEager());
6.     Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
8.     //遍历所有的beanName,通过getBean获取
9.     for (String candidate : candidateNames) {
10.         if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
11.             //
12.             addCandidateEntry(result, candidate, descriptor, requiredType);
13.         }
14.     }
15.     return result;
16. }
18. private void addCandidateEntry(Map<String, Object> candidates, String candidateName,
19.         DependencyDescriptor descriptor, Class<?> requiredType) {
21.     Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
22.     if (!(beanInstance instanceof NullBean)) {
23.         candidates.put(candidateName, beanInstance);
24.     }
25. }
27. public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
28.         throws BeansException {
29.     //通过类型找到beanName,然后再找到其实例
30.     return beanFactory.getBean(beanName);
31. }

复制代码

applyPropertyValues

程序运行到这里，已经完成了对所有注入属性的获取，但是获取的属性是以PropertyValues形式存在的，还并没有应用到已经实例化的bean中，这一工作是在applyPropertyValues中。继续跟踪到方法体中：

1. protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {  
2.     if (pvs == null || pvs.isEmpty()) {  
3.         return;  
4.     }  
6.     MutablePropertyValues mpvs = null;  
7.     List<PropertyValue> original;  
9.     if (System.getSecurityManager() != null) {  
10.         if (bw instanceof BeanWrapperImpl) {  
11.             ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());  
12.         }  
13.     }  
15.     if (pvs instanceof MutablePropertyValues) {  
16.         mpvs = (MutablePropertyValues) pvs;  
17.         //如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanwapper中  
18.         if (mpvs.isConverted()) {  
19.             // Shortcut: use the pre-converted values as-is.  
20.             try {  
21.                 bw.setPropertyValues(mpvs);  
22.                 return;  
23.             }  
24.             catch (BeansException ex) {  
25.                 throw new BeanCreationException(  
26.                         mbd.getResourceDescription(), beanName, "Error setting property values", ex);  
27.             }  
28.         }  
29.         original = mpvs.getPropertyValueList();  
30.     }  
31.     else {  
32.         //如果pvs并不是使用MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法  
33.         original = Arrays.asList(pvs.getPropertyValues());  
34.     }  
36.     TypeConverter converter = getCustomTypeConverter();  
37.     if (converter == null) {  
38.         converter = bw;  
39.     }  
40.     //获取对应的解析器  
41.     BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);  
43.     // Create a deep copy, resolving any references for values.  
44.     List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());  
45.     boolean resolveNecessary = false;  
46.     //遍历属性，将属性转换为对应类的对应属性的类型  
47.     for (PropertyValue pv : original) {  
48.         if (pv.isConverted()) {  
49.             deepCopy.add(pv);  
50.         }  
51.         else {  
52.             String propertyName = pv.getName();  
53.             Object originalValue = pv.getValue();  
54.             Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);  
55.             Object convertedValue = resolvedValue;  
56.             boolean convertible = bw.isWritableProperty(propertyName) &&  
57.                     !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);  
58.             if (convertible) {  
59.                 convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);  
60.             }  
61.             // Possibly store converted value in merged bean definition,  
62.             // in order to avoid re-conversion for every created bean instance.  
63.             if (resolvedValue == originalValue) {  
64.                 if (convertible) {  
65.                     pv.setConvertedValue(convertedValue);  
66.                 }  
67.                 deepCopy.add(pv);  
68.             }  
69.             else if (convertible && originalValue instanceof TypedStringValue &&  
70.                     !((TypedStringValue) originalValue).isDynamic() &&  
71.                     !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {  
72.                 pv.setConvertedValue(convertedValue);  
73.                 deepCopy.add(pv);  
74.             }  
75.             else {  
76.                 resolveNecessary = true;  
77.                 deepCopy.add(new PropertyValue(pv, convertedValue));  
78.             }  
79.         }  
80.     }  
81.     if (mpvs != null && !resolveNecessary) {  
82.         mpvs.setConverted();  
83.     }  
85.     // Set our (possibly massaged) deep copy.  
86.     try {  
87.         bw.setPropertyValues(new MutablePropertyValues(deepCopy));  
88.     }  
89.     catch (BeansException ex) {  
90.         throw new BeanCreationException(  
91.                 mbd.getResourceDescription(), beanName, "Error setting property values", ex);  
92.     }  
93. }

复制代码

我们来看看具体的属性赋值过程

1. public class MyTestBean {
2.     private String name ;
4.     public MyTestBean(String name) {
5.         this.name = name;
6.     }
8.     public MyTestBean() {
9.     }
11.     public String getName() {
12.         return name;
13.     }
15.     public void setName(String name) {
16.         this.name = name;
17.     }
18. }
20. <bean id="myTestBean"  >
21.         <property name="name" value="dabin"></property>
22. </bean>

复制代码

如上 bw.setPropertyValues 最终都会走到如下方法

1. @Override
2. public void setValue(final @Nullable Object value) throws Exception {
3.     //获取writeMethod，也就是我们MyTestBean的setName方法
4.     final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
5.             ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
6.             this.pd.getWriteMethod());
7.     if (System.getSecurityManager() != null) {
8.         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
9.             ReflectionUtils.makeAccessible(writeMethod);
10.             return null;
11.         });
12.         try {
13.             AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
14.                     writeMethod.invoke(getWrappedInstance(), value), acc);
15.         }
16.         catch (PrivilegedActionException ex) {
17.             throw ex.getException();
18.         }
19.     }
20.     else {
21.         ReflectionUtils.makeAccessible(writeMethod);
22.         //通过反射调用方法进行赋值
23.         writeMethod.invoke(getWrappedInstance(), value);
24.     }
25. }

复制代码

就是利用反射进行调用对象的set方法赋值
至此，doCreateBean() 第二个过程：属性填充 已经分析完成了，下篇分析第三个过程：循环依赖的处理，其实循环依赖并不仅仅只是在 doCreateBean() 中处理，其实在整个加载 bean 的过程中都有涉及，所以下篇内容并不仅仅只局限于 doCreateBean()。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！