MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java Spring Boot中的依赖注入机制

2024-03-304.0k 阅读

1. 依赖注入的基本概念

在深入探讨 Java Spring Boot 中的依赖注入机制之前，我们先来理解依赖注入（Dependency Injection，简称 DI）的基本概念。从本质上讲，依赖注入是一种设计模式，它允许我们将对象所依赖的其他对象通过外部方式提供给该对象，而不是让对象自己去创建这些依赖对象。

假设我们有一个 UserService 类，它依赖于一个 UserRepository 类来进行用户数据的持久化操作。传统的方式下，UserService 可能会在内部自行创建 UserRepository 的实例，如下代码所示：

public class UserService {
    private UserRepository userRepository = new UserRepository();

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

这种方式存在一些问题。首先，UserService 与 UserRepository 的具体实现紧密耦合，如果需要更换 UserRepository 的实现，比如从基于文件的存储切换到基于数据库的存储，就需要修改 UserService 的代码。其次，在单元测试 UserService 时，很难将一个模拟的 UserRepository 注入进去，因为 UserService 总是创建自己的 UserRepository 实例。

依赖注入则解决了这些问题。通过依赖注入，UserService 不再负责创建 UserRepository，而是由外部提供 UserRepository 的实例。这样，UserService 与 UserRepository 的具体实现解耦，同时也方便进行单元测试。

2. Spring Boot 中的依赖注入实现方式

Spring Boot 提供了多种方式来实现依赖注入，主要包括构造函数注入、Setter 方法注入和字段注入。

2.1 构造函数注入

构造函数注入是通过类的构造函数来提供依赖对象。以下是一个使用构造函数注入的示例：

public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

在 Spring Boot 中，配置构造函数注入非常简单。假设我们有一个配置类 AppConfig：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }

    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
}

在上述代码中，userService 方法通过构造函数参数接收 UserRepository 实例，并将其传递给 UserService 的构造函数。构造函数注入的优点是，对象一旦创建，其依赖关系就已经确定，并且依赖对象不可变（通过 final 修饰）。这有助于提高代码的安全性和可维护性，同时也便于进行单元测试。

2.2 Setter 方法注入

Setter 方法注入是通过对象的 Setter 方法来提供依赖对象。以下是一个使用 Setter 方法注入的示例：

public class UserService {
    private UserRepository userRepository;

    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

在 Spring Boot 配置类中，可以这样配置 Setter 方法注入：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }

    @Bean
    public UserService userService() {
        UserService userService = new UserService();
        userService.setUserRepository(userRepository());
        return userService;
    }
}

Setter 方法注入的优点是，对象在创建后可以动态地改变其依赖关系。这种方式适合于那些依赖关系可能在运行时发生变化的场景。然而，由于依赖对象可以被动态改变，可能会导致代码的可维护性变差，尤其是在多线程环境下。

2.3 字段注入

字段注入是通过直接在类的字段上使用依赖注入注解来提供依赖对象。以下是一个使用字段注入的示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

字段注入非常简洁，不需要编写构造函数或 Setter 方法。但是，字段注入也有一些缺点。首先，它违反了依赖注入的基本原则，即依赖应该通过构造函数或 Setter 方法显式地提供。其次，字段注入会使类与 Spring 框架紧密耦合，不利于进行单元测试，因为很难在测试中控制依赖对象的注入。

3. 依赖注入注解

在 Spring Boot 中，有几个重要的注解用于实现依赖注入。

3.1 @Autowired

@Autowired 是 Spring 框架中最常用的依赖注入注解。它可以用于构造函数、Setter 方法和字段上。当 Spring 容器在创建一个使用 @Autowired 注解的对象时，它会尝试在容器中找到一个匹配的 bean 来注入。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    // 也可以用于构造函数
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // 也可以用于Setter方法
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

如果在容器中找不到匹配的 bean，Spring 会抛出 NoSuchBeanDefinitionException 异常。此外，如果容器中有多个匹配的 bean，Spring 会抛出 NoUniqueBeanDefinitionException 异常。为了解决多个匹配 bean 的问题，可以结合 @Qualifier 注解使用。

3.2 @Qualifier

@Qualifier 注解用于在多个匹配的 bean 中指定要注入的具体 bean。假设我们有两个 UserRepository 的实现类 JdbcUserRepository 和 MongoUserRepository：

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    @Qualifier("jdbcUserRepository")
    private UserRepository userRepository;

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

在配置类中，我们需要为每个 UserRepository 实现类指定一个唯一的名称：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean("jdbcUserRepository")
    public UserRepository jdbcUserRepository() {
        return new JdbcUserRepository();
    }

    @Bean("mongoUserRepository")
    public UserRepository mongoUserRepository() {
        return new MongoUserRepository();
    }
}

通过 @Qualifier 注解，我们可以明确指定要注入的 UserRepository 实现类，避免了因多个匹配 bean 而导致的异常。

