【spring源码分析】IOC容器初始化（九）

前言：上篇文章末尾提到createBeanInstance方法中使用工厂方法实例化Bean对象，本文将对该方法进行分析。

AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod

1     protected BeanWrapper instantiateUsingFactoryMethod(
2             String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
3 
4         return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
5     }

可以看到这里是委托给ConstructorResolver来实现的：

  1 // ConstructorResolver
  2 public BeanWrapper instantiateUsingFactoryMethod(
  3             String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  4         // 构造BeanWrapperImpl对象
  5         BeanWrapperImpl bw = new BeanWrapperImpl();
  6         // 初始化BeanWrapperImpl 向BeanWrapper对象中添加ConversionService对象和属性编辑器PropertyEditor对象
  7         this.beanFactory.initBeanWrapper(bw);
  8 
  9         // 获得factoryBean、factoryClass、isStatic、factoryBeanName属性
 10         Object factoryBean;
 11         Class<?> factoryClass;
 12         boolean isStatic;
 13 
 14         String factoryBeanName = mbd.getFactoryBeanName();
 15         // 工厂名不为空
 16         if (factoryBeanName != null) {
 17             // 如果工厂名和beanName相等，则抛出BeanDefinitionStoreException异常
 18             if (factoryBeanName.equals(beanName)) {
 19                 throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
 20                                                        "factory-bean reference points back to the same bean definition");
 21             }
 22             // 获取工厂实例
 23             factoryBean = this.beanFactory.getBean(factoryBeanName);
 24             // 如果是单例模式，并且已经缓存中已经存在beanName则抛出异常
 25             if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
 26                 throw new ImplicitlyAppearedSingletonException();
 27             }
 28             factoryClass = factoryBean.getClass();
 29             isStatic = false;
 30         } else {
 31             // 工厂名为空，则其可能是一个静态工厂
 32             // 静态工厂创建bean，必须要提供工厂的全类名
 33             // It's a static factory method on the bean class.
 34             if (!mbd.hasBeanClass()) {
 35                 throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
 36                                                        "bean definition declares neither a bean class nor a factory-bean reference");
 37             }
 38             factoryBean = null;
 39             factoryClass = mbd.getBeanClass();
 40             isStatic = true;
 41         }
 42 
 43         // 获得factoryMethodToUse、argsHolderToUse、argsToUse属性
 44         Method factoryMethodToUse = null;
 45         ArgumentsHolder argsHolderToUse = null;
 46         Object[] argsToUse = null;
 47 
 48         // 如果指定了构造参数则直接使用
 49         // 在调用getBean方法的时候指定方法参数
 50         if (explicitArgs != null) {
 51             argsToUse = explicitArgs;
 52         } else {
 53             // 没有指定，则尝试从配置文件中解析
 54             Object[] argsToResolve = null;
 55             // 同步
 56             synchronized (mbd.constructorArgumentLock) {
 57                 // 获取缓存中的构造函数或者工厂方法
 58                 factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
 59                 if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
 60                     // 获取缓存中的构造参数
 61                     // Found a cached factory method...
 62                     argsToUse = mbd.resolvedConstructorArguments;
 63                     if (argsToUse == null) {
 64                         argsToResolve = mbd.preparedConstructorArguments;
 65                     }
 66                 }
 67             }
 68             // 缓存中存在，则解析存储在BeanDefinition中的参数
 69             // 如给定方法的构造函数 f(int ,int),通过此方法后就会把配置文件中的("1","1")转换为(1,1)
 70             // 缓存中的值可能是原始值，也可能是最终值
 71             if (argsToResolve != null) {
 72                 argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
 73             }
 74         }
 75 
 76         if (factoryMethodToUse == null || argsToUse == null) {
 77             // Need to determine the factory method...
 78             // Try all methods with this name to see if they match the given arguments.
 79             // 获取工厂方法的类的全类名
 80             factoryClass = ClassUtils.getUserClass(factoryClass);
 81 
 82             List<Method> candidateList = null;
 83             // 同步
 84             if (mbd.isFactoryMethodUnique) {
 85                 // 获取工厂方法
 86                 if (factoryMethodToUse == null) {
 87                     factoryMethodToUse = mbd.getResolvedFactoryMethod();
 88                 }
 89                 // 获取所有待定的工厂方法
 90                 if (factoryMethodToUse != null) {
 91                     candidateList = Collections.singletonList(factoryMethodToUse);
 92                 }
 93             }
 94             // 如果工厂方法为空，则通过getCandidateMethods获取所有的待定方法
 95             if (candidateList == null) {
 96                 candidateList = new ArrayList<>();
 97                 Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
 98                 for (Method candidate : rawCandidates) {
 99                     if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
100                         candidateList.add(candidate);
101                     }
102                 }
103             }
104 
105             // 通过工厂方法创建bean
106             if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
107                 Method uniqueCandidate = candidateList.get(0);
108                 if (uniqueCandidate.getParameterCount() == 0) {
109                     mbd.factoryMethodToIntrospect = uniqueCandidate;
110                     synchronized (mbd.constructorArgumentLock) {
111                         mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
112                         mbd.constructorArgumentsResolved = true;
113                         mbd.resolvedConstructorArguments = EMPTY_ARGS;
114                     }
115                     bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
116                     return bw;
117                 }
118             }
119 
120             Method[] candidates = candidateList.toArray(new Method[0]);
121             // 排序构造函数
122             // public构造函数优先参数数量降序，非public构造函数参数数量降序
123             AutowireUtils.sortFactoryMethods(candidates);
124 
125             // 用于承载解析后的构造函数参数的值
126             ConstructorArgumentValues resolvedValues = null;
127             boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
128             int minTypeDiffWeight = Integer.MAX_VALUE;
129             Set<Method> ambiguousFactoryMethods = null;
130 
131             int minNrOfArgs;
132             if (explicitArgs != null) {
133                 minNrOfArgs = explicitArgs.length;
134             } else {
135                 // We don't have arguments passed in programmatically, so we need to resolve the
136                 // arguments specified in the constructor arguments held in the bean definition.
137                 // getBean没有传递参数，则需要解析保存在BeanDefinition构造函数中指定的参数
138                 if (mbd.hasConstructorArgumentValues()) {
139                     // 构造函数参数
140                     ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
141                     resolvedValues = new ConstructorArgumentValues();
142                     // 解析构造函数参数
143                     // 将bean的构造函数解析为resolvedValues对象，其中会涉及到其他的bean
144                     minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
145                 } else {
146                     minNrOfArgs = 0;
147                 }
148             }
149 
150             // 记录UnsatisfiedDependencyException异常集合
151             LinkedList<UnsatisfiedDependencyException> causes = null;
152 
153             // 遍历candidates
154             for (Method candidate : candidates) {
155                 // 方法体参数
156                 Class<?>[] paramTypes = candidate.getParameterTypes();
157 
158                 if (paramTypes.length >= minNrOfArgs) {
159                     // 保存参数对象
160                     ArgumentsHolder argsHolder;
161                     // getBean()传递了参数
162                     if (explicitArgs != null) {
163                         // Explicit arguments given -> arguments length must match exactly.
164                         // 显示给定参数，参数长度必须完全匹配
165                         if (paramTypes.length != explicitArgs.length) {
166                             continue;
167                         }
168                         // 根据参数创建参数持有者ArgumentsHolder对象
169                         argsHolder = new ArgumentsHolder(explicitArgs);
170                     } else {
171                         // Resolved constructor arguments: type conversion and/or autowiring necessary.
172                         // 根据提供的参数，解析构造函数
173                         try {
174                             String[] paramNames = null;
175                             // 获取ParameterNameDiscoverer对象
176                             // ParameterNameDiscoverer用于解析方法和构造函数的参数名，为参数名称探测器
177                             ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
178                             // 获取指定构造函数的参数名
179                             if (pnd != null) {
180                                 paramNames = pnd.getParameterNames(candidate);
181                             }
182                             // 在已解析构造函数参数值的情况下，创建一个参数持有者ArgumentsHolder对象
183                             argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
184                                                              paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
185                         } catch (UnsatisfiedDependencyException ex) {
186                             if (logger.isTraceEnabled()) {
187                                 logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
188                             }
189                             // Swallow and try next overloaded factory method.
190                             if (causes == null) {
191                                 causes = new LinkedList<>();
192                             }
193                             // 发生UnsatisfiedDependencyException异常，添加到causes中
194                             causes.add(ex);
195                             continue;
196                         }
197                     }
198 
199                     // isLenientConstructorResolution判断解析构造函数的时候是否以宽松模式还是严格模式
200                     // 宽松模式：使用具有"最接近的模式"进行匹配
201                     // 严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常
202                     int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
203                             argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
204                     // Choose this factory method if it represents the closest match.
205                     // 代表最接近的类型匹配，选择作为构造函数
206                     if (typeDiffWeight < minTypeDiffWeight) {
207                         factoryMethodToUse = candidate;
208                         argsHolderToUse = argsHolder;
209                         argsToUse = argsHolder.arguments;
210                         minTypeDiffWeight = typeDiffWeight;
211                         ambiguousFactoryMethods = null;
212                     }
213                     // Find out about ambiguity: In case of the same type difference weight
214                     // for methods with the same number of parameters, collect such candidates
215                     // and eventually raise an ambiguity exception.
216                     // However, only perform that check in non-lenient constructor resolution mode,
217                     // and explicitly ignore overridden methods (with the same parameter signature).
218                     // 如果具有相同参数数量的方法具有相同的类型差异权重，则收集此类型选项
219                     // 但是仅在非宽松模式构造函数解析模式下执行该检查，并显示忽略重写方法（具有相同的参数签名）
220                     else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
221                             !mbd.isLenientConstructorResolution() &&
222                             paramTypes.length == factoryMethodToUse.getParameterCount() &&
223                             !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
224                         // 查找多个可匹配的方法
225                         if (ambiguousFactoryMethods == null) {
226                             ambiguousFactoryMethods = new LinkedHashSet<>();
227                             ambiguousFactoryMethods.add(factoryMethodToUse);
228                         }
229                         ambiguousFactoryMethods.add(candidate);
230                     }
231                 }
232             }
233 
234             // 没有可执行的工厂方法，则抛出异常
235             if (factoryMethodToUse == null || argsToUse == null) {
236                 if (causes != null) {
237                     UnsatisfiedDependencyException ex = causes.removeLast();
238                     for (Exception cause : causes) {
239                         this.beanFactory.onSuppressedException(cause);
240                     }
241                     throw ex;
242                 }
243                 List<String> argTypes = new ArrayList<>(minNrOfArgs);
244                 if (explicitArgs != null) {
245                     for (Object arg : explicitArgs) {
246                         argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
247                     }
248                 } else if (resolvedValues != null) {
249                     Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
250                     valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
251                     valueHolders.addAll(resolvedValues.getGenericArgumentValues());
252                     for (ValueHolder value : valueHolders) {
253                         String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
254                                 (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
255                         argTypes.add(argType);
256                     }
257                 }
258                 String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
259                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
260                                                 "No matching factory method found: " +
261                                                         (mbd.getFactoryBeanName() != null ?
262                                                                 "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
263                                                         "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
264                                                         "Check that a method with the specified name " +
265                                                         (minNrOfArgs > 0 ? "and arguments " : "") +
266                                                         "exists and that it is " +
267                                                         (isStatic ? "static" : "non-static") + ".");
268             } else if (void.class == factoryMethodToUse.getReturnType()) {
269                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
270                                                 "Invalid factory method '" + mbd.getFactoryMethodName() +
271                                                         "': needs to have a non-void return type!");
272             } else if (ambiguousFactoryMethods != null) {
273                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
274                                                 "Ambiguous factory method matches found in bean '" + beanName + "' " +
275                                                         "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
276                                                         ambiguousFactoryMethods);
277             }
278 
279             // 将解析的构造函数加入缓存
280             if (explicitArgs == null && argsHolderToUse != null) {
281                 mbd.factoryMethodToIntrospect = factoryMethodToUse;
282                 argsHolderToUse.storeCache(mbd, factoryMethodToUse);
283             }
284         }
285 
286         // 创建bean对象，并设置到BeanWrapperImpl中
287         bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
288         return bw;
289     }

