浅析 Spring 启动过程：从源码到核心方法

发布于：2025-05-16 ⋅ 阅读:(11) ⋅ 点赞:(0)

浅析 Spring 启动过程：从源码到核心方法


在这里插入图片描述
在 Java 企业级开发中，Spring 框架是最常用的基础框架之一。了解 Spring 的启动过程，对于理解 Spring 的工作原理、优化应用性能以及排查问题都有着至关重要的作用。本文将结合纯 Spring 的注解方式启动类，深入解读 Spring 启动过程的源码，重点分析 refresh()方法及其包含的关键步骤。

一、Spring 注解方式启动类 Demo

首先，我们创建一个简单的 Spring 项目，通过注解方式启动 Spring 容器。

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@ComponentScan("com.coderzpw")      // 扫描该路径下的包
@Configuration
public class AppConfig {
    public static void main(String[] args) {
        // Spring容器启动
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

        // 可以在这里获取Bean进行后续操作

        // 容器关闭
        applicationContext.close();
    }
}

在上述代码中：

  • @Configuration注解表明该类是一个配置类，用于替代传统的 XML 配置文件。
  • @ComponentScan("com.coderzpw") 注解用于扫描指定包及其子包下的所有@Component、@Service、@Repository、@Controller等注解标注的类，并将它们注册为 Spring 容器中的 Bean。
  • 在main方法中，通过AnnotationConfigApplicationContext来创建 Spring 应用上下文，传入配置类AppConfig.class，从而启动 Spring 容器。

二、Spring 启动过程源码解析

当我们调用AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);时，Spring 的启动过程便开始了。接下来我们深入源码，一探究竟。

​AnnotationConfigApplicationContext构造函数

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
	this();
	register(annotatedClasses);
	refresh();
}

上述代码中：

  • this()调用了无参构造函数，在无参构造函数中会初始化reader和scanner，用于读取配置类和扫描 Bean。
  • register(componentClasses)方法将传入的配置类注册到容器中。
  • 最后调用的refresh()方法是 Spring 启动过程的核心，它完成了 Spring 容器的初始化、Bean 的加载、配置的解析等一系列关键操作。

refresh()方法详解

对 BeanPostProcessor、BeanFactoryPostProcessor不熟悉的同学可以查看下面文章：
【Spring BeanFactoryPostProcessor：机制解读与代码实践】
【Spring BeanPostProcessor：机制解读与代码实践】

