黑鲨AI助手带你吃透Spring IoC与DI：从概念到面试全攻略

发布时间：北京时间2026年4月10日

在Java企业级开发中，Spring框架几乎占据了统治地位，而理解其核心灵魂——控制反转（Inversion of Control，简称IoC） 与依赖注入（Dependency Injection，简称DI） ，是每个Java开发者迈入高级编程的第一道门槛-。很多初学者甚至工作两三年的开发者，往往只会用注解写代码，却讲不清“为什么要反转”“谁依赖于谁”“底层是怎么实现的”，面试被问到时支支吾吾。今天，黑鲨AI助手就从零开始，用生活类比带大家理清概念，用代码示例跑通流程，再深入底层原理，最后送上高频面试题的参考答案，帮你建立一条从“会写”到“懂原理”的完整知识链路。

一、痛点切入：为什么需要IoC与DI？

在传统开发中，我们使用对象的方式是这样的：

// 传统方式：紧耦合的痛苦
public class OrderService {
    // 硬编码依赖：直接new具体实现
    private PaymentService payment = new AlipayService();
    private Logger logger = new FileLogger("/tmp/log");
    
    void processOrder() {
        payment.pay();      // 想换成微信支付？改代码！
        logger.log("订单处理完成");
    }
}

这段代码看起来简单直接，却隐藏着三个致命问题：

• 改需求要改代码：想从支付宝换到微信支付，必须修改OrderService源码并重新编译

• 无法做单元测试：没法Mock掉真实的支付和日志服务，测试时必须连接真实外部系统

• 依赖爆炸：如果PaymentService本身又依赖数据库连接、配置服务……你会陷入“new对象”的无底洞-9

为了解决这些痛点，控制反转（IoC） 应运而生——把对象的创建和管理权从开发者手中“反转”给容器。

二、核心概念：控制反转（IoC）

定义：控制反转（Inversion of Control，简称IoC）是一种设计原则，将对象的创建、依赖管理权从程序员转移给框架或容器，从而实现解耦-9。

拆解这个定义中的关键点：

• “控制” ：指的是对象的创建权、生命周期管理权

• “反转” ：从“程序自己掌控”变为“容器外部管理”

• “容器” ：在Spring中，ApplicationContext就是IoC容器的核心实现

生活化类比：传统开发就像你自己做饭——想吃到菜，得自己买菜、洗菜、切菜、炒菜，样样亲力亲为。而IoC就像你点外卖——你只需要告诉平台“我想要什么菜”，平台自动完成采购、烹饪、配送的全过程，你坐等收货就行-46。你的精力从“操心怎么做”转移到“聚焦吃什么”上。

IoC的核心价值不在于“少写几行new代码”，而在于彻底解耦——你的业务代码不再依赖具体实现的创建逻辑，换一种实现方式只需告诉容器即可。

三、关联概念：依赖注入（DI）

定义：依赖注入（Dependency Injection，简称DI）是一种设计模式，是IoC的具体实现方式，由容器动态地将依赖关系注入到对象中-9。

继续用外卖类比喻：

• IoC是“你点外卖”这个思想——你不再亲自下厨，把做饭的控制权交给了外部

• DI是“骑手把餐送到你手里”这个具体动作——容器主动把依赖对象“送”给你

没有DI，IoC只是一句空口号；正是DI让“反转控制权”真正落地。在Spring框架中，这种模式的应用被称作依赖注入（DI）-1。

四、概念关系与区别总结

一句话记住：IoC是“思想”，DI是“手段” ——IoC告诉你要把控制权交给容器，DI告诉容器怎么把依赖送进来-。

五、代码示例：从传统到Spring，一步步感受“反转”

先用最简洁的示例，直观感受Spring IoC与DI带来的变化。

5.1 传统方式（紧耦合）

// UserRepository接口
public interface UserRepository {
    String findUserName(long id);
}

// 具体实现
public class UserRepositoryImpl implements UserRepository {
    @Override
    public String findUserName(long id) {
        return "用户" + id;
    }
}

// UserService——紧耦合，直接new具体实现
public class UserService {
    private UserRepository userRepository = new UserRepositoryImpl();
    