分析：

由于该方法实在是太长了，因此对其进行分段分析。

#1 首先初始化了BeanwrapperImpl，需确认工厂对象，获取工厂名称，如果工厂名不为null，则走如下流程：

 1       String factoryBeanName = mbd.getFactoryBeanName();
 2         // 工厂名不为空
 3         if (factoryBeanName != null) {
 4             // 如果工厂名和beanName相等，则抛出BeanDefinitionStoreException异常
 5             if (factoryBeanName.equals(beanName)) {
 6                 throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
 7                                                        "factory-bean reference points back to the same bean definition");
 8             }
 9             // 获取工厂实例
10             factoryBean = this.beanFactory.getBean(factoryBeanName);
11             // 如果是单例模式，并且已经缓存中已经存在beanName则抛出异常
12             if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
13                 throw new ImplicitlyAppearedSingletonException();
14             }
15             factoryClass = factoryBean.getClass();
16             isStatic = false;
17         }

分析：

如果factoryBeanName与beanName一样，则抛出BeanDefinitionStoreException异常。
然后通过AbstractBeanFactory#getBean方法获取工厂实例对象。
如果BeanDefinition为单例模式，且singletonObjects缓存中已经存在该bean对象了，则抛出异常。因为单例模式下且缓存中存在是不需要再次创建bean对象的，单例模式的bean只会实例化一次。

