先说结论

  • 如果只提供了一个无参的构造方法：返回 null
  • 如果只提供了一个有参的构造方法：返回 1
  • 如果提供了多个 @Autowired

Spring 在推断构造方法的时候，如果提供了多个合格的构造方法，会使用哪一个构造方法来创建实例呢？

  1. public class IndexService {
  3.     public IndexService(){
  4.         System.out.println("IndexService using default constructor");
  5.     }
  7.     public IndexService(UserService userService){
  8.         System.out.println("IndexService using userService constructor");
  9.     }
  11.     public IndexService(UserService userService, OrderService orderService){
  12.         System.out.println("IndexService using userService & orderService constructor");
  13.     }
  14. }

答案是，使用默认的构造方法创建实例

如果在需要的构造方法上加上了注解 @Autowired 呢

  1. @Component
  2. public class IndexService {
  4.     public IndexService(){
  5.         System.out.println("IndexService using default constructor");
  6.     }
  8.     public IndexService(UserService userService){
  9.         System.out.println("IndexService using userService constructor");
  10.     }
  12.     @Autowired
  13.     public IndexService(UserService userService, OrderService orderService){
  14.         System.out.println("IndexService using userService & orderService constructor");
  15.     }
  16. }

答案是：很简单，既然你指定了需要注入的构造方法，我就使用你提供的构造方法

那么如果我想让 Spring 自动推断出最长参数的构造方法，除了使用 @Autowried 还有别的方法么？答案肯定是有的，那么我们就需要使用 BeanFactoryPostProcessor 了，利用他改变 AutowireMode 模型为 AUTOWIRE_CONSTRUCTOR，此时就能自动使用参数最长的构造方法了

  1. @Component
  2. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  4.     @Override
  5.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  6.         GenericBeanDefinition bd = (GenericBeanDefinition) beanFactory.getBeanDefinition("indexService");
  7.         bd.setAutowireMode(GenericBeanDefinition.AUTOWIRE_CONSTRUCTOR);
  8.     }
  9. }

Spring 是如果推断构造方法的

  1. Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  2. if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  3.     mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  4.     // 再次进行推断，并确定使用哪一个构造方法，并注入
  5.     return autowireConstructor(beanName, mbd, ctors, args);
  6. }

开始推断构造方法：处理实现了 SmartInstantiationAwareBeanPostProcessor 接口的后置处理器 AutowiredAnnotationBeanPostProcessor

1、提供了一个构造方法，是无参构造方法：
ctors == null

2、提供了一个构造方法，不是无参构造方法：
ctors = 1，会使用提供的构造方法，因为可以只能使用这个构造方法

3、提供了多个合格的构造方法，包括无参构造方法：
ctors == null，会调用无参构造方法，因为 spring 不知道应该利用那个构造方法装配

4、提供了多个合格的构造方法，不含无参构造方法，且都没有将其标明 @Autowired，且注入模式是 no：
ctors == null，然后抛出异常：No default constructor found

5、提供了多个合格的构造方法，不含无参构造方法，且都没有将其标明 @Autowired，且注入模式是 byConstructor：
ctors == null，找到参数值最长的合理的构造方法

6、提供了多个合格的构造方法，不含无参构造方法，且都将其标明 @Autowired(required=false)：
ctors != null，找到参数值最长的合理的构造方法

7、提供了多个合格的构造方法，至少有一个标明了 @Autowired(required=false)
ctors != null，会继续推断使用哪一个构造方法，通常为第一个解析到的构造方法（这里会参数长度排序）

8、提供了多个合格的构造方法，至少有一个标明了 @Autowired(required=true) 和 @Autowired(required=false)
直接报异常：Invalid autowire-marked constructor

