罗罗编程学习记录
本页内容 展开查看

06.2.1.2 依赖注入与循环依赖

所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.2 Java Spring 生态 / 06.2.1 Spring Framework

本节要解决的问题

  • Bean 之间怎么“找到彼此”?
  • 两个 Bean 互相依赖时,容器为什么不会死循环?
  • 为什么构造器注入会报循环依赖,而 setter 注入不会?

06.2.1.2-001 构造器注入、setter 注入、字段注入有什么区别?

一句话结论

构造器注入在创建时必须提供全部依赖,能保证不可变与完全初始化;setter/字段注入允许先创建再填充,灵活但隐藏依赖、难测试。

对比

方式 依赖何时注入 能否 final 循环依赖 推荐度
构造器 实例化时 可以 构造器之间会失败 高
setter 实例化后 不可以 可被三级缓存解决 中
字段 实例化后(反射) 不可以 可被解决 低

示例

@Service
public class OrderService {
    private final OrderRepository repo;      // final 保证不可变
    public OrderService(OrderRepository repo) {
        this.repo = repo;
    }
}

常见误区

  • 构造器注入不是“更麻烦”,而是把依赖变成显式契约,编译期就能发现缺失。
  • 字段注入无法在单元测试中直接 new 出完整对象,通常要反射或容器。

追问

  • 为什么 Spring 官方推荐构造器注入?依赖不可变、非空、易于测试、避免循环依赖。
  • 构造器注入需要 @Autowired 吗?只有一个构造器时可省略(Spring 4.3+)。

06.2.1.2-002 @Autowired 的注入流程是怎样的?

一句话结论

由 AutowiredAnnotationBeanPostProcessor 在 Bean 初始化前扫描构造器、字段、方法上的 @Autowired,按类型/限定符从容器解析依赖并反射注入。

展开原理

  1. 容器实例化 Bean 后,调用所有 BeanPostProcessor 的 postProcessBeforeInitialization。
  2. AutowiredAnnotationBeanPostProcessor 找到注入点(InjectionMetadata)。
  3. 每个注入点调用 DefaultListableBeanFactory.resolveDependency。
  4. 先按类型找候选,再按 @Qualifier/@Primary/@Priority 收敛;找不到抛 NoSuchBeanDefinitionException。
  5. 反射设置字段或调用 setter/构造器。

示例

@Component
public class A {
    @Autowired
    private B b;          // 字段注入:容器反射赋值
}

常见误区

  • @Autowired(required=false) 找不到时注入 null,容易在运行期 NPE。
  • 静态字段不能被 @Autowired 注入。

追问

  • 注入发生在 Bean 生命周期的哪一步?实例化之后、@PostConstruct 之前。
  • 为什么构造器注入在实例化阶段就要解析?因为构造参数必须当时提供。

06.2.1.2-003 同一类型有多个 Bean 时,如何决定注入哪个?

一句话结论

按优先级:@Qualifier 精确指定 > @Primary 标记默认 > @Priority/Ordered 排序 > 字段名/参数名与 Bean 名匹配;仍无法唯一则报错。

示例

@Bean @Primary
public PayService wxPay() { return new WxPayService(); }

@Bean
public PayService aliPay() { return new AliPayService(); }

@Autowired @Qualifier("aliPay")
private PayService payService;   // 明确选支付宝

常见误区

  • 字段名恰好等于 Bean 名时会“碰巧”注入成功,改名后突然报错。
  • @Primary 只影响“没有限定符”的注入点,不会覆盖 @Qualifier。

追问

  • 集合注入多个实现会怎样?List<PayService> 会拿到全部候选,顺序受 @Order 影响。
  • 如何禁用某个候选?设置 autowireCandidate=false 或使用条件注解。

06.2.1.2-004 什么是循环依赖,Spring 默认能解决哪些?

一句话结论

A 依赖 B、B 又依赖 A 形成环。Spring 能解决单例 + setter/字段注入的循环依赖,不能解决构造器注入和原型 Bean 的循环依赖。

概念解释

创建 A 需要 B,创建 B 又需要 A。如果没有提前暴露“半成品”引用,容器会无限递归。Spring 的办法是:先实例化 A,把 A 的早期引用放进缓存,再创建 B 时注入这个引用,最后完成 A 的初始化。

图示

getBean(A)
  → 实例化 A(此时 A 尚未注入属性)
  → 暴露 A 的 ObjectFactory 到三级缓存
  → 填充 A 的属性,发现依赖 B
     → getBean(B)
        → 实例化 B,注入 A(从缓存拿到早期引用)
     → B 完成
  → A 完成初始化

常见误区

  • 循环依赖被解决不等于设计合理;它通常说明职责边界不清。
  • 代理场景下(AOP)早期引用可能是代理,实际注入的可能是代理对象。

追问

  • 为什么 Spring Boot 2.6 后默认禁止循环依赖?spring.main.allow-circular-references=false,鼓励重构。
  • 如何发现循环依赖?启动报 BeanCurrentlyInCreationException,看异常里的 Bean 链。

06.2.1.2-005 三级缓存分别存什么,为什么需要三级?

一句话结论

一级 singletonObjects 存完整单例;二级 earlySingletonObjects 存提前暴露的早期引用;三级 singletonFactories 存能生成早期引用的 ObjectFactory(用于 AOP 代理)。

