解密Spring中的Bean实例化：推断构造方法（上）

在Spring中，一个bean需要通过实例化来获取一个对象，而实例化的过程涉及到构造方法的调用。本文将主要探讨简单的构造推断和实例化过程，让我们首先深入了解实例化的步骤。
实例化源码

1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
2.     // Make sure bean class is actually resolved at this point.
3.     Class<?> beanClass = resolveBeanClass(mbd, beanName);
5.     .....
7.     // BeanDefinition中添加了Supplier，则调用Supplier来得到对象
8.     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
9.     if (instanceSupplier != null) {
10.         return obtainFromSupplier(instanceSupplier, beanName);
11.     }
13.     // @Bean对应的BeanDefinition
14.     if (mbd.getFactoryMethodName() != null) {
15.         return instantiateUsingFactoryMethod(beanName, mbd, args);
16.     }
18.     // Shortcut when re-creating the same bean...
19.     // 一个原型BeanDefinition，会多次来创建Bean，那么就可以把该BeanDefinition所要使用的构造方法缓存起来，避免每次都进行构造方法推断
20.     boolean resolved = false;
21.     boolean autowireNecessary = false;
22.     if (args == null) {
23.         synchronized (mbd.constructorArgumentLock) {
24.             if (mbd.resolvedConstructorOrFactoryMethod != null) {
25.                 resolved = true;
26.                 // autowireNecessary表示有没有必要要进行注入，比如当前BeanDefinition用的是无参构造方法，那么autowireNecessary为false，否则为true，表示需要给构造方法参数注入值
27.                 autowireNecessary = mbd.constructorArgumentsResolved;
28.             }
29.         }
30.     }
31.     if (resolved) {
32.         // 如果确定了当前BeanDefinition的构造方法，那么看是否需要进行对构造方法进行参数的依赖注入（构造方法注入）
33.         if (autowireNecessary) {
34.             // 方法内会拿到缓存好的构造方法的入参
35.             return autowireConstructor(beanName, mbd, null, null);
36.         }
37.         else {
38.             // 构造方法已经找到了，但是没有参数，那就表示是无参，直接进行实例化
39.             return instantiateBean(beanName, mbd);
40.         }
41.     }
43.     // 如果没有找过构造方法，那么就开始找了
45.     // Candidate constructors for autowiring?
46.     // 提供一个扩展点，可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法
47.     // 比如AutowiredAnnotationBeanPostProcessor会把加了@Autowired注解的构造方法找出来，具体看代码实现会更复杂一点
48.     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
50.     // 如果推断出来了构造方法，则需要给构造方法赋值，也就是给构造方法参数赋值，也就是构造方法注入
51.     // 如果没有推断出来构造方法，但是autowiremode为AUTOWIRE_CONSTRUCTOR，则也可能需要给构造方法赋值，因为不确定是用无参的还是有参的构造方法
52.     // 如果通过BeanDefinition指定了构造方法参数值，那肯定就是要进行构造方法注入了
53.     // 如果调用getBean的时候传入了构造方法参数值，那肯定就是要进行构造方法注入了
54.     if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
55.             mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
56.         return autowireConstructor(beanName, mbd, ctors, args);
57.     }
59.     // Preferred constructors for default construction?
60.     ctors = mbd.getPreferredConstructors();
61.     if (ctors != null) {
62.         return autowireConstructor(beanName, mbd, ctors, null);
63.     }
65.     // No special handling: simply use no-arg constructor.
66.     // 不匹配以上情况，则直接使用无参构造方法
67.     return instantiateBean(beanName, mbd);
68. }

复制代码

在Spring框架中的AbstractAutowireCapableBeanFactory类中的createBeanInstance()方法是用来执行实例化Bean对象的操作，该方法会根据Bean界说信息和配置选项，颠末一系列步骤和逻辑判断，终极创建一个全新的Bean实例。大抵步骤如下：

• 根据BeanDefinition加载类并获取对应的Class对象
  
• 如果BeanDefinition绑定了一个Supplier，那么应调用Supplier的get方法以获取一个对象，并将其直接返回。
  
• 如果在BeanDefinition中存在factoryMethodName属性，则调用该工厂方法以获取一个bean对象，并将其返回。
  
• 如果BeanDefinition已经自动构造过了，那么就调用autowireConstructor()方法来自动构造一个对象。
  
• 调用SmartInstantiationAwareBeanPostProcessor接口的determineCandidateConstructors()方法，以确定哪些构造方法是可用的。
  