如果工厂名为null，则走如下分支：

 1      else {
 2             // 工厂名为空，则其可能是一个静态工厂
 3             // 静态工厂创建bean，必须要提供工厂的全类名
 4             // It's a static factory method on the bean class.
 5             if (!mbd.hasBeanClass()) {
 6                 throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
 7                                                        "bean definition declares neither a bean class nor a factory-bean reference");
 8             }
 9             factoryBean = null;
10             factoryClass = mbd.getBeanClass();
11             isStatic = true;
12         }

分析：

如果BeanDefinition中没有解析类，则抛出异常，异常信息也描述得非常清晰："bean definition的描述中既没有bean class也没有工厂的引用。
将factoryClass设置为BeanDefinition的beanClass，并将isStatic=true，表明可能存在一个静态工厂。

#2 工厂对象确认后，需确认构造参数。

#2.1 如果explicitArgs存在，则直接使用该参数。explicitArgs是调用getBean方法的入参，如果该参数不为null，则可以确定构造函数的参数就是它了。

1     // 确定构造参数
2         // 如果getBean()已传递，则直接使用
3         if (explicitArgs != null) {
4             argsToUse = explicitArgs;
5         }

#2.2 如果未传入构造参数，则走如下分支：

 1 else {
 2             // 没有指定，则尝试从缓存中获取
 3             Object[] argsToResolve = null;
 4             // 同步
 5             synchronized (mbd.constructorArgumentLock) {
 6                 // 获取缓存中的构造函数或者工厂方法
 7                 factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
 8                 if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
 9                     // 获取缓存中的构造参数
10                     // Found a cached factory method...
11                     argsToUse = mbd.resolvedConstructorArguments;
12                     if (argsToUse == null) {
13                         argsToResolve = mbd.preparedConstructorArguments;
14                     }
15                 }
16             }
17             // 缓存中存在，则解析存储在BeanDefinition中的参数
18             // 如给定方法的构造函数 f(int ,int),通过此方法后就会把配置文件中的("1","1")转换为(1,1)
19             // 缓存中的值可能是原始值，也可能是最终值
20             if (argsToResolve != null) {
21                 argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
22             }
23         }

