Spring容器启动核心：refresh()方法深度解析

Spring容器refresh()方法深度解析

原创已于 2025-08-15 14:51:21 修改 · 1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言 #java #后端 #spring

于 2025-08-15 14:45:57 首次发布

在Spring应用的生命周期中，refresh()方法是容器初始化的心脏，它承担着从配置到完整应用上下文的神奇转变。本文将深入剖析refresh()的执行流程，揭示Spring容器启动的底层奥秘。

一、refresh()方法全景图

// AbstractApplicationContext.java
public void refresh() throws BeansException {
    synchronized (this.startupShutdownMonitor) {
        // 准备工作
        prepareRefresh();
        
        // 创建BeanFactory并加载Bean定义
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        
        // 配置BeanFactory
        prepareBeanFactory(beanFactory);
        
        try {
            // 后处理BeanFactory
            postProcessBeanFactory(beanFactory);
            
            // 调用BeanFactoryPostProcessor
            invokeBeanFactoryPostProcessors(beanFactory);
            
            // 注册BeanPostProcessor
            registerBeanPostProcessors(beanFactory);
            
            // 初始化消息源
            initMessageSource();
            
            // 初始化应用事件广播器
            initApplicationEventMulticaster();
            
            // 模板方法：特殊Bean的初始化
            onRefresh();
            
            // 注册监听器
            registerListeners();
            
            // 完成BeanFactory初始化，实例化所有单例Bean
            finishBeanFactoryInitialization(beanFactory);
            
            // 完成上下文刷新
            finishRefresh();
        }
        catch (BeansException ex) {
            // 异常处理...
        }
        finally {
            // 清理缓存...
        }
    }
}

二、核心步骤深度解析

1. prepareRefresh() - 刷新前准备

protected void prepareRefresh() {
    // 记录启动时间
    this.startupDate = System.currentTimeMillis();
    
    // 设置激活标志
    this.active.set(true);
    this.closed.set(false);
    
    // 日志输出
    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }
    
    // 初始化占位符属性源（Spring Boot扩展点）
    initPropertySources();
    
    // 验证环境变量（检查必要属性是否存在）
    getEnvironment().validateRequiredProperties();
    
    // 存储早期事件
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

2. obtainFreshBeanFactory() - 获取BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // AbstractRefreshableApplicationContext类中：
    refreshBeanFactory();
    return getBeanFactory();
}

// 典型实现（GenericApplicationContext不同）
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 创建新的Bean工厂
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        
        // 定制化BeanFactory（设置是否允许循环依赖等）
        customizeBeanFactory(beanFactory);
        
        // 加载Bean定义（XML、JavaConfig或注解）
        loadBeanDefinitions(beanFactory);
        this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
        throw new ApplicationContextException(...);
    }
}

3. prepareBeanFactory() - BeanFactory基本配置

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    
    // 设置表达式解析器（SpEL）
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
    
    // 添加属性编辑器注册器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar());
    
    // 添加BeanPostProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    
    // 忽略依赖的Aware接口（由ApplicationContextAwareProcessor处理）
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    // ... 其他Aware接口
    
    // 注册可解析的依赖
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
    // 注册早期后处理器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
}

4. postProcessBeanFactory() - 子类扩展点

// 模板方法，供子类覆盖
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 典型实现：Web应用添加ServletContextAwareProcessor
    // ServletContextAwareProcessor用来处理ServletContext注入问题
    beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(servletContext));
    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
}

5. invokeBeanFactoryPostProcessors() - BeanFactory后置处理

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // 执行PriorityOrdered、Ordered和普通BeanFactoryPostProcessor
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // 清除元数据缓存
    if (beanFactory.getTempClassLoader() == null) {
        beanFactory.clearMetadataCache();
    }
}

执行顺序：

6. registerBeanPostProcessors() - 注册Bean后置处理器

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

后处理器注册流程：

获取所有BeanPostProcessor实现类
按优先级分类：
- PriorityOrdered
- Ordered
- 普通
按分类顺序注册到BeanFactory

7. initMessageSource() - 国际化支持

