Spring启动源码分析以及生命周期

一、启动流程

整体代码

AbstractApplicationContext.refresh 为 Spring IOC 容器启动整个逻辑。refresh刷新意味Spring 可以在运行时刷新 BeanFactory ,那么我们不需要重启应用去更新容器。

@Override
public void refresh() throws BeansException, IllegalStateException {
   //1、加锁避免同时关闭或者启动以及线程安全问题
   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();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}
复制代码

流程分析

1、prepareRefresh-预刷新- PropertySource

刷新前的准备，设置以及 active 状态，最重要的是 初始化 PropertySource （子类按需初始化一些属性值）,然后 校验必须的配置属性时可以解析的 。

2、obtainFreshBeanFactory-获得刷新后Beanfactory

通知子类刷新 Beanfactory 并获取刷新后的，子类分两种实现一种是每次刷新重新创建 Beanfactory ,还有一种是不做任何处理仅仅只设置下状态,分别对应可刷新刷新下文- AbstractRefreshableApplicationContext 和 GenericApplicationContext .

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //刷新Beanfactory
	refreshBeanFactory();
    //返回当前BeanFactory
	return getBeanFactory();
}
复制代码

GenericApplicationContext

与为每次刷新创建新的内部 BeanFactory 实例的其他 ApplicationContext 实现相比，此上下文的内部 BeanFactory 从一开始就可用，以便能够在其上注册 BeanDefinition 。 refresh() 只能被调用一次 。内嵌的 BeanFactory 是 DefaultListableBeanFactory 。

@Override
protected final void refreshBeanFactory() throws IllegalStateException {
   if (!this.refreshed.compareAndSet(false, true)) {
      throw new IllegalStateException(
            "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
   }
   this.beanFactory.setSerializationId(getId());
}
//内嵌的BeanFactory
private final DefaultListableBeanFactory beanFactory;
复制代码

AbstractRefreshableApplicationContext

每次刷新都会创建创建一个 BeanFactory 。注意重新重新创建 BeanFactory 为** DefaultListableBeanFactory **！！！

//刷新BeanFactory
protected final void refreshBeanFactory() throws BeansException {
   //存在则销毁
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      //创建新beanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      //配置`Beanfactory` 
      customizeBeanFactory(beanFactory);
      //BeanDefinition 
      loadBeanDefinitions(beanFactory);
       //更新引用
      this.beanFactory = beanFactory;
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}
复制代码

1. 判断 Beanfactory 是否存在，存在则销毁Bean和关闭 Beanfactory

2. 创建新的 Beanfactory

   实际上是创建** DefaultListableBeanFactory **，参数是获取当前 ParentBeanFactory ,Spring IOC 的层次获取Bean

   protected DefaultListableBeanFactory createBeanFactory() {
      return new DefaultListableBeanFactory(getInternalParentBeanFactory());
   }
   复制代码

3. 配置 Beanfactory

   配置了是否允许Beandefinition重写和是否允许循环引用

   protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
      if (this.allowBeanDefinitionOverriding != null) {
         beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
      }
      if (this.allowCircularReferences != null) {
         beanFactory.setAllowCircularReferences(this.allowCircularReferences);
      }
   }
   复制代码

4. 加载 BeanDefinition

   最重要的一步，根据不同子类（不同的 ApplicationContext ）读取Bean的配置元数据以加载 BeanDefinition ，钩子函数同于创建 BeanFactory 后根据不同应用上下去加载 BeanDefinitions 。加载的 BeanDefinition 注册进( registerBeanDefinition ) beanDefinitionMap ( ConcurrentHashMap )根据元数据配置类型主要分以下4中：

/**
 * Load bean definitions into the given bean factory, typically through
 * delegating to one or more bean definition readers.
 */
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
      throws BeansException, IOException;
//DefaultListableBeanFactory
private final Map beanDefinitionMap = new ConcurrentHashMap<>(256);

复制代码