    public String getUserInfo(long id) {
        return userRepository.findUserName(id);
    }
}

问题：UserService和UserRepositoryImpl绑死了，想换一种Repository实现必须改源码。

5.2 Spring IoC + DI方式（低耦合）

Step 1：标记Bean，交给Spring容器管理

@Repository   // 告诉Spring：这个类需要被容器管理，成为一个Bean
public class UserRepositoryImpl implements UserRepository {
    @Override
    public String findUserName(long id) {
        return "用户" + id;
    }
}

@Service      // 告诉Spring：这也是一个Bean
public class UserService {
    private final UserRepository userRepository;
    
    @Autowired   // 关键注解：告诉Spring容器，请帮我注入一个UserRepository的实现
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public String getUserInfo(long id) {
        return userRepository.findUserName(id);
    }
}

Step 2：启动Spring容器

@SpringBootApplication  // 组合注解：包含配置、自动配置和组件扫描
public class Application {
    public static void main(String[] args) {
        // 启动容器，Spring会自动创建所有Bean并完成依赖注入
        ConfigurableApplicationContext context = 
            SpringApplication.run(Application.class, args);
        
        // 直接从容器获取UserService，无需手动new
        UserService userService = context.getBean(UserService.class);
        System.out.println(userService.getUserInfo(123));
    }
}

关键点标注：

• @Repository / @Service：将普通Java类标记为Spring容器管理的Bean-

• @Autowired：声明依赖关系，告诉容器“我需要这个类型的Bean，请帮我注入”-

• @SpringBootApplication：包含了@ComponentScan，自动扫描当前包及子包中带注解的类并注册为Bean-56

六、依赖注入的三种方式

Spring支持三种主要的DI方式，理解它们的区别对面试和日常开发都很重要-9：

6.1 构造器注入（推荐方式）

@Service
public class OrderService {
    private final PaymentService paymentService;
    
    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

优点：依赖不可变、防止循环依赖、便于单元测试（Spring官方首选）

6.2 Setter注入

@Service
public class OrderService {
    private PaymentService paymentService;
    
