ApplicationContext 创建与刷新

ApplicationContext 创建与刷新是 Spring Boot 启动的核心阶段，完成 Bean 定义的加载和实例化。

ApplicationContext 创建

createApplicationContext()

protected ConfigurableApplicationContext createApplicationContext() {
    return this.applicationContextFactory.create(this.webApplicationType);
}

// 默认工厂实现
public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
    switch (webApplicationType) {
        case SERVLET:
            return new AnnotationConfigServletWebServerApplicationContext();
        case REACTIVE:
            return new AnnotationConfigReactiveWebServerApplicationContext();
        default:
            return new AnnotationConfigApplicationContext();
    }
}

上下文类型选择

refresh() 核心流程

AbstractApplicationContext.refresh()

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

        // 1. 准备刷新上下文
        prepareRefresh();

        // 2. 获取 BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3. 准备 BeanFactory
        prepareBeanFactory(beanFactory);

        // 4. 后处理器处理 BeanFactory
        postProcessBeanFactory(beanFactory);

        // 5. 执行 BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactory);

        // 6. 注册 BeanPostProcessor
        registerBeanPostProcessors(beanFactory);

        // 7. 初始化消息源
        initMessageSource();

        // 8. 初始化事件广播器
        initApplicationEventMulticaster();

        // 9. 初始化特殊 Bean（Web 容器等）
        onRefresh();

        // 10. 注册监听器
        registerListeners();

        // 11. 完成所有 Bean 初始化
        finishBeanFactoryInitialization(beanFactory);

        // 12. 完成刷新
        finishRefresh();
    }
}

prepareRefresh()

初始化准备工作

protected void prepareRefresh() {
    // 设置启动时间
    this.startupDate = System.currentTimeMillis();

    // 设置活跃状态
    this.closed.set(false);
    this.active.set(true);

    // 初始化属性源
    initPropertySources();

    // 校验必要属性
    getEnvironment().validateRequiredProperties();
}

obtainFreshBeanFactory()

BeanFactory 创建

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 刷新 BeanFactory
    refreshBeanFactory();

    // 返回 BeanFactory
    return getBeanFactory();
}

protected final void refreshBeanFactory() throws BeansException {
    if (!hasBeanFactory()) {
        // 创建 DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory);
        // 加载 Bean 定义
        loadBeanDefinitions(beanFactory);
        this.beanFactory = beanFactory;
    }
}

prepareBeanFactory()

BeanFactory 标准配置

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());

    // 设置表达式解析器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());

    // 添加属性编辑器注册器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar());

    // 添加特殊 BeanPostProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor());

    // 注册标准环境 Bean
    beanFactory.registerSingleton("environment", getEnvironment());
    beanFactory.registerSingleton("systemProperties", getEnvironment().getSystemProperties());
    beanFactory.registerSingleton("systemEnvironment", getEnvironment().getSystemEnvironment());
}

invokeBeanFactoryPostProcessors()

执行后处理器顺序

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 1. 先执行 BeanDefinitionRegistryPostProcessor
    //    - ConfigurationClassPostProcessor（处理 @Configuration）
    //    - 处理 @ComponentScan、@Import 等

    // 2. 后执行普通 BeanFactoryPostProcessor
    //    - PropertySourcesPlaceholderConfigurer
    //    - 自定义后处理器
}

ConfigurationClassPostProcessor 核心逻辑

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    // 1. 解析 @Configuration 类
    // 2. 处理 @ComponentScan
    // 3. 处理 @Import
    // 4. 处理 @ImportResource
    // 5. 处理 @Bean 方法
    // 6. 注册所有 BeanDefinition
}

onRefresh()

Web 容器初始化

// ServletWebServerApplicationContext
protected void onRefresh() {
    super.onRefresh();
    try {
        // 创建 Web 容器
        createWebServer();
    } catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}

private void createWebServer() {
    WebServer webServer = null;
    ServletWebServerFactory factory = getWebServerFactory();
    webServer = factory.getWebServer(getSelfInitializer());
    this.webServer = webServer;
    // 启动容器（在 finishRefresh 中）
}

finishBeanFactoryInitialization()

完成非延迟 Bean 初始化

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化 ConversionService
    if (!beanFactory.hasConversionService()) {
        beanFactory.setConversionService(createConversionService());
    }

    // 冻结所有 Bean 定义（不允许修改）
    beanFactory.freezeConfiguration();

    // 初始化所有非延迟加载的单例 Bean
    beanFactory.preInstantiateSingletons();
}

preInstantiateSingletons()

public void preInstantiateSingletons() throws BeansException {
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                // 处理 FactoryBean
            } else {
                // 获取 Bean（触发创建）
                getBean(beanName);
            }
        }
    }
}

finishRefresh()

刷新完成处理

protected void finishRefresh() {
    // 清除资源缓存
    clearResourceCaches();

    // 初始化生命周期处理器
    initLifecycleProcessor();

    // 发布 ContextRefreshedEvent
    publishEvent(new ContextRefreshedEvent(this));

    // 启动 Web 容器
    LiveBeansView.registerApplicationContext(this);
}

注意：refresh() 方法是 Spring 容器的核心，理解每个步骤对排查启动问题至关重要。

要点总结

• ApplicationContext 根据应用类型自动选择
• refresh() 包含 12 个核心步骤
• ConfigurationClassPostProcessor 处理配置类
• onRefresh() 创建 Web 容器
• finishRefresh() 触发容器启动