IOC 容器启动核心十二步笔记（附 Spring 源码辅助）

Liuxz2025-10-222025-11-12

IOC 容器是 Spring 框架的核心，其启动过程本质是资源加载、Bean 定义解析、容器初始化、Bean 实例化与依赖注入的完整流程。以 Spring 的AbstractApplicationContext为核心实现类，梳理启动核心十二步，结合关键源码深入理解。

一、容器启动十二步核心流程

第一步：初始化 ApplicationContext 容器实例

核心作用：创建 IOC 容器的基础实例，指定配置源（如 XML 文件、注解配置类），初始化容器的基本属性（如资源加载器、环境变量）。
关键源码：

// 以ClassPathXmlApplicationContext为例
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
    super(parent);
    setConfigLocations(configLocations); // 设置配置文件路径
    if (refresh) {
        refresh(); // 核心启动方法，后续步骤均在其中执行
    }
}

说明：容器实例创建后，通过refresh()方法触发后续所有启动流程，这是 Spring IOC 启动的入口。

第二步：准备刷新容器（prepareRefresh）

核心作用：初始化容器的刷新状态，验证环境变量，初始化属性源（PropertySource）。
关键源码：

@Override
protected void prepareRefresh() {
    // 1. 设置容器启动时间和刷新状态
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    
    // 2. 初始化环境（验证必要的环境变量）
    initPropertySources();
    getEnvironment().validateRequiredProperties();
    
    // 3. 初始化早期事件监听器集合
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

说明：此步骤为容器刷新做前置准备，确保环境配置合法，避免后续流程因环境问题失败。

第三步：获取 BeanFactory（obtainFreshBeanFactory）

核心作用：创建或刷新 BeanFactory（Spring 的 Bean 工厂，负责 Bean 的创建与管理），加载配置资源并解析为 BeanDefinition。
关键源码：

@Override
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory(); // 刷新BeanFactory，核心是创建DefaultListableBeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}

// AbstractRefreshableApplicationContext的refreshBeanFactory实现
@Override
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        DefaultListableBeanFactory beanFactory = createBeanFactory(); // 创建核心BeanFactory实例
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory); // 定制BeanFactory（如是否允许循环引用）
        loadBeanDefinitions(beanFactory); // 加载并解析BeanDefinition（关键步骤）
        this.beanFactory = beanFactory;
    } catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

说明：DefaultListableBeanFactory是 Spring 默认的 BeanFactory 实现，后续所有 Bean 操作均基于此实例。

第四步：准备 BeanFactory（prepareBeanFactory）

核心作用：对 BeanFactory 进行功能增强，注册容器必要的系统 Bean（如类加载器、环境 Bean），设置 BeanPostProcessor 等。
关键源码：

@Override
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 1. 设置BeanFactory的类加载器、表达式解析器等基础属性
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
    // 2. 添加Spring内置的BeanPostProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    
    // 3. 忽略部分Aware接口的自动注入（由ApplicationContextAwareProcessor处理）
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    
    // 4. 注册系统Bean（如environment、systemProperties）
    beanFactory.registerSingleton("environment", getEnvironment());
    beanFactory.registerSingleton("systemProperties", System.getProperties());
}

说明：此步骤为 BeanFactory “赋能”，使其具备 Spring 容器的高级特性（如 Aware 接口支持、属性编辑）。

第五步：BeanFactory 后置处理（postProcessBeanFactory）

核心作用：允许子类扩展 BeanFactory 的功能，在 BeanDefinition 加载完成后、Bean 实例化前对 BeanFactory 进行定制。
关键源码：

// 抽象方法，由子类实现（如WebApplicationContext添加Servlet相关Bean）
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

// 示例：AnnotationConfigWebApplicationContext的实现
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    super.postProcessBeanFactory(beanFactory);
    if (this.servletContext != null) {
        beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    }
}

说明：该步骤是 Spring 的扩展点，用户可通过重写此方法添加自定义逻辑。

第六步：执行 BeanFactoryPostProcessor（invokeBeanFactoryPostProcessors）

核心作用：执行所有注册的BeanFactoryPostProcessor，对 BeanDefinition 进行修改（如属性占位符替换、扫描额外的 Bean）。
关键源码：

@Override
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
    // 若使用AspectJ，注册相关的BeanFactoryPostProcessor
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

