推断构造流程

  1. if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  2. mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  3. return autowireConstructor(beanName, mbd, ctors, args);
  4. }
  1. public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
  2. @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
  3. BeanWrapperImpl bw = new BeanWrapperImpl();
  4. this.beanFactory.initBeanWrapper(bw);
  5. Constructor<?> constructorToUse = null;
  6. ArgumentsHolder argsHolderToUse = null;
  7. Object[] argsToUse = null;
  8. // 如果getBean()传入了args,那构造方法要用的入参就直接确定好了
  9. if (explicitArgs != null) {
  10. argsToUse = explicitArgs;
  11. }
  12. else {
  13. Object[] argsToResolve = null;
  14. synchronized (mbd.constructorArgumentLock) {
  15. constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
  16. if (constructorToUse != null && mbd.constructorArgumentsResolved) {
  17. // Found a cached constructor...
  18. argsToUse = mbd.resolvedConstructorArguments;
  19. if (argsToUse == null) {
  20. argsToResolve = mbd.preparedConstructorArguments;
  21. }
  22. }
  23. }
  24. if (argsToResolve != null) {
  25. argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
  26. }
  27. }
  28. // 如果没有确定要使用的构造方法,或者确定了构造方法但是所要传入的参数值没有确定
  29. if (constructorToUse == null || argsToUse == null) {
  30. // Take specified constructors, if any.
  31. // 如果没有指定构造方法,那就获取beanClass中的所有构造方法所谓候选者
  32. Constructor<?>[] candidates = chosenCtors;
  33. if (candidates == null) {
  34. Class<?> beanClass = mbd.getBeanClass();
  35. try {
  36. candidates = (mbd.isNonPublicAccessAllowed() ?
  37. beanClass.getDeclaredConstructors() : beanClass.getConstructors());
  38. }
  39. catch (Throwable ex) {
  40. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  41. "Resolution of declared constructors on bean Class [" + beanClass.getName() +
  42. "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
  43. }
  44. }
  45. // 如果只有一个候选构造方法,并且没有指定所要使用的构造方法参数值,并且该构造方法是无参的,那就直接用这个无参构造方法进行实例化了
  46. if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
  47. Constructor<?> uniqueCandidate = candidates[0];
  48. if (uniqueCandidate.getParameterCount() == 0) {
  49. synchronized (mbd.constructorArgumentLock) {
  50. mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
  51. mbd.constructorArgumentsResolved = true;
  52. mbd.resolvedConstructorArguments = EMPTY_ARGS;
  53. }
  54. bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
  55. return bw;
  56. }
  57. }
  58. // Need to resolve the constructor.
  59. boolean autowiring = (chosenCtors != null ||
  60. mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
  61. ConstructorArgumentValues resolvedValues = null;
  62. // 确定要选择的构造方法的参数个数的最小值,后续判断候选构造方法的参数个数如果小于minNrOfArgs,则直接pass掉
  63. int minNrOfArgs;
  64. if (explicitArgs != null) {
  65. // 如果直接传了构造方法参数值,那么所用的构造方法的参数个数肯定不能少于
  66. minNrOfArgs = explicitArgs.length;
  67. }
  68. else {
  69. // 如果通过BeanDefinition传了构造方法参数值,因为有可能是通过下标指定了,比如0位置的值,2位置的值,虽然只指定了2个值,但是构造方法的参数个数至少得是3个
  70. ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
  71. resolvedValues = new ConstructorArgumentValues();
  72. // 处理RuntimeBeanReference
  73. minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
  74. }
  75. // 对候选构造方法进行排序,public的方法排在最前面,都是public的情况下参数个数越多越靠前
  76. AutowireUtils.sortConstructors(candidates);
  77. int minTypeDiffWeight = Integer.MAX_VALUE;
  78. Set<Constructor<?>> ambiguousConstructors = null;
  79. Deque<UnsatisfiedDependencyException> causes = null;
  80. // 遍历每个构造方法,进行筛选
  81. for (Constructor<?> candidate : candidates) {
  82. // 参数个数
  83. int parameterCount = candidate.getParameterCount();
  84. // 本次遍历时,之前已经选出来了所要用的构造方法和入参对象,并且入参对象个数比当前遍历到的这个构造方法的参数个数多,则不用再遍历,退出循环
  85. if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
  86. // Already found greedy constructor that can be satisfied ->
  87. // do not look any further, there are only less greedy constructors left.
  88. break;
  89. }
  90. // 如果参数个数小于所要求的参数个数,则遍历下一个,这里考虑的是同时存在public和非public的构造方法
  91. if (parameterCount < minNrOfArgs) {
  92. continue;
  93. }
  94. ArgumentsHolder argsHolder;
  95. Class<?>[] paramTypes = candidate.getParameterTypes();
  96. // 没有通过getBean()指定构造方法参数值
  97. if (resolvedValues != null) {
  98. try {
  99. // 如果在构造方法上使用了@ConstructorProperties,那么就直接取定义的值作为构造方法的参数名
  100. String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
  101. // 获取构造方法参数名
  102. if (paramNames == null) {
  103. ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
  104. if (pnd != null) {
  105. paramNames = pnd.getParameterNames(candidate);
  106. }
  107. }
  108. // 根据参数类型、参数名找到对应的bean对象
  109. argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
  110. getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
  111. }
  112. catch (UnsatisfiedDependencyException ex) {
  113. // 当前正在遍历的构造方法找不到可用的入参对象,记录一下
  114. if (logger.isTraceEnabled()) {
  115. logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
  116. }
  117. // Swallow and try next constructor.
  118. if (causes == null) {
  119. causes = new ArrayDeque<>(1);
  120. }
  121. causes.add(ex);
  122. continue;
  123. }
  124. }
  125. else {
  126. // Explicit arguments given -> arguments length must match exactly.
  127. // 没有通过BeanDefinition指定构造方法参数值,但是在调getBean方法是传入了参数值,那就表示只能用对应参数个数的构造方法
  128. if (parameterCount != explicitArgs.length) {
  129. continue;
  130. }
  131. // 不用再去BeanFactory中查找bean对象了,已经有了,同时当前正在遍历的构造方法就是可用的构造方法
  132. argsHolder = new ArgumentsHolder(explicitArgs);
  133. }
  134. // 当前遍历的构造方法所需要的入参对象都找到了,根据参数类型和找到的参数对象计算出来一个匹配值,值越小越匹配
  135. // Lenient表示宽松模式
  136. int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
  137. argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
  138. // Choose this constructor if it represents the closest match.
  139. // 值越小越匹配
  140. if (typeDiffWeight < minTypeDiffWeight) {
  141. constructorToUse = candidate;
  142. argsHolderToUse = argsHolder;
  143. argsToUse = argsHolder.arguments;
  144. minTypeDiffWeight = typeDiffWeight;
  145. ambiguousConstructors = null;
  146. }
  147. // 值相等的情况下,记录一下匹配值相同的构造方法
  148. else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
  149. if (ambiguousConstructors == null) {
  150. ambiguousConstructors = new LinkedHashSet<>();
  151. ambiguousConstructors.add(constructorToUse);
  152. }
  153. ambiguousConstructors.add(candidate);
  154. }
  155. }
  156. // 遍历结束 x
  157. // 如果没有可用的构造方法,就取记录的最后一个异常并抛出
  158. if (constructorToUse == null) {
  159. if (causes != null) {
  160. UnsatisfiedDependencyException ex = causes.removeLast();
  161. for (Exception cause : causes) {
  162. this.beanFactory.onSuppressedException(cause);
  163. }
  164. throw ex;
  165. }
  166. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  167. "Could not resolve matching constructor on bean class [" + mbd.getBeanClassName() + "] " +
  168. "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
  169. }
  170. // 如果有可用的构造方法,但是有多个
  171. else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
  172. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  173. "Ambiguous constructor matches found on bean class [" + mbd.getBeanClassName() + "] " +
  174. "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
  175. ambiguousConstructors);
  176. }
  177. // 如果没有通过getBean方法传入参数,并且找到了构造方法以及要用的入参对象则缓存
  178. if (explicitArgs == null && argsHolderToUse != null) {
  179. argsHolderToUse.storeCache(mbd, constructorToUse);
  180. }
  181. }
  182. Assert.state(argsToUse != null, "Unresolved constructor arguments");
  183. bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
  184. return bw;
  185. }