• 如果存在可用的构造方法，大概当前BeanDefinition的autowired属性设置为AUTOWIRE_CONSTRUCTOR，大概BeanDefinition中指定了构造方法参数值，大概在创建Bean时指定了构造方法参数值，那么将调用autowireConstructor()方法来自动构造一个对象。
  
• 最后，如果不符合前述环境，那么将根据不带参数的构造方法来实例化一个对象。
  

推断构造方法

我们看下源码：

1. public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
2.         throws BeanCreationException {
3.   //前面跟@Lookup相关，我们不看
4.     .....
6.     // Quick check on the concurrent map first, with minimal locking.
7.     Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
8.     if (candidateConstructors == null) {
9.         // Fully synchronized resolution now...
10.         synchronized (this.candidateConstructorsCache) {
11.             candidateConstructors = this.candidateConstructorsCache.get(beanClass);
12.             if (candidateConstructors == null) {
13.                 Constructor<?>[] rawCandidates;
14.                 try {
15.                     // 拿到所有的构造方法
16.                     rawCandidates = beanClass.getDeclaredConstructors();
17.                 }
18.                 catch (Throwable ex) {
19.                     throw new BeanCreationException(beanName,
20.                             "Resolution of declared constructors on bean Class [" + beanClass.getName() +
21.                             "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
22.                 }
23.                 List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
25.                 // 用来记录required为true的构造方法，一个类中只能有一个required为true的构造方法
26.                 Constructor<?> requiredConstructor = null;
27.                 // 用来记录默认无参的构造方法
28.                 Constructor<?> defaultConstructor = null;
29.                 ......
30.                 int nonSyntheticConstructors = 0;
32.                 // 遍历每个构造方法
33.                 for (Constructor<?> candidate : rawCandidates) {
34.                     if (!candidate.isSynthetic()) {
35.                         // 记录一下普通的构造方法
36.                         nonSyntheticConstructors++;
37.                     }
38.                     else if (primaryConstructor != null) {
39.                         continue;
40.                     }
42.                     // 当前遍历的构造方法是否写了@Autowired
43.                     MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
44.                     if (ann == null) {
45.                         // 如果beanClass是代理类，则得到被代理的类的类型,我们不看这种情况
46.                         .......
47.                     }
49.                     // 当前构造方法上加了@Autowired
50.                     if (ann != null) {
51.                         // 整个类中如果有一个required为true的构造方法，那就不能有其他的加了@Autowired的构造方法
52.                         if (requiredConstructor != null) {
53.                             throw new BeanCreationException(beanName,
54.                                     "Invalid autowire-marked constructor: " + candidate +
55.                                     ". Found constructor with 'required' Autowired annotation already: " +
56.                                     requiredConstructor);
57.                         }
59.                         boolean required = determineRequiredStatus(ann);
60.                         if (required) {
61.                             if (!candidates.isEmpty()) {
62.                                 throw new BeanCreationException(beanName,
63.                                         "Invalid autowire-marked constructors: " + candidates +
64.                                         ". Found constructor with 'required' Autowired annotation: " +
65.                                         candidate);
66.                             }
67.                             // 记录唯一一个required为true的构造方法
68.                             requiredConstructor = candidate;
69.                         }
70.                         // 记录所有加了@Autowired的构造方法，不管required是true还是false
71.                         // 如果默认无参的构造方法上也加了@Autowired，那么也会加到candidates中
72.                         candidates.add(candidate);
74.                         // 从上面代码可以得到一个结论，在一个类中，要么只能有一个required为true的构造方法，要么只能有一个或多个required为false的方法
75.                     }
76.                     else if (candidate.getParameterCount() == 0) {
77.                         // 记录唯一一个无参的构造方法
78.                         defaultConstructor = candidate;
79.                     }
81.                     // 有可能存在有参、并且没有添加@Autowired的构造方法
82.                 }
85.                 if (!candidates.isEmpty()) {
86.                     // Add default constructor to list of optional constructors, as fallback.
87.                     // 如果不存在一个required为true的构造方法，则所有required为false的构造方法和无参构造方法都是合格的
88.                     if (requiredConstructor == null) {
89.                         if (defaultConstructor != null) {
90.                             candidates.add(defaultConstructor);
91.                         }
92.                         else if (candidates.size() == 1 && logger.isInfoEnabled()) {
93.                             logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
94.                                     "': single autowire-marked constructor flagged as optional - " +
95.                                     "this constructor is effectively required since there is no " +
96.                                     "default constructor to fall back to: " + candidates.get(0));
97.                         }
98.                     }
99.                     // 如果只存在一个required为true的构造方法，那就只有这一个是合格的
100.                     candidateConstructors = candidates.toArray(new Constructor<?>[0]);
101.                 }
102.                 // 没有添加了@Autowired注解的构造方法，并且类中只有一个构造方法，并且是有参的
103.                 else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
104.                     candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
105.                 }
106.                 ......
107.                 else {
108.                     // 如果有多个有参、并且没有添加@Autowired的构造方法，是会返回空的
109.                     candidateConstructors = new Constructor<?>[0];
110.                 }
111.                 this.candidateConstructorsCache.put(beanClass, candidateConstructors);
112.             }
113.         }
114.     }
115.     return (candidateConstructors.length > 0 ? candidateConstructors : null);
116. }