分析：

整个流程其实就是尝试从缓存中获取构造函数参数，如果存在则通过resolvePreparedArguments进行转换，由于缓存中的值可能是最终值，也可能不是最终值。比如构造函数中的类型为Integer类型的1，但缓存中的类型有可能是String类型的"1"，所以即便是从缓存中得到了构造参数，也需要经过一番的类型转换才能确保参数类型完全对应。关于resolvePreparedArguments函数的解析，将在后续文章中体现。

#2.3 如果缓存中未获取到构造参数，则走如下分支：

 1 if (factoryMethodToUse == null || argsToUse == null) {
 2             // Need to determine the factory method...
 3             // Try all methods with this name to see if they match the given arguments.
 4             // 获取工厂方法的类的全类名
 5             factoryClass = ClassUtils.getUserClass(factoryClass);
 6 
 7             List<Method> candidateList = null;
 8             // 同步
 9             if (mbd.isFactoryMethodUnique) {
10                 // 获取工厂方法
11                 if (factoryMethodToUse == null) {
12                     factoryMethodToUse = mbd.getResolvedFactoryMethod();
13                 }
14                 // 获取所有待定的工厂方法
15                 if (factoryMethodToUse != null) {
16                     candidateList = Collections.singletonList(factoryMethodToUse);
17                 }
18             }
19             // 如果工厂方法为空，则通过getCandidateMethods获取所有的待定方法
20             if (candidateList == null) {
21                 candidateList = new ArrayList<>();
22                 Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
23                 for (Method candidate : rawCandidates) {
24                     if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
25                         candidateList.add(candidate);
26                     }
27                 }
28             }
29 
30             // 通过工厂方法创建bean
31             if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
32                 Method uniqueCandidate = candidateList.get(0);
33                 if (uniqueCandidate.getParameterCount() == 0) {
34                     mbd.factoryMethodToIntrospect = uniqueCandidate;
35                     synchronized (mbd.constructorArgumentLock) {
36                         mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
37                         mbd.constructorArgumentsResolved = true;
38                         mbd.resolvedConstructorArguments = EMPTY_ARGS;
39                     }
40                     bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
41                     return bw;
42                 }
43             }