展开原理

  • 为什么不能只把半成品放进一级?因为半成品还没初始化,不能被普通获取。
  • 为什么需要三级而不是二级?如果 A 需要被代理,提前暴露的应该是代理对象而不是原始对象。ObjectFactory 在需要时才调用 getEarlyBeanReference 生成代理,避免所有 Bean 都提前代理。
  • 获取顺序:一级 → 二级 → 三级;三级取出后升级到二级,并删除三级。

示例

// 简化示意
ObjectFactory<?> factory = () -> getEarlyBeanReference(beanName, mbd, bean);
this.singletonFactories.put(beanName, factory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);

常见误区

  • 三级缓存不是为了“缓存三种 Bean”,而是同一 Bean 在三个不同成熟度的存放位置。
  • 只有发生循环依赖时才会用到二、三级;正常 Bean 直接进一级。

追问

  • 为什么 AOP 代理需要 ObjectFactory?因为要等确定发生循环依赖时才提前创建代理,避免重复代理。
  • 二级缓存什么时候清除?Bean 完全初始化进入一级后,会从二/三级移除。

06.2.1.2-006 为什么构造器注入的循环依赖无法解决?

一句话结论

构造器注入要求“创建 A 时就必须拿到完整的 B”,而 B 又要求完整的 A,二者都无法先出生,容器只能报错。

展开原理

  • setter/字段注入允许“先 new 出空对象,再填属性”,所以能提前暴露早期引用。
  • 构造器注入没有“空对象阶段”,反射调用构造器前必须解析所有参数。
  • Spring 在 createBeanInstance 阶段就会解析构造参数,此时无法从缓存拿到尚未创建的对象。

示例

@Service
public class A {
    public A(B b) {}   // 创建 A 必须现有 B
}
@Service
public class B {
    public B(A a) {}   // 创建 B 必须现有 A
}

常见误区

  • 用 @Lazy 标在构造参数上可以打破这个环,因为注入的是延迟代理,不是真实 Bean。

追问

  • 为什么 @Lazy 能解决?代理对象可以先创建,真正调用方法时才解析目标 Bean。
  • 除了 @Lazy 还有什么办法?重构依赖、引入事件/中介、改为 setter 注入。

06.2.1.2-007 @Lazy 是如何打破循环依赖的?

一句话结论

@Lazy 注入的是一个延迟解析的代理,创建阶段不需要真实 Bean;直到第一次调用方法时才向容器要目标对象。

示例

@Service
public class A {
    public A(@Lazy B b) { this.b = b; }  // 注入代理
}

常见误区

  • @Lazy 只是把问题延后,若调用发生在容器还未完成初始化时,仍可能失败。
  • 代理会增加一次调用开销,且调试时看到的是代理类。

追问

  • @Lazy 和 @Scope("prototype") 有关系吗?没有,前者延迟解析,后者控制实例数量。
  • 为什么 @Lazy 注解在字段上有时无效?需要容器能处理该注入点,且代理创建器已注册。

06.2.1.2-008 @DependsOn 有什么用?

一句话结论

@DependsOn 强制指定 Bean 的创建顺序:当前 Bean 初始化前,先确保依赖的 Bean 已创建。

示例

@Bean
@DependsOn("dataSource")
public JdbcTemplate jdbcTemplate() {
    return new JdbcTemplate();
}

常见误区

  • 它只影响创建顺序,不注入依赖;不要用它替代正常的依赖声明。
  • 滥用会掩盖真实依赖关系,增加启动耦合。

追问

  • 什么时候必须用?初始化顺序敏感、又无法用参数表达的第三方组件。
  • 和 @Order 的区别?@Order 控制同一类型集合的排序,不控制 Bean 创建顺序。

06.2.1.2-009 如何注入同一类型的多个 Bean?

一句话结论

注入 List<T>、Set<T>、Map<String,T> 可拿到全部候选;Map 的 key 是 Bean 名,List 顺序可用 @Order 控制。

示例

@Autowired
private List<PayService> services;

@Autowired
private Map<String, PayService> serviceMap;

常见误区

  • 集合为空不会报错,会注入空集合;需要至少一个时用 @Autowired(required=true) 也不保证,需自己校验。
  • Map 注入的 key 不是 @Qualifier,而是 Bean 名称。

追问

  • 如何只注入满足条件的实现?结合 @Qualifier 或自定义 @Group 注解过滤。
  • 集合注入的顺序稳定吗?默认受注册顺序影响,建议显式 @Order。

06.2.1.2-010 NoSuchBeanDefinitionException 常见原因有哪些?

一句话结论

通常是“没注册、没扫描到、类型不匹配、条件不满足、作用域不对、被代理后类型变化”六类原因。

排查清单

  1. 类不在 @ComponentScan 包下,或缺少 @Component/@Service。
  2. @Bean 方法所在配置类没有被加载。
  3. 注入类型是接口,但实现类没注册;或泛型擦除导致匹配失败。
  4. @ConditionalOnXxx 条件不满足,Bean 根本没注册。
  5. 原型 Bean 在单例初始化阶段尚未创建(时序问题)。
  6. AOP 代理是 JDK 代理,按具体类注入会失败。

追问

  • 如何快速看容器里有哪些 Bean?注入 ApplicationContext 后遍历 getBeanDefinitionNames()。
  • 为什么有时启动不报错、运行才报?懒加载或 required=false 把问题延后了。

本节自检

  • [ ] 能说出三种注入方式的取舍
  • [ ] 能画出三级缓存的获取顺序
  • [ ] 能解释构造器循环依赖为何失败
  • [ ] 能用 @Lazy/重构两种方式解决循环依赖
  • [ ] 能排查 NoSuchBeanDefinitionException