3.3 @Inject 和 @Resource

@Inject 注解来自于 JSR-330（Java 依赖注入规范），它与 @Autowired 功能类似，也是用于依赖注入。@Resource 注解来自于 JSR-250，它既可以按名称注入，也可以按类型注入。

import javax.inject.Inject;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Inject
    private UserRepository userRepository;

    @Resource(name = "jdbcUserRepository")
    private UserRepository anotherUserRepository;
}

虽然 @Inject 和 @Resource 也能实现依赖注入，但在 Spring Boot 项目中，@Autowired 是更常用的选择，因为它是 Spring 框架原生的注解，与 Spring 的集成度更高。

4. 依赖注入的原理

理解 Spring Boot 中依赖注入的原理对于深入掌握这一机制非常重要。Spring Boot 依赖注入的核心是 Spring 容器，它负责管理应用程序中的所有 bean，并处理它们之间的依赖关系。

当 Spring 容器启动时，它会读取配置文件（如 XML 配置文件或基于 Java 配置类），并根据配置信息创建 bean 定义。这些 bean 定义描述了如何创建 bean 实例、其依赖关系以及其他属性。

对于每个需要依赖注入的 bean，Spring 容器会在创建该 bean 实例时，根据其依赖关系查找并注入相应的 bean。如果依赖的 bean 还没有被创建，Spring 容器会先创建该依赖 bean。这个过程是递归进行的，直到所有依赖的 bean 都被创建并注入。

例如，当创建 UserService 实例时，Spring 容器会检查 UserService 的依赖关系，发现它依赖于 UserRepository。于是，Spring 容器会查找 UserRepository 的 bean 定义，并创建 UserRepository 实例，然后将其注入到 UserService 实例中。

在实际实现中，Spring 使用反射机制来创建 bean 实例和调用构造函数、Setter 方法进行依赖注入。通过反射，Spring 可以在运行时动态地获取类的构造函数、方法和字段，并进行相应的操作。

5. 依赖注入与控制反转（IoC）

依赖注入与控制反转（Inversion of Control，简称 IoC）密切相关。实际上，依赖注入是控制反转的一种具体实现方式。

控制反转的核心思想是将对象的控制权从对象本身转移到外部容器。在传统的编程方式中，对象自己负责创建和管理其依赖对象，即对象对其依赖对象具有控制权。而在控制反转的模式下，对象不再负责创建和管理其依赖对象，而是由外部容器（如 Spring 容器）来负责这些工作。

依赖注入是实现控制反转的一种手段。通过依赖注入，我们将对象所依赖的其他对象通过外部方式提供给该对象，从而实现了对象控制权的转移。例如，在前面的 UserService 示例中，通过依赖注入，UserService 不再自己创建 UserRepository，而是由 Spring 容器将 UserRepository 注入进来，这就是控制反转的体现。

控制反转和依赖注入的结合，使得应用程序的代码更加松耦合、可维护和可测试。它是 Spring 框架的核心设计理念之一，也是现代 Java 开发中常用的编程模式。

6. 依赖注入在实际项目中的应用场景

6.1 分层架构中的依赖管理

在一个典型的三层架构（表现层、业务逻辑层、数据访问层）的 Java 应用程序中，依赖注入起着至关重要的作用。表现层的控制器（Controller）通常依赖于业务逻辑层的服务（Service），而业务逻辑层的服务又依赖于数据访问层的存储库（Repository）。

例如，在一个电商项目中，OrderController 负责处理与订单相关的 HTTP 请求，它依赖于 OrderService 来执行业务逻辑，如订单的创建、查询和修改。OrderService 又依赖于 OrderRepository 来进行订单数据的持久化操作。通过依赖注入，我们可以轻松地在不同层之间解耦，使得各层的代码可以独立开发、测试和维护。

// 表现层
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/orders")
    public String createOrder(@RequestBody Order order) {
        return orderService.createOrder(order);
    }
}

// 业务逻辑层
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    public String createOrder(Order order) {
        // 执行业务逻辑
        orderRepository.save(order);
        return "Order created successfully";
    }
}

// 数据访问层
import org.springframework.stereotype.Repository;

@Repository
public class OrderRepository {

    public void save(Order order) {
        // 实现数据持久化逻辑
    }
}

6.2 单元测试中的依赖模拟

在进行单元测试时，依赖注入使得我们可以轻松地模拟依赖对象，从而专注于测试目标对象的功能。例如，要测试 UserService 的 saveUser 方法，我们可以创建一个模拟的 UserRepository，并通过依赖注入将其注入到 UserService 中。

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.*;

public class UserServiceTest {

    @Test
    public void testSaveUser() {
        UserRepository mockUserRepository = Mockito.mock(UserRepository.class);
        UserService userService = new UserService(mockUserRepository);

        User user = new User();
        userService.saveUser(user);

        Mockito.verify(mockUserRepository, Mockito.times(1)).save(user);
    }
}

