Spring 如何选择类构造器

@Component
public class IndexService {
   @Autowired
   OrderDao orderDao;
   public IndexService() {
   }
   public IndexService(OrderDao orderDao) {
      this.orderDao = orderDao;
   }
   public IndexService(OrderDao orderDao, Luban luban) {
   }
}


@Component
public class IndexService {
   @Autowired
   OrderDao orderDao;
   public IndexService(OrderDao orderDao) {
      this.orderDao = orderDao;
   }
   public IndexService(OrderDao orderDao, Luban luban) {
   }
}


protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // Make sure bean class is actually resolved at this point.
   Class<?> beanClass = resolveBeanClass(mbd, beanName);
   /**
    * 检测一个类的访问权限spring默认情况下对于非public的类是允许访问的。
    */
   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
   }
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }
   /**
    *
    * 如果工厂方法不为空，则通过工厂方法构建 bean 对象
    @Bean其实就是通过这种方法来实例化的
    */
   if (mbd.getFactoryMethodName() != null)  {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }
   // Shortcut when re-creating the same bean...
   /**
    * 从spring的原始注释可以知道这个是一个Shortcut，什么意思呢？
    * 当多次构建同一个 bean 时，可以使用这个Shortcut，
    * 也就是说不在需要次推断应该使用哪种方式构造bean
    *  比如在多次构建同一个prototype类型的 bean 时，就可以走此处的hortcut
    * 这里的 resolved 和 mbd.constructorArgumentsResolved 将会在 bean 第一次实例化的过程中被设置
    */
   boolean resolved = false;
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            //如果已经解析了构造方法的参数，则必须要通过一个带参构造方法来实例
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   if (resolved) {
      if (autowireNecessary) {
         // 通过构造方法自动装配的方式构造 bean 对象
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         //通过默认的无参构造方法进行
         return instantiateBean(beanName, mbd);
      }
   }
   // Candidate constructors for autowiring?
   //由后置处理器决定返回哪些构造方法
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
      return autowireConstructor(beanName, mbd, ctors, args);
   }
   // No special handling: simply use no-arg constructor.
   //使用默认的无参构造方法进行初始化
   return instantiateBean(beanName, mbd);
}


