北京时间 2026年4月8日

一、开篇引入

在 Java 后端开发的生态中，Spring 框架几乎无处不在。无论是单体应用、微服务架构，还是云原生场景，Spring 都扮演着“地基”般的角色。而支撑起这座地基的，正是两个核心概念——IoC（控制反转） 和 DI（依赖注入）。

对许多开发者来说，日常开发中天天在用 @Autowired、@Service，但一旦被问到“IoC 和 DI 的区别是什么？”“Spring 是怎么实现依赖注入的？”往往就答不上来了。这是学习 Spring 时最常见的痛点——会用，但不懂原理；知道概念，但说不清楚关系；面试问到，只能给出模棱两可的答案。

本文将从最基础的概念出发，逐步深入到底层实现原理，并配合代码示例和面试要点，帮你理清 IoC 与 DI 的知识链路。本文是系列第一篇，重点围绕“反射”展开，后续将深入容器启动流程和 Bean 生命周期。

二、痛点切入：为什么需要 IoC 和 DI？

先看一段传统 Java 代码：

// 依赖对象
public class UserDaoImpl implements UserDao {
    @Override
    public void queryUser() {
        System.out.println("查询用户信息");
    }
}

// 目标对象，手动创建依赖
public class UserServiceImpl implements UserService {
    // 主动 new 依赖对象，控制权在开发者手中
    private UserDao userDao = new UserDaoImpl();

    @Override
    public void queryUser() {
        userDao.queryUser();
    }
}

// 测试类：手动创建所有对象
public class Test {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.queryUser();
    }
}

这种写法的缺点非常明显：

• 耦合高：UserServiceImpl 直接依赖 UserDaoImpl 的具体实现类。如果需要将数据层从 MySQL 切换到 Oracle，必须修改 UserServiceImpl 的代码。

• 扩展性差：每增加一个新功能或替换一个实现，都要改动依赖方。

• 维护困难：当项目中有几十上百个对象时，手动管理所有依赖关系会让代码臃肿不堪。

• 可测试性差：单元测试时无法方便地 Mock 依赖对象。

为了解决这些问题，Spring 提出了 IoC（控制反转） 的设计思想，并通过 DI（依赖注入） 作为具体实现方式，将对象的创建和依赖管理从代码中剥离出来，交给容器统一处理-8。

三、核心概念讲解：IoC（控制反转）

标准定义：

IoC，全称 Inversion of Control，即“控制反转”。它是一种设计思想，核心是将对象的创建和依赖关系的管理权，从程序代码内部反转到外部容器中-8。

拆解关键词：

• “控制”：指的是对象的创建权、依赖的装配权。

• “反转”：相对于传统开发中程序主动控制，现在权力转移给了外部容器。

生活化类比：

想象一下自由恋爱和古代“父母之命、媒妁之言”的区别。自由恋爱中，你自己主动追求对象、自己决定和谁在一起——这就像传统开发中主动 new 对象。而在古代，你的婚姻大事由父母和媒人安排，你只管等着入洞房——这就像 IoC，对象的获取完全由容器（父母+媒人）来负责，你只需要“被动接收”即可-10。

核心作用：

IoC 解决了组件之间的解耦问题。让对象不再需要关心“如何创建依赖”，只需声明“我需要什么依赖”，容器会帮你处理好一切-1。

四、关联概念讲解：DI（依赖注入）

标准定义：

DI，全称 Dependency Injection，即“依赖注入”。它是 IoC 的具体实现方式，指容器在创建 Bean 时，自动将它所依赖的其他 Bean“注入”到目标 Bean 中-2。

DI 的三种主要形式：

推荐原则：强制依赖用构造器注入，可选依赖用 Setter 注入，尽量少用字段注入。构造器注入可以保证依赖不可变且便于测试-23-24。

五、概念关系与区别总结

一句话概括：IoC 是“把对象的创建权交给容器”的设计思想，DI 是“容器把依赖对象送上门”的具体实现方式。

六、代码示例演示

6.1 使用 Spring 重构后的代码

// 依赖对象：声明为 Spring Bean
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void queryUser() {
        System.out.println("查询用户信息");
    }
}

// 目标对象：依赖由容器注入
@Service
public class UserServiceImpl implements UserService {
    // 仅声明依赖，不主动创建
    private UserDao userDao;

    // 构造器注入——推荐方式
    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void queryUser() {
        userDao.queryUser();
    }
}

// 测试类：从容器中获取对象
public class Test {
    public static void main(String[] args) {
        // 容器初始化，自动创建 Bean、装配依赖
        ApplicationContext context = 
            new AnnotationConfigApplicationContext(AppConfig.class);
        // 直接获取对象，依赖已自动注入
        UserService userService = context.getBean(UserService.class);
        userService.queryUser();
    }
}

6.2 改进效果对比

七、底层原理与技术支撑：反射

Spring 的 IoC 容器究竟是如何动态创建对象、注入依赖的？答案是：Java 反射机制。

7.1 反射是什么？

反射是 Java 在运行时动态获取类的结构信息（字段、方法、构造函数）并操作这些成员的能力。传统代码在编译时就知道要调用哪个类的方法，而反射可以在运行时才决定-72。

