Spring 5 DefaultListableBeanFactory— isAutowireCandidate源码分析
原文链接：

isAutowireCandidate(String , DependencyDescriptor )

确定指定的bean定义是否可以自动注入:

  1. 获取此BeanFactory的自动装配候选解析器

  2. 交由isAutowireCandidate(String, DependencyDescriptor, AutowireCandidateResolver) 处理并将结果返回出去

    1. /**
    2.   * 确定指定的bean定义是否可以自动注入
    3.   * @param beanName the name of the bean to check -- 要检查的bean名
    4.   * @param descriptor the descriptor of the dependency to resolve -- 要解决的依赖项的描述符
    5.   * @return 是否应将bean视为自动装配候选对象
    6.   * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
    7.   */
    8.  @Override
    9.  public boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
    10.          throws NoSuchBeanDefinitionException {
    11.      return isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver());
    12.  }

    isAutowireCandidate(String, DependencyDescriptor, AutowireCandidateResolver)

    确定指定的bean定义是否可以自动注入:

  3. 解决beanName存在于该工厂的情况:

  • 去除开头的’&'字符，返回剩余的字符串作为转换后的Bean名称【全类名】【变量 beanDefinitionName】
  • 如果工厂包含beanDefinitionName的BeanDefinition对象,就确定beanDefinitionName的合并后RootBeanDefinition 是否符合自动装配候选条件，以注入到声明匹配类型依赖项的其他bean中并将结果返回出去
  • 如果beanName在该BeanFactory的单例对象的高速缓存Map集合【DefaultSingletonBeanRegistry.singletonObjects】中, 获取beanName的Class对象，从而构建出RootBeanDefinition实例对象，最后确定该RootBeanDefinition实例对象是否符合自动装 配候选条件，以注入到声明匹配类型依赖项的其他bean中并将结果返回出去
  1. 解决beanName存在于该工厂的父工厂的情况：
  • 获取父工厂【变量 parent】
  • 如果父工厂是DefaultListableBeanFactory的实例对象,递归交由父工厂的该方法处理并将结果返回
  • 如果父工厂是ConfigurableListableBeanFactory的实例对象,就递归交由父工厂的isAutowireCandidate(String, DependencyDescriptor) 进行处理并将结果返回出去

