SpringBoot源码分析之Spring上下文refresh(重点)

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

refresh

首先来看SpringApplication#run方法中refresh()方法

    private void refreshContext(ConfigurableApplicationContext context) {
            refresh(context);
            if (this.registerShutdownHook) {
                try {
                    context.registerShutdownHook();
                }
                catch (AccessControlException ex) {
                    // Not allowed in some environments.
                }
            }
        }

调用的是

AbstractApplicationContext中的refresh方法:

    protected void refresh(ApplicationContext applicationContext) {
            Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
            ((AbstractApplicationContext) applicationContext).refresh();
        } 

方法如下:

    @Override
    public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {//refresh过程只能一个线程处理,不允许并发执行
          // 刷新前准备工作
          prepareRefresh();
          // 调用子类refreshBeanFactory()方法,获取bean factory
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
          // 创建bean Factory的通用设置,添加ApplicationContextAwareProcessor,
          // ResourceLoader、ApplicationEventPublisher、ApplicationContext这3个接口对应的bean都设置为当前的Spring容器,注册环境bean
          prepareBeanFactory(beanFactory);
          try {
             // 子类特殊的bean factory设置
             // GenericWebApplicationContext容器会在BeanFactory中添加ServletContextAwareProcessor用于处理ServletContextAware类型的bean初始化的时候调用setServletContext或者setServletConfig方法
             postProcessBeanFactory(beanFactory);
             // 实例化beanFactoryPostProcessor
             // 调用beanFactoryPostProcessor 这里会调用ConfigurationClassPostProcessor,解析@Configuration的类为BeanDefinition,为后面实例化作准备
             invokeBeanFactoryPostProcessors(beanFactory);
             // 注册 beanPostProcessors 包括自定义的BeanPostProcessor
             // 在实例化Bean后处理 比如AutowiredAnnotationBeanPostProcessor(处理被@Autowired注解修饰的bean并注入)、RequiredAnnotationBeanPostProcessor(处理被@Required注解修饰的方法)
             // 这些都是在创建Context时的reader的构造器中的AnnotationConfigUtils的registerAnnotationConfigProcessors方法中注册的
             registerBeanPostProcessors(beanFactory);
             // 初始化信息源,和国际化相关
             initMessageSource();
             // 初始化容器事件传播器
             initApplicationEventMulticaster();
             // 调用子类特殊的刷新逻辑
             // web程序的容器AnnotationConfigEmbeddedWebApplicationContext中会调用createEmbeddedServletContainer方法去创建内置的Servlet容器。
             onRefresh();
             // 为事件传播器注册事件监听器
             registerListeners();
             // 实例化所有非懒加载单例
             finishBeanFactoryInitialization(beanFactory);
             // 初始化容器的生命周期事件处理器,并发布容器的生命周期事件
             finishRefresh();
          }
          catch (BeansException ex) {
             // ...
          }
          finally {
             // ...
          }
       }
    }

prepareRefresh()方法

            @Override
        protected void prepareRefresh() {
            this.scanner.clearCache();
            super.prepareRefresh();
        }
    protected void prepareRefresh() {
            // 表示在真正做refresh操作之前需要准备做的事情:

            // 设置Spring容器的启动时间,撤销关闭状态,开启活跃状态。
            this.startupDate = System.currentTimeMillis();
            this.closed.set(false);
            this.active.set(true);

            if (logger.isInfoEnabled()) {
                logger.info("Refreshing " + this);
            }

            // Initialize any placeholder property sources in the context environment
            // 初始化属性源信息,初始化占位符
            initPropertySources();

            // Validate that all properties marked as required are resolvable
            // see ConfigurablePropertyResolver#setRequiredProperties
            // 验证环境信息里一些必须存在的属性
            getEnvironment().validateRequiredProperties();

            // Allow for the collection of early ApplicationEvents,
            // to be published once the multicaster is available...
            this.earlyApplicationEvents = new LinkedHashSet<>();
    }

obtainFreshBeanFactory()方法

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            // 获取刷新Spring上下文的Bean工厂
            refreshBeanFactory();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
    }

此时BeanFactory中注册的BeanDefinition和Bean实例

20191102100800\_1.png

20191102100800\_2.png

prepareBeanFactory方法

