当前位置：首页 > ops >正文

从 0 开始理解 Spring 的核心思想 —— IoC 和 DI(1)

ops 2025/6/19 5:49:42

前言

时光如白驹过隙,一晃笔者又小半个月没更新了,也许无人在意笔者为何没更新了,但笔者还是想通报一下, 笔者这段时间一方面在备战期末考试，另一方面也在梳理学习笔记。

现在，决定开启 Spring 系列博客的正式旅程。

本篇将聚焦 Spring 的核心思想之一 —— IoC（控制反转）与 DI（依赖注入）。希望与大家一同深入探讨，让 Spring 的“魔法”不再遥不可及。

为什么我们需要Spring？

在深入学习Spring的IoC（控制反转）和DI（依赖注入）之前，让我们先来看看一个简单的对比，你会立刻感受到Spring的魅力。

传统方式 vs Spring方式

传统的Java开发方式：

public class OrderController {private OrderService orderService;private PaymentService paymentService;private EmailService emailService;public OrderController() {// 手动创建所有依赖对象this.orderService = new OrderService();this.paymentService = new PaymentService();this.emailService = new EmailService();}public void processOrder(Order order) {orderService.saveOrder(order);paymentService.processPayment(order);emailService.sendConfirmation(order);}
}

使用 Spring 框架：

@RestController
public class OrderController {@Autowiredprivate OrderService orderService;@Autowiredprivate PaymentService paymentService;@Autowiredprivate EmailService emailService;@PostMapping("/orders")public void processOrder(@RequestBody Order order) {orderService.saveOrder(order);paymentService.processPayment(order);emailService.sendConfirmation(order);}
}

看起来差别不大？让我们继续往下看...

传统开发方式的痛点

1. 对象创建的噩梦

想象一下，当你的项目变得复杂时：

public class OrderService {private UserRepository userRepository;private ProductRepository productRepository;private InventoryService inventoryService;private DiscountService discountService;private AuditService auditService;public OrderService() {// 每个依赖都需要手动创建this.userRepository = new UserRepository();this.productRepository = new ProductRepository();this.inventoryService = new InventoryService();this.discountService = new DiscountService();this.auditService = new AuditService();// 但是等等...这些服务可能还有自己的依赖！// UserRepository可能需要DataSource// InventoryService可能需要CacheManager// 这会形成一个复杂的依赖链...}
}

问题显而易见：

代码臃肿：构造函数被大量的对象创建代码污染
硬编码依赖：如果要更换实现，必须修改源代码
测试困难：无法轻易mock依赖对象进行单元测试
维护噩梦：依赖关系复杂，牵一发而动全身

2. 配置地狱

还记得那些冗长的XML配置文件吗?

<!-- 传统的XML配置，数百行的重复配置 -->
<bean id="dataSource" class="com.mysql.jdbc.Driver"><property name="url" value="jdbc:mysql://localhost:3306/mydb"/><property name="username" value="root"/><property name="password" value="password"/>
</bean><bean id="userRepository" class="com.example.UserRepository"><property name="dataSource" ref="dataSource"/>
</bean><bean id="orderService" class="com.example.OrderService"><property name="userRepository" ref="userRepository"/><property name="productRepository" ref="productRepository"/><!-- ...更多配置... -->
</bean>

3. 测试的痛苦

// 传统方式下的单元测试
public class OrderServiceTest {@Testpublic void testCreateOrder() {// 为了测试OrderService，需要创建所有的依赖UserRepository userRepo = new UserRepository();ProductRepository productRepo = new ProductRepository();InventoryService inventoryService = new InventoryService();// ...还有更多依赖OrderService orderService = new OrderService();// 测试代码比业务代码还复杂！}
}

Spring带来的革命性改变

现在，让我们看看Spring是如何优雅地解决这些问题的：

1. 告别手动创建对象

@Service
public class OrderService {@Autowiredprivate UserRepository userRepository;@Autowiredprivate ProductRepository productRepository;@Autowiredprivate InventoryService inventoryService;// 构造函数变得干净简洁// 所有依赖由Spring自动注入public void createOrder(Order order) {// 专注于业务逻辑，而不是对象创建User user = userRepository.findById(order.getUserId());// ...业务逻辑}
}

2. 配置变得简单

@Configuration
@ComponentScan("com.example")
public class AppConfig {// 一个注解胜过千行XML
}// 或者更简单，使用Spring Boot
@SpringBootApplication
public class Application {// 零配置启动！
}

3. 测试变得轻松

@ExtendWith(SpringExtension.class)
class OrderServiceTest {@Mockprivate UserRepository userRepository;@InjectMocksprivate OrderService orderService;@Testvoid testCreateOrder() {// 轻松mock依赖，专注测试业务逻辑when(userRepository.findById(1L)).thenReturn(mockUser);orderService.createOrder(testOrder);verify(userRepository).findById(1L);}
}

真实场景模拟：一个电商系统的对比

让我们通过一个真实的电商系统场景来感受这种差异：

我们假设一个用户下单，系统需要：

扣减库存
执行支付
返回下单结果

传统方式的订单处理类：

// 传统方式：自己创建依赖对象
public class OrderService {private PaymentService paymentService;private InventoryService inventoryService;public OrderService() {this.paymentService = new PaymentService(); // 主动创建依赖对象this.inventoryService = new InventoryService();}public void createOrder() {inventoryService.deductStock();paymentService.pay();System.out.println("订单创建成功！");}public static void main(String[] args) {OrderService orderService = new OrderService();orderService.createOrder();}
}class PaymentService {public void pay() {System.out.println("支付成功！");}
}class InventoryService {public void deductStock() {System.out.println("库存扣减成功！");}
}

问题：

代码耦合严重，OrderService 无法方便地更换或测试依赖组件。

不利于维护，不利于扩展，不易于单元测试。

Spring方式的订单处理类：

1. 定义各个组件

import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;@Service
public class OrderService {@Autowiredprivate PaymentService paymentService;@Autowiredprivate InventoryService inventoryService;public void createOrder() {inventoryService.deductStock();paymentService.pay();System.out.println("订单创建成功！");}
}@Service
class PaymentService {public void pay() {System.out.println("支付成功！");}
}@Service
class InventoryService {public void deductStock() {System.out.println("库存扣减成功！");}
}

2. 启动类模拟运行

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;@SpringBootApplication
public class ECommerceApp {public static void main(String[] args) {ApplicationContext context = SpringApplication.run(ECommerceApp.class, args);OrderService orderService = context.getBean(OrderService.class);orderService.createOrder();}
}