Spring之推断构造方法源码解析 - 图1

推断构造方法不同情况总结

Spring之推断构造方法源码解析 - 图2
Spring中的一个Bean,需要实例化得到一个对象,而实例化就需要用到构造方法.
一般情况下,一个类只有一个构造方法:

  • 要么是无参构造
  • 要么是有参构造

如果只有一个无参构造,那么实例化就只能用这个无参构造
如果只有一个有参构造,那么实例化时能使用这个构造方法吗?我们需要分情况讨论:

  • 使用AnnotationConfigApplicationContext,会使用这个构造方法进行实例化,那么Spring会根据构造方法的参数信息去寻找Bean,然后传给构造方法
  • 使用ClassPathXmlApplicationContext,表示使用XML的方式来使用Bean,要么在XML中指定构造方法的参数值(手动换指定),要么配置autowire=constructor让Spring自动去寻找Bean作为构造方法的参数值

上面是只有一个构造方法的情况,那么如果有多个构造方法呢?
这里又分为两种情况,多个构造方法存不存在无参的构造方法
分析: 一个类存在多个构造方法,那么Spring进行实例化之前,该如何去确定到底用哪个构造方法呢?

  • 如果开发者指定了想要使用的构造方法,那么就用这个构造方法
  • 如果开发者没有指定想要使用的构造方法,就看开发者有没有让Spring自动去选择构造方法
  • 如果开发者也没有让Spring自动去选择构造方法,那么Spring利用无参构造方法,如果没有无参构造方法,就报错

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

  • XML中的标签,这个标签表示构造方法参数,所以可以根据这个确定想要使用的构造方法的参数个数,从而确定想要使用的构造方法
  • 通过@Autowired注解,@Autowired注解可以写在构造方法上,所以哪个构造方法上写了@Autowired注解,表示开发者想要使用哪个构造方法,当然,它和第一个方式的不同点就是,通过XML的方式,我们直接制定了构造方法的参数值,而通过@Autowired注解的方式,需要Spring通过byType+byName的方式去找到符合条件的Bean作为构造方法的参数值