文字不写了，看注释…

  1. @Override
  2. @Nullable
  3. public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
  4.     throws BeanCreationException {
  6.     // Let's check for lookup methods here...
  7.     // 是否检查过 lookup 方法
  8.     if (!this.lookupMethodsChecked.contains(beanName)) {
  9.         try {
  10.             ReflectionUtils.doWithMethods(beanClass, method -> {
  11.                 Lookup lookup = method.getAnnotation(Lookup.class);
  12.                 if (lookup != null) {
  13.                     Assert.state(this.beanFactory != null, "No BeanFactory available");
  14.                     LookupOverride override = new LookupOverride(method, lookup.value());
  15.                     try {
  16.                         RootBeanDefinition mbd = (RootBeanDefinition)
  17.                             this.beanFactory.getMergedBeanDefinition(beanName);
  18.                         mbd.getMethodOverrides().addOverride(override);
  19.                     }
  20.                     catch (NoSuchBeanDefinitionException ex) {
  21.                         throw new BeanCreationException(beanName,
  22.                                                         "Cannot apply @Lookup to beans without corresponding bean definition");
  23.                     }
  24.                 }
  25.             });
  26.         }
  27.         catch (IllegalStateException ex) {
  28.             throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
  29.         }
  30.         this.lookupMethodsChecked.add(beanName);
  31.     }
  33.     // Quick check on the concurrent map first, with minimal locking.
  34.     // ★ candidateConstructorsCache：存放已经被推断完成的类和该类被推断出来的构造方法的集合
  35.     // 检查当前的类是否在 candidateConstructorsCache 中已经存在了已经推断过的构造方法，如果被推断过，就直接拿出来使用
  36.     Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
  37.     if (candidateConstructors == null) {
  38.         // Fully synchronized resolution now...
  39.         synchronized (this.candidateConstructorsCache) {
  40.             candidateConstructors = this.candidateConstructorsCache.get(beanClass);
  41.             if (candidateConstructors == null) {
  42.                 Constructor<?>[] rawCandidates;
  43.                 try {
  44.                     // 拿到所有的构造方法
  45.                     rawCandidates = beanClass.getDeclaredConstructors();
  46.                 }
  47.                 catch (Throwable ex) {
  48.                     throw new BeanCreationException(beanName,
  49.                                                     "Resolution of declared constructors on bean Class [" + beanClass.getName() +
  50.                                                     "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
  51.                 }
  52.                 // 存放合格的构造方法，但是合格，并不代表都可用
  53.                 List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
  54.                 // 必要的构造方法，比如在构造方法上加 @Autowired
  55.                 Constructor<?> requiredConstructor = null;
  56.                 // 默认无参构造方法
  57.                 Constructor<?> defaultConstructor = null;
  58.                 // 推断主要的构造方法委托给 Kotlin，如果对于 Java 类，永远返回 null
  59.                 Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
  60.                 // 定义一个变量记录非合成的构造方法
  61.                 int nonSyntheticConstructors = 0;
  62.                 for (Constructor<?> candidate : rawCandidates) {
  63.                     if (!candidate.isSynthetic()) {
  64.                         nonSyntheticConstructors++;
  65.                     }
  66.                     else if (primaryConstructor != null) {
  67.                         continue;
  68.                     }
  69.                     // 检查构造方法上有没有 @Autowired 注解，并拿出 注解上的 属性
  70.                     AnnotationAttributes ann = findAutowiredAnnotation(candidate);
  71.                     // 没有 @Autowired 注解的情况
  72.                     if (ann == null) {
  73.                         // 看看 beanClass 是否是 CGLIB 代理类，并且是否有父类
  74.                         Class<?> userClass = ClassUtils.getUserClass(beanClass);
  75.                         if (userClass != beanClass) {
  76.                             try {
  77.                                 Constructor<?> superCtor =
  78.                                     userClass.getDeclaredConstructor(candidate.getParameterTypes());
  79.                                 ann = findAutowiredAnnotation(superCtor);
  80.                             }
  81.                             catch (NoSuchMethodException ex) {
  82.                                 // Simply proceed, no equivalent superclass constructor found...
  83.                             }
  84.                         }
  85.                     }
  86.                     // 有 @Autowired 注解的情况
  87.                     if (ann != null) {
  88.                         // 有注解，并且 @Autowired(required=true)，但是第一次肯定等于 null
  89.                         if (requiredConstructor != null) {
  90.                             throw new BeanCreationException(beanName,
  91.                                                             "Invalid autowire-marked constructor: " + candidate +
  92.                                                             ". Found constructor with 'required' Autowired annotation already: " +
  93.                                                             requiredConstructor);
  94.                         }
  95.                         // 推断注解上的值，也就是 required 的值
  96.                         boolean required = determineRequiredStatus(ann);
  97.                         if (required) {
  98.                             // 循环构造方法，如果发现多个 @Autowired 的构造方法，就会抛出异常
  99.                             if (!candidates.isEmpty()) {
  100.                                 throw new BeanCreationException(beanName,
  101.                                                                 "Invalid autowire-marked constructors: " + candidates +
  102.                                                                 ". Found constructor with 'required' Autowired annotation: " +
  103.                                                                 candidate);
  104.                             }
  105.                             // 给 requiredConstructor 赋值为 找到的构造方法
  106.                             requiredConstructor = candidate;
  107.                         }
  108.                         // 将构造方法放到 candidates 集合中
  109.                         candidates.add(candidate);
  110.                     }
  111.                     // 构造方法没有任何参数，说明是默认构造方法
  112.                     else if (candidate.getParameterCount() == 0) {
  113.                         defaultConstructor = candidate;
  114.                     }
  115.                 }
  116.                 if (!candidates.isEmpty()) {
  117.                     // Add default constructor to list of optional constructors, as fallback.
  118.                     if (requiredConstructor == null) {
  119.                         if (defaultConstructor != null) {
  120.                             candidates.add(defaultConstructor);
  121.                         }
  122.                         else if (candidates.size() == 1 && logger.isInfoEnabled()) {
  123.                             logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
  124.                                         "': single autowire-marked constructor flagged as optional - " +
  125.                                         "this constructor is effectively required since there is no " +
  126.                                         "default constructor to fall back to: " + candidates.get(0));
  127.                         }
  128.                     }
  129.                     // 推断多个构造方法
  130.                     candidateConstructors = candidates.toArray(new Constructor<?>[0]);
  131.                 }
  132.                 // 只提供了一个构造方法，并且是含参的
  133.                 else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
  134.                     candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
  135.                 }
  136.                 // 不会执行：primaryConstructor != null 是与 kotlin 相关，
  137.                 else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
  138.                          defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
  139.                     candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
  140.                 }
  141.                 // 不会执行：primaryConstructor != null 是与 kotlin 相关
  142.                 else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
  143.                     candidateConstructors = new Constructor<?>[] {primaryConstructor};
  144.                 }
  145.                 // 其他的情况，返回一个空集合
  146.                 else {
  147.                     candidateConstructors = new Constructor<?>[0];
  148.                 }
  149.                 // 将推断出来的构造方法存起来
  150.                 this.candidateConstructorsCache.put(beanClass, candidateConstructors);
  151.             }
  152.         }
  153.     }
  154.     // 返回多个构造方法的情况是：有多个 @Autowired(required=false)，才会成立
  155.     return (candidateConstructors.length > 0 ? candidateConstructors : null);
  156. }