• AbstractXmlApplicationContext :基于XMl配置元数据的上下文，针对不同类型的路径有

  FileSystemXmlApplicationContext :文件系统中XML配置

  ClassPathXmlApplicationContext :classPath下XMl配置

• AnnotationConfigWebApplicationContext :基于Java注解的配置元数据，也是最常用的。

• GroovyWebApplicationContext :基于Groovy的Web上下文

• XmlWebApplicationContext :基于XML的web上下文

3、prepareBeanFactory-预设置Beanfactory的标准配置

配置BeanFactory中一些 标准配置 也是基础配置，如注册环境相关的Bean、 ApplicationContextAwareProcessor 等等。

还有排除一些 Aware 接口的自动装配因为一些 Aware 接口中的方法是 setxxx 开头，所以需要排除。

4、postProcessBeanFactory-Bean工厂的前置处理

用于在 Beanfactory 创建 后的 回调 ,可能需要根据**不同应用上下文（即不同的子类）**对创建后的 Beanfactory 进行设置。此时 BeanDefinition 已经加载完毕，但是bean还未创建，这允许在某些 ApplicationContext 实现中注册特殊的 BeanPostProcessors 等

5、invokeBeanFactoryPostProcessors-执行BeanFactory后置处理器

Spring 预留的扩展点， BeanFactoryPostProcessor 允许我们对已经 加载的 BeanDefinition 进行修改或者添加新的BeanDefinition 。非常重要的 扩展点 ,例如:

（1）配置类解析- ConfigurationClassPostProcessor

ConfigurationClassPostProcessor 完成配置类解析和注册像 @ComponentScan 、 @Import 、 @Bean 、 @ImportSource 导入xml配置文件、 @PropertySource -导入properties文件、 ImportSelector （Spring Boot的自动装配就是注册一个 ImportSelector ）等等这些功能都是在这里实现的。以下为配置解析的代码：

protected final SourceClass doProcessConfigurationClass(
      ConfigurationClass configClass, SourceClass sourceClass, Predicate filter)
      throws IOException {

   if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
      // Recursively process any member (nested) classes first
      processMemberClasses(configClass, sourceClass, filter);
   }

   // Process any @PropertySource annotations 解析@PropertySource
   for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), PropertySources.class,
         org.springframework.context.annotation.PropertySource.class)) {
      if (this.environment instanceof ConfigurableEnvironment) {
         processPropertySource(propertySource);
      }
      //省略日志打印
   }

   // Process any @ComponentScan annotations 组件扫描
   Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
   if (!componentScans.isEmpty() &&
         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
      for (AnnotationAttributes componentScan : componentScans) {
         // The config class is annotated with @ComponentScan -> perform the scan immediately
         Set scannedBeanDefinitions =
               this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
         // Check the set of scanned definitions for any further config classes and parse recursively if needed
         for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
            if (bdCand == null) {
               bdCand = holder.getBeanDefinition();
            }
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
               parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
         }
      }
   }

   // Process any @Import annotations @Import注解
   processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

   // Process any @ImportResource annotations  @ImportResource导入的xml配置文件
   AnnotationAttributes importResource =
         AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
   if (importResource != null) {
      String[] resources = importResource.getStringArray("locations");
      Class readerClass = importResource.getClass("reader");
      for (String resource : resources) {
         String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
         configClass.addImportedResource(resolvedResource, readerClass);
      }
   }

   // Process individual @Bean methods @Bean方法
   Set beanMethods = retrieveBeanMethodMetadata(sourceClass);
   for (MethodMetadata methodMetadata : beanMethods) {
      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
   }

   // Process default methods on interfaces
   processInterfaces(configClass, sourceClass);

   // Process superclass, if any
   if (sourceClass.getMetadata().hasSuperClass()) {
      String superclass = sourceClass.getMetadata().getSuperClassName();
      if (superclass != null && !superclass.startsWith("java") &&
            !this.knownSuperclasses.containsKey(superclass)) {
         this.knownSuperclasses.put(superclass, configClass);
         // Superclass found, return its annotation metadata and recurse
         return sourceClass.getSuperClass();
      }
   }

   // No superclass -> processing is complete
   return null;
}
复制代码