7.2 Spring 如何用反射实现 IoC？

当 Spring 启动时，会扫描配置类或 XML 文件，解析出类的完整路径名，然后通过反射动态创建对象实例，并存入容器（本质是一个 ConcurrentHashMap）中-32。

简化版伪代码：

// 1. 从配置中读取类的全限定名
String classStr = "com.example.UserServiceImpl";

// 2. 通过反射获取 Class 对象
Class<?> clazz = Class.forName(classStr);

// 3. 通过反射创建实例
Object obj = clazz.getDeclaredConstructor().newInstance();

// 4. 存入容器（一个 Map 结构）
Map<String, Object> container = new ConcurrentHashMap<>();
container.put("userService", obj);

7.3 Spring 如何用反射实现 DI？

当一个 Bean 中声明了 @Autowired 依赖时，Spring 会通过反射找到对应的 Setter 方法或字段，并动态注入依赖对象-32。

依赖注入的简化版伪代码：

// 解析配置，获取依赖信息
String refStr = "userDao";
String setterName = "setUserDao";

// 从容器中获取依赖对象
Object paramBean = container.get(refStr);

// 通过反射获取 Setter 方法并调用
Method setter = clazz.getMethod(setterName, paramBean.getClass());
setter.invoke(obj, paramBean);  // 将 userDao 注入到 userService 中

7.4 反射的性能代价

反射虽然强大，但存在一定的性能开销：反射调用比直接调用慢约 3~5 倍，主要原因是 JVM 需要进行运行时类型检查、权限校验、参数封装等额外操作-。不过，Spring 通过 缓存 Class/Method 对象、调用 setAccessible(true) 绕过安全检查等方式进行了大量优化，这些开销在框架初始化阶段完全可以接受-72。

一句话总结：反射是 Spring IoC/DI 的“底层引擎”，没有反射就没有 Spring 的动态管理能力。

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

Q1：谈谈你对 IoC 和 DI 的理解，它们之间有什么关系？

参考答案（踩分点：思想 vs 实现）：

• IoC（控制反转） 是一种设计思想，核心是将对象的创建和依赖管理权从代码转移到外部容器。

• DI（依赖注入） 是 IoC 的具体实现方式，指容器在创建 Bean 时自动将依赖对象注入到目标 Bean 中。

• 两者关系：IoC 是“目标”，DI 是“手段”。Spring 通过 DI 来实现 IoC 思想。

Q2：Spring 的 IoC 容器底层用到了哪些技术？

参考答案（踩分点：反射 + 设计模式 + 容器存储）：

• Java 反射机制：动态创建对象、调用方法、注入依赖。

• 工厂模式：IoC 容器本质上是一个大工厂，负责所有 Bean 的创建和管理。

• 单例模式：Spring 中 Bean 默认是单例的，通过 ConcurrentHashMap 存储和管理。

• XML 解析 / 注解解析：读取配置元数据。

Q3：依赖注入的三种方式分别是什么？哪种最推荐？

参考答案（踩分点：三种方式 + 推荐理由）：

推荐构造器注入的原因：保证依赖不可为空、支持不可变对象、便于单元测试。

Q4：Spring 是怎么通过反射实现依赖注入的？

参考答案（踩分点：反射获取 Class → 实例化 → 获取 Method/Field → invoke/set）：

1. 容器启动时读取配置（XML 或注解），获取类的全限定名。

2. 通过 Class.forName() 获取 Class 对象。

3. 通过反射调用构造器创建对象实例。

4. 解析依赖关系，通过反射获取 Setter 方法或字段对象。

5. 调用 Method.invoke() 或 Field.set() 完成依赖注入。

Q5：BeanFactory 和 ApplicationContext 有什么区别？

参考答案（踩分点：懒加载 vs 预加载 + 功能差异）：

九、结尾总结

核心知识点回顾

1. IoC（控制反转） ：一种设计思想，将对象的创建和依赖管理权从代码转移到容器。

2. DI（依赖注入） ：IoC 的具体实现方式，容器自动将依赖对象注入到目标 Bean 中。

3. 反射机制：Spring IoC/DI 的底层技术基础，负责动态创建对象、调用方法和注入依赖。

4. 容器存储：IoC 容器本质是一个 ConcurrentHashMap，Key 是 Bean 名称，Value 是 Bean 实例。

5. 依赖注入三种方式：构造器注入（最推荐）、Setter 注入、字段注入（不推荐）。

重点强调

• IoC 是思想，DI 是落地——这是面试中最常被问到的区别，务必牢记。

• 反射虽然是 Spring 的核心支撑技术，但有一定的性能开销——Spring 通过缓存和优化手段将其降到最低。

• 理解 IoC/DI 的原理，是后续学习 Spring AOP、事务管理、源码阅读的基础。

下篇预告

下一篇将深入讲解 IoC 容器的启动流程和 Bean 的完整生命周期，从 BeanDefinition 的注册到 refresh() 方法的执行链，带你彻底吃透 Spring 容器的工作原理。

参考文献：

• 一文搞懂spring ioc底层原理-2

• Spring核心概念：IoC与DI深度解析-8

• 深入解析Spring IoC容器-1

• Java反射机制在Spring IOC中怎么用-32

• Spring面试题-64