对BeanFactory(Spring Bean容器)进行相关的设置为后续的使用做准备:

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
            // Tell the internal bean factory to use the context's class loader etc.
            // 设置classloader(用于加载bean),设置表达式解析器(解析bean定义中的一些表达式),添加属性编辑注册器(注册属性编辑器)
            beanFactory.setBeanClassLoader(getClassLoader());
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
            beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

            // Configure the bean factory with context callbacks.
            // 添加ApplicationContextAwareProcessor这个BeanPostProcessor。取消ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、EnvironmentAware这5个接口的自动注入。
            // 因为ApplicationContextAwareProcessor把这6个接口的实现工作做了
            beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
            beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
            beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
            beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
            beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
            beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

            // BeanFactory interface not registered as resolvable type in a plain factory.
            // MessageSource registered (and found for autowiring) as a bean.
            // 设置特殊的类型对应的bean。BeanFactory对应刚刚获取的BeanFactory;
            // ResourceLoader、ApplicationEventPublisher、ApplicationContext这3个接口对应的bean都设置为当前的Spring容器
            beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
            beanFactory.registerResolvableDependency(ResourceLoader.class, this);
            beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
            beanFactory.registerResolvableDependency(ApplicationContext.class, this);

            // Register early post-processor for detecting inner beans as ApplicationListeners.
            beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

            // Detect a LoadTimeWeaver and prepare for weaving, if found.
            if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
                beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                // Set a temporary ClassLoader for type matching.
                beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            }

            // Register default environment beans.
            // 注入一些其它信息的bean实例,比如environment、systemProperties等
            if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
                beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
            }
            if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
                beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
            }
            if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
                beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
            }
    }

postProcessBeanFactory方法

BeanFactory设置之后再进行后续的一些BeanFactory操作。

不同的Spring容器做不同的操作。比如GenericWebApplicationContext容器会在BeanFactory中添加ServletContextAwareProcessor用于处理ServletContextAware类型的bean初始化的时候调用setServletContext或者setServletConfig方法(跟ApplicationContextAwareProcessor原理一样)。

AnnotationConfigEmbeddedWebApplicationContext对应的postProcessBeanFactory方法:

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
      // 调用父类EmbeddedWebApplicationContext的实现
      super.postProcessBeanFactory(beanFactory);
      // 查看basePackages属性,如果设置了会使用ClassPathBeanDefinitionScanner去扫描basePackages包下的bean并注册
      if (this.basePackages != null && this.basePackages.length > 0) {
        this.scanner.scan(this.basePackages);
      }
      // 查看annotatedClasses属性,如果设置了会使用AnnotatedBeanDefinitionReader去注册这些bean
      if (this.annotatedClasses != null && this.annotatedClasses.length > 0) {
        this.reader.register(this.annotatedClasses);
      }
    }

父类EmbeddedWebApplicationContext的实现:

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
      beanFactory.addBeanPostProcessor(
          new WebApplicationContextServletContextAwareProcessor(this));//添加ServletContext注入处理器
      beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    }

invokeBeanFactoryPostProcessors方法

    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
            PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

            // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
            // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
            if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
                beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
                beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
            }
    }

getBeanFactoryPostProcessors()方法返回的数据://不使用dubbo时没有dubbo

由图可知这些BeanFactoryPostProcessor
实例都是在哪添加进context的beanFactoryPostProcessors属性中

20191102100800\_3.png

在Spring容器中找出实现了BeanFactoryPostProcessor接口的processor并执行。Spring容器会委托给PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors方法执行。

介绍两个接口:

  1. BeanFactoryPostProcessor:用来修改Spring容器中已经存在的bean的定义,使用ConfigurableListableBeanFactory对bean进行处理
  2. BeanDefinitionRegistryPostProcessor:继承BeanFactoryPostProcessor,作用跟BeanFactoryPostProcessor一样,只不过是使用BeanDefinitionRegistry对bean进行处理

基于web程序的Spring容器AnnotationConfigEmbeddedWebApplicationContext构造的时候,会初始化内部属性AnnotatedBeanDefinitionReader reader,这个reader构造的时候会在BeanFactory中注册一些post processor,包括BeanPostProcessor和BeanFactoryPostProcessor(比如ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor):

    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors方法**处理BeanFactoryPostProcessor的逻辑如下**:

从Spring容器中找出BeanDefinitionRegistryPostProcessor类型的bean(这些processor是在容器刚创建的时候通过构造AnnotatedBeanDefinitionReader的时候注册到容器中的以BeanDefinition形式),然后按照优先级分别执行,优先级的逻辑如下:

  1. 实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor先全部找出来,然后排序后依次执行
  2. 实现Ordered接口的BeanDefinitionRegistryPostProcessor找出来,然后排序后依次执行
  3. 没有实现PriorityOrdered和Ordered接口的BeanDefinitionRegistryPostProcessor找出来执行并依次执行

