Java 新手入门：依赖注入的 N 种姿势，总有一款适合你！-CSDN博客

本文链接：https://blog.csdn.net/qq_36807888/article/details/141017038

在 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 关键字，无法保证依赖的完整性。
- 简洁，代码量少。