Spring容器启动流程——refresh()单个方法分析

文章目录

Spring启动过程
- this()方法
- refresh()
- - prepareRefresh()
  - obtainFreshBeanFactory()
  - prepareBeanFactory()
  - postProcessBeanFactory()
  - invokeBeanFactoryPostProcessors
  - registerBeanPostProcessors
  - initMessageSource()
  - initApplicationEventMulticaster()
  - onRefresh()
  - registerListeners()
  - finishBeanFactoryInitialization
  - finishRefresh()

Spring启动过程

Spring启动过程在线流程图

在这里插入图片描述

运行下面代码启动Spring的时候，会经过下面的一些步骤：

创建一个BeanFactory --> 解析指定的配置类 —> 进行包扫描 —> 生成BeanDefinition --> BeanDefinitionMap、BeanpostProcessor、单例池

public static void main(String[] args) {

    // 创建一个Spring容器
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

    UserService userService = (UserService) context.getBean("userService");
    userService.test();
}

创建一个DefaultListableBeanFactory，在创建AnnotationConfigApplicationContext这个类时，会先初始化它的父类，在父类的构造函数中会创建一个DefaultListableBeanFactory对象，并赋值给BeanFactory属性

// GenericApplicationContext就是AnnotationConfigApplicationContext的父类
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

	private final DefaultListableBeanFactory beanFactory;

	......


	/**
	 * beanDefinitionMap、beanDefinitionNames等等常见的集合都是在DefaultListableBeanFactory这个类中的
	 * Create a new GenericApplicationContext.
	 */
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}
    
    ......
}

this()方法

这里主要就是给BeanFactory设置一些内容

接下来回到创建AnnotationConfigApplicationContext类的构造方法中

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    // 构造DefaultListableBeanFactory、AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner
    this();
    // 通过上一步创建的reader，把将参数传递过来的componentClasses生成BeanDefinition，并存入BeanDefinitionMap中
    register(componentClasses);
    refresh();
}


// 上面this()方法会到这里来
public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		// 重点就是会创建AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner
		this.reader = new AnnotatedBeanDefinitionReader(this);
		createAnnotatedBeanDefReader.end();
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

在创建AnnotatedBeanDefinitionReader类的构造方法中，最终会调用到AnnotationConfigUtils.registerAnnotationConfigProcessors()方法中，在该方法中就会往BeanFactory中注册很多常见的BeanPostProcessor。比如判断一个类能不能进行依赖注入、专门解析配置类的、@Autowired和@Resource注解相关的、事件相关的

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    BeanDefinitionRegistry registry, @Nullable Object source) {

    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {

        // 设置beanFactory的OrderComparator为AnnotationAwareOrderComparator
        // 它是一个Comparator，是一个比较器，可以用来进行排序，比如new ArrayList<>().sort(Comparator);
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        // 用来判断某个Bean能不能用来进行依赖注入
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    // 注册ConfigurationClassPostProcessor类型的BeanDefinition
    // 它就是用来解析配置类的
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 注册AutowiredAnnotationBeanPostProcessor类型的BeanDefinition
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 注册CommonAnnotationBeanPostProcessor类型的BeanDefinition
    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 注册PersistenceAnnotationBeanPostProcessor类型的BeanDefinition
    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition();
        try {
            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                                                AnnotationConfigUtils.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
        }
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 注册EventListenerMethodProcessor类型的BeanDefinition，用来处理@EventListener注解的
    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    // 注册DefaultEventListenerFactory类型的BeanDefinition，用来处理@EventListener注解的
    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

接下来是创建ClassPathBeanDefinitionScanner扫描器会进行的一些操作，这里就只是对@Component注解进行扫描的功能，在ClassPathScanningCandidateComponentProvider.registerDefaultFilters()方法中

protected void registerDefaultFilters() {

    // 注册@Component对应的AnnotationTypeFilter
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));

    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();

    try {
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
        logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
    }

    try {
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
        logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-330 API not available - simply skip.
    }
}

refresh()

上面只是给BeanFactory设置了一些内容，但肯定是还没有设置完的。接下来的重点就是在refresh()方法中