protected void initMessageSource() {
    // 检查是否已定义messageSource bean
    if (containsBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // 设置父MessageSource用于消息解析链
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    }
    else {
        // 创建默认实现
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

8. initApplicationEventMulticaster() - 事件广播器

protected void initApplicationEventMulticaster() {
    // 检查是否已定义
    if (containsBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster = 
            getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    }
    else {
        // 创建简单事件广播器
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
}

9. onRefresh() - 子类扩展点（Spring Boot关键入口）

// 模板方法，供子类扩展
protected void onRefresh() {
    // 对于Spring Boot应用程序：
    // 在这里创建内嵌Servlet容器（Tomcat/Jetty等）
}

// Spring Boot实现（ServletWebServerApplicationContext）
protected void onRefresh() {
    super.onRefresh();
    try {
        createWebServer(); // 创建Web服务器
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}

10. registerListeners() - 事件监听器

protected void registerListeners() {
    // 添加静态指定的监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    
    // 获取并注册所有ApplicationListener类型的Bean
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    
    // 发布早期事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
        getApplicationEventMulticaster().multicastEvent(earlyEvent);
    }
}

11. finishBeanFactoryInitialization() - 单例Bean初始化

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化ConversionService（类型转换）
    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));
    }
    
    // 注册默认的字符串解析器
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }
    
    // 初始化LoadTimeWeaverAware类型的Bean（AOP相关）
    beanFactory.setTempClassLoader(null);
    beanFactory.freezeConfiguration();
    
    // 实例化所有剩余的单例Bean（非延迟加载）
    beanFactory.preInstantiateSingletons();
}

核心实例化入口：

// DefaultListableBeanFactory
public void preInstantiateSingletons() {
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 处理FactoryBean特殊逻辑
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    // ...
                }
            }
            else {
                // 普通Bean实例化
                getBean(beanName);
            }
        }
    }
    
    // 处理所有SmartInitializingSingleton的回调
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            ((SmartInitializingSingleton) singletonInstance).afterSingletonsInstantiated();
        }
    }
}

12. finishRefresh() - 完成刷新

protected void finishRefresh() {
    // 清除上下文级别的资源缓存
    clearResourceCaches();
    
    // 初始化LifecycleProcessor
    initLifecycleProcessor();
    
    // 启动LifecycleProcessor
    getLifecycleProcessor().onRefresh();
    
    // 发布ContextRefreshedEvent事件
    publishEvent(new ContextRefreshedEvent(this));
    
    // 和JMX注册集成
    LiveBeansView.registerApplicationContext(this);
}

三、refresh()过程的钩子扩展点

1. BeanFactoryPostProcessor

@Component
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 可以修改bean定义
        BeanDefinition bd = beanFactory.getBeanDefinition("dataSource");
        bd.getPropertyValues().add("url", "jdbc:mysql://new-server/db");
    }
}

2. BeanPostProcessor

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // 在初始化方法调用前执行
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 在初始化方法调用后执行
        return bean;
    }
}

3. SmartInitializingSingleton

@Component
public class StartupValidator implements SmartInitializingSingleton {
    @Override
    public void afterSingletonsInstantiated() {
        // 所有单例Bean初始化完成后调用
        // 检查必要服务状态
    }
}

四、经典问题排查指南

1. Bean创建顺序问题

解决方案：

使用@DependsOn指定依赖关系
使用SmartInitializingSingleton处理后续初始化
使用事件驱动机制解耦

2. 循环依赖解决

Spring三级缓存解决循环依赖：

3. AOP代理时机

关键点：

在BeanPostProcessor的后处理方法中生成代理
AbstractAutoProxyCreator负责AOP代理创建

// AbstractAutoProxyCreator
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 检查是否已经是代理对象
        if (!isInfrastructureClass(bean.getClass()) && shouldSkip(bean.getClass(), beanName)) {
            return bean;
        }
        // 创建代理
        return wrapIfNecessary(bean, beanName);
    }
    return bean;
}

五、性能优化建议

减少BeanDefinition扫描：

@ComponentScan(
    basePackages = "com.example.core",
    excludeFilters = @Filter(type = FilterType.REGEX, pattern = "com.example.core.test.*")
)

延迟初始化：

# application.yml
spring:
  main:
    lazy-initialization: true

并行初始化：

// 实现ApplicationContextInitializer
public class ParallelInitContext implements ApplicationContextInitializer<GenericApplicationContext> {
    @Override
    public void initialize(GenericApplicationContext context) {
        ((DefaultListableBeanFactory) context.getBeanFactory())
            .setAllowBeanDefinitionOverriding(true);
        context.setAllowBeanDefinitionOverriding(true);
        // 启用并行初始化
        System.setProperty("spring.beaninfo.ignore", "true");
    }
}