分析：

如果在缓存中未到构造参数，则尝试通过native方法获取工厂方法类的全类名，如果得到工厂方法只有一个时，则通过instantiate方法实例化bean，然后注入到BeanWrapperImpl中，直接返回。

instantiate方法会在后面进行分析。

#2.4 当上述分支都不满足，则走如下分支：通过提取配置文件中的信息来执行构建操作（代码还是有些长，分段来看）：

 1           Method[] candidates = candidateList.toArray(new Method[0]);
 2             // 排序构造函数
 3             // public构造函数优先参数数量降序，非public构造函数参数数量降序
 4             AutowireUtils.sortFactoryMethods(candidates);
 5 
 6             // 用于承载解析后的构造函数参数的值
 7             ConstructorArgumentValues resolvedValues = null;
 8             boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
 9             int minTypeDiffWeight = Integer.MAX_VALUE;
10             Set<Method> ambiguousFactoryMethods = null;
11 
12             int minNrOfArgs;
13             if (explicitArgs != null) {
14                 minNrOfArgs = explicitArgs.length;
15             } else {
16                 // We don't have arguments passed in programmatically, so we need to resolve the
17                 // arguments specified in the constructor arguments held in the bean definition.
18                 // getBean没有传递参数，则需要解析保存在BeanDefinition构造函数中指定的参数
19                 if (mbd.hasConstructorArgumentValues()) {
20                     // 构造函数参数
21                     ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
22                     resolvedValues = new ConstructorArgumentValues();
23                     // 解析构造函数参数
24                     // 将bean的构造函数解析为resolvedValues对象，其中会涉及到其他的bean
25                     minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
26                 } else {
27                     minNrOfArgs = 0;
28                 }
29             }

分析：

