┌──────────────────────────────────────────────────────────────┐
│ Spring Bean 生命周期(10步) │
├──────────────────────────────────────────────────────────────┤
│ │
│ 1. 实例化(Instantiation) │
│ → BeanDefinition → 反射创建Bean实例(只是空对象) │
│ │ │
│ 2. 属性赋值(Populate Properties) │
│ → @Autowired / @Value 注入依赖 │
│ │ │
│ 3. BeanNameAware.setBeanName() │
│ │ │
│ 4. BeanFactoryAware.setBeanFactory() │
│ │ │
│ 5. BeanPostProcessor.postProcessBeforeInitialization() │
│ → 前置处理(@PostConstruct在此阶段执行) │
│ │ │
│ 6. InitializingBean.afterPropertiesSet() │
│ │ │
│ 7. init-method(自定义初始化方法) │
│ │ │
│ 8. BeanPostProcessor.postProcessAfterInitialization() │
│ → 后置处理(AOP代理在此阶段生成!) │
│ │ │
│ ====== Bean 就绪,可以使用 ====== │
│ │ │
│ 9. DisposableBean.destroy() │
│ │ │
│ 10. destroy-method(自定义销毁方法) │
│ │
└──────────────────────────────────────────────────────────────┘
记忆口诀:实例化 → 填属性 → Aware → 前置 → 初始化 → 后置 → 就绪 → 销毁
// 生命周期代码示例
@Component
public class OrderService implements BeanNameAware, BeanFactoryAware,
InitializingBean, DisposableBean {
@Autowired
private UserService userService; // 步骤2:属性注入
@Override
public void setBeanName(String name) { // 步骤3
System.out.println("3. BeanName: " + name);
}
@Override
public void setBeanFactory(BeanFactory bf) { // 步骤4
System.out.println("4. BeanFactory set");
}
@PostConstruct
public void postConstruct() { // 步骤5中执行
System.out.println("5. @PostConstruct");
}
@Override
public void afterPropertiesSet() { // 步骤6
System.out.println("6. afterPropertiesSet");
}
// 步骤7:@Bean(initMethod="customInit") 或 @Bean(initMethod="customInit")
public void customInit() {
System.out.println("7. custom init-method");
}
@PreDestroy
public void preDestroy() { // 步骤9
System.out.println("9. @PreDestroy");
}
@Override
public void destroy() { // 步骤9
System.out.println("9. DisposableBean.destroy");
}
}
什么是循环依赖:
循环依赖场景:
A 依赖 B(@Autowired B)
B 依赖 A(@Autowired A)
创建A → 发现需要B → 创建B → 发现需要A → ???
如果不处理:无限递归 → StackOverflowError
三级缓存:
// DefaultSingletonBeanRegistry 中的三级缓存
/** 一级缓存:存放完全初始化好的Bean(成品) */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
/** 二级缓存:存放早期暴露的Bean引用(半成品,可能被代理增强) */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
/** 三级缓存:存放Bean工厂(ObjectFactory),用于生成早期引用 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
三级缓存解决循环依赖的完整流程:
场景:A 依赖 B,B 依赖 A
┌──────────────────────────────────────────────────────────────┐
│ 步骤1:创建A │
│ 1.1 实例化A(new A(),A还是空对象) │
│ 1.2 将A的ObjectFactory放入三级缓存 │
│ singletonFactories.put("a", () -> getEarlyBeanReference(a)) │
│ 1.3 属性注入:发现需要B │
│ │
│ 步骤2:创建B │
│ 2.1 实例化B(new B()) │
│ 2.2 将B的ObjectFactory放入三级缓存 │
│ 2.3 属性注入:发现需要A │
│ 2.4 查找A: │
│ 一级缓存 singletonObjects → 没有 │
│ 二级缓存 earlySingletonObjects → 没有 │
│ 三级缓存 singletonFactories → 找到! │
│ → 调用ObjectFactory.getObject() │
│ → 得到A的早期引用(如果需要AOP代理,返回代理对象) │
│ → 将A的早期引用放入二级缓存 │
│ → 从三级缓存移除A │
│ 2.4 B属性注入完成 → B初始化完成 │
│ 2.5 B放入一级缓存,清除二三级缓存中的B │
│ │
│ 步骤3:回到A的创建 │
│ 1.3(继续)B已创建完成,A的属性注入完成 │
│ 1.4 A初始化完成 │
│ 1.5 A放入一级缓存,清除二三级缓存中的A │
│ │
│ 结果:A和B都成功创建,循环依赖被解决 │
└──────────────────────────────────────────────────────────────┘
源码关键片段:
// AbstractAutowireCapableBeanFactory.doCreateBean()
// 实例化后、属性注入前,将ObjectFactory放入三级缓存
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 三级缓存:存放ObjectFactory
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// getEarlyBeanReference:如果需要AOP代理,返回代理对象;否则返回原始对象
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessors()) {
exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
// AbstractAutoProxyCreator.getEarlyBeanReference() 会在此创建AOP代理!
}
return exposedObject;
}
// DefaultSingletonBeanRegistry.getSingleton() 查找Bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 二级缓存
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// Double-check
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 三级缓存 → 调用ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject); // 放入二级
this.singletonFactories.remove(beanName); // 移除三级
}
}
}
}
}
}
return singletonObject;
}
问题:只用一级+二级缓存行不行?
答案:如果不需要AOP代理,两级缓存就够了。
但如果Bean需要AOP代理,三级缓存是必须的。
原因分析:
A(需要AOP代理)→ B → A 的循环依赖场景:
只用两级缓存的问题:
1. A实例化后放入二级缓存(此时A还未被代理)
2. B创建时从二级缓存拿到A的原始对象(非代理)
3. A完成初始化后,AOP生成代理对象
4. B持有的是A的原始对象,而一级缓存中是A的代理对象
5. B中的A和容器中的A不一致!→ Bug
三级缓存如何解决:
1. A实例化后,三级缓存存放 ObjectFactory
2. B创建时,调用ObjectFactory.getObject()
→ getEarlyBeanReference() 会提前创建A的代理对象
3. 代理A放入二级缓存
4. B持有的是A的代理对象 ✓
5. A初始化完成后,使用已经创建好的代理对象(不会重复创建代理)
核心逻辑:
三级缓存的ObjectFactory是一个"延迟决策"机制
→ 正常情况下不需要提前创建代理(在BeanPostProcessor阶段创建)
→ 但如果有循环依赖,就必须提前创建代理
→ ObjectFactory让Spring在"需要时才决定"是否提前创建代理
不能被三级缓存解决的循环依赖:
1. 构造器注入的循环依赖
@Component
public class A {
public A(B b) {} // 构造器注入B
}
@Component
public class B {
public B(A a) {} // 构造器注入A
}
→ 实例化A时就需要B,实例化B时就需要A
→ 此时A还没创建出来,无法放入三级缓存
→ 报错:BeanCurrentlyInCreationException
解决方案:
- 改用setter/字段注入
- 使用@Lazy延迟加载
@Component
public class A {
public A(@Lazy B b) {} // 传入B的代理对象,延迟创建
}
2. prototype作用域的循环依赖
→ prototype不会缓存,无法通过缓存解决
→ 报错:BeanCurrentlyInCreationException
3. @Async + 循环依赖(Spring 5.2.x的Bug)
→ AsyncAnnotationBeanPostProcessor也实现了SmartInstantiationAwareBeanPostProcessor
→ 可能导致提前暴露的代理对象类型不一致
→ Spring Boot 2.6+ 默认禁止循环依赖(spring.main.allow-circular-references=false)
@Autowired注入流程(AutowiredAnnotationBeanPostProcessor):
1. 扫描@Autowired/@Value注解的字段和方法
→ InjectionMetadata(收集需要注入的点)
2. 属性注入时 resolveDependency()
→ 按类型查找(type by type)
→ 如果找到多个 → 按@Qualifier/字段名筛选
→ 如果还是多个 → 抛出NoUniqueBeanDefinitionException
3. 注入方式:
字段注入:field.set(beanInstance, resolvedValue) (反射)
构造器注入:constructor.newInstance(resolvedArgs)
Setter注入:method.invoke(beanInstance, resolvedValue)
@Autowired vs 构造器注入:
字段注入(@Autowired on field):
- 代码简洁
- 无法声明不可变(final字段不能@Autowired)
- 无法在构造器中做校验
- 隐藏了类的依赖关系
构造器注入(推荐):
- 依赖明确(构造器参数就是所有依赖)
- 可以声明final(不可变)
- 可以在构造器中做校验
- 如果使用Lombok @AllArgsConstructor则同样简洁
- Spring官方推荐!
Q1: 三级缓存的value分别是什么类型?
一级缓存singletonObjects:存放完全初始化好的Bean(Object);二级缓存earlySingletonObjects:存放早期Bean引用(可能是代理对象);三级缓存singletonFactories:存放ObjectFactory(lambda表达式,调用时才决定是否生成代理)。
Q2: Spring Boot 2.6为什么默认禁止循环依赖?
循环依赖是设计问题,Spring团队认为不应该依赖这个"特性"。禁止后强制开发者重构代码,消除循环依赖。可通过spring.main.allow-circular-references=true开启,但不推荐。
Q3: BeanPostProcessor和BeanFactoryPostProcessor的区别?
BeanFactoryPostProcessor在Bean实例化之前执行,修改BeanDefinition(如PropertyPlaceholderConfigurer替换占位符)。BeanPostProcessor在Bean实例化之后执行,修改Bean实例(如AOP代理)。执行时机不同,操作对象不同。
Q4: @Resource和@Autowired的区别?
@Resource是JSR-250标准注解,先按名称匹配,再按类型;@Autowired是Spring注解,先按类型匹配,再按名称(需配合@Qualifier)。@Resource可以不指定name(使用字段名),@Autowired默认按类型。
Q5: prototype Bean在每次获取时都会走完整的生命周期吗?
是的。prototype Bean不会缓存,每次getBean()都会创建新实例,走完整的实例化→属性注入→初始化流程。但Spring不负责prototype Bean的销毁(需要客户端代码自己清理)。
1. 写出Bean生命周期的10个步骤,标注AOP代理在哪一步生成。
2. 画出A依赖B、B依赖A时三级缓存的变化过程(每一步标注三级缓存的状态)。
3. 为什么构造器注入的循环依赖无法解决?用创建流程解释。
4. 编写代码验证三级缓存:创建两个互相@Autowired的Bean,分别在构造器、@PostConstruct、afterPropertiesSet中打印日志,观察执行顺序。
5. 如果一个Bean同时被AOP代理和参与循环依赖,代理对象是在哪个阶段创建的?如果不在循环依赖场景中,代理对象又是在哪个阶段创建的?