public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
      throws BeanCreationException {
   // Let's check for lookup methods here..
   /**
    * 处理含有@Lookup注解的方法
    * 如果集合中没有BeanName，则走一遍Bean中所有的方法，过滤是否含有Lookup方法
    */
   if (!this.lookupMethodsChecked.contains(beanName)) {
      try {
         /**
          * 在方法中循环过滤所有的方法
          */
         ReflectionUtils.doWithMethods(beanClass, method -> {
            /**
             * 获取method上的@Lookup注解
             */
            Lookup lookup = method.getAnnotation(Lookup.class);
            /**
             * 存在此注解的话，就将方法和注解中的内容构建LookupOverride对象，设置进BeanDefinition中
             */
            if (lookup != null) {
               Assert.state(this.beanFactory != null, "No BeanFactory available");
               LookupOverride override = new LookupOverride(method, lookup.value());
               try {
                  RootBeanDefinition mbd = (RootBeanDefinition) this.beanFactory.getMergedBeanDefinition(beanName);
                  mbd.getMethodOverrides().addOverride(override);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(beanName,
                        "Cannot apply @Lookup to beans without corresponding bean definition");
               }
            }
         });
      }
      catch (IllegalStateException ex) {
         throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
      }
      /**
       * 无论对象中是否含有@Lookup方法，过滤完成后都会放到集合中，证明此Bean已经检查完@Lookup注解了
       */
      this.lookupMethodsChecked.add(beanName);
   }
   // Quick check on the concurrent map first, with minimal locking.
   /**
    * 从缓存中拿构造函数，不存在的话就进入代码块中再拿一遍，还不存在的话就进行下方的逻辑
    * 双重检查
    */
   Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
   if (candidateConstructors == null) {
      // Fully synchronized resolution now...
      synchronized (this.candidateConstructorsCache) {
         candidateConstructors = this.candidateConstructorsCache.get(beanClass);
         if (candidateConstructors == null) {
            Constructor<?>[] rawCandidates;
            try {
               //获取所有构造函数
               rawCandidates = beanClass.getDeclaredConstructors();
            }
            catch (Throwable ex) {
               throw new BeanCreationException(beanName,
                     "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                     "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
            }
            /**
             * 候选构造函数列表
             */
            List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
            /**
             * 用户指定的必须用的构造函数
             */
            Constructor<?> requiredConstructor = null;
            /**
             * 默认用的构造函数
             * (其实就是无参构造)
             */
            Constructor<?> defaultConstructor = null;
            /**
             * 这个不知道什么鬼，看代码是只会在Kotlin语言中存在
             */
            Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
            /**
             * 构造方法数量计数
             */
            int nonSyntheticConstructors = 0;
            for (Constructor<?> candidate : rawCandidates) {
               if (!candidate.isSynthetic()) {
                  nonSyntheticConstructors++;
               }
               else if (primaryConstructor != null) {
                  continue;
               }
               //find加了@Autowired的构造函数
               AnnotationAttributes ann = findAutowiredAnnotation(candidate);
               /**
                * 注解不存在,则再通过方法获取用户类，如果是用户类则返回用户类，还判断了CGLIB情况，
                * CGLIB情况则返回目标类，然后获取参数一致的构造函数再获取注解
                */
               if (ann == null) {
                  Class<?> userClass = ClassUtils.getUserClass(beanClass);
                  if (userClass != beanClass) {
                     try {
                        Constructor<?> superCtor =
                              userClass.getDeclaredConstructor(candidate.getParameterTypes());
                        ann = findAutowiredAnnotation(superCtor);
                     }
                     catch (NoSuchMethodException ex) {
                        // Simply proceed, no equivalent superclass constructor found...
                     }
                  }
               }
               /**
                * 构造函数上存在注解
                */
               if (ann != null) {
                  if (requiredConstructor != null) {
                     throw new BeanCreationException(beanName,
                           "Invalid autowire-marked constructor: " + candidate +
                           ". Found constructor with 'required' Autowired annotation already: " +
                           requiredConstructor);
                  }
                  /**
                   * 获取@Autowired注解中required属性的值
                   * 值得注意的是如果是默认的即没加required
                   * 这里返回的也会是true
                   */
                  boolean required = determineRequiredStatus(ann);
                  if (required) {
                     if (!candidates.isEmpty()) {
                        throw new BeanCreationException(beanName,
                              "Invalid autowire-marked constructors: " + candidates +
                              ". Found constructor with 'required' Autowired annotation: " +
                              candidate);
                     }
                     requiredConstructor = candidate;
                  }
                  candidates.add(candidate);
               }
               else if (candidate.getParameterCount() == 0) {
                  defaultConstructor = candidate;
               }
            }
            /**
             * 不为空，则直接用candidates的
             */
            if (!candidates.isEmpty()) {
               // Add default constructor to list of optional constructors, as fallback.
               if (requiredConstructor == null) {
                  if (defaultConstructor != null) {
                     candidates.add(defaultConstructor);
                  }
                  else if (candidates.size() == 1 && logger.isWarnEnabled()) {
                     logger.warn("Inconsistent constructor declaration on bean with name '" + beanName +
                           "': single autowire-marked constructor flagged as optional - " +
                           "this constructor is effectively required since there is no " +
                           "default constructor to fall back to: " + candidates.get(0));
                  }
               }
               candidateConstructors = candidates.toArray(new Constructor<?>[0]);
            }
            /**
             * 如果只有一个构造函数，且参数个数大于0的。，那么就选用它
             */
            else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
               candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
            }
            /**
             * 如果有两个，然后primaryConstructor和defaultConstructor都不为null
             * 且两个不相等，则两个都作为返回值
             */
            else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
                  defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
               candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
            }
            /**
             * 如果只有primaryConstructor，且primaryConstructor不为null，则使用他
             */
            else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
               candidateConstructors = new Constructor<?>[] {primaryConstructor};
            }
            /**
             * 啥都不满足就是没有
             * 即Spring会用他自己的默认的构造函数(其实就是无参构造)
             */
            else {
               candidateConstructors = new Constructor<?>[0];
            }
            this.candidateConstructorsCache.put(beanClass, candidateConstructors);
         }
      }
   }
   return (candidateConstructors.length > 0 ? candidateConstructors : null);
}


@Component
public class IndexService {
   @Autowired
   OrderDao orderDao;
   public IndexService() {
   }
}


@Component
public class IndexService {
   @Autowired
   OrderDao orderDao;
   public IndexService(OrderDao orderDao) {
   }
}


@Component
public class IndexService {
   @Autowired
   OrderDao orderDao;
   public IndexService() {
   }
   @Autowired(required = false)
   public IndexService(OrderDao orderDao) {
      this.orderDao = orderDao;
   }
   @Autowired(required = false)
   public IndexService(OrderDao orderDao, Luban luban) {
   }
}