接下来从Spring容器内查找BeanFactoryPostProcessor接口的实现类,然后执行(如果processor已经执行过,则忽略),这里的查找规则跟上面查找BeanDefinitionRegistryPostProcessor一样,先找PriorityOrdered,然后是Ordered,最后是两者都没。

这里需要说明的是ConfigurationClassPostProcessor这个processor是优先级最高的被执行的processor(实现了PriorityOrdered接口)。这个ConfigurationClassPostProcessor会去BeanFactory中找出所有有@Configuration注解的bean,然后使用ConfigurationClassParser去解析这个类。ConfigurationClassParser内部有个Map类型的configurationClasses属性用于保存解析的类,ConfigurationClass是一个对要解析的配置类的封装,内部存储了配置类的注解信息、被@Bean注解修饰的方法、@ImportResource注解修饰的信息、ImportBeanDefinitionRegistrar等都存储在这个封装类中

这里ConfigurationClassPostProcessor最先被处理还有另外一个原因是如果程序中有自定义的BeanFactoryPostProcessor,那么这个PostProcessor首先得通过ConfigurationClassPostProcessor被解析出来,然后才能被Spring容器找到并执行。(ConfigurationClassPostProcessor不先执行的话,这个Processor是不会被解析的,不会被解析的话也就不会执行了)。

在我们的程序中,只有主类CoreApplication有@Configuration注解(@SpringBootApplication注解带有@Configuration注解),所以这个配置类会被ConfigurationClassParser的parse(set)方法解析,这个方法又会递归调用parse(AnnotationMetadate,String),调用processConfigurationClass(ConfigurationClass) ConfigurationClass可以有多种创建方法,最终实际调用doProcessConfigurationClass(ConfigurationClass,SourceClass)方法

①parse(set)

②parse(metadate,beanName)

processConfigurationClass(ConfigurationClass)

SourceClass sourceClass = asSourceClass(configClass);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}

while (sourceClass != null);

this.configurationClasses.put(configClass,configclass)

doProcessConfigurationClass解析过程如下:这里的递归可能会把自己搞晕,看原文好一点

一.处理成员类

二.处理@PropertySources注解:进行一些配置信息的解析

三.处理@ComponentScan注解:使用ComponentScanAnnotationParser扫描basePackage下的需要解析的类 实际处理的是ClassPathBeanDefinitionScnner的doScan(basePackages)完成,(@SpringBootApplication注解也包括了@ComponentScan注解,只不过basePackages是空的,空的话会去获取当前@Configuration修饰的类所在的包),并注册到BeanFactory中(这个时候bean并没有进行实例化,而是进行了注册。具体的实例化在finishBeanFactoryInitialization方法中执行)。对于扫描出来的类,返回holder结果集scannedBeanDefinitions,循环遍历holder结果集,递归解析(把扫描出来的component当做CofigurationClass解析)parse(className,beanName)方法(另一个重载方法)最终进入doProcessConfigurationClass(ConfigurationClass,SourceClass)方法,因为此时的ConfigurationClass不包含ComponentScan注解,所以对当前这个ConfiguationClass往下处理,假如是@component注解的类,那么在doProcessConfigurationclass()方法中没有什么处理,就跳过这个被当成ConfigurationClass的BeanDefinition ComponentScanAnnotationParser相关资料见 https://fangjian0423.github.io/2017/06/11/spring-custom-component-provider/

四.处理@Import注解:先递归找出所有的注解,然后再过滤出只有@Import注解的类,得到@Import注解的值。比如查找@SpringBootApplication注解的@Import注解数据的话,首先发现@SpringBootApplication不是一个@Import注解,然后递归调用修饰了@SpringBootApplication的注解,发现有个@EnableAutoConfiguration注解,再次递归发现被@Import(EnableAutoConfigurationImportSelector.class)修饰,还有@AutoConfigurationPackage注解修饰,再次递归@AutoConfigurationPackage注解,发现被@Import(AutoConfigurationPackages.Registrar.class)注解修饰,所以@SpringBootApplication注解对应的@Import注解有2个,分别是@Import(AutoConfigurationPackages.Registrar.class)和@Import(EnableAutoConfigurationImportSelector.class)。找出所有的@Import注解之后,开始处理逻辑:

1.遍历这些@Import注解内部的属性类集合