    @Autowired
    public void setPaymentService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

优点：依赖可选、可在运行时重新注入；缺点：依赖可变，不够安全

6.3 字段注入（最简洁但最不推荐）

@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;
}

优点：代码最简洁；缺点：不可测试、依赖不可见、违反单一职责

七、底层原理：Spring IoC容器是如何工作的？

理解了“是什么”和“怎么用”，再来看“为什么能这样”——Spring底层是如何实现IoC与DI的？

IoC的本质是Spring容器接管了对象的创建、依赖注入、销毁等全流程，底层主要靠 “反射 + 设计模式” 来实现-29。核心流程如下：

7.1 IoC容器核心接口

• BeanFactory：IoC容器的最底层接口，定义了getBean()等基础能力，采用懒加载（调用时才创建Bean）

• ApplicationContext：日常开发使用的接口，继承自BeanFactory，默认启动时创建所有单例Bean，并增加了国际化、事件发布等企业级功能-29

7.2 Bean的生命周期（从创建到销毁）

7.3 核心数据结构：BeanDefinition

容器将扫描到的类封装为BeanDefinition对象，包含类名、作用域、依赖关系、初始化方法等信息，相当于“Bean的说明书”。这些定义被注册到BeanDefinitionRegistry中，本质上是一个Map<String, BeanDefinition>-29。

7.4 三级缓存解决循环依赖

当Bean A依赖Bean B，Bean B又依赖Bean A时，Spring通过三级缓存解决（仅针对单例、Setter注入）：

• 一级缓存（singletonObjects） ：存放完全初始化好的Bean

• 二级缓存（earlySingletonObjects） ：存放早期暴露的Bean（已实例化但未初始化）

• 三级缓存（singletonFactories） ：存放Bean工厂，用于生成早期曝光的Bean（用于AOP代理）-37

⚠️ 构造器注入的循环依赖无法解决，会抛出BeanCurrentlyInCreationException-37。

八、高频面试题与参考答案

Q1：请解释IoC和DI分别是什么？两者的关系是什么？

参考答案：

IoC（控制反转） 是一种设计思想——将对象的创建和依赖管理权从应用程序代码转移到容器或框架，从而降低耦合。DI（依赖注入） 是IoC的具体实现方式，指容器在创建对象时自动将依赖的对象“注入”到目标对象中。两者的关系是：IoC是思想，DI是手段。通俗地说，IoC告诉你“别自己创建对象，交给容器管”；DI告诉你“容器通过构造器、Setter或字段把依赖送给你”-46。

踩分点：定义清晰 + 点明“思想与手段”的关系 + 说出三种注入方式。

Q2：@Autowired注解的作用是什么？它按什么规则匹配Bean？

参考答案：

@Autowired是Spring提供的自动装配注解，用于标记需要被注入的依赖。默认按类型（byType） 匹配——Spring容器会查找与字段/参数类型匹配的Bean进行注入。如果找到多个相同类型的Bean，Spring会再按名称（byName） 匹配；如果仍无法确定，需要配合@Qualifier指定Bean名称或使用@Primary标记主选Bean-。

踩分点：说明默认byType + 多Bean时的处理策略 + @Qualifier的用途。

Q3：构造器注入、Setter注入和字段注入有什么区别？Spring官方推荐哪一种？

参考答案：

三种注入方式各有特点：

• 构造器注入（官方推荐）：依赖通过构造参数传入，依赖不可变，便于单元测试，能有效避免循环依赖

• Setter注入：依赖可选，允许运行时修改，但可变性降低了安全性

• 字段注入（最不推荐）：代码最简洁，但依赖不可见，无法测试，违反单一职责原则-9

Spring官方首选构造器注入，因为它能保证依赖不缺失且对象状态完整-55。

踩分点：列出三种方式 + 说清各自优缺点 + 明确推荐构造器注入。

Q4：Spring是如何解决循环依赖问题的？

参考答案：

Spring通过三级缓存解决单例Bean的Setter注入循环依赖：

• 一级缓存（singletonObjects）：存放完全初始化好的Bean

• 二级缓存（earlySingletonObjects）：存放早期暴露的Bean（已实例化但未初始化）

• 三级缓存（singletonFactories）：存放Bean工厂，用于生成早期曝光的Bean

以A依赖B、B依赖A为例：创建A时，先将A的工厂存入三级缓存，然后发现需要B，便去创建B；创建B时又需要A，此时从三级缓存获取A的早期引用（放入二级缓存），B完成创建后返回，A继续完成初始化。但构造器注入的循环依赖无法解决，会直接抛出异常-37。

踩分点：说出三级缓存 + 解释各缓存的作用 + 强调构造器注入不可解决。

Q5：BeanFactory和ApplicationContext有什么区别？

参考答案：

BeanFactory是Spring IoC容器的最底层接口，提供基础的getBean()能力，采用懒加载——只有调用getBean()时才创建Bean实例。ApplicationContext是BeanFactory的子接口，在日常开发中更常用，它默认启动时创建所有单例Bean（预加载），并增加了国际化、事件发布、资源加载等企业级功能-29。

踩分点：懒加载 vs 预加载 + ApplicationContext的扩展功能。

九、总结

核心知识点回顾：

1. IoC（控制反转） ：将对象的创建权从代码交给容器，是一种解耦的设计思想

2. DI（依赖注入） ：IoC的具体实现手段，容器通过构造器/Setter/字段将依赖主动“送”给对象

3. 二者关系：IoC是思想，DI是手段——思想指导方向，手段落地执行

4. 三种注入方式：构造器注入（推荐）、Setter注入、字段注入

5. 底层原理：反射 + BeanDefinition + 三级缓存 + 生命周期管理

易错点提醒：

• 不要把IoC和DI混为一谈——面试常考二者的区别与联系

• 构造器注入的循环依赖无法解决，字段注入不可测试

• @Autowired默认按类型匹配，多Bean时需要@Qualifier辅助

下一期我们将深入 Spring AOP（面向切面编程） ，讲解如何将日志、事务等横切关注点优雅地从业务代码中剥离出来，敬请关注-51！