通过依赖注入，我们可以在测试环境中灵活地替换真实的依赖对象为模拟对象，避免了因依赖对象的复杂性而影响测试的准确性和效率。

6.3 插件化和可扩展性

在一些需要支持插件化或可扩展性的应用程序中，依赖注入也发挥着重要作用。例如，一个内容管理系统（CMS）可能允许用户安装不同的插件来扩展其功能，如不同类型的文件上传处理器、不同的用户认证策略等。

通过依赖注入，CMS 可以根据配置动态地加载和注入不同的插件实现。这样，CMS 的核心代码不需要了解具体插件的实现细节，只需要定义好接口，插件开发者只需要实现这些接口，并通过依赖注入的方式将插件注入到系统中，从而实现系统的可扩展性。

7. 依赖注入的最佳实践

7.1 优先使用构造函数注入

如前文所述，构造函数注入具有诸多优点，如对象创建后依赖关系即确定、依赖对象不可变等。因此，在大多数情况下，应该优先使用构造函数注入。它不仅提高了代码的安全性和可维护性，也便于进行单元测试。

7.2 避免过度使用字段注入

虽然字段注入非常简洁，但它存在一些缺点，如违反依赖注入原则、与 Spring 框架紧密耦合等。因此，应尽量避免在实际项目中过度使用字段注入，尤其是在大型项目中。

7.3 合理使用 @Qualifier 注解

当存在多个匹配的 bean 时，一定要合理使用 @Qualifier 注解来明确指定要注入的 bean，避免因依赖注入错误而导致的运行时异常。

7.4 保持依赖关系的清晰和简单

在设计应用程序的依赖关系时，应尽量保持其清晰和简单。避免出现复杂的依赖循环，即 A 依赖 B，B 依赖 C，而 C 又依赖 A 的情况。如果出现依赖循环，Spring 容器在启动时会抛出异常。可以通过重新设计依赖关系或使用 @Lazy 注解来解决依赖循环问题。

8. 依赖注入的高级特性

8.1 延迟注入（Lazy Loading）

延迟注入是指在需要使用依赖对象时才进行创建和注入，而不是在容器启动时就创建所有的依赖对象。在 Spring Boot 中，可以使用 @Lazy 注解来实现延迟注入。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    @Lazy
    private UserRepository userRepository;

    public void saveUser(User user) {
        userRepository.save(user);
    }
}

通过 @Lazy 注解，UserRepository 的创建和注入会延迟到 UserService 第一次调用 userRepository 的方法时。这在一些依赖对象创建开销较大，且在应用程序启动时不一定需要立即使用的情况下非常有用，可以提高应用程序的启动性能。

8.2 条件注入（Conditional Injection）

条件注入是指根据一定的条件来决定是否注入某个依赖对象。在 Spring Boot 中，可以使用 @Conditional 注解来实现条件注入。

假设我们有两个 UserRepository 的实现类 JdbcUserRepository 和 FileUserRepository，并且希望根据配置文件中的某个属性来决定使用哪个 UserRepository。

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class JdbcCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String storageType = context.getEnvironment().getProperty("storage.type");
        return "jdbc".equals(storageType);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    @Conditional(JdbcCondition.class)
    public UserRepository jdbcUserRepository() {
        return new JdbcUserRepository();
    }

    @Bean
    @Conditional(FileCondition.class)
    public UserRepository fileUserRepository() {
        return new FileUserRepository();
    }
}

通过 @Conditional 注解，我们可以根据不同的条件动态地决定注入哪个 UserRepository 实现类，从而提高应用程序的灵活性和可配置性。

8.3 多环境配置下的依赖注入

在实际项目中，通常会有不同的运行环境，如开发环境、测试环境和生产环境。每个环境可能需要不同的依赖配置。Spring Boot 提供了多环境配置的功能，结合依赖注入可以轻松地满足不同环境的需求。

我们可以在 application.properties 文件中定义不同环境的配置，如 application-dev.properties、application-test.properties 和 application-prod.properties。

在配置类中，可以根据当前激活的环境来决定注入不同的 bean。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {

    @Autowired
    private Environment environment;

    @Bean
    public UserRepository userRepository() {
        if ("dev".equals(environment.getActiveProfiles()[0])) {
            return new DevUserRepository();
        } else if ("prod".equals(environment.getActiveProfiles()[0])) {
            return new ProdUserRepository();
        }
        return null;
    }
}

通过这种方式，我们可以在不同的环境下轻松切换依赖对象的实现，提高了应用程序的适应性和可维护性。

通过以上对 Java Spring Boot 中依赖注入机制的详细介绍，包括基本概念、实现方式、注解、原理、与控制反转的关系、应用场景、最佳实践以及高级特性等方面，相信读者对这一重要机制有了更深入的理解和掌握。在实际项目开发中，合理运用依赖注入可以构建出更加松耦合、可维护和可测试的应用程序。