2.如果这个类是个ImportSelector接口的实现类,实例化这个ImportSelector,如果这个类也是DeferredImportSelector接口的实现类,那么加入ConfigurationClassParser的deferredImportSelectors属性中让第③步处理。否则调用ImportSelector的selectImports方法得到需要Import的类,然后对这些类递归做@Import注解的处理

3.如果这个类是ImportBeanDefinitionRegistrar接口的实现类,设置到配置类的importBeanDefinitionRegistrars属性中

4.其它情况下把这个类入队到ConfigurationClassParser的importStack(队列)属性中,然后把这个类当成是@Configuration注解修饰的类递归重头开始解析这个类,调用processConfigurationClass方法

五.处理@ImportResource注解:获取@ImportResource注解的locations属性,得到资源文件的地址信息。然后遍历这些资源文件并把它们添加到配置类的
importedResources属性

六.处理@Bean注解:获取被@Bean注解修饰的方法,
然后添加到配置类的beanMethods属性

七.处理默认方法接口

八.处理父类(如果有)返回父类

九.返回null

doProcessConfigurationClass解析过程

processConfigurationClass(ConfigurationClass)

parse(metadate,beanName)

③processDeferredImportSelector():处理第四步@Import注解产生的DeferredImportSelector,进行selectImports方法的调用找出需要import的类,然后再调用第四步相同的处理逻辑处理

parse(set)

parse完用ConfigurationClassBeanDefinitionReader,loadBeanDefinitions(set

这里@SpringBootApplication注解被@EnableAutoConfiguration修饰,@EnableAutoConfiguration注解被@Import(EnableAutoConfigurationImportSelector.class)修饰,所以在第四步会找出这个@Import修饰的类EnableAutoConfigurationImportSelector,这个类刚好实现了DeferredImportSelector接口,接着就会在第③步被执行。第 步③selectImport得到的类就是自动化配置类。

EnableAutoConfigurationImportSelector的selectImport方法会在spring.factories文件中找出key为EnableAutoConfiguration对应的值,有81个,这81个就是所谓的自动化配置类(XXXAutoConfiguration)。

ConfigurationClassParser解析(包括递归解析)完成之后,被解析出来的类会放到configurationClasses属性中(processConfigurationClass(ConfigurationClass)方法最后)。然后使用ConfigurationClassBeanDefinitionReader去解析这些类(第一次调用parse完成返回到processConfigBeanDefinitions方法)。

这个时候这些bean只是以beanDefinition被注册到了Spring容器中。下面这段代码是ConfigurationClassBeanDefinitionReader的解析bean过程:

    public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
      TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
      for (ConfigurationClass configClass : configurationModel) {
        // 对每一个配置类,调用loadBeanDefinitionsForConfigurationClass方法
        loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
      }
    }
    private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
        TrackedConditionEvaluator trackedConditionEvaluator) {
      // 使用条件注解判断是否需要跳过这个配置类
      if (trackedConditionEvaluator.shouldSkip(configClass)) {
        // 跳过配置类的话在Spring容器中移除bean的注册
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
          this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClassFor(configClass.getMetadata().getClassName());
        return;
      }
      if (configClass.isImported()) {
        // 如果自身是被@Import注释所import的,注册自己
        registerBeanDefinitionForImportedConfigurationClass(configClass);
      }
      // 注册方法中被@Bean注解修饰的bean
      for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
      }
      // 注册@ImportResource注解注释的资源文件中的bean
      loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
      // 注册@Import注解中的ImportBeanDefinitionRegistrar接口的registerBeanDefinitions
      loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
    }

ConfigurationClassBeanDefinitionReader

invokeBeanFactoryPostProcessors方法总结来说就是从Spring容器中找出BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的实现类并按照一定的规则顺序进行执行。 其中ConfigurationClassPostProcessor这个BeanDefinitionRegistryPostProcessor优先级最高,它会对项目中的@Configuration注解修饰的类(@Component、@ComponentScan、@Import、@ImportResource修饰的类也会被处理)进行解析,解析完成之后把这些bean注册到BeanFactory中。需要注意的是这个时候注册进来的bean还没有实例化。

下面这图就是对ConfigurationClassPostProcessor后置器的总结:

20191102100800\_4.png

registerBeanPostProcessors方法

参考资料
BeanPostProcessor接口总结
Spring内置BeanPostProcessor总结

从Spring容器中找出的BeanPostProcessor接口的bean,并设置到BeanFactory的属性中。之后bean被实例化的时候会调用这个BeanPostProcessor。

