【小家Spring】为脱离Spring IOC容器管理的Bean赋能【依赖注入】的能力，并分析原理（借助AutowireCapableBeanFactory赋能）（上）-阿里云开发者社区

前言

咋一看标题，小伙伴们是否还有点小激动呢？觉得这怎么可能呢？

可能我们（大众）都是这样认为：自从用上了Spring这个优秀的框架，一般小伙伴们都是一言不合就把对象塞进Spring的IOC容器里面，交给它来替我们管理。

不可否认的是，把Bean交给Spring管理，确实极其的方便，优点一大把，并且还几乎没有啥缺点。这也就是为何咱们一言不合就把Bean扔给Spring的原因。（在Spring的技术栈里这么做，完全没有问题）

然而，就Spring框架本身而言。它的强大的依赖注入，不仅仅能给自家的Bean使用，还能赋能给容器之外的Bean，快速的把需要注入的对象给它装配好。

本来我也一直以为你想用Spring的依赖注入功能，就得交给Spring容器进行管理。直到我上周看AutowireCapableBeanFactory源码的时候，上面的JavaDoc就清晰的写到了，它还可以为非容器内的Bean服务~

注意：原对象可以不在Spring的IOC容器里，但是需要被依赖注入的成员，就必须是Spring容器管辖的Bean

本篇文章实际用处可能较少（可能在继承某些特殊的第三方框架的时候需要），但是掌握了本篇文章的内容，能让你更加清晰的了解到Spring依赖注入的原理（一般应用开发者不会使用这个接口，但如果你是框架设计者，你有必要了解这个接口）

我们使用的应用上下文ApplicationContext它就提供了

AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

虽然它不直接继承，但是它允许你拿这个工具去做你需要的事。~~~

Spring源码基于的Spring版本为：5.0.6.RELEASE（下同）

Spring源码基于的Spring版本为：5.0.6.RELEASE（下同）

Spring源码基于的Spring版本为：5.0.6.RELEASE（下同）

AutowireCapableBeanFactory 的解释

 * Extension of the {@link org.springframework.beans.factory.BeanFactory}
 * interface to be implemented by bean factories that are capable of
 * autowiring, provided that they want to expose this functionality for
 * existing bean instances.

AutowireCapableBeanFactory在BeanFactory基础上实现了对存在实例的管理.可以使用这个接口集成其它框架,捆绑并填充并不由Spring管理生命周期并已存在的实例.像集成WebWork的Actions 和Tapestry Page就很实用.

public interface AutowireCapableBeanFactory extends BeanFactory {
  int AUTOWIRE_NO = 0;
  int AUTOWIRE_BY_NAME = 1;
  int AUTOWIRE_BY_TYPE = 2;
  int AUTOWIRE_CONSTRUCTOR = 3;
  @Deprecated
  int AUTOWIRE_AUTODETECT = 4;
  // 注意这个CreateBean和下面的CrateBean的不同
  //JavaDoc：It does <i>not</> imply traditional by-name or by-type autowiring of properties;
  // 也就是说它只管给你创建Bean，但是不管给你根据Name或者Type进行注入哦
  // 当然，你可以显示在对应属性上指定@Autowired注解，让他也可以达到相同的效果
  <T> T createBean(Class<T> beanClass) throws BeansException;
  void autowireBean(Object existingBean) throws BeansException;
  Object configureBean(Object existingBean, String beanName) throws BeansException;
  Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
  Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
  void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
      throws BeansException;
  void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
  Object initializeBean(Object existingBean, String beanName) throws BeansException;
  Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException;
  Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException;
  void destroyBean(Object existingBean);
  <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
  @Nullable
  Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
  @Nullable
  Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
      @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}

这里就不解释各个方法了，具体参考：

【小家Spring】BeanFactory体系和ApplicationContext体系，两大体系各接口分析、区别和联系

Demo Show

说得可能还是一头雾水，上个例子先看看效果吧：

以createBean() 方法为例