refresh()方法位于AbstractApplicationContext类中，其源码如下：

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 准备上下文环境，记录启动时间，标记活动状态等
		prepareRefresh();

		// 告诉子类刷新内部bean工厂
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 准备bean工厂，设置一些属性，如类加载器、表达式解析器等
		prepareBeanFactory(beanFactory);

		try {
			// 允许子类在bean工厂准备好后进行进一步的设置
			postProcessBeanFactory(beanFactory);

			// 执行BeanFactoryPostProcessor接口的实现类，在bean实例化之前修改bean的定义
			invokeBeanFactoryPostProcessors(beanFactory);

			// 注册BeanPostProcessor接口的实现类，用于在bean实例化、配置和初始化前后进行处理
			registerBeanPostProcessors(beanFactory);

			// 初始化消息源，用于国际化等功能
			initMessageSource();

			// 初始化应用事件广播器
			initApplicationEventMulticaster();

			// 留给子类初始化其他特殊bean的钩子方法
			onRefresh();

			// 注册监听器到事件广播器
			registerListeners();

			// 实例化所有剩余的非惰性单例bean
			finishBeanFactoryInitialization(beanFactory);

			// 完成刷新过程，发布容器刷新完成事件等
			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();

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

refresh()方法主要包含 12 个步骤，每个步骤都承担着不同的职责：

  1. prepareRefresh();
    【准备工作】
    作用：在开始刷新容器之前，进行一些准备工作，如设置容器的启动时间、标记容器为活跃状态、清除缓存等。这是 IoC 容器启动的前奏，为后续的初始化操作做好准备。
  2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    【获取Bean工厂】
    作用：获取或创建一个新的 BeanFactory 实例，BeanFactory 是 Spring IoC 容器的核心，负责管理 Bean 的定义和实例化。这个步骤是 IoC 容器启动的基础，后续的 Bean 加载和创建都依赖于BeanFactory。（重要：XML配置形势下，加载BeanDefinition就是在这个步骤，具体方法步骤：obtainFreshBeanFactory -> refreshBeanFactory -> loadBeanDefinitions）
  3. prepareBeanFactory(beanFactory);
    【配置 Bean 工厂】【为BeanFactory做基础的配置】
    作用：对获取到的 BeanFactory 进行一些默认配置，如设置类加载器、添加默认的Bean 后置处理器（例如ApplicationContextAwareProcessor、ApplicationListenerDetector）、设置表达式解析器等。这些配置会影响后续 Bean 的创建和初始化过程。
  4. postProcessBeanFactory(beanFactory);
    【后置处理 Bean 工厂】【子类做后置扩展处理】
    作用：允许子类对 BeanFactory 进行额外的后置处理，例如注册自定义的 BeanPostProcessor 或 BeanFactoryPostProcessor。这为开发者提供了扩展 IoC 容器功能的机会。
  5. invokeBeanFactoryPostProcessors(beanFactory);
    【调用注册的BeanFactoryPostProcessor实现类】
    作用：调用所有注册的 BeanFactoryPostProcessor 实现类，这些处理器可以在 Bean 定义加载完成后、Bean 实例化之前对 Bean 定义进行修改。通过这个步骤，开发者可以动态地修改 Bean 的定义信息。
  6. registerBeanPostProcessors(beanFactory);
    【注册 BeanPostProcessor的实现类】【只注册、不调用】
    作用：注册所有的 BeanPostProcessor实现类，这些处理器会在Bean实例化、配置和初始化前后进行额外的处理。例如，AutowiredAnnotationBeanPostProcessor可以处理@Autowired注解，实现自动装配功能
  7. initMessageSource();
    【初始化消息源】
    作用：初始化消息源，用于支持国际化和消息解析。这在需要处理多语言的应用程序中非常有用。
  8. initApplicationEventMulticaster();
    【初始化应用[事件广播器]】
    [事件广播器]：负责将事件广播给所有注册的监听器。
    [事件发布者（ApplicationEventPublisher）]：负责发布事件
    [事件监听器（ApplicationListener）]：负责监听特定类型的事件
    作用：初始化应用事件广播器，用于发布和监听应用程序中的事件。Spring 的事件机制允许组件之间进行松耦合的通信。
  9. onRefresh();
    【留给子类扩展】【空实现】【子类特定的刷新操作】
    作用：允许子类实现特定的刷新逻辑，例如在 WebApplicationContext 中，会创建和初始化 Servlet 上下文。
  10. registerListeners();
    【注册监听器】
    作用：注册应用程序中的事件监听器，这些监听器会监听由事件广播器发布的事件，并执行相应的处理逻辑。
  11. finishBeanFactoryInitialization(beanFactory);
    【实例化所有剩余的单例 Bean】【Bean 实例化、初始化、BeanPostProcessor的执行】
    作用：实例化所有剩余的单例 Bean，这是 IoC 容器启动的核心步骤之一。在这个过程中，BeanFactory 会根据 Bean 定义创建 Bean 实例，并进行依赖注入和初始化操作。
  12. finishRefresh();
    【完成刷新】
    作用：完成容器的刷新工作，清除缓存、发布容器刷新完成事件等。此时，IoC 容器已经完全启动并可以正常使用。

三、refresh()的核心方法/步骤

obtainFreshBeanFactory() - 获取Bean工厂

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();    // 触发BeanDefinition加载
    return getBeanFactory();
}

obtainFreshBeanFactory()是Spring容器启动流程中的核心方法，其核心性体现在：

  • BeanFactory生命周期起点：负责创建或刷新BeanFactory实例，是IoC容器诞生的起点
  • 配置加载入口：触发XML配置的解析流程，将配置转化为可操作的BeanDefinition对象

BeanDefinition加载流程解析

1. 传统Spring项目（XML配置为例）

核心步骤：

  • refreshBeanFactory()：销毁旧容器 → 创建DefaultListableBeanFactory → 加载BeanDefinition
  • loadBeanDefinitions()：通过XmlBeanDefinitionReader解析XML文件，生成BeanDefinition并注册

源码示例：

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
	// ....
	initBeanDefinitionReader(beanDefinitionReader);
	loadBeanDefinitions(beanDefinitionReader);
}

2. SpringBoot项目（注解驱动）

  • 实现差异：
    • 本质使用GenericApplicationContext代替AbstractRefreshableApplicationContext
    • obtainFreshBeanFactory()仅设置序列化ID，不执行配置加载
  • 实际加载入口：
    • ConfigurationClassPostProcessor（后置处理器）扫描@Configuration类
    • @ComponentScan注解触发包扫描，动态注册BeanDefinition