该方法委托给了PostProcessorRegistrationDelegate类的registerBeanPostProcessors方法执行。这里的过程跟invokeBeanFactoryPostProcessors类似:

  1. 先找出实现了PriorityOrdered接口的BeanPostProcessor并排序后加到BeanFactory的BeanPostProcessor集合中
  2. 找出实现了Ordered接口的BeanPostProcessor并排序后加到BeanFactory的BeanPostProcessor集合中
  3. 没有实现PriorityOrdered和Ordered接口的BeanPostProcessor加到BeanFactory的BeanPostProcessor集合中

这些已经存在的BeanPostProcessor在postProcessBeanFactory方法中已经说明,都是由AnnotationConfigUtils的registerAnnotationConfigProcessors方法注册的。这些BeanPostProcessor包括有AutowiredAnnotationBeanPostProcessor(处理被@Autowired注解修饰的bean并注入)、RequiredAnnotationBeanPostProcessor(处理被@Required注解修饰的方法)、CommonAnnotationBeanPostProcessor(处理@PreDestroy、@PostConstruct、@Resource等多个注解的作用)等。

如果是自定义的BeanPostProcessor,已经被ConfigurationClassPostProcessor注册到容器内。

这些BeanPostProcessor会在这个方法内被实例化(通过调用BeanFactory的getBean方法,如果没有找到实例化的类,就会去实例化)。

initMessageSource方法

在Spring容器中初始化一些国际化相关的属性。

initApplicationEventMulticaster方法

在Spring容器中初始化事件广播器,事件广播器用于事件的发布。

SpringBoot源码分析之SpringBoot的启动过程中分析过,EventPublishingRunListener这个SpringApplicationRunListener会监听事件,其中发生contextPrepared事件的时候EventPublishingRunListener会把事件广播器注入到BeanFactory中。

所以initApplicationEventMulticaster不再需要再次注册,只需要拿出BeanFactory中的事件广播器然后设置到Spring容器的属性中即可。如果没有使用SpringBoot的话,Spring容器得需要自己初始化事件广播器。

onRefresh方法

一个模板方法,不同的Spring容器做不同的事情。

比如web程序的容器AnnotationConfigEmbeddedWebApplicationContext中会调用createEmbeddedServletContainer方法去创建内置的Servlet容器。 资料: 内置Servlet容器

目前SpringBoot只支持3种内置的Servlet容器:

  1. Tomcat
  2. Jetty
  3. Undertow

registerListeners方法

把Spring容器内的时间监听器和BeanFactory中的时间监听器都添加到事件广播器中。

然后如果存在early event的话,广播出去。

finishBeanFactoryInitialization方法

实例化BeanFactory中已经被注册但是未实例化的所有实例(懒加载的不需要实例化)。

比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类,在这个时候都会被初始化。

实例化的过程各种BeanPostProcessor开始起作用。

参考资料 BeanPostProcessor接口总结Spring内置BeanPostProcessor总结

finishRefresh方法

refresh做完之后需要做的其他事情。

  1. 初始化生命周期处理器,并设置到Spring容器中(LifecycleProcessor)
  2. 调用生命周期处理器的onRefresh方法,这个方法会找出Spring容器中实现了SmartLifecycle接口的类并进行start方法的调用
  3. 发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
  4. 调用LiveBeansView的registerApplicationContext方法:如果设置了JMX相关的属性,则就调用该方法
  5. 发布EmbeddedServletContainerInitializedEvent事件告知对应的ApplicationListener进行响应的操作

总结

Spring容器的refresh过程就是上述11个方法的介绍。内容还是非常多的,本文也只是说了个大概,像bean的实例化过程没有具体去分析,这方面的内容以后会看情况去做分析。

这篇文章也是为之后的文章比如内置Servlet容器的创建启动、条件注解的使用等打下基础。

原文参考 http://fangjian0423.github.io/2017/05/10/springboot-context-refresh/

https://blog.csdn.net/liaokailin/article/details/49107209 贴代码,完整,篇幅多,要耐心看

http://zhangh.tk/2017/07/16/%E3%80%90Spring%E3%80%91%E5%AE%B9%E5%99%A8%E5%88%B7%E6%96%B0/#initMessageSource

https://blog.csdn.net/qq_26000415/article/details/78915221 同样代码多,不推荐

ConfigurationClassPostProcessor类加载解析 https://blog.csdn.net/qq_26000415/article/details/78917682 不推荐


来源:http://ddrv.cn

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » SpringBoot源码分析之Spring上下文refresh(重点)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