再来看第二点,如果开发者没有指定想要使用的构造方法,那么就看开发者有没有让Spring自动去选择构造方法,对于这一点,只能用在ClassPathXmlApplicationContext,因为通过AnnotationConfigApplicationContext没有办法去指定某个Bean可以自动去选择构造方法,而通过ClassPathXmlApplicationContext可以在XML中指定某个Bean的autowire=constructor,虽然这个属性表示通过构造方法自动注入,但是需要自动的去选择一个构造方法进行自动注入,因为是构造方法,所以顺便会去进行实例化.
当然,还有一种情况,就是多个构造方法上写了@Autowired注解,那么此时Spring就会报错.
但是,因为@Autowired还有一个属性required,默认为true,所以一个类中,只有能一个构造方法标注了@Autowired或@Autowired(required=true),有多个@Autowired(required=false),这种情况下,需要Spring从这些构造方法中去自动选择一个构造方法.

AbstractAutowireCapableBeanFactory#createBeanInstance源码思路

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);
    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());
    }
    // BeanDefinition中添加了Supplier,则调用Supplier来得到对象
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }
    // @Bean对应的BeanDefinition
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    // Shortcut when re-creating the same bean...
    // 一个原型BeanDefinition,会多次来创建Bean,那么就可以把该BeanDefinition所要使用的构造方法缓存起来,避免每次都进行构造方法推断
    boolean resolved = false;
    boolean autowireNecessary = false;
    // 没有参数就会去看有没有入参值缓存, 给了参数就不会找缓存了
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                // autowireNecessary表示有没有必要要进行注入,比如当前BeanDefinition用的是无参构造方法,那么autowireNecessary为false,否则为true,表示需要给构造方法参数注入值
                // autowireNecessary 无参的话就是false
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    // 当前 已经缓存了构造方法入参值
    if (resolved) {
        // 如果确定了当前BeanDefinition的构造方法,那么看是否需要进行对构造方法进行参数的依赖注入(构造方法注入)
        if (autowireNecessary) {
            // 方法内会拿到缓存好的构造方法的入参
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            // 构造方法已经找到了,但是没有参数,那就表示是无参,直接进行实例化
            return instantiateBean(beanName, mbd);
        }
    }
    // 如果没有找过构造方法,那么就开始找了
    // Candidate constructors for autowiring?
    // 提供一个扩展点,可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法
    // 比如AutowiredAnnotationBeanPostProcessor会把加了@Autowired注解的构造方法找出来,具体看代码实现会更复杂一点
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    // 如果推断出来了构造方法,则需要给构造方法赋值,也就是给构造方法参数赋值,也就是构造方法注入
    // 如果没有推断出来构造方法,但是AutowireMode为AUTOWIRE_CONSTRUCTOR,则也可能需要给构造方法赋值,因为不确定是用无参的还是有参的构造方法
    // 如果通过BeanDefinition指定了构造方法参数值,那肯定就是要进行构造方法注入了
    // 如果调用getBean的时候传入了构造方法参数值,那肯定就是要进行构造方法注入了
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    // Preferred constructors for default construction?
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }
    // No special handling: simply use no-arg constructor.
    // 不匹配以上情况,则直接使用无参构造方法
    return instantiateBean(beanName, mbd);
}
  • AbstractAutowireCapableBeanFactory#createBeanInstance中会去创建一个Bean实例
  • 根据BeanDefinition加载类得到Class对象
  • 如果BeanDefinition绑定了一个Supplier,那就调用Supplier#get得到一个对象并且直接返回
  • 如果BeanDefinition中存在factoryMethodName.那么就调用工厂方法得到一个Bean对象并且返回
  • 如果BeanDefinition已经自动构造过了,那么就调用autowireConstructor自动构造一个对象
  • 调用SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors得到哪些构造方法是可以用的
  • 如果存在可用得到的构造方法,或者当前BeanDefinition的autowire=AUTOWIRE_CONSTRUCTOR,或者BeanDefinition中指定了构造方法参数值,或者创建Bean的时候指定了构造方法参数值,那么就调用autowireConstructor去自动构造一个对象
  • 最后,如果不是上面的情况,就根据无参构造去进行实例化一个对象

    ConstructorResolver#autowireConstructor

  • 先检查是否指定了具体的构造方法和构造方法参数值,或者在BeanDefinition中缓存了具体的构造方法或构造方法参数值,如果存在那么则直接使用该构造方法进行实例化

  • 如果没有确定的构造方法或构造方法参数值,那么
    • 如果没有确定的构造方法,那么则找出类中所有的构造方法
    • 如果只有一个无参的构造方法,那么直接使用无参的构造方法进行实例化
    • 如果有多个可用的构造方法或者当前Bean需要自动通过构造方法注入
    • 根据所指定的构造方法参数值,确定所需要的最少的构造方法参数值的个数
    • 对所有的构造方法进行排序,参数个数多的在前面
    • 遍历每个构造方法
    • 如果不是调用getBean方法时所指定的构造方法参数值,那么则根据构造方法参数类型找值
    • 如果是调用getBean方法时所指定的构造方法参数值,就直接利用这些值
    • 如果根据当前构造方法找到了对应的构造方法参数值,那么这个构造方法就是可用的,但是不一定这个构造方法就是最佳的,所以这里会涉及到是否有多个构造方法匹配了同样的值,这个时候就会用值和构造方法类型进行匹配程度的打分,找到一个最匹配的

      为什么分越少优先级越高

      // 当前遍历的构造方法所需要的入参对象都找到了,根据参数类型和找到的参数对象计算出来一个匹配值,值越小越匹配
      // Lenient表示宽松模式
      int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
         argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
      // Choose this constructor if it represents the closest match.
      // 值越小越匹配
      if (typeDiffWeight < minTypeDiffWeight) {
      constructorToUse = candidate;
      argsHolderToUse = argsHolder;
      argsToUse = argsHolder.arguments;
      minTypeDiffWeight = typeDiffWeight;
      ambiguousConstructors = null;
      }
      // 值相等的情况下,记录一下匹配值相同的构造方法
      else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
      if (ambiguousConstructors == null) {
         ambiguousConstructors = new LinkedHashSet<>();
         ambiguousConstructors.add(constructorToUse);
      }
      ambiguousConstructors.add(candidate);
      }
      
      主要是计算找到的bean和构造方法参数类型匹配程度有多高
      如果构造方法的参数类型为A,那么完全匹配,得分为0
      如果构造方法的参数类型为B,那么得分为2 如果构造方法的参数类型为C,那么得分为4 如果构造方法的参数类型为D,那么得分为1