// 准备一个Child类
@Getter
@Setter
public class Child {
  // 注意：这里并没有@Autowired注解的
    private HelloService helloService;
    private String name;
    private Integer age;
}
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(RootConfig.class);
        // ApplicationContext里面是持久AutowireCapableBeanFactory这个工具的，它真实的实现类一般都是：DefaultListableBeanFactory
        AutowireCapableBeanFactory autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();
        // 我们吧Child的创建过程都交给Bean工厂去帮我们处理，自己连new都不需要了 （createBean方法执行多次，就会创建多个child实例）
        Child child = (Child) autowireCapableBeanFactory.createBean(Child.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
        //简直残暴，没有@Autowired注解都给注入进来了~~~  至于为什么，看看下面的分析，你就知道了
        System.out.println(child.getHelloService()); //com.fsx.service.HelloServiceImpl@6a78afa0
        // 抛出异常 No qualifying bean of type 'com.fsx.bean.Child' available 
        // 能佐证：我们的Bean并没交给Spring容器管理，它只是帮我们创建好了，并把对应属性注入进去了
        Child bean = applicationContext.getBean(Child.class);
        System.out.println(bean);
    }

看到这个现象有没有很惊喜，我们哪怕不是Spring去管理的对象，都能够依赖注入进来容器内的对象，并且，并且连@Autowired注解都不需要。所以更别谈Spring内部的容器，并且还标注了注解的，那就应该更容易去实现了

所以，了解了本文后，再回过头去看看Spring内部的自动化的依赖注入，就会说一句：也就那样嘛，哈哈~

以createBean() 方法为例的源码分析

在上面Demo Show的基础上，我们来看看源码，到底是怎么做到的。

来到AbstractAutowireCapableBeanFactory#createBean：

  @Override
  public Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
    // Use non-singleton bean definition, to avoid registering bean as dependent bean.
    RootBeanDefinition bd = new RootBeanDefinition(beanClass,  autowireMode, dependencyCheck);
    // 这里看到了，采用的不是单例，而是prototype
    bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    // For the nullability warning, see the elaboration in AbstractBeanFactory.doGetBean;
    // in short: This is never going to be null unless user-declared code enforces null.
    // doc说得很明白，这里返回值永远不可能为null。除非调用者强制return null
    // 注意的是:这里BeanName就是beanClass.getName()
    return createBean(beanClass.getName(), bd, null);
  }
// 最终都调用到了下面这个createBean方法。它也是AbstractBeanFactory提供的一个抽象方法
// 最终也由AbstractAutowireCapableBeanFactory去实现的。 我们熟悉的doGetBean()方法，最终也是调用它来创建实例对象  只是doGetBean()把单例对象都缓存起来了
// 这个方法很单纯：创建一个实例，然后初始化他（给属性们赋值），然后return出去即可
  @Override
  protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
    if (logger.isDebugEnabled()) {
      logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;
    // Make sure bean class is actually resolved at this point, and
    // clone the bean definition in case of a dynamically resolved Class
    // which cannot be stored in the shared merged bean definition.
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
    }
    // Prepare method overrides.
    // 解析一些@lookup注解之类的  忽略
    try {
      mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
          beanName, "Validation of method overrides failed", ex);
    }
    try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      // 这个之前都解释过了，就不解释了。若BeanPostProcessors 产生了一个代理对象，就不需要我去创建了，就不继续往下走了（AOP都走这里）
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
        return bean;
      }
    }
    catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
          "BeanPostProcessor before instantiation of bean failed", ex);
    }
    try {
      // 重点来了。它是本类的一个protected方法，专门用于处理创建Bean的过程（包括属性赋值之类的）
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
    }
    catch (Throwable ex) {
      throw new BeanCreationException(
          mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
  }

这里再看看doCreateBean吧，因为之前有讲过这个方法，这里就看看止看看核心步骤。

  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args){
  BeanWrapper instanceWrapper = null;
  ...
  //createBeanInstance 是重点（都是返回一个BeanWrapper）  它也是本类的一个protected方法
  instanceWrapper = createBeanInstance(beanName, mbd, args);
  // Bean已经实例化好了,准备初始化吧
  ...
  // 执行MergedBeanDefinitionPostProcessor
  // 处理循环引用，现在若我们Bean不在容器里，肯定是不存在循环引用的（但是我依赖的Bean可能还没创建是真的，也是这里来处理的）
  ...
  // 给Bean实例的各个属性进行赋值 比如调用InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation、给属性注入值（并不依赖于@Autowired注解）
  // 执行InstantiationAwareBeanPostProcessor#postProcessPropertyValues等等
  populateBean(beanName, mbd, instanceWrapper);
  // 初始化Bean 执行一些初始化方法init @PostContruct方法等等 
  //BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization等等
  exposedObject = initializeBean(beanName, exposedObject, mbd);
}