Spring Bean加载流程详解
Spring Bean的加载流程可以分成两个大阶段：容器启动阶段和Bean实例化阶段。
整体流程概览
容器启动：
1. 加载配置（XML、注解、Java配置）
2. 解析配置，生成BeanDefinition
3. BeanDefinition注册到BeanFactoryBean实例化（延迟或立即）：
4. 实例化Bean（反射创建对象）
5. 属性填充（依赖注入）
6. 初始化（各种回调）
7. 放入单例池
8. Bean可以使用了Bean销毁：
9. 容器关闭时，执行销毁回调
下面我详细展开每一步。
第一阶段：容器启动阶段
步骤1：加载配置文件
Spring支持三种配置方式，都会在容器启动时加载。
方式1：XML配置（传统方式）
<beans><bean id="userService" class="com.example.UserService"><property name="userDao" ref="userDao"/></bean>
</beans>
容器启动时，Spring会：
- 读取XML文件
- 解析XML标签
- 生成BeanDefinition
方式2：注解配置（最常用）
@Configuration
@ComponentScan("com.example")
public class AppConfig {@Beanpublic UserService userService() {return new UserService();}
}
容器启动时，Spring会：
- 扫描@ComponentScan指定的包
- 找到@Component、@Service、@Repository等注解
- 解析@Bean方法
- 生成BeanDefinition
方式3：SpringBoot自动配置
SpringBoot会：
- 扫描starter包的META-INF/spring.factories
- 加载@EnableAutoConfiguration指定的配置类
- 根据条件注解（@ConditionalOnClass等）决定是否生效
实际项目中：
我们现在的项目基本都用注解配置：
- 简洁明了
- 类型安全
- 便于重构
步骤2：解析BeanDefinition
什么是BeanDefinition？
BeanDefinition是Bean的"设计图纸"或"元数据"，描述了如何创建Bean。
BeanDefinition包含的信息：
- beanClass - Bean的类型（如com.example.UserService）
- scope - 作用域（singleton、prototype等）
- lazyInit - 是否懒加载
- dependsOn - 依赖的Bean
- initMethodName - 初始化方法名
- destroyMethodName - 销毁方法名
- propertyValues - 属性值
- constructorArgumentValues - 构造器参数
解析过程：
@Service注解 → BeanDefinitionReader读取↓创建BeanDefinition对象↓设置beanClass=UserService设置scope=singleton设置lazyInit=false...
形象理解：
BeanDefinition就像建筑图纸：
- 图纸说明了房子怎么盖（但房子还没盖）
- 包含了所有建筑信息
- 真正的房子（Bean实例）还没创建
步骤3：注册BeanDefinition
BeanDefinition注册到BeanDefinitionRegistry，实际上是一个Map。
注册过程：
// 伪代码
Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();// 注册
beanDefinitionMap.put("userService", userServiceBeanDefinition);
此时：
- 配置已加载
- BeanDefinition已生成
- 但Bean实例还没创建
- 只是有了"图纸"
这是容器启动阶段，很快，通常几百毫秒。
第二阶段：Bean实例化阶段
步骤4：实例化Bean
实例化就是创建Bean的实例对象，主要通过反射。
实例化时机：
立即实例化（eager）：
- 单例Bean默认在容器启动时实例化
- 可以提前发现问题
延迟实例化（lazy）：
- 第一次getBean时才实例化
- 加快容器启动速度
实例化方式：
方式1：构造器实例化（最常用）
@Service
public class UserService {public UserService() {// 无参构造器}
}// Spring通过反射调用构造器：
UserService bean = UserService.class.newInstance();
方式2：构造器注入
@Service
public class UserService {private final UserDao userDao;// Spring会调用这个构造器，注入依赖public UserService(UserDao userDao) {this.userDao = userDao;}
}
方式3：工厂方法实例化
@Configuration
public class AppConfig {@Beanpublic UserService userService() {// Spring调用这个方法创建Beanreturn new UserService();}
}
方式4：FactoryBean实例化
public class MyFactoryBean implements FactoryBean<UserService> {@Overridepublic UserService getObject() {// Spring调用这个方法获取Beanreturn new UserService();}
}
此时：
- Bean对象已创建（new出来了）
- 但属性还是null（还没注入）
- 还没初始化
步骤5：属性填充（依赖注入）
属性填充就是依赖注入的过程，给Bean的属性赋值。
Spring会扫描Bean的属性：
@Service
public class UserService {@Autowiredprivate UserDao userDao; // 需要注入@Value("${app.name}")private String appName; // 需要注入
}
注入过程：
1. 发现@Autowired注解↓
2. 从容器中查找UserDao类型的Bean↓
3. 如果找到，通过反射设置字段值field.set(userService, userDaoBean)↓
4. 发现@Value注解↓
5. 从环境变量或配置文件读取值↓
6. 设置字段值
注入方式：
字段注入：
@Autowired
private UserDao userDao;
Setter注入：
@Autowired
public void setUserDao(UserDao userDao) {this.userDao = userDao;
}
构造器注入（推荐）：
public UserService(UserDao userDao) {this.userDao = userDao;
}
注入时机：
- 在实例化之后
- 在初始化之前
- 此时对象已创建，开始注入依赖
循环依赖的处理：
如果A依赖B，B依赖A：
- Spring用三级缓存解决
- 提前暴露正在创建的Bean
- 后面我可以详细展开
此时：
- Bean对象已创建
- 属性已注入
- 但还没初始化
步骤6：初始化Bean（重点！）
这是Bean加载流程中最复杂的部分，涉及很多回调接口。按执行顺序来说：
完整的初始化流程（9个步骤）：
1. Aware接口回调（注入Spring内部对象）
如果Bean实现了这些接口，Spring会回调：BeanNameAware.setBeanName() → 注入Bean的名字BeanClassLoaderAware.setBeanClassLoader() → 注入类加载器BeanFactoryAware.setBeanFactory() → 注入BeanFactoryApplicationContextAware.setApplicationContext() → 注入ApplicationContext（最常用）
实际例子：
@Component
public class MyBean implements ApplicationContextAware {private ApplicationContext context;@Overridepublic void setApplicationContext(ApplicationContext context) {// Spring会自动调用，注入ApplicationContextthis.context = context;}public void doSomething() {// 可以通过context获取其他BeanOtherBean bean = context.getBean(OtherBean.class);}
}
2. BeanPostProcessor前置处理
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) {// 在Bean初始化之前调用// 可以修改Bean、替换BeanSystem.out.println("Before init: " + beanName);return bean;}
}
这个方法会在所有Bean初始化前调用。
3. @PostConstruct注解方法
@Service
public class UserService {@PostConstructpublic void init() {// Spring会自动调用这个方法System.out.println("UserService初始化");// 做一些初始化工作}
}
这是JSR-250标准，我们项目中最常用的初始化方式。
4. InitializingBean接口
@Service
public class UserService implements InitializingBean {@Overridepublic void afterPropertiesSet() throws Exception {// Spring会自动调用System.out.println("属性设置完成后调用");}
}
这是Spring自己的接口。
5. init-method（配置的初始化方法）
@Bean(initMethod = "customInit")
public UserService userService() {return new UserService();
}// UserService中
public void customInit() {// Spring会调用这个方法System.out.println("自定义初始化方法");
}
6. BeanPostProcessor后置处理
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {// 在Bean初始化之后调用// 这里可以创建代理对象（AOP就是在这里生成代理的）System.out.println("After init: " + beanName);return bean; // 或返回代理对象
}
AOP的代理对象就是在这个阶段生成的！
完整的初始化顺序（重要，面试常问）：
1. BeanNameAware.setBeanName()
2. BeanClassLoaderAware.setBeanClassLoader()
3. BeanFactoryAware.setBeanFactory()
4. ApplicationContextAware.setApplicationContext()↓
5. BeanPostProcessor.postProcessBeforeInitialization()↓
6. @PostConstruct方法↓
7. InitializingBean.afterPropertiesSet()↓
8. init-method方法↓
9. BeanPostProcessor.postProcessAfterInitialization()（生成代理）
我的记忆口诀：
Aware注入内部对象 → 前置处理 → @PostConstruct → InitializingBean → init-method → 后置处理（生成代理）
实际经验：
我们项目中最常用的是@PostConstruct：
- 简单直观
- 标准注解
- 不需要实现接口
比如：
- 初始化缓存
- 预加载数据
- 建立连接
步骤7：注册到单例池
初始化完成后，Spring会把Bean放入单例池（一个Map）。
单例池：
// 伪代码
Map<String, Object> singletonObjects = new ConcurrentHashMap<>();// 注册
singletonObjects.put("userService", userServiceBean);
此时：
- Bean完全创建好了
- 依赖已注入
- 已初始化
- 可以使用了
以后getBean()时：
- 直接从单例池拿
- 不会再创建新的
- 除非是prototype作用域
步骤8：Bean可以使用
放入单例池后就可以使用了。
使用方式：
方式1：依赖注入（推荐）
@Service
public class OrderService {@Autowiredprivate UserService userService; // Spring自动注入
}
方式2：手动获取
ApplicationContext context = ...;
UserService userService = context.getBean(UserService.class);
实际项目中：
- 99%用依赖注入
- 1%特殊场景手动获取（如动态获取Bean）
第二阶段：Bean销毁阶段
步骤9：销毁Bean
当容器关闭时（如应用停止），Spring会销毁Bean。
销毁顺序（和初始化相反）：
1. @PreDestroy方法↓
2. DisposableBean.destroy()↓
3. destroy-method方法
实际例子：
@Service
public class DatabaseService {private Connection connection;@PostConstructpublic void init() {// 初始化：建立连接connection = dataSource.getConnection();}@PreDestroypublic void cleanup() {// 销毁：关闭连接if (connection != null) {connection.close();}}
}
我的实际使用：
我们在@PreDestroy方法中：
- 关闭数据库连接
- 关闭线程池
- 清理缓存
- 释放资源
Spring优雅停机：
- 收到停止信号
- 不再接受新请求
- 等待现有请求处理完
- 执行@PreDestroy
- 关闭容器
第三部分：Bean生命周期完整流程图
下面是完整的Bean生命周期流程图：
【容器启动阶段】
1. 加载配置├─ XML配置├─ 注解配置└─ 自动配置↓
2. 解析BeanDefinition├─ 解析@Component等注解├─ 解析@Bean方法└─ 生成BeanDefinition对象↓
3. 注册BeanDefinition└─ 放入beanDefinitionMap【Bean实例化阶段】
4. 实例化Bean├─ 推断构造器├─ 通过反射调用构造器└─ 创建Bean对象（属性都是null）↓
5. 属性填充（依赖注入）├─ 解析@Autowired注解├─ 从容器获取依赖Bean├─ 通过反射设置属性└─ 处理@Value注入↓
6. Aware接口回调├─ BeanNameAware├─ BeanFactoryAware└─ ApplicationContextAware↓
7. BeanPostProcessor前置处理└─ postProcessBeforeInitialization()↓
8. 初始化├─ @PostConstruct方法├─ InitializingBean.afterPropertiesSet()└─ init-method↓
9. BeanPostProcessor后置处理├─ postProcessAfterInitialization()└─ 【重要】生成代理对象（AOP）↓
10. 注册到单例池└─ singletonObjects.put(beanName, bean)↓
11. Bean可以使用└─ getBean()直接返回【Bean销毁阶段】
12. 容器关闭├─ @PreDestroy方法├─ DisposableBean.destroy()└─ destroy-method↓
13. 从单例池移除└─ singletonObjects.remove(beanName)
这就是一个Bean从创建到销毁的完整生命周期！
第四部分：三级缓存与循环依赖
Spring通过三级缓存来解决循环依赖，这是Bean加载流程中的一个重要机制。
什么是循环依赖？
@Service
public class A {@Autowiredprivate B b; // A依赖B
}@Service
public class B {@Autowiredprivate A a; // B依赖A
}// A需要B，B需要A，循环了
三级缓存：
// 一级缓存：单例池（成品Bean）
Map<String, Object> singletonObjects = new ConcurrentHashMap<>();// 二级缓存：早期Bean引用（半成品Bean）
Map<String, Object> earlySingletonObjects = new HashMap<>();// 三级缓存：Bean工厂（用于创建代理）
Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
解决循环依赖的流程：
创建A：
1. 实例化A（对象已创建，属性为null）
2. 把A的工厂放入三级缓存
3. 填充A的属性，发现需要B↓创建B：4. 实例化B5. 把B的工厂放入三级缓存6. 填充B的属性，发现需要A7. 从缓存获取A：- 一级缓存没有（A还没完全创建好）- 二级缓存没有- 三级缓存有！取出A的工厂，创建A的代理- 把A的代理放入二级缓存- 返回A的代理给B8. B创建完成，放入一级缓存↓
9. A拿到B，继续创建
10. A创建完成，放入一级缓存
关键点：
- 提前暴露正在创建的Bean（通过三级缓存）
- B注入的是A的早期引用（可能是代理对象）
- 最终A和B都创建成功
但有限制：
- 只能解决单例Bean的循环依赖
- 不能解决构造器的循环依赖
- 不能解决prototype的循环依赖
我的实际经验：
循环依赖在项目中偶尔会遇到：
- 通常是设计不合理
- 最好重构代码，避免循环依赖
- 如果实在避免不了，Spring的三级缓存可以解决
第五部分：实战理解
下面结合实际代码来说明Bean的加载过程，这样更直观。
代码：
@Service
public class UserService implements ApplicationContextAware {@Autowiredprivate UserDao userDao;@Value("${app.version}")private String appVersion;private ApplicationContext context;public UserService() {System.out.println("1. 构造器执行");}@Overridepublic void setApplicationContext(ApplicationContext context) {System.out.println("2. ApplicationContextAware回调");this.context = context;}@PostConstructpublic void init() {System.out.println("3. @PostConstruct初始化");System.out.println(" userDao = " + userDao);System.out.println(" appVersion = " + appVersion);}@PreDestroypublic void destroy() {System.out.println("4. @PreDestroy销毁");}public void doWork() {System.out.println("5. Bean正常工作");}
}
执行顺序：
容器启动：
→ 扫描到@Service注解
→ 生成UserService的BeanDefinition
→ 注册到BeanDefinitionRegistry开始创建Bean：
→ 1. 构造器执行（实例化）
→ 属性填充：注入userDao（从容器获取）注入appVersion（从配置读取）
→ 2. ApplicationContextAware回调
→ BeanPostProcessor前置处理
→ 3. @PostConstruct初始化
→ BeanPostProcessor后置处理（生成代理）
→ 放入单例池Bean可用：
→ 5. Bean正常工作容器关闭：
→ 4. @PreDestroy销毁
→ 从单例池移除
输出：
1. 构造器执行
2. ApplicationContextAware回调
3. @PostConstruct初始化userDao = com.example.UserDao@12345appVersion = 1.0.0
5. Bean正常工作
...
4. @PreDestroy销毁
这就是一个完整的Bean生命周期！
第六部分：高频问题解答
问题1：Bean是什么时候创建的？
单例Bean：
- 默认在容器启动时创建（eager）
- 可以配置@Lazy延迟创建
prototype Bean：
- 每次getBean()时创建
- 不会放入单例池
实际项目中：
- 单例Bean在应用启动时创建
- 启动时间长一点，但运行时快
- prototype用得很少
问题2：构造器、@PostConstruct、InitializingBean的执行顺序？
执行顺序（重要）：
1. 构造器↓
2. @Autowired属性注入↓
3. @PostConstruct↓
4. InitializingBean.afterPropertiesSet()↓
5. init-method
为什么这个顺序？
- 构造器：创建对象
- 属性注入：注入依赖
- @PostConstruct：可以使用注入的依赖了
- InitializingBean：Spring接口
- init-method：自定义方法
实际使用建议：
我一般只用@PostConstruct，因为：
- 最简单直观
- 是Java标准（JSR-250）
- 不需要实现接口或配置
问题3：BeanPostProcessor是干什么的？
BeanPostProcessor是Bean的后置处理器，可以在Bean初始化前后做增强。
两个方法：
- postProcessBeforeInitialization() - 初始化前
- postProcessAfterInitialization() - 初始化后
典型应用：
1. AOP代理生成
AbstractAutoProxyCreator（AOP的实现）：
postProcessAfterInitialization() {if (需要代理这个Bean) {创建代理对象返回代理对象}返回原始Bean
}
@Transactional、@Cacheable等都是在这里生成代理的！
2. 注解处理
@Autowired、@Value、@PostConstruct等注解的处理也是通过BeanPostProcessor实现的。
我的实际使用：
我们项目中自定义过BeanPostProcessor：
- 处理自定义注解
- 修改Bean的属性
- 记录Bean创建日志
问题4：循环依赖是如何解决的？
通过三级缓存来解决，前面已经详细说明了。
核心机制：
- 提前暴露正在创建的Bean
- B可以拿到A的早期引用
- 最终都创建成功
限制：
- 只能解决单例的字段注入循环依赖
- 不能解决构造器循环依赖（无法提前暴露）
- 不能解决prototype循环依赖（不会缓存）
最佳实践：
循环依赖通常说明设计有问题，最好：
- 重构代码
- 提取公共依赖
- 打破循环
第七部分：知识要点总结
回答Bean生命周期问题的要点
1. 先说整体流程
- 分两个阶段：容器启动、Bean实例化
- 主要步骤：实例化 → 属性填充 → 初始化 → 使用 → 销毁
2. 详细展开各步骤
- 实例化：反射创建对象
- 属性填充：依赖注入
- 初始化：各种回调（重点说顺序）
3. 说明关键机制
- 三级缓存解决循环依赖
- BeanPostProcessor生成代理
4. 结合实际经验
- 常用@PostConstruct做初始化
- 常用@PreDestroy做清理
核心要点
✅ 说出完整的初始化顺序 - Aware回调 → 前置处理 → @PostConstruct → InitializingBean...
✅ 三级缓存机制 - Spring通过三级缓存解决循环依赖
✅ 代理生成时机 - AOP的代理是在BeanPostProcessor后置处理时生成的
✅ 源码理解 - 了解AbstractAutowireCapableBeanFactory的doCreateBean方法
✅ 实际经验 - 项目中常用@PostConstruct初始化缓存
常见误区
需要避免的错误理解：
❌ "Bean就是new出来的" - 太简单，忽略了复杂的生命周期
❌ "初始化就是调用init方法" - 不完整，初始化有多个步骤
❌ "循环依赖Spring会报错" - 不对，单例字段注入的循环依赖可以解决
第八部分：快速记忆
口诀记忆
Bean加载七步曲：
- 一扫描，二解析，三注册定义
- 四实例，五注入，六初始化
- 七放池，可使用，销毁有回调
初始化六步骤：
- Aware接口先回调，前置处理做准备
- PostConstruct第一个，InitializingBean第二
- init-method是第三，后置处理生成代理
三级缓存记忆：
- 一级缓存存成品，二级缓存存半成品
- 三级缓存存工厂，循环依赖靠它解
数字记忆
完整流程步骤数：
- 容器启动：3步
- Bean创建：9步
- Bean销毁：3步
- 总共：15步
初始化回调数：
- Aware接口：4个
- 初始化方法：3个（@PostConstruct、afterPropertiesSet、init-method）
- BeanPostProcessor：2个（前置、后置）
附录：高频问题清单
以下是面试常问的问题：
基础问题
- ✅ Spring Bean的生命周期是什么？
- ✅ Bean是如何创建的？
- ✅ 什么是BeanDefinition？
- ✅ Bean什么时候实例化？
初始化相关
- ✅ Bean的初始化流程是什么？
- ✅ @PostConstruct、InitializingBean、init-method的执行顺序？
- ✅ Aware接口有哪些？什么时候回调？
- ✅ BeanPostProcessor是干什么的？
- ✅ AOP的代理是什么时候生成的？
循环依赖
- ✅ Spring如何解决循环依赖？
- ✅ 什么是三级缓存？
- ✅ 构造器循环依赖能解决吗？
- ✅ prototype循环依赖能解决吗？
销毁相关
- ✅ Bean如何销毁？
- ✅ @PreDestroy什么时候执行？
实战问题
- ✅ 你在项目中如何初始化Bean？
- ✅ 遇到过循环依赖吗？怎么解决的？
- ✅ 如何自定义Bean的创建过程？
本文档已经覆盖了所有这些问题！
总结：核心观点
观点1：理解Bean生命周期是理解Spring的关键
很多Spring的特性都建立在Bean生命周期之上：
- 依赖注入
- AOP
- 事件机制
- 生命周期回调
观点2：初始化顺序要记住
面试最常问的就是初始化顺序：
- 构造器 → 属性注入 → Aware → 前置处理 → @PostConstruct → InitializingBean → init-method → 后置处理
观点3：三级缓存是循环依赖的关键
理解三级缓存，就理解了Spring如何解决循环依赖。这是面试的加分项。
观点4：代理生成在后置处理
AOP的代理对象是在BeanPostProcessor的后置处理阶段生成的。这是很多人不知道的。
观点5：@PostConstruct是最佳实践
虽然有多种初始化方式，但@PostConstruct是最推荐的：
- 简单直观
- Java标准
- 最常用
我的核心理念：深入理解源码，但不死记硬背，关键是理解为什么这么设计。
