源码通透-spring-IOC-finishBeanFactoryInitialization

野性酷女 2022-02-12 20:02 238阅读 0赞

# 一、AbstractApplicationContext\#finishBeanFactoryInitialization #

--------------------

spring源码版本：spring5.0  
JDK版本: 1.8  
我保存的源码地址：[https://gitee.com/paincupid/spring-framework.git][https_gitee.com_paincupid_spring-framework.git]  
或者官网地址：[https://github.com/spring-projects/spring-framework.git][https_github.com_spring-projects_spring-framework.git]  
更多源码文章：[https://github.com/arthur-dy-lee/arthur-dy-lee-note][https_github.com_arthur-dy-lee_arthur-dy-lee-note]

### 文章目录 ###

*  一、AbstractApplicationContext\#finishBeanFactoryInitialization
 *  二、AbstractBeanFactory\#getBean 调用过程
 *   *  2.1 栈信息打印

入口类 AbstractApplicationContext\#refresh()

@Override
    	public void refresh() throws BeansException, IllegalStateException { 
    		synchronized (this.startupShutdownMonitor) { 
    			// Prepare this context for refreshing.
    			prepareRefresh();
    			// Tell the subclass to refresh the internal bean factory.
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    			// Prepare the bean factory for use in this context.
    			prepareBeanFactory(beanFactory);
    			try { 
    				// Allows post-processing of the bean factory in context subclasses.
    				postProcessBeanFactory(beanFactory);
    				// Invoke factory processors registered as beans in the context.
    				invokeBeanFactoryPostProcessors(beanFactory);  // <------------
    				// Register bean processors that intercept bean creation.
    				registerBeanPostProcessors(beanFactory);
    				// Initialize message source for this context.
    				initMessageSource();
    				// Initialize event multicaster for this context.
    				initApplicationEventMulticaster();
    				// Initialize other special beans in specific context subclasses.
    				onRefresh();
    				// Check for listener beans and register them.
    				registerListeners();
    				// Instantiate all remaining (non-lazy-init) singletons.
    				finishBeanFactoryInitialization(beanFactory);
    				// Last step: publish corresponding event.
    				finishRefresh();
    			}
    --------------------- 
    ## 1 作用
    
    > Finish the initialization of this context's bean factory initializing all remaining singleton beans.
    
    即
    
    >完成spring上下文的初始化，初始化beanFactory剩余的单例bean。
    
    ## 源码
    
    ```java
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
       // Initialize conversion service for this context.
       if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
             beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { 
          beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
       }
    
       // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
       String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
       for (String weaverAwareName : weaverAwareNames) { 
          getBean(weaverAwareName);
       }
    
       // Stop using the temporary ClassLoader for type matching.
       beanFactory.setTempClassLoader(null);
    
       // Allow for caching all bean definition metadata, not expecting further changes.
       beanFactory.freezeConfiguration();
    
       // Instantiate all remaining (non-lazy-init) singletons.
       beanFactory.preInstantiateSingletons();
    }

DefaultListableBeanFactory\#preInstantiateSingletons

> Instantiate all remaining (non-lazy-init) singletons.

即

> 初始化剩余的非懒加载单例

@Override
    public void preInstantiateSingletons() throws BeansException { 
       if (this.logger.isDebugEnabled()) { 
          this.logger.debug("Pre-instantiating singletons in " + this);
       }
    
       // Iterate over a copy to allow for init methods which in turn register new bean definitions.
       // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
       List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    
       // Trigger initialization of all non-lazy singleton beans...
       for (String beanName : beanNames) { 
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
          if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { 
             if (isFactoryBean(beanName)) { 
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { 
                   isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() { 
                      @Override
                      public Boolean run() { 
                         return ((SmartFactoryBean<?>) factory).isEagerInit();
                      }
                   }, getAccessControlContext());
                }
                else { 
                   isEagerInit = (factory instanceof SmartFactoryBean &&
                         ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                if (isEagerInit) { 
                    // <------------- 很重要，此处调用getBean()方法 
                   getBean(beanName);
                }
             }
             else { 
               
                 // <------------- 很重要，此处调用getBean()方法 
                getBean(beanName);
             }
          }
       }
    
       // Trigger post-initialization callback for all applicable beans...
       for (String beanName : beanNames) { 
          Object singletonInstance = getSingleton(beanName);
          if (singletonInstance instanceof SmartInitializingSingleton) { 
             final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
             if (System.getSecurityManager() != null) { 
                AccessController.doPrivileged(new PrivilegedAction<Object>() { 
                   @Override
                   public Object run() { 
                      smartSingleton.afterSingletonsInstantiated();
                      return null;
                   }
                }, getAccessControlContext());
             }
             else { 
                smartSingleton.afterSingletonsInstantiated();
             }
          }
       }
    }

# 二、AbstractBeanFactory\#getBean 调用过程 #

--------------------

## 2.1 栈信息打印 ##

以springmvc为框架，打印mapper的实例化过程

newInstance:47, MapperProxyFactory (org.apache.ibatis.binding)
    newInstance:52, MapperProxyFactory (org.apache.ibatis.binding)
    getMapper:50, MapperRegistry (org.apache.ibatis.binding)
    getMapper:732, Configuration (org.apache.ibatis.session)
    getMapper:318, SqlSessionTemplate (org.mybatis.spring)
    getObject:95, MapperFactoryBean (org.mybatis.spring.mapper)
    doGetObjectFromFactoryBean:168, FactoryBeanRegistrySupport (org.springframework.beans.factory.support)
    getObjectFromFactoryBean:103, FactoryBeanRegistrySupport (org.springframework.beans.factory.support)
    getObjectForBeanInstance:1574, AbstractBeanFactory (org.springframework.beans.factory.support)
    doGetBean:253, AbstractBeanFactory (org.springframework.beans.factory.support)
    getBean:201, AbstractBeanFactory (org.springframework.beans.factory.support)
    doGetBean:274, AbstractBeanFactory (org.springframework.beans.factory.support)
    getBean:196, AbstractBeanFactory (org.springframework.beans.factory.support)
    findAutowireCandidates:1145, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    doResolveDependency:1069, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    resolveDependency:967, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    inject:543, AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement (org.springframework.beans.factory.annotation)
    inject:88, InjectionMetadata (org.springframework.beans.factory.annotation)
    postProcessPropertyValues:331, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    populateBean:1214, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    -----------
    doCreateBean:543, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    createBean:482, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    getObject:305, AbstractBeanFactory$1 (org.springframework.beans.factory.support)
    getSingleton:230, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
    doGetBean:301, AbstractBeanFactory (org.springframework.beans.factory.support)
    getBean:196, AbstractBeanFactory (org.springframework.beans.factory.support)
    findAutowireCandidates:1145, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    doResolveDependency:1069, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    resolveDependency:967, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    inject:543, AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement (org.springframework.beans.factory.annotation)
    inject:88, InjectionMetadata (org.springframework.beans.factory.annotation)
    postProcessPropertyValues:331, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    populateBean:1214, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    doCreateBean:543, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    createBean:482, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    getObject:305, AbstractBeanFactory$1 (org.springframework.beans.factory.support)
    getSingleton:230, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
    doGetBean:301, AbstractBeanFactory (org.springframework.beans.factory.support)
    getBean:196, AbstractBeanFactory (org.springframework.beans.factory.support)
    preInstantiateSingletons:772, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    finishBeanFactoryInitialization:834, AbstractApplicationContext (org.springframework.context.support)
    --------------------------------
    refresh:537, AbstractApplicationContext (org.springframework.context.support)
    configureAndRefreshWebApplicationContext:667, FrameworkServlet (org.springframework.web.servlet)
    createWebApplicationContext:633, FrameworkServlet (org.springframework.web.servlet)
    createWebApplicationContext:681, FrameworkServlet (org.springframework.web.servlet)
    initWebApplicationContext:552, FrameworkServlet (org.springframework.web.servlet)
    initServletBean:493, FrameworkServlet (org.springframework.web.servlet)
    init:136, HttpServletBean (org.springframework.web.servlet)
    init:160, GenericServlet (javax.servlet)

AbstractBeanFactory\#getBean

@Override
    public Object getBean(String name) throws BeansException { 
       return doGetBean(name, null, null, false);
    }

AbstractBeanFactory\#doGetBean

protected <T> T doGetBean(
          final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
          throws BeansException { 
    
       final String beanName = transformedBeanName(name);
       Object bean;
    
       // Eagerly check singleton cache for manually registered singletons.
       Object sharedInstance = getSingleton(beanName);
       if (sharedInstance != null && args == null) { 
          //.....
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
       }
    
       else { 
          // Fail if we're already creating this bean instance:
          // We're assumably within a circular reference.
          if (isPrototypeCurrentlyInCreation(beanName)) { 
             throw new BeanCurrentlyInCreationException(beanName);
          }
    
          // Check if bean definition exists in this factory.
          BeanFactory parentBeanFactory = getParentBeanFactory();
          if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
             // Not found -> check parent.
             String nameToLookup = originalBeanName(name);
             if (args != null) { 
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
             }
             else { 
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
             }
          }
    
          if (!typeCheckOnly) { 
             markBeanAsCreated(beanName);
          }
    
          try { 
             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
             checkMergedBeanDefinition(mbd, beanName, args);
    
             // Guarantee initialization of beans that the current bean depends on.
             String[] dependsOn = mbd.getDependsOn();
             if (dependsOn != null) { 
                for (String dependsOnBean : dependsOn) { 
                   if (isDependent(beanName, dependsOnBean)) { 
                      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                   }
                   registerDependentBean(dependsOnBean, beanName);
                   getBean(dependsOnBean);
                }
             }
    
             // Create bean instance.
             if (mbd.isSingleton()) { 
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { 
                   @Override
                   public Object getObject() throws BeansException { 
                      try { 
                         return createBean(beanName, mbd, args);
                      }
                      catch (BeansException ex) { 
                         // Explicitly remove instance from singleton cache: It might have been put there
                         // eagerly by the creation process, to allow for circular reference resolution.
                         // Also remove any beans that received a temporary reference to the bean.
                         destroySingleton(beanName);
                         throw ex;
                      }
                   }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
             }
    
             else if (mbd.isPrototype()) { 
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try { 
                   beforePrototypeCreation(beanName);
                   prototypeInstance = createBean(beanName, mbd, args);
                }
                finally { 
                   afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
             }
    
             else { 
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) { 
                   throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                }
                try { 
                   Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() { 
                      @Override
                      public Object getObject() throws BeansException { 
                         beforePrototypeCreation(beanName);
                         try { 
                            return createBean(beanName, mbd, args);
                         }
                         finally { 
                            afterPrototypeCreation(beanName);
                         }
                      }
                   });
                   bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) { 
                   throw new BeanCreationException(beanName,
                         "Scope '" + scopeName + "' is not active for the current thread; " +
                         "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                         ex);
                }
             }
          }
          catch (BeansException ex) { 
             cleanupAfterBeanCreationFailure(beanName);
             throw ex;
          }
       }
    
       // Check if required type matches the type of the actual bean instance.
       if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) { 
          try { 
             return getTypeConverter().convertIfNecessary(bean, requiredType);
          }
          catch (TypeMismatchException ex) { 
             if (logger.isDebugEnabled()) { 
                logger.debug("Failed to convert bean '" + name + "' to required type [" +
                      ClassUtils.getQualifiedName(requiredType) + "]", ex);
             }
             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
          }
       }
       return (T) bean;
    }

DefaultSingletonBeanRegistry\#getSingleton

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
       Assert.notNull(beanName, "'beanName' must not be null");
       synchronized (this.singletonObjects) { 
          Object singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null) { 
             if (this.singletonsCurrentlyInDestruction) { 
                throw new BeanCreationNotAllowedException(beanName,
                      "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
                      "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
             }
             if (logger.isDebugEnabled()) { 
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
             }
             beforeSingletonCreation(beanName);
             boolean newSingleton = false;
             boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
             if (recordSuppressedExceptions) { 
                this.suppressedExceptions = new LinkedHashSet<Exception>();
             }
             try { 
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
             }
             catch (IllegalStateException ex) { 
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) { 
                   throw ex;
                }
             }
             catch (BeanCreationException ex) { 
                if (recordSuppressedExceptions) { 
                   for (Exception suppressedException : this.suppressedExceptions) { 
                      ex.addRelatedCause(suppressedException);
                   }
                }
                throw ex;
             }
             finally { 
                if (recordSuppressedExceptions) { 
                   this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
             }
             if (newSingleton) { 
                addSingleton(beanName, singletonObject);
             }
          }
          return (singletonObject != NULL_OBJECT ? singletonObject : null);
       }
    }

AbstractBeanFactory\#getObject

AbstractAutowireCapableBeanFactory\#createBean

AbstractAutowireCapableBeanFactory\#doCreateBean

/** * Actually create the specified bean. Pre-creation processing has already happened * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks. * <p>Differentiates between default bean instantiation, use of a * factory method, and autowiring a constructor. * @param beanName the name of the bean * @param mbd the merged bean definition for the bean * @param args explicit arguments to use for constructor or factory method invocation * @return a new instance of the bean * @throws BeanCreationException if the bean could not be created * @see #instantiateBean * @see #instantiateUsingFactoryMethod * @see #autowireConstructor */
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) { 
       // Instantiate the bean.
       BeanWrapper instanceWrapper = null;
       if (mbd.isSingleton()) { 
          instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
       }
       if (instanceWrapper == null) { 
          // <------------ 
          instanceWrapper = createBeanInstance(beanName, mbd, args);
       }
       final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
       Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    
       // Allow post-processors to modify the merged bean definition.
       synchronized (mbd.postProcessingLock) { 
          if (!mbd.postProcessed) { 
             applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
             mbd.postProcessed = true;
          }
       }
    
       // Eagerly cache singletons to be able to resolve circular references
       // even when triggered by lifecycle interfaces like BeanFactoryAware.
       boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
             isSingletonCurrentlyInCreation(beanName));
       if (earlySingletonExposure) { 
          if (logger.isDebugEnabled()) { 
             logger.debug("Eagerly caching bean '" + beanName +
                   "' to allow for resolving potential circular references");
          }
          addSingletonFactory(beanName, new ObjectFactory<Object>() { 
             @Override
             public Object getObject() throws BeansException { 
                return getEarlyBeanReference(beanName, mbd, bean);
             }
          });
       }
    
       // Initialize the bean instance.
       Object exposedObject = bean;
       try { 
          // <---------- 
          populateBean(beanName, mbd, instanceWrapper);
          if (exposedObject != null) { 
             exposedObject = initializeBean(beanName, exposedObject, mbd);
          }
       }
       catch (Throwable ex) { 
          if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { 
             throw (BeanCreationException) ex;
          }
          else { 
             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
          }
       }
    
       if (earlySingletonExposure) { 
          Object earlySingletonReference = getSingleton(beanName, false);
          if (earlySingletonReference != null) { 
             if (exposedObject == bean) { 
                exposedObject = earlySingletonReference;
             }
             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                for (String dependentBean : dependentBeans) { 
                   if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
                      actualDependentBeans.add(dependentBean);
                   }
                }
                //...
             }
          }
       }
    
       // Register bean as disposable.
       try { 
          registerDisposableBeanIfNecessary(beanName, bean, mbd);
       }
       catch (BeanDefinitionValidationException ex) { 
          throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
       }
    
       return exposedObject;
    }

[https_gitee.com_paincupid_spring-framework.git]: https://gitee.com/paincupid/spring-framework.git
[https_github.com_spring-projects_spring-framework.git]: https://github.com/spring-projects/spring-framework.git
[https_github.com_arthur-dy-lee_arthur-dy-lee-note]: https://github.com/arthur-dy-lee/arthur-dy-lee-note