7. Spring 中的 DI 是什么？

PangHu大约 4 分钟

DI（Dependency Injection，依赖注入） 是一种设计模式，用于实现控制反转（Inversion of Control, IOC）。它通过将对象所依赖的其他对象从外部注入，而不是在对象内部直接创建这些依赖对象，从而降低类之间的耦合性，提高代码的可测试性和可维护性。

在 Spring 框架中，DI 是实现 IOC 的主要机制。Spring 容器负责管理 Bean 的生命周期，并在合适的时机将所需的依赖对象注入到 Bean 中。

2. 为什么需要 DI？

在传统的编程方式中，类通常通过 new 关键字创建依赖对象，导致类与类之间紧密耦合，这使得代码难以维护、测试和扩展。例如：

public class ServiceA {
    private ServiceB serviceB;

    public ServiceA() {
        this.serviceB = new ServiceB(); // 强耦合，难以替换 ServiceB
    }
}

这种方式的问题是：

难以测试：测试 ServiceA 时，无法轻松替换 ServiceB 为 Mock 对象。
难以扩展：如果 ServiceB 需要更换实现或在不同的场景下使用不同的实现，ServiceA 必须进行修改。
高耦合性：ServiceA 和 ServiceB 之间的依赖关系紧密耦合，违背了“开闭原则”。

通过依赖注入，可以将 ServiceB 的创建责任交给外部，ServiceA 只需接收一个 ServiceB 的实例，从而降低耦合度，提升代码的灵活性。

3. Spring 中的依赖注入方式

Spring 提供了多种依赖注入的方式，主要包括以下几种：

3.1 构造器注入

通过构造器参数将依赖注入到类中，适合依赖关系明确且必须在对象实例化时就完成的情况。

@Component
public class ServiceA {
    private final ServiceB serviceB;

    @Autowired
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

在构造器注入中，依赖对象 ServiceB 是通过构造函数传递给 ServiceA 的，这确保了 ServiceA 对 ServiceB 的依赖在创建时就已经满足。

3.2 Setter 注入

通过 Setter 方法将依赖注入到类中，适合依赖关系可以在对象实例化后动态注入的情况。

@Component
public class ServiceA {
    private ServiceB serviceB;

    @Autowired
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

在 Setter 注入中，Spring 容器在创建 ServiceA 实例后，通过调用 setServiceB 方法将 ServiceB 注入到 ServiceA 中。这种方式允许在对象实例化后注入依赖，具有更大的灵活性。

3.3 字段注入

直接在类的成员变量上使用 @Autowired 注解将依赖注入到类中，这种方式简洁明了，但可能会在测试时带来不便。

@Component
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

在字段注入中，Spring 通过反射机制直接将 ServiceB 注入到 ServiceA 的字段中。这种方式简单易用，但不利于进行单元测试（因为字段是私有的，难以替换为 Mock 对象）。

4. Spring 中的 DI 示例

以下是一个完整的 Spring DI 示例，包括构造器注入和字段注入：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {}

@Component
class ServiceA {
    private final ServiceB serviceB;

    @Autowired
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    public void execute() {
        System.out.println("Executing ServiceA with dependency on ServiceB");
        serviceB.perform();
    }
}

@Component
class ServiceB {
    public void perform() {
        System.out.println("ServiceB is performing its task");
    }
}

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        ServiceA serviceA = context.getBean(ServiceA.class);
        serviceA.execute();
    }
}

工作流程：

AppConfig 作为配置类，使用 @ComponentScan 告诉 Spring 容器扫描 com.example 包下的组件。
ServiceA 和 ServiceB 被 @Component 注解标识，表示它们是 Spring 管理的 Bean。
ServiceA 通过构造器注入的方式接收 ServiceB 的实例，Spring 容器在创建 ServiceA 实例时自动注入 ServiceB 实例。
在 MainApp 的 main 方法中，通过 ApplicationContext 获取 ServiceA 的实例，并调用 execute 方法。

5. 总结

依赖注入（DI） 是 Spring 框架的核心特性之一，它通过将对象之间的依赖关系交给 Spring 容器来管理，实现了控制反转（IOC）。DI 可以显著降低类之间的耦合性，提升代码的可测试性和可维护性。Spring 提供了多种依赖注入方式，如构造器注入、Setter 注入和字段注入，开发者可以根据实际需求灵活选择合适的注入方式。