Spring DI 源码分析&时序图 非原创- 2020-12-26 23:22- spring: spring DI 时序图
—-

依赖注入发生的时间

当 Spring IOC 容器完成了 Bean 定义资源的定位、载入和解析注册以后，IOC 容器中已经管理类 Bean定义的相关数据，但是此时 IOC 容器还没有对所管理的 Bean 进行依赖注入，依赖注入在以下两种情况发生：
1)、用户第一次调用 getBean()方法时，IOC 容器触发依赖注入。
2)、当用户在配置文件中将元素配置了 lazy-init=false 属性，即让容器在解析注册 Bean 定义时进行预实例化，触发依赖注入。

BeanFactory 接口定义了 Spring IOC 容器的基本功能规范，是 Spring IOC 容器所应遵守的最底层和最基本的编程规范。BeanFactory 接口中定义了几个 getBean()方法，就是用户向 IOC 容器索取管理的Bean 的方法，我们通过分析其子类的具体实现，理解 Spring IOC 容器在用户索取 Bean 时如何完成依赖注入。
image.png
在 BeanFactory 中我们可以看到 getBean(String…)方法，但它具体实现在 AbstractBeanFactory 中。

源码分析

寻找获取 Bean 的入口

AbstractBeanFactory 的 getBean()相关方法的源码如下：

  1.     @Override
  2.     public Object getBean(String name) throws BeansException {
  3.         //doGetBean才是真正向IoC容器获取被管理Bean的过程
  4.         return doGetBean(name, null, null, false);
  5.     }
  7.     //获取IOC容器中指定名称和类型的Bean
  8.     @Override
  9.     public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
  10.         //doGetBean才是真正向IoC容器获取被管理Bean的过程
  11.         return doGetBean(name, requiredType, null, false);
  12.     }
  14.     //获取IOC容器中指定名称和参数的Bean
  15.     @Override
  16.     public Object getBean(String name, Object... args) throws BeansException {
  17.         //doGetBean才是真正向IoC容器获取被管理Bean的过程
  18.         return doGetBean(name, null, args, false);
  19.     }
  21.     //获取IOC容器中指定名称、类型和参数的Bean
  22.     public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
  23.             throws BeansException {
  24.         //doGetBean才是真正向IoC容器获取被管理Bean的过程
  25.         return doGetBean(name, requiredType, args, false);
  26.     }    
  28. @SuppressWarnings("unchecked")
  29.     //真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方
  30.     protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  31.             @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  33.         //根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖
  34.         //如果指定的是别名，将别名转换为规范的Bean名称
  35.         final String beanName = transformedBeanName(name);
  36.         Object bean;
  38.         // Eagerly check singleton cache for manually registered singletons.
  39.         //先从缓存中取是否已经有被创建过的单态类型的Bean
  40.         //对于单例模式的Bean整个IOC容器中只创建一次，不需要重复创建
  41.         Object sharedInstance = getSingleton(beanName);
  42.         //IOC容器创建单例模式Bean实例对象
  43.         if (sharedInstance != null && args == null) {
  44.             if (logger.isDebugEnabled()) {
  45.                 //如果指定名称的Bean在容器中已有单例模式的Bean被创建
  46.                 //直接返回已经创建的Bean
  47.                 if (isSingletonCurrentlyInCreation(beanName)) {
  48.                     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
  49.                             "' that is not fully initialized yet - a consequence of a circular reference");
  50.                 }
  51.                 else {
  52.                     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  53.                 }
  54.             }
  55.             //获取给定Bean的实例对象，主要是完成FactoryBean的相关处理
  56.             //注意：BeanFactory是管理容器中Bean的工厂，而FactoryBean是
  57.             //创建创建对象的工厂Bean，两者之间有区别
  58.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  59.         }
  61.         else {
  62.             // Fail if we're already creating this bean instance:
  63.             // We're assumably within a circular reference.
  64.             //缓存没有正在创建的单例模式Bean
  65.             //缓存中已经有已经创建的原型模式Bean
  66.             //但是由于循环引用的问题导致实例化对象失败
  67.             if (isPrototypeCurrentlyInCreation(beanName)) {
  68.                 throw new BeanCurrentlyInCreationException(beanName);
  69.             }
  71.             // Check if bean definition exists in this factory.
  72.             //对IOC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否
  73.             //能在当前的BeanFactory中获取的所需要的Bean，如果不能则委托当前容器
  74.             //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找
  75.             BeanFactory parentBeanFactory = getParentBeanFactory();
  76.             //当前容器的父级容器存在，且当前容器中不存在指定名称的Bean
  77.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  78.                 // Not found -> check parent.
  79.                 //解析指定Bean名称的原始名称
  80.                 String nameToLookup = originalBeanName(name);
  81.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  82.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  83.                             nameToLookup, requiredType, args, typeCheckOnly);
  84.                 }
  85.                 else if (args != null) {
  86.                     // Delegation to parent with explicit args.
  87.                     //委派父级容器根据指定名称和显式的参数查找
  88.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  89.                 }
  90.                 else {
  91.                     // No args -> delegate to standard getBean method.
  92.                     //委派父级容器根据指定名称和类型查找
  93.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  94.                 }
  95.             }
  97.             //创建的Bean是否需要进行类型验证，一般不需要
  98.             if (!typeCheckOnly) {
  99.                 //向容器标记指定的Bean已经被创建
  100.                 markBeanAsCreated(beanName);
  101.             }
  103.             try {
  104.                 //根据指定Bean名称获取其父级的Bean定义
  105.                 //主要解决Bean继承时子类合并父类公共属性问题
  106.                 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  107.                 checkMergedBeanDefinition(mbd, beanName, args);
  109.                 // Guarantee initialization of beans that the current bean depends on.
  110.                 //获取当前Bean所有依赖Bean的名称
  111.                 String[] dependsOn = mbd.getDependsOn();
  112.                 //如果当前Bean有依赖Bean
  113.                 if (dependsOn != null) {
  114.                     for (String dep : dependsOn) {
  115.                         if (isDependent(beanName, dep)) {
  116.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  117.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  118.                         }
  119.                         //递归调用getBean方法，获取当前Bean的依赖Bean
  120.                         registerDependentBean(dep, beanName);
  121.                         //把被依赖Bean注册给当前依赖的Bean
  122.                         getBean(dep);
  123.                     }
  124.                 }
  126.                 // Create bean instance.
  127.                 //创建单例模式Bean的实例对象
  128.                 if (mbd.isSingleton()) {
  129.                     //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
  130.                     sharedInstance = getSingleton(beanName, () -> {
  131.                         try {
  132.                             //创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义
  133.                             return createBean(beanName, mbd, args);
  134.                         }
  135.                         catch (BeansException ex) {
  136.                             // Explicitly remove instance from singleton cache: It might have been put there
  137.                             // eagerly by the creation process, to allow for circular reference resolution.
  138.                             // Also remove any beans that received a temporary reference to the bean.
  139.                             //显式地从容器单例模式Bean缓存中清除实例对象
  140.                             destroySingleton(beanName);
  141.                             throw ex;
  142.                         }
  143.                     });
  144.                     //获取给定Bean的实例对象
  145.                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  146.                 }
  148.                 //IOC容器创建原型模式Bean实例对象
  149.                 else if (mbd.isPrototype()) {
  150.                     // It's a prototype -> create a new instance.
  151.                     //原型模式(Prototype)是每次都会创建一个新的对象
  152.                     Object prototypeInstance = null;
  153.                     try {
  154.                         //回调beforePrototypeCreation方法，默认的功能是注册当前创建的原型对象
  155.                         beforePrototypeCreation(beanName);
  156.                         //创建指定Bean对象实例
  157.                         prototypeInstance = createBean(beanName, mbd, args);
  158.                     }
  159.                     finally {
  160.                         //回调afterPrototypeCreation方法，默认的功能告诉IOC容器指定Bean的原型对象不再创建
  161.                         afterPrototypeCreation(beanName);
  162.                     }
  163.                     //获取给定Bean的实例对象
  164.                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  165.                 }
  167.                 //要创建的Bean既不是单例模式，也不是原型模式，则根据Bean定义资源中
  168.                 //配置的生命周期范围，选择实例化Bean的合适方法，这种在Web应用程序中
  169.                 //比较常用，如：request、session、application等生命周期
  170.                 else {
  171.                     String scopeName = mbd.getScope();
  172.                     final Scope scope = this.scopes.get(scopeName);
  173.                     //Bean定义资源中没有配置生命周期范围，则Bean定义不合法
  174.                     if (scope == null) {
  175.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  176.                     }
  177.                     try {
  178.                         //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例
  179.                         Object scopedInstance = scope.get(beanName, () -> {
  180.                             beforePrototypeCreation(beanName);
  181.                             try {
  182.                                 return createBean(beanName, mbd, args);
  183.                             }
  184.                             finally {
  185.                                 afterPrototypeCreation(beanName);
  186.                             }
  187.                         });
  188.                         //获取给定Bean的实例对象
  189.                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  190.                     }
  191.                     catch (IllegalStateException ex) {
  192.                         throw new BeanCreationException(beanName,
  193.                                 "Scope '" + scopeName + "' is not active for the current thread; consider " +
  194.                                 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  195.                                 ex);
  196.                     }
  197.                 }
  198.             }
  199.             catch (BeansException ex) {
  200.                 cleanupAfterBeanCreationFailure(beanName);
  201.                 throw ex;
  202.             }
  203.         }
  205.         // Check if required type matches the type of the actual bean instance.
  206.         //对创建的Bean实例对象进行类型检查
  207.         if (requiredType != null && !requiredType.isInstance(bean)) {
  208.             try {
  209.                 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  210.                 if (convertedBean == null) {
  211.                     throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  212.                 }
  213.                 return convertedBean;
  214.             }
  215.             catch (TypeMismatchException ex) {
  216.                 if (logger.isDebugEnabled()) {
  217.                     logger.debug("Failed to convert bean '" + name + "' to required type '" +
  218.                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
  219.                 }
  220.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  221.             }
  222.         }
  223.         return (T) bean;
  224.     }

