在 Spring 的世界里，依赖注入就像一座桥梁，将不同的组件连接起来，构建出一个松耦合、易维护的应用程序。今天我们就来聊聊 Spring 依赖注入的那些事儿，带你轻松掌握这项必备技能！
什么是依赖注入？
简单来说，依赖注入就是将一个对象所依赖的其他对象，通过外部的方式传递进来，而不是由对象本身来创建。这样做的好处是可以降低代码耦合度，提高代码的可重用性和可测试性。
假设你正在开发一个电商网站，其中有一个订单服务 OrderService，它依赖于商品服务 ProductService 和用户服务 UserService 来完成下单操作。
1. 传统方式 (不使用依赖注入):
public class OrderService { private ProductService productService = new ProductService(); // 自己创建依赖 private UserService userService = new UserService(); public void placeOrder(Order order) { // ... 获取商品信息 Product product = productService.getProductById(order.getProductId()); // ... 获取用户信息 User user = userService.getUserById(order.getUserId()); // ... 创建订单 // ... } }
这种方式的缺点很明显：
- OrderService 强依赖于 ProductService 和 UserService 的具体实现，如果要替换成其他实现，就需要修改 OrderService 的代码。
- 代码难以测试，因为你无法轻易地替换 ProductService 和 UserService 的模拟实现进行单元测试。
2. 依赖注入方式：
public class OrderService { @Autowired // 声明依赖，由 Spring 容器注入 private ProductService productService; @Autowired private UserService userService; public void placeOrder(Order order) { // ... 获取商品信息 Product product = productService.getProductById(order.getProductId()); // ... 获取用户信息 User user = userService.getUserById(order.getUserId()); // ... 创建订单 // ... } }
使用依赖注入后：
- OrderService 只依赖于 ProductService 和 UserService 的接口，而不依赖于它们的具体实现，降低了代码耦合度。
- 你可以通过配置文件或注解轻松地替换 ProductService 和 UserService 的实现，提高了代码的灵活性和可配置性。
- 你可以方便地注入 ProductService 和 UserService 的模拟实现进行单元测试，提高了代码的可测试性。
Spring 主要提供了以下三种依赖注入的方式：
1. 构造器注入：
通过构造方法将依赖的对象传递给目标对象。
// 定义 CoffeeBean 类 public class CoffeeBean { // ... 咖啡豆相关属性和方法 } // 定义 Water 类 public class Water { // ... 水相关属性和方法 } // 定义 CoffeeMachine 类 public class CoffeeMachine { // ... 咖啡机相关属性和方法 } // 定义 CoffeeMaker 类 public class CoffeeMaker { private final CoffeeBean coffeeBean; // 声明依赖，不可变 private final Water water; private final CoffeeMachine coffeeMachine; // 通过构造方法注入依赖 public CoffeeMaker(CoffeeBean coffeeBean, Water water, CoffeeMachine coffeeMachine) { this.coffeeBean = coffeeBean; this.water = water; this.coffeeMachine = coffeeMachine; } // ... 其他方法，例如 makeCoffee() }
代码解读：
- CoffeeMaker 类依赖于 CoffeeBean、Water 和 CoffeeMachine 三个类。
- 通过在 CoffeeMaker 的构造方法中声明这三个类的参数，并在创建 CoffeeMaker 对象时将它们传递进去，就实现了构造器注入。
- 使用 final 关键字修饰依赖对象，可以确保它们在对象创建后不可修改，保证了依赖的完整性。
2. Setter 注入：
通过 Setter 方法将依赖的对象传递给目标对象。
public class CoffeeMaker { private CoffeeBean coffeeBean; private Water water; private CoffeeMachine coffeeMachine; // 通过 Setter 方法注入依赖 @Autowired public void setCoffeeBean(CoffeeBean coffeeBean) { this.coffeeBean = coffeeBean; } @Autowired public void setWater(Water water) { this.water = water; } @Autowired public void setCoffeeMachine(CoffeeMachine coffeeMachine) { this.coffeeMachine = coffeeMachine; } // ... 其他方法 }
代码解读：
- CoffeeMaker 类中定义了三个 Setter 方法，分别用于设置 coffeeBean、water 和 coffeeMachine 属性。
- 在每个 Setter 方法上使用 @Autowired 注解，告诉 Spring 容器在创建 CoffeeMaker 对象后，自动调用这些 Setter 方法注入依赖的对象。
3. 字段注入：
直接在字段上使用 @Autowired 注解，让 Spring 自动注入依赖的对象。
public class CoffeeMaker { @Autowired private CoffeeBean coffeeBean; @Autowired private Water water; @Autowired private CoffeeMachine coffeeMachine; // ... 其他方法 }
代码解读：
- 在 CoffeeMaker 类的字段上使用 @Autowired 注解，告诉 Spring 容器在创建 CoffeeMaker 对象后，自动为这些字段注入依赖的对象。
- 这种方式最为简洁，但可读性稍差，而且无法在字段上使用 final 关键字。
三种方式的比较：
- 构造器注入：
- 当依赖的对象较多时，构造方法会变得臃肿。
- 如果依赖关系发生变化，就需要修改构造方法。
- 能够保证依赖的对象在对象创建时就已设置，避免出现 NullPointerException。
- 代码更易于维护，因为依赖关系清晰明确。
- Setter 注入：
- 无法保证依赖的对象在对象创建时就已设置，可能导致 NullPointerException。
- 代码可读性稍差，因为依赖关系分散在各个 Setter 方法中。
- 灵活，可以根据需要选择性地注入依赖的对象。
- 如果依赖关系发生变化，只需要添加或修改对应的 Setter 方法即可。
- 字段注入：
- 可读性较差，容易与其他代码混淆。
- 无法在字段上使用 final 关键字，无法保证依赖的完整性。
- 简洁，代码量少。
总结
依赖注入是 Spring 框架的核心机制之一，它可以帮助我们编写更加松耦合、易测试、易维护的代码。三种依赖注入方式各有优缺点，选择哪种方式取决于具体的需求和编码习惯。
希望这篇公众号文章能够帮助你更好地理解 Spring 依赖注入的不同方式，并在实际开发中灵活运用