复制代码

接下来，让我们更深入地探讨推断构造方法，并且我还简单绘制了一张图示。

通常环境下，一个类通常只包含一个构造方法：
要么是无参的构造方法，要么是有参的构造方法。
如果一个类只有一个无参构造方法，那么在实例化时只能使用这个构造方法；而如果一个类只有一个有参构造方法，实例化时是否可以使用这个构造方法则取决于具体环境：

• 使用AnnotationConfigApplicationContext举行实例化时，Spring会根据构造方法的参数信息去寻找对应的bean，并将找到的bean传递给构造方法。这样可以实现依赖注入，确保实例化的对象具有所需的依赖项。
  
• 当使用ClassPathXmlApplicationContext时，表明使用XML配置文件的方式来界说bean。在XML中，可以手动指定构造方法的参数值来实例化对象，也可以通过配置autowire=constructor属性，让Spring自动根据构造方法的参数类型去寻找对应的bean作为参数值，实现自动装配。
  

上面是只有一个构造方法的环境，那么如果一个类存在多个构造方法，那么Spring举行实例化之前，该如何去确定到底用哪个构造方法呢？

• 如果开发者明确界说了他们想要使用的构造方法，那么程序将会优先使用这个构造方法。
  
• 如果开发者没有明确指定他们想要使用的构造方法，体系会自动检查开发者是否已经配置了让Spring框架自动选择构造方法的选项。
  
• 如果开发者没有显式地指定让Spring框架自动选择构造方法的环境下，Spring将会默认尝试使用无参构造方法。如果目标类中没有无参构造方法，则体系将会抛出错误提示。
  

针对第一点，开发者可以通过什么方式来指定使用哪个构造方法呢？

• 在XML中，标签用于表示构造方法的参数。开发者可以根据这个标签确定所需使用的构造方法的参数个数，从而精确指定想要使用的构造方法。
  
• 通过@Autowired注解，我们可以在构造方法上使用@Autowired注解。因此，当我们在特定构造方法上使用@Autowired注解时，表示开发者希望使用该构造方法。与通过xml方式直接指定构造方法参数值的方式不同，@Autowired注解方式需要Spring通过byType+byName的方式来查找符合条件的bean作为构造方法的参数值。
  
• 当然，还有一种环境需要思量，即当多个构造方法上都标注了@Autowired注解时，此时Spring会抛出错误。然而，由于@Autowired注解具有一个required属性，默认值为true，因此在一个类中只能有一个构造方法标注了@Autowired大概@Autowired(required=true)，否则会导致错误。不外，可以有多个构造方法标注@Autowired(required=false)。在这种环境下，Spring会自动从这些构造方法中选择一个举行注入。
  

在第二种环境下，如果开发者没有明确指定要使用的构造方法，Spring将尝试自动选择一个符合的构造方法举行注入。这种环境下，只能通过ClassPathXmlApplicationContext实现，由于使用AnnotationConfigApplicationContext无法指定让Spring自动选择构造方法。通过ClassPathXmlApplicationContext，可以在XML配置文件中指定某个bean的autowire属性为constructor，从而告诉Spring可以自动选择构造方法。
总结

在Spring中，实例化Bean对象涉及构造方法的调用。通过分析源码，我们了解到实例化的步骤和推断构造方法的过程。当一个类只有一个构造方法时，Spring会根据具体环境决定是否使用该构造方法。如果一个类存在多个构造方法，就需要根据具体环境具体分析。本文简单判断了哪些构造方法是符合实例化的，但在存在多个符合条件的构造方法时，具体使用哪个构造方法尚未讨论。因此，我筹划单独写一篇文章来详细讨论这个问题。毕竟是太复杂了。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。