接下来方便写笔记，我们把AnnotationConfigApplicationContext成为Spring容器，把AnnotationConfigWebApplicationContext成为SPringMVC容器

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    // 构造DefaultListableBeanFactory、AnnotatedBeanDefinitionReader、ClassPathBeanDefinitionScanner
    this();
    // 通过上一步创建的reader，把将参数传递过来的componentClasses生成BeanDefinition，并存入BeanDefinitionMap中
    register(componentClasses);
    refresh();
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

        // Prepare this context for refreshing.
        // 往Environment中添加一些环境变量，并检查是否有必须的环境变量
        // 在Spring容器中没有重写该方法，所以执行的是一个空方法，而在Springmvc容器中重写了该方法，会把ServletContext中的参数对设置到Environment
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 这里会判断能否刷新，并且返回一个BeanFactory, 刷新不代表完全情况，主要是先执行Bean的销毁，
        // 然后重新生成一个BeanFactory，再在接下来的步骤中重新去扫描等等
        // 我们这里使用Spring容器的父类的该方法的实现中，它不允许我们重复刷新，SpringMVC的那个类允许重复刷新，重复刷新就是调用refresh()方法
        // Spring容器这里其实就是把上一步构造方法中创建的BeanFactory对象直接返回
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 准备BeanFactory
        // 1. 设置BeanFactory的类加载器、SpringEL表达式解析器、类型转化注册器
        // 2. 添加三个BeanPostProcessor，注意是具体的BeanPostProcessor实例对象
        // 3. 记录ignoreDependencyInterface
        // 4. 记录ResolvableDependency
        // 5. 添加三个单例Bean
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 子类来设置一下BeanFactory
            postProcessBeanFactory(beanFactory);

            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");

            // Invoke factory processors registered as beans in the context.
            // BeanFactory准备好了之后，执行BeanFactoryPostProcessor，开始对BeanFactory进行处理
            // 默认情况下:
            // 此时beanFactory的beanDefinitionMap中有6个BeanDefinition，5个基础BeanDefinition+AppConfig的BeanDefinition
            // 而这6个中只有一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor
            // 这里会执行ConfigurationClassPostProcessor进行@Component的扫描，扫描得到BeanDefinition，并注册到beanFactory中
            // 注意：扫描的过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些BeanFactoryPostProcessor也得在这一步执行
            invokeBeanFactoryPostProcessors(beanFactory);  // scanner.scan()

            // Register bean processors that intercept bean creation.
            // 将扫描到的BeanPostProcessors实例化并排序，并添加到BeanFactory的beanPostProcessors属性中去
            registerBeanPostProcessors(beanFactory);

            beanPostProcess.end();

            // Initialize message source for this context.
            // 设置ApplicationContext的MessageSource，要么是用户设置的，要么是DelegatingMessageSource
            initMessageSource();

            // Initialize event multicaster for this context.
            // 设置ApplicationContext的applicationEventMulticaster，要么是用户设置的，要么是SimpleApplicationEventMulticaster
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 给子类的模板方法
            onRefresh();

            // Check for listener beans and register them.
            // 把定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            // 完成Bean工厂的初始化，在这个方法内部会去实例化非懒加载的单例Bean
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        }

        catch (BeansException ex) {
            ......
        }

        finally {
            ......
        }
    }
}

prepareRefresh()

往Environment中添加一些环境变量，并检查是否有必须的环境变量

父类中定义的方法模板，子类去实现的重写的，AnnotationConfigApplicationContext没有重写该方法，但是SpringMVC的那个类重写了。比如子类可以把ServletContext中的参数对设置到Environment

还会对Environment进行有没有启动时必须要有的环境变量

// 创建一个Spring容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(AppConfig.class);
// Spring启动时 测试设置必须要有的环境变量
context.getEnvironment().setRequiredProperties("aaaa");

context.refresh();

还有一些其他的监听器相关的

obtainFreshBeanFactory()

也是一个父类的模板方法，根据子类自己的具体实现去运行

这里会判断能否刷新，并且返回一个BeanFactory, 刷新不代表完全情况，主要是先执行Bean的销毁，然后重新生成一个BeanFactory，再在接下来的步骤中重新去扫描等等
我们这里使用Spring的AnnotationConfigApplicationContext容器的父类的该方法的实现中，它不允许我们重复刷新，SpringMVC的AnnotationConfigWebApplicationContext类允许重复刷新，重复刷新就是使用context重复调用refresh()方法

