spring分析-启动大致流程

spring 实现分析

从spring 的启动开始，启动始终绕不开 refresh 方法，这个是spring的核心方法，用来启动spring

/**
* spring 启动的核心方法
* @throws BeansException
* @throws IllegalStateException
*/
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 准备启动阶段，记录启动时间，准备 properties 和 验证
        prepareRefresh();

        // 获取 beanFactory  通常是 DefaultListableBeanFactory 实例，在 注解配置 和 xml 配置中的实现稍微有些不同
        // 不同总的来说就是获取一个 DefaultListableBeanFactory
        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 准备阶段，就是对 beanFactory 进行一些配置
        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // 准备完毕后的一个方法，子类可以对 beanFactory 继续做一些修改，本类中是一个空方法
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            // 这是一个重要的地方，对应接口为 BeanFactoryPostProcessor 以及子接口 BeanDefinitionRegistryPostProcessor
            // BeanFactoryPostProcessor 接口是可以针对 beanFactory 做一些修改，譬如添加一些 bean 之类的
            // BeanDefinitionRegistryPostProcessor 接口只是方法参数为 BeanDefinitionRegistry，可以再添加一些 BeanDefinition
            // 这个接口是一个重要的扩展接口，spring 内部 或者外部都可以通过这个接口的实现来扩展
            // 可以通过 ApplicationContext 的 addBeanFactoryPostProcessor 方法添加，或者注册 Bean，spring 就可以感知到，进行触发
            // 发生顺序很重要，先调用通过 beanFactory.add 添加的，然后调用 BeanDefinition 容器里面的
            // spring 内部的第一个调用的容器中的定义就是 ConfigurationClassPostProcessor，这个用了根据 配置类来找各个地方的 BeanDefinition ，注册到 容器中
            // 无论xml配置还是注解配置，通常有一个入口配置（springboot 中通常就是 Application），然后根据这个配置类，找到其他的配置类，根据所有配置类（找到一个解析一个）找到定义的 bean
            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);

            // 经过上一步调用后，所有的 BeanDefinition 都已经找到并且注册到容器中类
            // 这一步就是找到容器中实现 BeanPostProcessor 的 BeanDefinition，然后添加到 beanFactory 中
            // BeanPostProcessor 这个也是一个非常重要的扩展接口，譬如spring内部各种 Aware 接口，就是有 这个接口的实现类扩展出来的
            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);


            // 初始化 MessageSource 接口，如果没有，就使用默认的，注册到容器里面
            // 这里需要说明一下，spring 内部有两个容器，一个是 bean 容器的，一个是 BeanDefinition 容器的，实例是根据 BeanDefinition 的定义生成的
            // Initialize message source for this context.
            initMessageSource();

            // 初始化 ApplicationEventMulticaster 接口，如果没有，就使用默认的，注册到容器里面
            // Initialize event multicaster for this context.
            initApplicationEventMulticaster();

            // 这是一个空方法，子类可以实现，可以在 bean 容器里面添加一些东西
            // Initialize other special beans in specific context subclasses.
            onRefresh();

            // 这里是注册 ApplicationListener ，一些是通过 beanFactory 注册的，一些是用户自定义的 Bean ，然后发布 early 事件
            // Check for listener beans and register them.
            registerListeners();

            // 这个方法里面将实例化所有非延时加载的单例 bean
            // 实例化就是调用 getBean 方法
            // 这里将触发 BeanPostProcessor
            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);

            // 这里是最后一步，清空 resource缓存，注册生命周期处理bean，然后获取所有 周期接口的实现启动，发布启动事件，注册到 JMX
            // 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();

            // 取消refresh
            // 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();
        }
    }
}

这个方法固定住了 spring 的启动步骤，已经预留了扩展空方法（内部扩展用），和扩展接口（外部扩展用）
譬如不同环境下的 ApplicationContext 可以重写空方法来适应直接的环境（譬如web），spring的使用者，或者第三方框架集成到spirng，则可以通过扩展接口。
整个流程并不复杂，复杂的地方在可以通过扩展接口来修改内部的一些内容，spring 内部也是实现这些接口来进行扩展的 BeanFactoryPostProcessor BeanDefinitionRegistryPostProcessor 这两个接口在BeanFactory 准备好后进行修改，可以注册 bean 或者 BeanDefinition，譬如注解配置，主要找到主配置如果，就可以根据主配置上的信息寻找到各个地方的 BeanDefinition ，注册到 BeanFactory 中
BeanPostProcessor 接口，可以在 Bean 实例化前后进行调用，spring 内部扩展出来的各种 Aware 接口，就根据这个接口的实现扩展出来的

我们根据启动流程，来完整分析一下spirng的启动细节，先从注解配置开始看

AnnotationConfigApplicationContext

refresh 之前

使用注解配置启动，最简单的启动代码如下

@Configuration
@ComponentScan
public class Application {
   
   

    @Bean
    MessageService mockMessageService() {
        return () -> "Hello World!";
    }

    @Bean
    public BeanFactoryPostProcessor beanFactoryPostProcessor() {
        return new BeanFactoryPostProcessor() {
            @Override
            public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
                System.out.println(" = = = = = = = = = = == = =  = ");
            }
        };
    }

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
        MessagePrinter printer = context.getBean(MessagePrinter.class);
        printer.printMessage();
        System.out.println("================= beanDefinition names ===========");
        for (String name : context.getBeanDefinitionNames()) {
            System.out.println(name);
        }
        System.out.println("============= bean names =============");
        Iterator<String> beanNamesIterator = ((AnnotationConfigApplicationContext) context).getBeanFactory().getBeanNamesIterator();
        while (beanNamesIterator.hasNext()) {
            System.out.println(beanNamesIterator.next());
        }
    }
}

通常指定一个或者多个配置类，或者指定要扫描的包,最后调用的构造方法为

// 默认构造
public AnnotationConfigApplicationContext() {
    // 注意，这个里面在 beanFactory 中添加类一些 BeanFactoryPostProcessor
    this.reader = new AnnotatedBeanDefinitionReader(this);
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}
// 指定配置类
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    this();
    register(annotatedClasses);
    refresh();
}

// 指定包扫描
public AnnotationConfigApplicationContext(String... basePackages) {
    this();
    scan(basePackages);
    refresh();
}

在构造 reader 的时候回添加几个 BeanFactoryPostProcessor 的实现，这里就不贴调用过程，直接贴最后调用注册的地方

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

    // 通常来说 ApplicationContext 内部的 beanFactory 是 DefaultListableBeanFactory 实现
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        // 设置依赖排序实现
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        // 设置注入候选解析
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    // 下面添加一些 BeanDefinition 到 registry
    // 注意，这里用的是 LinkedHashSet，是有顺序的
    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(4);

    // 添加 ConfigurationClassPostProcessor，这个类第一个添加，实现 BeanDefinitionRegistryPostProcessor，功能就是根据配置类，解析 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，功能后面分析
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBe