外观
01 - 从 refresh() 读懂 Spring:Bean 定义、后处理器与单例初始化
适用版本:Spring Framework 6.x、Java 17。核心流程在 Spring Framework 5.3.x 中大体一致,但内部实现和细节可能随小版本变化。
本文是专题入口。阅读时先区分三个层次:对象的创建说明、实际创建出的对象,以及组织这些对象的应用容器。
摘要
Spring 应用启动失败时,真正有用的往往不是最后一行异常,而是“容器走到了哪一步”。本文沿 AbstractApplicationContext#refresh() 拆解 Bean 定义处理、后处理器注册、单例创建和事件发布,并给出一套可直接用于启动故障的定位方法。
1. 场景引入:为什么启动日志总像一团线
假设一个 Spring Boot 服务启动失败,下面用简化的异常链说明排查思路:
text
ApplicationContextException: Unable to start web server
Caused by: UnsatisfiedDependencyException: Error creating bean with name 'orderController'
Caused by: BeanCreationException: Error creating bean with name 'orderService'
Caused by: IllegalStateException: payment endpoint must not be blank有人看到 Unable to start web server,开始检查端口;有人看到 UnsatisfiedDependencyException,怀疑 @Autowired;还有人直接搜索整段异常,希望找到一份能复制的配置。
这段异常链中,Web 容器启动失败是外层现象,orderController 和 orderService 创建失败是异常的传播路径,支付地址为空是最接近业务根因的信息。具体是在构造器、工厂方法还是初始化回调中检查地址,还要查看堆栈中的方法位置。
排查这类问题,不能只认识几个异常名称。更可靠的方法是先回答两个问题:
- Spring 容器启动分为哪些阶段?
- 当前异常发生在 Bean 定义阶段、Bean 创建阶段,还是容器刷新完成之后?
先确定阶段,再检查该阶段的输入和依赖,才能避免把配置缺失误判成端口或注入机制的问题。
2. 先把三个概念分清楚
2.1 IoC:对象控制权发生了转移
**IoC(Inversion of Control,控制反转)**指对象的创建、依赖组装和生命周期管理不再完全由业务代码主动完成,而是交给容器。
由 Spring 容器管理的对象称为 Bean。依赖注入(Dependency Injection,DI)是容器把一个对象所需的其他对象传给它的过程,也是实现 IoC 的常见方式。
没有容器时,代码主动创建依赖。下面是说明对象关系的局部片段:
java
PaymentClient client = new PaymentClient("https://pay.example.com");
OrderService service = new OrderService(client);交给 Spring 后,业务类通过构造器声明需要什么。下面的片段需要同时为 PaymentClient 提供 Bean 定义:
java
import org.springframework.stereotype.Service;
@Service
public class OrderService {
private final PaymentClient paymentClient;
public OrderService(PaymentClient paymentClient) {
this.paymentClient = paymentClient;
}
}容器先找到 PaymentClient,再把它传入 OrderService 的构造器。对象关系因此从业务调用代码中抽离出来,容器也能统一安排初始化、销毁等生命周期回调,以及代理增强。代理是包在目标对象外的一层调用入口,可在调用业务方法时执行额外逻辑;AOP(面向切面编程)常用代理实现事务、日志等能力。
2.2 BeanFactory:管理 Bean 的底层能力
BeanFactory 是 Spring IoC 容器的基础接口。它负责按名称或类型获取 Bean,管理 Bean 定义,并协调 Bean 的创建与依赖解析。
可以先把它理解成一套“Bean 生产与管理系统”,而不是普通的 Map<String, Object>。Map 只能保存已经存在的对象,BeanFactory 还要处理:
- Bean 如何实例化;
- 构造器和工厂方法如何选择;
- 依赖如何查找与注入;
- 初始化回调何时执行;
- 是否需要创建 AOP 代理;
- 单例、原型等作用域如何管理。
最常见的完整实现是 DefaultListableBeanFactory。
这里要区分 BeanDefinition(Bean 定义) 与 Bean 实例:前者是描述类型、作用域和创建方式等信息的元数据,后者是按这些信息创建出的对象。定义存在,不代表对象已经创建,更不代表初始化成功。
作用域决定对象的共享范围。默认单例通常在同一个 BeanFactory、同一个 Bean 名称下共享一个实例;原型作用域则通常在每次获取时重新创建。懒加载表示推迟创建时机,而不是跳过创建过程。
2.3 ApplicationContext:在 BeanFactory 之上组织应用
ApplicationContext 在 BeanFactory 的能力之上增加了应用级功能,例如:
- 国际化消息;
- 应用事件发布;
- 资源加载;
- 环境变量与配置属性;
- 容器生命周期管理;
- 自动发现并执行各种扩展点。
因此,日常开发里说的“Spring 容器”通常是某种 ApplicationContext。它内部持有或创建 BeanFactory,再通过一次完整的刷新过程把应用组织起来。
先用一条主线串起这些概念:准备创建说明 → 安装处理这些说明和对象的扩展点 → 创建并初始化对象 → 完成容器生命周期处理。前两步为后面的对象创建提供规则,最后一步才把已经组装好的组件组织到应用运行阶段。
3. refresh():Spring 容器启动的主干道
Spring 容器实现很多,但常见上下文最终都会沿着 AbstractApplicationContext#refresh() 完成初始化。这里的 refresh(刷新) 不是简单地“重新加载页面”,而是准备或重建容器运行状态。
下面是经过简化的主流程:
图表将在阅读到此处时加载…
源码骨架可以概括为:
java
// 为突出主线而简化,不是可替换框架源码的完整实现
public void refresh() {
prepareRefresh();
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
prepareBeanFactory(beanFactory);
postProcessBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
registerBeanPostProcessors(beanFactory);
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
registerListeners();
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}真实源码还包含启动步骤记录、并发保护、异常销毁和状态恢复等逻辑。下面按职责划分阶段;具体上下文可能在不同时间注册定义或创建基础设施对象,不能把表格理解成严格互斥的时间区间。Environment 表示容器的环境与属性访问入口,Profile 是用于选择环境相关配置的一组名称。
| 阶段 | 主要处理对象 | 典型问题 |
|---|---|---|
| 准备上下文 | Environment、状态标记、早期事件 | 必填配置缺失、Profile 错误 |
| 获得 BeanFactory | BeanDefinition 注册表 | 配置类解析失败、Bean 重名 |
| 处理 BeanDefinition | BeanFactoryPostProcessor | 条件装配异常、属性占位符问题 |
| 注册 Bean 后处理器 | BeanPostProcessor | AOP、注入、校验等基础设施异常 |
| 创建普通单例 | Bean 实例及依赖关系 | 循环依赖、构造异常、初始化失败 |
| 完成刷新 | 生命周期组件、事件监听器 | Web Server、消息消费者启动失败 |
4. 第一段:准备上下文与 BeanFactory
4.1 prepareRefresh() 先准备运行环境
这一阶段会记录启动时间、设置上下文活动状态,并对属性源执行初始化和必要校验。
如果某个自定义上下文要求必须存在指定属性,那么缺少环境变量可能在任何业务 Bean 创建之前就使启动终止。
需要注意,Spring Boot 的外部化配置加载还包含 Boot 自己的启动机制,不能把所有配置加载过程都归到 Framework 的 prepareRefresh()。本文讨论的是 Spring Framework 容器刷新主线;Boot 启动与自动配置会在后续文章单独展开。
4.2 obtainFreshBeanFactory() 获得可用的 BeanFactory
不同上下文获得 BeanFactory 的方式并不完全相同。
例如,某些上下文会创建新的 DefaultListableBeanFactory 并加载 Bean 定义;注解上下文则可能更早就创建了 BeanFactory,刷新时主要完成状态准备。这里应抓住稳定职责:
ApplicationContext负责组织刷新过程,BeanFactory负责保存 Bean 定义并创建 Bean。
前面介绍的 BeanDefinition 在这一阶段进入或已经存在于注册表中,其创建元数据通常包含:
- Bean 类型;
- 作用域;
- 是否懒加载;
- 构造参数;
- 属性值;
- 工厂方法;
- 初始化与销毁方法;
- 依赖关系等元数据。
此时多数业务 Bean 还没有创建。容器主要是在建立“生产说明书”。
4.3 prepareBeanFactory() 安装容器基础设施
这一阶段会配置类加载器、表达式解析器、属性编辑器,并注册部分容器级依赖与后处理器。
例如,业务 Bean 能声明对 ApplicationContext、ApplicationEventPublisher 等容器对象的依赖,并不是因为这些对象都以普通业务 Bean 的方式注册,而是 BeanFactory 提供了相应的依赖解析能力。
这些设施先准备好,后续创建 Bean 时才能解析表达式、转换属性值,并把容器对象交给需要它们的 Bean。postProcessBeanFactory() 则留给上下文子类补充配置,随后才进入统一的后处理器执行阶段。
5. 第二段:先改生产说明书,再创建产品
后处理器是容器在约定阶段调用的扩展接口。这里的“后”不表示一定等应用启动完成后才运行,而是指在容器处理流程中进一步加工定义或对象:
text
BeanFactoryPostProcessor:主要处理 BeanDefinition
BeanPostProcessor:主要处理 Bean 实例5.1 invokeBeanFactoryPostProcessors()
BeanFactoryPostProcessor 允许容器在普通 Bean 实例化前修改 Bean 定义。
这个顺序有直接原因:如果对象已经按旧定义创建,再修改创建说明就无法自然影响那个对象。因此,配置解析和定义修改应先完成,普通业务对象随后再按处理后的定义创建。
其中,BeanDefinitionRegistryPostProcessor 还可以继续注册新的 BeanDefinition。Spring 的注解配置能力大量依赖这一阶段。例如,配置类解析器需要识别 @Configuration、@ComponentScan、@Import 和 @Bean,再把发现的组件转成 BeanDefinition。组件扫描和配置类解析的细节见 02 - 一个 @Component 如何变成 BeanDefinition;Spring Boot 自动配置则通过另一条候选导入链进入这一阶段,见 17 - Spring Boot 自动配置与条件装配。
这解释了一个常见现象:
扫描不到组件时,问题往往发生在 Bean 实例创建之前。此时盯着
@Autowired的字段看,方向已经偏了。
如果日志显示配置类解析失败、Bean 名称冲突或类无法加载,应优先检查:
- 启动类和扫描包的位置;
@ComponentScan范围;@Import引入的配置;- 条件装配是否满足;
- 依赖中是否存在不兼容类。
5.2 registerBeanPostProcessors()
Bean 定义处理之后,容器会注册 BeanPostProcessor,把后续加工 Bean 的处理器装入处理链。注册处理器与处理业务 Bean 是两个时间点:处理器必须先就位,业务 Bean 创建时才能接受相应加工。它的初始化前后回调,以及相关扩展接口,是依赖注入、生命周期注解和 AOP 自动代理等能力的重要基础。
下面是一个局部示例;只有把它注册到上下文,容器才会调用它:
java
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class LoggingBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
if (beanName.equals("orderService")) {
System.out.println("orderService initialized: " + bean.getClass());
}
return bean;
}
}这个日志处理器不替换对象,因此返回传入的 bean,让后续处理器继续加工。返回 null 会截断后续处理链;替换为不兼容对象则可能破坏依赖方的类型要求。
6. 第三段:创建非懒加载单例
finishBeanFactoryInitialization() 是启动阶段最容易出现长堆栈的地方。容器会完成类型转换服务等基础设施的准备,然后实例化剩余的非懒加载单例。
下面以构造器或工厂方法接收依赖的常见路径说明单个 Bean 的创建过程。属性注入所需的依赖则在属性填充阶段解析:
图表将在阅读到此处时加载…
实例化只是得到对象,属性填充负责补齐依赖,初始化回调负责准备对象内部状态,后处理器还可能把它包装成代理。实际过程也涉及构造器推断、循环依赖和 Aware 回调等细节。Aware 是一组让 Bean 接收容器信息的回调接口,例如接收 Bean 名称;循环依赖则指多个 Bean 的依赖关系形成闭环。后续文章会分别展开这些分支。
现阶段最需要记住的是:
getBean()返回的对象不一定就是构造器创建出的原始对象,它可能经过多个后处理器,最终成为代理对象。
6.1 为什么一个 Bean 失败会拖垮整个应用
默认情况下,非懒加载单例会在容器刷新期间完成创建。假设依赖链是:
text
orderController -> orderService -> paymentClient如果 paymentClient 初始化失败,orderService 无法完成依赖组装,orderController 也无法创建。异常会沿依赖链逐层包装,最终导致 refresh() 失败。
refresh() 捕获到严重异常后,会销毁本次已经创建的单例并取消刷新,避免留下一个只初始化了一半却仍对外提供服务的上下文。
这是一种正确性保护,不是 Spring “过于脆弱”。一个关键依赖没有准备好时,让应用明确启动失败,通常比带着不完整状态接收流量更安全。
7. 第四段:完成刷新并启动生命周期组件
业务单例创建完成不等于整个应用已经完全可用。
finishRefresh() 会完成生命周期处理并发布 ContextRefreshedEvent。实现了特定生命周期接口的组件可能在这一阶段启动。Web 应用中,Web Server 的创建与启动还受到具体 ApplicationContext 子类和 Spring Boot 启动流程影响。
ContextRefreshedEvent 是上下文完成刷新时发布的事件,监听器可据此执行逻辑。它不能直接等同于业务已就绪:如果缓存预热或下游连接仍在异步准备,就绪探针仍需根据业务条件决定是否允许接收流量。就绪探针是部署平台判断实例能否处理请求的检查入口。
因此,下列异常虽然都发生在“启动期间”,所属阶段并不一样:
| 现象 | 更可能的阶段 |
|---|---|
| 配置类解析报错 | BeanDefinition 处理阶段 |
NoSuchBeanDefinitionException | 依赖解析或 Bean 创建阶段 |
BeanCurrentlyInCreationException | Bean 创建与循环依赖处理阶段 |
@PostConstruct 抛异常 | Bean 初始化阶段 |
| 端口被占用 | Web Server 启动阶段 |
| 消费者连接消息队列失败 | 生命周期组件启动或业务初始化阶段 |
表格用于缩小范围,不代表只凭异常类型就能下最终结论。具体位置仍应结合完整 Caused by 链和框架日志验证。
8. 代码实战:不用 Spring Boot 观察容器刷新
下面使用纯 Spring Framework 创建一个最小容器,避免自动配置掩盖核心过程。
Maven 依赖示例:
xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.1.14</version>
</dependency>示例使用 Java 17 和 Spring Framework 6.1.14,该版本不代表当前最新版本。实际项目应使用统一的 BOM(集中管理一组依赖版本的清单)或依赖管理,并根据目标版本验证源码细节。
将下面的完整 Java 示例保存为 RefreshDemo.java,在已引入上述 Maven 依赖的 Java 项目中运行 main 方法。这里的支付地址只是字符串,示例不会发起支付请求:
java
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class RefreshDemo {
public static void main(String[] args) {
// 无参构造只创建上下文对象,此时还没有执行完整 refresh。
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext();
context.register(AppConfig.class);
System.out.println("1. configuration registered");
context.refresh();
System.out.println("4. context refreshed");
OrderService service = context.getBean(OrderService.class);
service.createOrder();
context.close();
}
@Configuration
static class AppConfig {
@Bean
static BeanPostProcessor traceBeanPostProcessor() {
return new BeanPostProcessor() {
@Override
public Object postProcessBeforeInitialization(
Object bean, String beanName) {
if (beanName.equals("orderService")) {
System.out.println("2. before initialization");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(
Object bean, String beanName) {
if (beanName.equals("orderService")) {
System.out.println("3. after initialization");
}
return bean;
}
};
}
@Bean
PaymentClient paymentClient() {
return new PaymentClient("https://pay.example.com");
}
@Bean
OrderService orderService(PaymentClient paymentClient) {
return new OrderService(paymentClient);
}
}
static class PaymentClient {
private final String endpoint;
PaymentClient(String endpoint) {
if (endpoint == null || endpoint.isBlank()) {
throw new IllegalArgumentException("endpoint must not be blank");
}
this.endpoint = endpoint;
}
}
static class OrderService {
private final PaymentClient paymentClient;
OrderService(PaymentClient paymentClient) {
this.paymentClient = paymentClient;
}
void createOrder() {
System.out.println("order created, client=" + paymentClient);
}
}
}预期输出顺序大致如下:
text
1. configuration registered
2. before initialization
3. after initialization
4. context refreshed
order created, client=...这里把 BeanPostProcessor 工厂方法声明为 static,可以避免为了创建该后处理器而过早实例化配置类。对于返回 BeanFactoryPostProcessor 或 BeanPostProcessor 的 @Bean 方法,这是值得保留的习惯。
8.1 主动制造一次初始化失败
把配置改成:
java
@Bean
PaymentClient paymentClient() {
return new PaymentClient(""); // 模拟缺失的关键配置
}预期结果是 context.refresh() 抛出异常,4. context refreshed 不会输出。下面是原因链的示意,不是逐字堆栈输出;应结合方法位置从最内层业务原因向外读:
text
IllegalArgumentException: endpoint must not be blank
-> paymentClient 工厂方法失败
-> Bean 创建失败
-> ApplicationContext 刷新失败这里失败的是 paymentClient 工厂方法中的地址校验,属于 Bean 创建阶段,检查方向是创建参数及其配置来源。
9. 反例与正例:不要在初始化阶段偷偷做远程调用
9.1 反例:构造时访问远程服务
以下两段都是设计示意片段,需要项目提供 ProductClient 及其 Bean 定义。假设 loadAllProducts() 会访问远程服务。
java
import org.springframework.stereotype.Component;
@Component
public class ProductCache {
public ProductCache(ProductClient client) {
// 反例:网络抖动会直接阻塞或打断整个容器启动
client.loadAllProducts();
}
}问题不只是“启动变慢”:
- 构造器职责变得不可预测;
- 网络超时会包装成 Bean 创建异常;
- 测试创建上下文时也会访问真实下游;
- 重试、降级和就绪状态难以表达;
- 多个实例同时发布时可能冲击下游。
9.2 正例:分离对象构造与外部资源准备
SmartLifecycle 是参与容器启动和停止的生命周期接口。把外部资源准备放到 start(),可以分离对象构造与运行阶段的职责,但同步执行的远程调用仍会阻塞启动;换一个回调位置并不会消除网络依赖。
java
import org.springframework.context.SmartLifecycle;
import org.springframework.stereotype.Component;
@Component
public class ProductCacheLifecycle implements SmartLifecycle {
private final ProductClient client;
private volatile boolean running;
public ProductCacheLifecycle(ProductClient client) {
this.client = client;
}
@Override
public void start() {
// 生产代码必须配置超时,并明确失败后是阻止启动还是降级运行。
client.loadAllProducts();
running = true;
}
@Override
public void stop() {
running = false;
}
@Override
public boolean isRunning() {
return running;
}
}上面的片段只展示职责划分,不包含重试、降级和客户端资源关闭策略。选择 SmartLifecycle 或其他初始化方式前,需要明确:
- 该资源是不是应用可用的必要条件;
- 失败时应该启动失败还是降级;
- 谁负责超时、重试和关闭;
- 就绪探针何时才能报告可用。
如果数据不是启动必需,可以在首次使用时加载或异步预热;如果它是强依赖,则应设置有界超时并让启动明确失败。具体策略取决于业务可用性要求。
10. 容易踩的坑
10.1 坑:只看异常最外层
ApplicationContextException、BeanCreationException 经常只是包装层。应保留完整日志,从最后一个有业务意义的 Caused by 开始反向还原依赖链。
但“最底层异常永远是真相”也不严谨。某些框架会在底层重试并聚合异常,应同时关注第一个失败时间点、被抑制异常和上下文信息。
10.2 坑:把所有初始化都塞进 @PostConstruct
@PostConstruct 是标记初始化回调的方法注解。对刷新期间创建的 Bean,这个回调执行时依赖通常已经注入,但整个容器尚未刷新完成。此时执行慢 SQL、远程请求或启动后台线程,会放大启动时间和失败复杂度。
初始化回调适合完成对象内部、快速、确定性的状态准备,不适合无限等待外部系统。
10.3 坑:为了启动成功而给所有 Bean 加 @Lazy
懒加载只是把创建时机从启动阶段推迟到首次使用。它可能缩短启动时间,也可能把确定性的启动失败变成首个用户请求失败。
是否使用懒加载,应结合启动目标、内存占用和故障暴露时机评估,不能把它当作 Bean 创建异常的通用修复。
10.4 坑:在 BeanFactoryPostProcessor 中过早获取普通 Bean
BeanFactory 后处理阶段的主要对象是 BeanDefinition。此时主动调用 getBean() 可能导致普通 Bean 提前实例化,使它错过后续处理器,出现 AOP 或注入行为不完整的问题。
10.5 坑:一个配置类承担所有启动逻辑
扫描、数据源、消息队列、定时任务和外部客户端全部堆在一个配置类里,会让依赖关系和失败边界变得模糊。按基础设施与业务模块拆分配置,更容易从异常中的 Bean 名称定位责任范围。
11. 启动故障定位清单
第一步:先判断失败阶段
| 日志关键词 | 优先检查 |
|---|---|
Failed to parse configuration class | 配置类、类路径、@Import、版本兼容性 |
ConflictingBeanDefinitionException | 扫描范围、Bean 命名、重复配置 |
NoSuchBeanDefinitionException | Bean 是否注册、条件是否满足、泛型与限定符 |
NoUniqueBeanDefinitionException | 同类型候选、@Primary、@Qualifier |
BeanCurrentlyInCreationException | 循环依赖、构造器依赖、提前代理 |
BeanCreationException | 构造器、工厂方法、属性填充、初始化回调 |
ApplicationContextException | 继续查看内部原因,可能是 Web 或生命周期组件 |
第二步:展开完整原因链
不要只复制日志最后 20 行。至少保留:
- 第一个 ERROR 前后的上下文;
- 完整
Caused by链; - Bean 名称和注入点;
- 当前启用的 Profile;
- Spring Boot、Spring Framework 与 JDK 版本。
第三步:确认“定义不存在”还是“创建失败”
这是两个完全不同的方向:
- 定义不存在:检查扫描、导入、条件装配和 Bean 名称;
- 定义存在但创建失败:检查构造器、依赖链、配置值和初始化回调。
第四步:检查最近变更与运行环境
- 是否新增了自动配置或 Starter;
- 是否调整包名或启动类位置;
- 是否升级 Spring、Boot、JDK 或第三方依赖;
- 环境变量、Secret、配置中心数据是否齐全;
- 下游地址、证书、DNS 和端口是否可达;
- 是否只有某个 Profile 或某个部署环境失败。
第五步:再决定是否进入源码
遇到以下情况时,读源码通常很有价值:
- Bean 明明存在,却没有成为候选项;
- 后处理器顺序导致行为不同;
- 代理对象类型与预期不一致;
- 某项自动配置的条件没有生效;
- 同一配置在不同版本表现不同。
如果只是配置值缺失或端口占用,先解决直接原因,不必为了“源码排障”把简单问题复杂化。
12. 源码阅读路标
第一次跟 Spring 启动源码,不建议从 Spring Boot 的 main 一路逐行进入所有分支。可以按下面的路标建立断点:
AbstractApplicationContext#refreshPostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessorsPostProcessorRegistrationDelegate#registerBeanPostProcessorsDefaultListableBeanFactory#preInstantiateSingletonsAbstractBeanFactory#doGetBeanAbstractAutowireCapableBeanFactory#createBeanAbstractAutowireCapableBeanFactory#doCreateBeanAbstractAutowireCapableBeanFactory#initializeBean
调试时挑一个自己定义的 Bean,并为 Bean 名称加条件断点,否则 Spring 内部 Bean 数量很多,单步调试很容易淹没在基础设施对象中。
还可以临时打开相关日志:
下面是 Spring Boot 项目的 YAML 配置片段;纯 Framework 示例需要通过所用日志框架配置对应日志级别。
yaml
logging:
level:
org.springframework.context.support: DEBUG
org.springframework.beans.factory.support: DEBUGDEBUG 日志量与具体版本有关,生产环境开启前应评估日志量,定位完成后及时恢复。
13. 进阶:把启动过程看成两条流水线
沿前面的阶段,可以进一步把启动过程划分为元数据和对象两条流水线。这个模型用于判断问题处理的是创建规则还是实际对象,不表示两条流水线在所有分支中绝对隔离。
元数据流水线
text
配置来源
-> BeanDefinition
-> BeanFactoryPostProcessor 修改或补充定义
-> 得到最终 Bean 创建说明对象流水线
text
读取 BeanDefinition
-> 实例化
-> 依赖注入
-> 初始化前处理
-> 初始化回调
-> 初始化后处理
-> 原始对象或代理对象许多问题之所以难排,是因为把两条流水线混在了一起:
- 包扫描问题属于元数据流水线;
@Autowired候选解析横跨定义与对象创建;@PostConstruct异常属于对象流水线;- AOP 代理通常在 Bean 后处理阶段形成;
- 事务是否生效还取决于调用是否经过最终代理对象。
两条流水线通过依赖解析衔接:容器从定义中找到候选,再获取或创建对应对象。因此,“找不到候选”和“候选创建失败”可能都表现为注入异常,却需要沿不同方向检查。
14. 总结
排查 Spring 启动失败的关键,是先把异常放回 refresh() 的具体阶段,再沿 Bean 定义或 Bean 创建链路追到根因。
可带走的三个要点:
ApplicationContext组织应用启动,BeanFactory保存 BeanDefinition 并负责 Bean 的创建与依赖解析。BeanFactoryPostProcessor主要处理 BeanDefinition,BeanPostProcessor主要处理 Bean 实例,二者发生在普通单例创建之前和期间。- 启动故障先区分“Bean 没有被定义”和“Bean 已定义但创建失败”,再结合完整
Caused by链定位阶段。
阅读导航
- 定义如何进入容器:02 - 一个 @Component 如何变成 BeanDefinition
- Boot 如何补充定义:17 - Spring Boot 自动配置与条件装配
- 单个 Bean 如何创建:03 - getBean() 背后的单例 Bean 创建链路
- 扩展点如何选择:18 - Spring 扩展点选型与执行顺序
- 启动性能证据:19 - Spring 启动慢与 Bean 创建慢排查
- 跨层故障分诊:20 - Spring 线上问题排查手册