Object[] objects = new Object[]{new A()};

// 0
System.out.println(MethodInvoker.getTypeDifferenceWeight(new Class[]{A.class}, objects));

// 2
System.out.println(MethodInvoker.getTypeDifferenceWeight(new Class[]{B.class}, objects));

// 4
System.out.println(MethodInvoker.getTypeDifferenceWeight(new Class[]{C.class}, objects));

// 1
System.out.println(MethodInvoker.getTypeDifferenceWeight(new Class[]{D.class}, objects));

所以,我们可以发现,越匹配分数越低

@Bean的情况

首先Spring会把@Bean修饰的方法解析成BeanDefinition

  • 如果方法是static的,那么解析出来的BeanDefinition中
    • factoryBeanName为AppConfig所对应的beanName,比如”appConfig”
    • factoryMethodName为对应的方法名,比如”aService”
    • factoryClass为AppConfig.class
  • 如果方法不是static的,那么解析出来的BeanDefinition中
    • factoryBeanName为null
    • factoryMethodName为对应的方法名,比如”aService”
    • factoryClass也为AppConfig.class

在由@Bean生成的BeanDefinition中,有一个重要的属性isFactoryMethodUnique,表示factoryMethod是不是唯一的,在普通情况下@Bean生成的BeanDefinition的isFactoryMethodUnique为true,但是如果出现了方法重载,那么就是特殊的情况

@Bean
public static AService aService(){
  return new AService();
    }

@Bean
public AService aService(BService bService){
  return new AService();
}