典型应用：PropertySourcesPlaceholderConfigurer用于替换 BeanDefinition 中的${}占位符，ConfigurationClassPostProcessor用于解析@Configuration注解的配置类。

第七步：注册 BeanPostProcessor（registerBeanPostProcessors）

核心作用：注册所有BeanPostProcessor（Bean 后置处理器），用于在 Bean 实例化、初始化前后执行自定义逻辑（如 AOP 代理、属性注入增强）。
关键源码：

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

说明：BeanPostProcessor分为BeanBeforeInitialization和BeanAfterInitialization两类，Spring 会按优先级排序后注册，后续在 Bean 生命周期中触发。

第八步：初始化消息源（initMessageSource）

核心作用：初始化国际化消息源（MessageSource），支持多语言配置。
关键源码：

@Override
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            ((HierarchicalMessageSource) this.messageSource).setParentMessageSource(getInternalParentMessageSource());
        }
    } else {
        // 若未自定义，创建默认的MessageSource
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

说明：默认使用DelegatingMessageSource，用户可通过注册名为messageSource的 Bean 自定义消息源。

第九步：初始化应用事件多播器（initApplicationEventMulticaster）

核心作用：初始化事件多播器（ApplicationEventMulticaster），负责事件的发布与监听者的通知。
关键源码：

@Override
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    } else {
        // 默认创建SimpleApplicationEventMulticaster
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
}

说明：事件多播器是 Spring 事件驱动模型的核心，支持同步 / 异步事件发布。

第十步：初始化特殊 Bean（onRefresh）

核心作用：允许子类初始化特定场景的 Bean（如 Web 容器中的 DispatcherServlet、定时任务的 ScheduledTaskRegistrar）。
关键源码：

// 抽象方法，由子类实现
protected void onRefresh() throws BeansException {
    // For subclasses: do nothing by default.
}

// 示例：AbstractRefreshableWebApplicationContext的实现
@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        registerDispatcherServlet(); // 注册Spring MVC的DispatcherServlet
    } catch (Exception ex) {
        throw new ApplicationContextException("Unable to register DispatcherServlet", ex);
    }
}

说明：该步骤是 Spring 针对特定场景的扩展点，不同类型的 ApplicationContext 有不同实现。

第十一步：注册事件监听器（registerListeners）

核心作用：注册所有应用事件监听器（ApplicationListener），并发布早期事件。
关键源码：

@Override
protected void registerListeners() {
    // 1. 注册容器中已有的监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    
    // 2. 从BeanFactory中获取所有ApplicationListener类型的Bean并注册
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    
    // 3. 发布早期收集的事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

说明：监听器注册后，可响应容器发布的事件（如ContextRefreshedEvent容器刷新完成事件）。

第十二步：完成容器刷新（finishRefresh）

核心作用：初始化生命周期处理器，发布容器刷新完成事件，激活 Bean 的生命周期方法。
关键源码：

@Override
protected void finishRefresh() {
    // 1. 清除资源缓存
    clearResourceCaches();
    
    // 2. 初始化生命周期处理器
    initLifecycleProcessor();
    
    // 3. 触发所有Bean的start()方法（实现Lifecycle接口的Bean）
    getLifecycleProcessor().onRefresh();
    
    // 4. 发布ContextRefreshedEvent事件
    publishEvent(new ContextRefreshedEvent(this));
    
    // 5. 注册容器到MBeanServer（JMX支持）
    LiveBeansView.registerApplicationContext(this);
}

说明：此步骤执行后，IOC 容器正式启动完成，Bean 已完成实例化和依赖注入，可对外提供服务。

二、核心总结

流程本质：IOC 容器启动的十二步可归纳为 “容器初始化→资源加载与解析→BeanFactory 增强→Bean 生命周期处理→事件发布” 五大阶段。
核心组件：ApplicationContext（容器入口）、BeanFactory（Bean 管理核心）、BeanDefinition（Bean 元数据）、BeanPostProcessor（Bean 增强）、ApplicationEventMulticaster（事件驱动）。
扩展点：postProcessBeanFactory、onRefresh、BeanFactoryPostProcessor、BeanPostProcessor是 Spring 提供的核心扩展点，支持用户定制容器行为。

通过以上步骤和源码分析，可清晰理解 Spring IOC 容器从创建到可用的完整链路，为后续深入学习 Bean 生命周期、依赖注入等机制奠定基础。