prepareBeanFactory(beanFactory) - 配置 Bean 工厂

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 告诉内部 Bean 工厂使用上下文的类加载器等。
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
	
	// 注册ApplicationContextAwareProcessor （ApplicationContextAwareProcessor负责处理实现了ApplicationContextAware的类）
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	// 

	// 注册早期后处理器，用于将内部 bean 检测为 ApplicationListeners。
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// ...

	// 注册默认的 环境Bean
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

核心配置：

  • 设置类加载器
  • 添加默认的Bean 后置处理器（例如ApplicationContextAwareProcessor、ApplicationListenerDetector）
  • 注册默认的 环境bean

invokeBeanFactoryPostProcessors() - 调用注册的BeanFactoryPostProcessor实现类

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// 【核心】调用 BeanFactoryPostProcessors
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

	// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
	// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
	// ...
}

进入invokeBeanFactoryPostProcessors：

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
	// 【 1. 处理所有 BeanDefinitionRegistryPostProcessor（子接口）】
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
		List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
				new LinkedList<BeanDefinitionRegistryPostProcessor>();
	
		// 分阶段处理：PriorityOrdered → Ordered → 普通实现
	
		// 执行 PriorityOrdered 
		invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
	
		// 执行 Ordered
		invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
	
		// 执行 普通实现
		invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}
	
	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}
	
	// ...
	
	// 【 2. 处理所有 BeanFactoryPostProcessor】
	// 分阶段处理：PriorityOrdered → Ordered → 普通实现
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
	List<String> orderedPostProcessorNames = new ArrayList<String>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
	
	// 执行 PriorityOrdered 
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
	
	// 执行 Ordered
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
	
	// 执行 普通实现
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
	// ...
}

具体执行方法：invokeBeanFactoryPostProcessors

/**
 * 调用给定的BeanFactoryPostProcessor bean。
 */
private static void invokeBeanFactoryPostProcessors(
		Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

	for (BeanFactoryPostProcessor postProcessor : postProcessors) {
	    // 执行具体的postProcessBeanFactory方法
		postProcessor.postProcessBeanFactory(beanFactory);
	}
}

其中ConfigurationClassPostProcessor是BeanFactoryPostProcessor的子类，会在该阶段执行其后置处理逻辑。负责解析 @Configuration 类及其注解（如 @ComponentScan、@Bean），动态注册新的 BeanDefinition
ConfigurationClassPostProcessor核心功能：

  1. 扫描配置类： 识别 @Configuration 类，解析其上的 @ComponentScan、@Import 等注解
  2. 处理条件注解： 根据 @Conditional 注解判断是否注册对应的 BeanDefinition

finishBeanFactoryInitialization() - 实例化、初始化所有剩余的单例 Bean【重要】【重要】【重要】

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// ...

	// 实例化所有剩余的 （非 lazy-init） 单例。【核心】【重要】【bean实例化 -> 属性填充 -> 初始化】
	beanFactory.preInstantiateSingletons();
}

finishBeanFactoryInitialization() 方法核心作用总结：

  1. 初始化基础服务
    • 设置类型转换服务（ConversionService），处理 @Value 和属性注入的类型转换
  2. 冻结 Bean 配置
    • 调用 freezeConfiguration()，停止修改 BeanDefinition，确保后续实例化过程的线程安全
  3. 实例化非懒加载单例 Bean
    • 遍历所有 BeanDefinition，触发 getBean() 实例化非抽象、单例且非懒加载的 Bean
    • 特殊处理 FactoryBean：根据 SmartFactoryBean.isEagerInit() 判断是否立即生成目标对象
  4. 初始化回调与扩展
    • 触发 SmartInitializingSingleton.afterSingletonsInstantiated()，在所有单例创建完成后执行自定义逻辑
    • 处理 LoadTimeWeaverAware 接口，支持类加载期字节码增强（如 AspectJ LTW）
  5. 资源回收与优化
    • 释放临时类加载器（TempClassLoader），避免内存泄漏

该方法涉及 Spring IoC 最复杂的实例化阶段，包括 bean的实例化、属性填充（解决循环依赖）、BeanPostProcesser的前置处理（部分Aware处理逻辑）、bean的初始化、BeanPostProcesser的后置处理（AOP 代理的生成时机）等细节

一篇文章是讲解不清楚finishBeanFactoryInitialization()的，请期待后续总结 ✿ヽ(°▽°)ノ✿

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布