通过上面对向 IOC 容器获取 Bean 方法的分析，我们可以看到在 Spring 中，如果 Bean 定义的单例模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象。如果 Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。除此之外，Bean 定义还可以扩展为指定其生命周期范围。
上面的源码只是定义了根据 Bean 定义的模式，采取的不同创建 Bean 实例对象的策略，具体的 Bean实例 对象的创 建过程 由实现了 ObjectFactory 接口 的匿名内 部类的 createBean()方法 完成，ObjectFactory 使 用 委 派 模 式 ，具体的 Bean 实 例 创 建 过 程 交 由 其 实 现 类AbstractAutowireCapableBeanFactory 完成，我们继续分析AbstractAutowireCapableBeanFactory的 createBean()方法的源码，理解其创建 Bean 实例的具体实现过程。

开始实例化

AbstractAutowireCapableBeanFactory 类实现了 ObjectFactory 接口，创建容器指定的 Bean 实例对象，同时还对创建的 Bean 实例对象进行初始化处理。其创建 Bean 实例对象的方法源码如下：

  1. //创建Bean实例对象
  2.     @Override
  3.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  4.             throws BeanCreationException {
  6.         if (logger.isDebugEnabled()) {
  7.             logger.debug("Creating instance of bean '" + beanName + "'");
  8.         }
  9.         RootBeanDefinition mbdToUse = mbd;
  10.         //判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载
  11.         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  12.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  13.             mbdToUse = new RootBeanDefinition(mbd);
  14.             mbdToUse.setBeanClass(resolvedClass);
  15.         }
  17.         // Prepare method overrides.
  18.         //校验和准备Bean中的方法覆盖
  19.         try {
  20.             mbdToUse.prepareMethodOverrides();
  21.         }
  22.         catch (BeanDefinitionValidationException ex) {
  23.             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  24.                     beanName, "Validation of method overrides failed", ex);
  25.         }
  27.         try {
  28.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  29.             //如果Bean配置了初始化前和初始化后的处理器，则试图返回一个需要创建Bean的代理对象
  30.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  31.             if (bean != null) {
  32.                 return bean;
  33.             }
  34.         }
  35.         catch (Throwable ex) {
  36.             throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  37.                     "BeanPostProcessor before instantiation of bean failed", ex);
  38.         }
  40.         try {
  41.             //创建Bean的入口
  42.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  43.             if (logger.isDebugEnabled()) {
  44.                 logger.debug("Finished creating instance of bean '" + beanName + "'");
  45.             }
  46.             return beanInstance;
  47.         }
  48.         catch (BeanCreationException ex) {
  49.             // A previously detected exception with proper bean creation context already...
  50.             throw ex;
  51.         }
  52.         catch (ImplicitlyAppearedSingletonException ex) {
  53.             // An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...
  54.             throw ex;
  55.         }
  56.         catch (Throwable ex) {
  57.             throw new BeanCreationException(
  58.                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  59.         }
  60.     }
  63.     //真正创建Bean的方法
  64.     protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  65.             throws BeanCreationException {
  67.         // Instantiate the bean.
  68.         //封装被创建的Bean对象
  69.         BeanWrapper instanceWrapper = null;
  70.         if (mbd.isSingleton()) {
  71.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  72.         }
  73.         if (instanceWrapper == null) {
  74.             instanceWrapper = createBeanInstance(beanName, mbd, args);
  75.         }
  76.         final Object bean = instanceWrapper.getWrappedInstance();
  77.         //获取实例化对象的类型
  78.         Class<?> beanType = instanceWrapper.getWrappedClass();
  79.         if (beanType != NullBean.class) {
  80.             mbd.resolvedTargetType = beanType;
  81.         }
  83.         // Allow post-processors to modify the merged bean definition.
  84.         //调用PostProcessor后置处理器
  85.         synchronized (mbd.postProcessingLock) {
  86.             if (!mbd.postProcessed) {
  87.                 try {
  88.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  89.                 }
  90.                 catch (Throwable ex) {
  91.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  92.                             "Post-processing of merged bean definition failed", ex);
  93.                 }
  94.                 mbd.postProcessed = true;
  95.             }
  96.         }
  98.         // Eagerly cache singletons to be able to resolve circular references
  99.         // even when triggered by lifecycle interfaces like BeanFactoryAware.
  100.         //向容器中缓存单例模式的Bean对象，以防循环引用
  101.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  102.                 isSingletonCurrentlyInCreation(beanName));
  103.         if (earlySingletonExposure) {
  104.             if (logger.isDebugEnabled()) {
  105.                 logger.debug("Eagerly caching bean '" + beanName +
  106.                         "' to allow for resolving potential circular references");
  107.             }
  108.             //这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
  109.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  110.         }
  112.         // Initialize the bean instance.
  113.         //Bean对象的初始化，依赖注入在此触发
  114.         //这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean
  115.         Object exposedObject = bean;
  116.         try {
  117.             //将Bean实例对象封装，并且Bean定义中配置的属性值赋值给实例对象
  118.             populateBean(beanName, mbd, instanceWrapper);
  119.             //初始化Bean对象
  120.             exposedObject = initializeBean(beanName, exposedObject, mbd);
  121.         }
  122.         catch (Throwable ex) {
  123.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  124.                 throw (BeanCreationException) ex;
  125.             }
  126.             else {
  127.                 throw new BeanCreationException(
  128.                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  129.             }
  130.         }
  132.         if (earlySingletonExposure) {
  133.             //获取指定名称的已注册的单例模式Bean对象
  134.             Object earlySingletonReference = getSingleton(beanName, false);
  135.             if (earlySingletonReference != null) {
  136.                 //根据名称获取的已注册的Bean和正在实例化的Bean是同一个
  137.                 if (exposedObject == bean) {
  138.                     //当前实例化的Bean初始化完成
  139.                     exposedObject = earlySingletonReference;
  140.                 }
  141.                 //当前Bean依赖其他Bean，并且当发生循环引用时不允许新创建实例对象
  142.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  143.                     String[] dependentBeans = getDependentBeans(beanName);
  144.                     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  145.                     //获取当前Bean所依赖的其他Bean
  146.                     for (String dependentBean : dependentBeans) {
  147.                         //对依赖Bean进行类型检查
  148.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  149.                             actualDependentBeans.add(dependentBean);
  150.                         }
  151.                     }
  152.                     if (!actualDependentBeans.isEmpty()) {
  153.                         throw new BeanCurrentlyInCreationException(beanName,
  154.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +
  155.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  156.                                 "] in its raw version as part of a circular reference, but has eventually been " +
  157.                                 "wrapped. This means that said other beans do not use the final version of the " +
  158.                                 "bean. This is often the result of over-eager type matching - consider using " +
  159.                                 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  160.                     }
  161.                 }
  162.             }
  163.         }
  165.         // Register bean as disposable.
  166.         //注册完成依赖注入的Bean
  167.         try {
  168.             registerDisposableBeanIfNecessary(beanName, bean, mbd);
  169.         }
  170.         catch (BeanDefinitionValidationException ex) {
  171.             throw new BeanCreationException(
  172.                     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  173.         }
  175.         return exposedObject;
  176.     }