（2）BeanFactory后置处理器的SPI 扩展: BeanDefinitionRegistryPostProcessor

对标准 BeanFactoryPostProcessor SPI 扩展，允许在常规 BeanFactoryPostProcessor 检测开始之前注册进一步的 bean 定义。特别是， BeanDefinitionRegistryPostProcessor 可以注册进一步的 bean 定义，这些定义反过来定义 BeanFactoryPostProcessor 实例。

6、registerBeanPostProcessors-注册Bean后置处理器

BeanPostProcessor 是在Bean 初始化前后 触发进行扩展，所以在实例化bean之前需要注册 BeanPostProcessor （完成Bean后置器的初始化）。

7、initMessageSource-初始化消息资源

初始化消息资源例如 i18n(国际化)

8、initApplicationEventMulticaster-初始化事件广播器

初始化事件广播器以广播事件。 默认情况 下是 SimpleApplicationEventMulticaster 且所有侦听器都在 调用线程 中调用。这允许恶意侦听器阻塞整个应用程序的危险，但增加了最小的开销。可以指定一个替代任务执行器，让侦听器在不同的线程中执行，例如从线程池中执行。 所以利用Spring事件机制来初始化一个资源的适合建议不要太久（因为会阻塞刷新流程） 。

ps：之前犯过一个错误，由于 HDFSClient 在初始化的时候一旦连不上就会不断重试非常耗时（而且不会错误提示），而这个初始化逻辑是放在 @PostConstruct 导致本地在测试其他代码的时候启动巨慢，所以改成事件机制在收到 ContextRefreshedEvent 后初始化，但是发现还是很慢，然后才发现默认情况下是由刷新线程的来广播的。所以之后改成线程池了。

9、onRefresh-钩子函数

钩子函数表示Beanfactory正在刷新中，用于在实例化单例Bean 之前 处理化一些特殊的Bean。允许 子类 处理一些 特殊的Bean的初始化 。

10、registerListeners-注册Listener

注册监听器相关的Bean，用于处理广播器中的事件

11、finishBeanFactoryInitialization-单例Bean实例化

BeanFactory初始化-实例化 所有 的 单例非延迟加载 的Bean。Bean生命周期也体现在里面。实际上所有Bean的创建**都是通过 getBean **去创建的。

1. 初始化conversion service
2. 注册默认的EmbeddedValueResolver
3. 初始化LoadTimeWeaverAware Bean
4. 初始化所有的 非懒加载单例 Bean

//DefaultListableBeanFactory类中
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));
   }

   // Register a default embedded value resolver if no bean post-processor
   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
   // at this point, primarily for resolution in annotation attribute values.
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // 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();
}
复制代码

（1）初始化所有非懒加载的单例Bean

在 DefaultListableBeanFactory 中（也就是创建 BeanFactory ）中实现了该方法。遍历所有的Bean名称 通过 getBean 方法去创建哪些 单例非懒加载 的Bean。

@Override
public void preInstantiateSingletons() throws BeansException {
    //日志打印
   // 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 beanNames = new ArrayList<>(this.beanDefinitionNames);
   // Trigger initialization of all non-lazy singleton beans... 遍历所有的beanName
   for (String beanName : beanNames) {
       //获取合并的BeanDefinition  MergedBeanDefinition？？？
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      //是单例非懒加载非抽象
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         if (isFactoryBean(beanName)) {
            //先尝试获取其FactoryBean
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
               FactoryBean factory = (FactoryBean) bean;
               boolean isEagerInit;
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged(
                        (PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean) factory).isEagerInit());
               }
               //如果是优先innit??
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {
             //非FactoryBean直接创建Bean
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans... 触发特殊的后置SmartInitializingSingleton
   for (String beanName : beanNames) {
       //从单例池种获取
      Object singletonInstance = getSingleton(beanName);
       //如果是SmartInitializingSingleton 则执行后置
      if (singletonInstance instanceof SmartInitializingSingleton) {
         SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction