← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L10 - Spring-Bean生命周期与循环依赖

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、Bean生命周期10步(完整流程)


┌──────────────────────────────────────────────────────────────┐
│              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注入原理


@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的销毁(需要客户端代码自己清理)。

面试速记卡(考前30秒速看)

练习题(自测)

1. 写出Bean生命周期的10个步骤,标注AOP代理在哪一步生成。

2. 画出A依赖B、B依赖A时三级缓存的变化过程(每一步标注三级缓存的状态)。

3. 为什么构造器注入的循环依赖无法解决?用创建流程解释。

4. 编写代码验证三级缓存:创建两个互相@Autowired的Bean,分别在构造器、@PostConstruct、afterPropertiesSet中打印日志,观察执行顺序。

5. 如果一个Bean同时被AOP代理和参与循环依赖,代理对象是在哪个阶段创建的?如果不在循环依赖场景中,代理对象又是在哪个阶段创建的?

学习资料