首先对工厂方法进行排序处理，排序规则：public工厂方法优先，参数数量降序，然后非public工厂方法优先，参数数量降序。
如果入参中带有构造参数，则直接获取构造参数的个数。
否则需从BeanDefinition中获取构造函数，并进行解析。xml配置文件的构造函数解析在加载BeanDefinition的过程中有提及。
然后通过resolveConstructorArguments解析构造函数，并返回构造参数的最小个数。resolveConstructorArguments函数目前这里不做分析。

#2.4.1 上步中确定了构造参数，接下来进行构造函数的确定：

 1           // 遍历candidates
 2             for (Method candidate : candidates) {
 3                 // 方法体参数
 4                 Class<?>[] paramTypes = candidate.getParameterTypes();
 5 
 6                 if (paramTypes.length >= minNrOfArgs) {
 7                     // 保存参数对象
 8                     ArgumentsHolder argsHolder;
 9                     // getBean()传递了参数
10                     if (explicitArgs != null) {
11                         // Explicit arguments given -> arguments length must match exactly.
12                         // 显示给定参数，参数长度必须完全匹配
13                         if (paramTypes.length != explicitArgs.length) {
14                             continue;
15                         }
16                         // 根据参数创建参数持有者ArgumentsHolder对象
17                         argsHolder = new ArgumentsHolder(explicitArgs);
18                     } else {
19                         // Resolved constructor arguments: type conversion and/or autowiring necessary.
20                         // 根据提供的参数，解析构造函数
21                         try {
22                             String[] paramNames = null;
23                             // 获取ParameterNameDiscoverer对象
24                             // ParameterNameDiscoverer用于解析方法和构造函数的参数名，为参数名称探测器
25                             ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
26                             // 获取指定构造函数的参数名
27                             if (pnd != null) {
28                                 paramNames = pnd.getParameterNames(candidate);
29                             }
30                             // 在已解析构造函数参数值的情况下，创建一个参数持有者ArgumentsHolder对象
31                             argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
32                                                              paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
33                         } catch (UnsatisfiedDependencyException ex) {
34                             if (logger.isTraceEnabled()) {
35                                 logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
36                             }
37                             // Swallow and try next overloaded factory method.
38                             if (causes == null) {
39                                 causes = new LinkedList<>();
40                             }
41                             // 发生UnsatisfiedDependencyException异常，添加到causes中
42                             causes.add(ex);
43                             continue;
44                         }
45                     }
46 
47                     // isLenientConstructorResolution判断解析构造函数的时候是否以宽松模式还是严格模式
48                     // 宽松模式：使用具有"最接近的模式"进行匹配
49                     // 严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常
50                     int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
51                             argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
52                     // Choose this factory method if it represents the closest match.
53                     // 代表最接近的类型匹配，选择作为构造函数
54                     if (typeDiffWeight < minTypeDiffWeight) {
55                         factoryMethodToUse = candidate;
56                         argsHolderToUse = argsHolder;
57                         argsToUse = argsHolder.arguments;
58                         minTypeDiffWeight = typeDiffWeight;
59                         ambiguousFactoryMethods = null;
60                     }
61                     // Find out about ambiguity: In case of the same type difference weight
62                     // for methods with the same number of parameters, collect such candidates
63                     // and eventually raise an ambiguity exception.
64                     // However, only perform that check in non-lenient constructor resolution mode,
65                     // and explicitly ignore overridden methods (with the same parameter signature).
66                     // 如果具有相同参数数量的方法具有相同的类型差异权重，则收集此类型选项
67                     // 但是仅在非宽松模式构造函数解析模式下执行该检查，并显示忽略重写方法（具有相同的参数签名）
68                     else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
69                             !mbd.isLenientConstructorResolution() &&
70                             paramTypes.length == factoryMethodToUse.getParameterCount() &&
71                             !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
72                         // 查找多个可匹配的方法
73                         if (ambiguousFactoryMethods == null) {
74                             ambiguousFactoryMethods = new LinkedHashSet<>();
75                             ambiguousFactoryMethods.add(factoryMethodToUse);
76                         }
77                         ambiguousFactoryMethods.add(candidate);
78                     }
79                 }
80             }

分析：