如果上面各种情况都没有涉及，默认是返回true，表示应将bean视为自动装配候选对象

  1. /**
  2.      * <p>确定指定的bean定义是否可以自动注入 </p>
  3.      * Determine whether the specified bean definition qualifies as an autowire candidate,
  4.      * to be injected into other beans which declare a dependency of matching type.
  5.      * <p>确定指定的bean定义是否符合自动装配候选条件，以注入到声明匹配类型依赖项的其他bean中。</p>
  6.      * @param beanName the name of the bean definition to check
  7.      *                 -- 要检查的beanDefinition名称
  8.      * @param descriptor the descriptor of the dependency to resolve
  9.      *                   -- 要解析的依赖项的描述符
  10.      * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
  11.      *                 -- AutowireCandidateResolver用于实际的解析算法
  12.      * @return whether the bean should be considered as autowire candidate
  13.      *  -- 是否应将bean视为自动装配候选对象
  14.      * @see #isAutowireCandidate(String, RootBeanDefinition, DependencyDescriptor, AutowireCandidateResolver)
  15.      */
  16.     protected boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
  17.             throws NoSuchBeanDefinitionException {
  18.         // 去除开头的'&'字符，返回剩余的字符串作为转换后的Bean名称【全类名】
  19.         String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  20.         // 如果工厂包含beanDefinitionName得BeanDefinition对象
  21.         if (containsBeanDefinition(beanDefinitionName)) {
  22.             // 确定beanDefinitionName的合并后RootBeanDefinition是否符合自动装配候选条件，
  23.             // 以注入到声明匹配类型依赖项的其他bean中.并将结果返回出去
  24.             return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(beanDefinitionName), descriptor, resolver);
  25.         }
  26.         //这里应该是直接调用registerSingeton(String,Object)方法的情况
  27.         //如果beanName在该BeanFactory的singletonObjects【单例对象的高速缓存Map集合】中
  28.         else if (containsSingleton(beanName)) {
  29.             //获取beanName的Class对象，从而构建出RootBeanDefinition实例对象，最后确定该RootBeanDefinition实例对象是否符合自动装
  30.             // 配候选条件，以注入到声明匹配类型依赖项的其他bean中并将结果返回出去
  31.             return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver);
  32.         }
  33.         //获取父工厂
  34.         BeanFactory parent = getParentBeanFactory();
  35.         //如果父工厂是DefaultListableBeanFactory的实例对象
  36.         if (parent instanceof DefaultListableBeanFactory) {
  37.             // No bean definition found in this factory -> delegate to parent.
  38.             // 在该工厂中找不到BeanDefinition ->委托给父对象
  39.             // 递归交由父工厂处理并将结果返回
  40.             return ((DefaultListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor, resolver);
  41.         }
  42.         //如果父工厂是ConfigurableListableBeanFactory的实例对象
  43.         else if (parent instanceof ConfigurableListableBeanFactory) {
  44.             // If no DefaultListableBeanFactory, can't pass the resolver along.
  45.             // 如果没有DefaultLisableBeanFactory,则无法传递解析器
  46.             // 这个时候，由于ConfigurableListableBeanFactory没有提供isAutowireCandidate(String, DependencyDescriptor, AutowireCandidateResolver)的
  47.             // 重载方法，所以递归交由父工厂的isAutowireCandidate(String, DependencyDescriptor)进行处理并将结果返回出去
  48.             return ((ConfigurableListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor);
  49.         }
  50.         else {
  51.             //如果上面各种情况都没有涉及，默认是返回true，表示应将bean视为自动装配候选对象
  52.             return true;
  53.         }
  54.     }

isAutowireCandidate(String, RootBeanDefinition, DependencyDescriptor, AutowireCandidateResolver)

确定mbd可以自动注入到descriptor所包装的field/methodParam中:

  1. 去除开头的’&’字符，返回剩余的字符串作为转换后的Bean名称【可能是全类名】【变量 beanDefinitionName】
  2. 为mdb解析出对应的bean class对象
  3. 如果mbd指明了引用非重载方法的工厂方法名称【RootBeanDefinition.isFactoryMethodUnique】 且 mbd还没有缓存 用于自省的唯一工厂方法候选【RootBeanDefinition.factoryMethodToIntrospect】:如果可能，新建一个ConstuctorResolver 对象来解析mbd中factory方法
  4. 根据mbd,beanName,beanDefinitionName的别名构建一个BeanDefinitionHolder实例,交给resolver进行判断, 是否可以自动注入并将结果返回出去。resolver的判断依据还是看mdb的AbstractBeanDefinition.isAutowireCandidate()结果。

————————————————
[

](https://blog.csdn.net/qq_30321211/article/details/108362842)

  1. /**
  2.      * <p>
  3.      *  确定mbd可以自动注入到descriptor所包装的field/methodParam中
  4.      * </p>
  5.      * Determine whether the specified bean definition qualifies as an autowire candidate,
  6.      * to be injected into other beans which declare a dependency of matching type.
  7.      * <p>确定指定的bean定义是否符合自动装配候选条件，以注入到声明匹配类型依赖项的其他bean中。</p>
  8.      * @param beanName the name of the bean definition to check -- 要检查的beanDefinition名
  9.      * @param mbd the merged bean definition to check -- 要检查的合并后BeanDefinition
  10.      * @param descriptor the descriptor of the dependency to resolve -- 要解析的依赖项的描述符
  11.      * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
  12.      *                 -- AutowireCandidateResolver用于实际的分析算法
  13.      * @return whether the bean should be considered as autowire candidate
  14.      *  -- 是否应将bean视为自动装配候选对象
  15.      */
  16.     protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
  17.             DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
  18.         //去除开头的'&'字符，返回剩余的字符串作为转换后的Bean名称【可能是全类名】
  19.         String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
  20.         //为mdb解析出对应的bean class对象
  21.         resolveBeanClass(mbd, beanDefinitionName);
  22.         //如果mbd指明了引用非重载方法的工厂方法名称 且 mbd还没有缓存用于自省的唯一工厂方法候选
  23.         if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
  24.             //如果可能，新建一个ConstuctorResolver对象来解析mbd中factory方法
  25.             new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
  26.         }
  27.         // 根据mbd,beanName,beanDefinitionName的别名构建一个BeanDefinitionHolder实例,交给resolver进行判断
  28.         // 是否可以自动注入。resolver的判断依据还是看mdb的isAutowireCandidate()结果。这个需要看BeanDefinition的结果
  29.         return resolver.isAutowireCandidate(
  30.                 new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
  31.     }

其中 BeanDefinition的autowireCandidate属性是在创建BeanDefinition的阶段就默认是true的，可以参考下面的这个博客