Spring的AnnotationConfigApplicationContext容器这里其实就是把构造方法中创建的BeanFactory对象直接返回

AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.register(AppConfig.class);
context.refresh();
context.refresh();
context.refresh();

prepareBeanFactory()

把类加载器设置到BeanFactory的属性中
如果支持EL表达式，那么就去创建一个SpringEL表达式解析器
注册一些默认的类型转换器
添加一些BeanPostProcessor，用来处理一些Aware回调
添加一些Aware类型的接口到ignoredDependencyInterfaces这个Set集合中，Spring原始依赖注入时会判断忽略这个集合中的类型
往resolvableDependencies这个Map中添加四个对象，依赖注入在DefaultListableBeanFactory.findAutowireCandidates()方法根据类型找bean对象会用到这个Map
往BeanFactory中添加ApplicationListenerDetector监听器
Aspectj相关的代码，不用太理会
添加一些环境变量相关的bean进单例池中

postProcessBeanFactory()

也是一个父类的模板方法，根据子类自己的具体实现去运行

invokeBeanFactoryPostProcessors

BeanFactory准备好了之后，执行BeanFactoryPostProcessor，开始对BeanFactory进行处理

这里会把BeanFactory当做方法参数传进去，在该方法中会去进行包扫描scanner.scan()，把扫描得到的BeanDefinition放到BeanFactory中。

在上面笔记《Bean生命周期——生成BeanDefinition》这一节有详细的介绍

registerBeanPostProcessors

将扫描到的BeanPostProcessors实例化并排序，并添加到BeanFactory的beanPostProcessors属性中去

上一个invokeBeanFactoryPostProcessors()方法会去进行包扫描，会扫描到我们自己定义的一些BeanPostProcessor，通过本方法添加进BeanFactory中去。

initMessageSource()

我们知道ApplicationContext相比较于BeanFactory而言，它是支持国际化功能的。

我们在使用国际化功能时，是会使用@Bean自己在配置类中写一个返回MessageSource的方法的。

因为之前的步骤已经包扫描完成了，这里会通过beanFactory.getBean("messageSource",MessageSource.class)得到这个MessageSource的Bean对象，然后赋值给BeanFactory的messageSource属性。

// 如果我们自己没有定义，Spring则默认生成一个
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;

initApplicationEventMulticaster()

和上一个国际化方法一样，这个是事件发布器。我们知道ApplicationContext相比较于BeanFactory而言，它是支持事件发布功能的。

我们在使用国际化功能时，是会使用@Bean自己在配置类中写一个返回ApplicationEventMulticaster的方法的。

因为之前的步骤已经包扫描完成了，这里会通过beanFactory.getBean("applicationEventMulticaster",ApplicationEventMulticaster.class)得到这个ApplicationEventMulticaster的Bean对象，然后赋值给BeanFactory的applicationEventMulticaster属性。

// 如果我们自己没有定义，Spring则默认生成一个
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

onRefresh()

也是一个父类的模板方法，根据子类自己的具体实现去运行

registerListeners()

把程序员自己定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件

finishBeanFactoryInitialization

完成Bean工厂的初始化，在这个方法内部会去实例化非懒加载的单例Bean

在上面笔记《Bean生命周期——Spring容器启动时创建单例Bean》这一节有详细的介绍

finishRefresh()

Spring容器启动完成后如果我们想要运行某些代码，就是通过此方法实现的

这里会通过beanFactory.getBean("lifecycleProcessor",LifecycleProcessor.class)得到这个LifecycleProcessor的Bean对象，然后赋值给BeanFactory的lifecycleProcessor属性。

然后在Spring容器启动完成后就会调用这个Bean对象的onRefresh()方法，也就是最终会调用start()方法

protected void finishRefresh() {
   ...

   // 设置lifecycleProcessor，默认为DefaultLifecycleProcessor
   initLifecycleProcessor();

   // 调用LifecycleBean的start()
   getLifecycleProcessor().onRefresh();

   ...
}

@Component
public class HsLifecycle implements SmartLifecycle{

    @Override
    public void start() {
        // Spring容器启动完成就会调用该方法
        System.out.println("start...");
    }

    @Override
    public void stop() {

    }

    @Override
    public boolean isRunning() {
        // 这个返回值为true才会调用stop()方法，为false则会调用start()方法
        return false;
    }
}