遍历所有构造函数。
如果方法体参数大于等于最小参数个数，则判断是否传入了构造参数，如果是，则根据入参创建参数持有者对象ArgumentsHolder；否则通过方法体获取指定构造函数的参数，并创建参数持有者对象ArgumentsHolder。
接着确定构造函数的解析是使用宽松模式还是严格模式。
严格模式：解析构造函数时，必须所有参数都需要匹配，否则抛出异常。
宽松模式：使用具有”最接近的模式”进行匹配。

#3.在参数与工厂构造函数确认好后，就可以进行bean的实例化了

 1 // 没有可执行的工厂方法，则抛出异常
 2             if (factoryMethodToUse == null || argsToUse == null) {
 3                 if (causes != null) {
 4                     UnsatisfiedDependencyException ex = causes.removeLast();
 5                     for (Exception cause : causes) {
 6                         this.beanFactory.onSuppressedException(cause);
 7                     }
 8                     throw ex;
 9                 }
10                 List<String> argTypes = new ArrayList<>(minNrOfArgs);
11                 if (explicitArgs != null) {
12                     for (Object arg : explicitArgs) {
13                         argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
14                     }
15                 } else if (resolvedValues != null) {
16                     Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
17                     valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
18                     valueHolders.addAll(resolvedValues.getGenericArgumentValues());
19                     for (ValueHolder value : valueHolders) {
20                         String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
21                                 (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
22                         argTypes.add(argType);
23                     }
24                 }
25                 String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
26                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
27                                                 "No matching factory method found: " +
28                                                         (mbd.getFactoryBeanName() != null ?
29                                                                 "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
30                                                         "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
31                                                         "Check that a method with the specified name " +
32                                                         (minNrOfArgs > 0 ? "and arguments " : "") +
33                                                         "exists and that it is " +
34                                                         (isStatic ? "static" : "non-static") + ".");
35             } else if (void.class == factoryMethodToUse.getReturnType()) {
36                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
37                                                 "Invalid factory method '" + mbd.getFactoryMethodName() +
38                                                         "': needs to have a non-void return type!");
39             } else if (ambiguousFactoryMethods != null) {
40                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
41                                                 "Ambiguous factory method matches found in bean '" + beanName + "' " +
42                                                         "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
43                                                         ambiguousFactoryMethods);
44             }
45 
46             // 将解析的构造函数加入缓存
47             if (explicitArgs == null && argsHolderToUse != null) {
48                 mbd.factoryMethodToIntrospect = factoryMethodToUse;
49                 argsHolderToUse.storeCache(mbd, factoryMethodToUse);
50             }
51         }
52 
53         // 创建bean对象，并设置到BeanWrapperImpl中
54         bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
55         return bw;

分析：

如果工厂方法为空或构造参数为空，经过一系列异常判断后，最后会将解析的构造函数加入缓存。
然后通过instantiate方法创建bean对象，并注入到BeanWrapperImpl中，最后返回bw。

 1 // ConstructorResolver
 2 
 3     public void storeCache(RootBeanDefinition mbd, Executable constructorOrFactoryMethod) {
 4             synchronized (mbd.constructorArgumentLock) {
 5                 mbd.resolvedConstructorOrFactoryMethod = constructorOrFactoryMethod;
 6                 mbd.constructorArgumentsResolved = true;
 7                 if (this.resolveNecessary) {
 8                     mbd.preparedConstructorArguments = this.preparedArguments;
 9                 } else {
10                     mbd.resolvedConstructorArguments = this.arguments;
11                 }
12             }
13         }
14 
15 // RootBeanDefinition.java
16       /**
17      * 构造函数的缓存锁
18      * Common lock for the four constructor fields below.
19      */
20     final Object constructorArgumentLock = new Object();
21 
22     /**
23      * 缓存已经解析的构造函数或工厂方法<br/>
24      * Package-visible field for caching the resolved constructor or factory method.
25      */
26     @Nullable
27     Executable resolvedConstructorOrFactoryMethod;
28 
29     /**
30      * 标记字段：标记构造函数、参数是否已经解析，默认为false<br/>
31      * Package-visible field that marks the constructor arguments as resolved.
32      */
33     boolean constructorArgumentsResolved = false;
34 
35     /**
36      * 缓存已经解析的构造函数参数，包括可见字段<br/>
37      * Package-visible field for caching fully resolved constructor arguments.
38      */
39     @Nullable
40     Object[] resolvedConstructorArguments;

分析：

这里就是将构造函数、构造参数进行缓存，也就是最开始为什么要从缓存中获取的原因。

ConstructorResolver#instantiate

 1 private Object instantiate(String beanName, RootBeanDefinition mbd,
 2                                @Nullable Object factoryBean, Method factoryMethod, Object[] args) {
 3 
 4         try {
 5 
 6             if (System.getSecurityManager() != null) {
 7                 return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
 8                                                              this.beanFactory.getInstantiationStrategy().instantiate(
 9                                                                      mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
10                                                      this.beanFactory.getAccessControlContext());
11             } else {
12                 return this.beanFactory.getInstantiationStrategy().instantiate(
13                         mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
14             }
15         } catch (Throwable ex) {
16             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
17                                             "Bean instantiation via factory method failed", ex);
18         }
19     }

分析：

该方法就是创建bean对象的方法，这里会委托调用SimpleInstantiationStrategy#instantiate方法。

 1 public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
 2                               @Nullable Object factoryBean, final Method factoryMethod, Object... args) {
 3 
 4         try {
 5             // 设置method可访问
 6             if (System.getSecurityManager() != null) {
 7                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
 8                     ReflectionUtils.makeAccessible(factoryMethod);
 9                     return null;
10                 });
11             } else {
12                 ReflectionUtils.makeAccessible(factoryMethod);
13             }
14 
15             // 获得原method对象
16             Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
17             try {
18                 // 设置新的method对象到currentlyInvokedFactoryMethod中
19                 currentlyInvokedFactoryMethod.set(factoryMethod);
20                 // 创建bean对象 通过反射执行工厂方法并返回创建的bean对象
21                 Object result = factoryMethod.invoke(factoryBean, args);
22                 // 未创建，则创建NullBean对象
23                 if (result == null) {
24                     result = new NullBean();
25                 }
26                 return result;
27             } finally {
28                 // 设置老的method对象到currentlyInvokedFactoryMethod中
29                 if (priorInvokedFactoryMethod != null) {
30                     currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
31                 } else {
32                     currentlyInvokedFactoryMethod.remove();
33                 }
34             }
35         } catch (IllegalArgumentException ex) {
36             throw new BeanInstantiationException(factoryMethod,
37                                                  "Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
38                                                          "args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
39         } catch (IllegalAccessException ex) {
40             throw new BeanInstantiationException(factoryMethod,
41                                                  "Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
42         } catch (InvocationTargetException ex) {
43             String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
44             if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
45                     ((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
46                 msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
47                         "declaring the factory method as static for independence from its containing instance. " + msg;
48             }
49             throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
50         }
51     }

分析：

首先设置方法的可访问性。
然后更新currentlyInvokedFactoryMethod缓存的方法。
核心点是通过反射执行工厂方法创建bean对象。
最后再次更新currentlyInvokedFactoryMethod。

至此通过工厂方法实例化Bean对象的过程分析完毕，真的是不容易，当然文中还有些方法未详细分析，后续再进行查漏补缺。

总结

instantiateUsingFactoryMethod方法体很大，但是其核心点就是确定工厂对象，获取构造函数和构造参数，最后通过SimpleInstantiationStrategy#instantiate反射执行工厂方法创建bean对象。

by Shawn Chen，2019.04.24日，下午。

posted @ 2019-04-24 16:52 developer_chan 阅读(1096) 评论(0) 编辑收藏举报

刷新页面返回顶部

developer

【spring源码分析】IOC容器初始化（九）

AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod

ConstructorResolver#instantiate

总结

=========================================================

比你优秀的人比你还努力，你有什么资格不去奋斗！

__一个有理想的程序员。

=========================================================