依赖注入如何实现？

访客全栈框架 2026-06-06 03:21:53 2

依赖注入如何实现？从原理到实战的完整解析

目录导读

什么是依赖注入？ —— 核心概念与设计思想
为什么需要依赖注入？ —— 解决耦合与测试难题
依赖注入的三种实现方式 —— 构造器、Setter、接口注入
主流框架中的依赖注入实现 —— Spring、Guice、Angular 示例
手写一个简易依赖注入容器 —— 从零实现 DI 框架
常见问题与最佳实践 —— 避免误区，提升代码质量
问答环节 —— 解答读者核心疑惑

什么是依赖注入？

依赖注入（Dependency Injection，简称 DI）是一种设计模式，其核心思想是：对象的依赖关系由外部容器在运行时注入，而非由对象自身通过 new 关键字创建。

传统代码中，一个类（如 ServiceA）如果需要使用另一个类（如 RepositoryB），它会直接 new RepositoryB()；而使用依赖注入后，ServiceA 只需声明“我需要一个 RepositoryB”，由外部容器（如 Spring IOC 容器）负责提供实例。

核心三要素

依赖（Dependency）：某个类完成功能所必须的其他对象。
注入（Injection）：将依赖传递给调用者的过程。
控制反转（IoC）：依赖获取的控制权从被调用者转移到了调用者外部，是 DI 的底层原则。

对比：传统代码中，高层模块依赖低层模块的具体实现；DI 让高层模块仅依赖抽象接口，具体实现由外部注入，实现了“依赖倒置原则”。

为什么需要依赖注入？

硬耦合的痛点

public class OrderService {
    private PaymentService paymentService = new WechatPayService(); // 硬编码
    public void processOrder() {
        paymentService.pay();
    }
}

无法切换支付方式：要改用支付宝，必须修改 OrderService 代码。
单元测试困难：无法用 Mock 对象替代真实的 WechatPayService。

依赖注入的优势

public class OrderService {
    private PaymentService paymentService;
    public OrderService(PaymentService paymentService) { // 通过构造器注入
        this.paymentService = paymentService;
    }
}

使用 DI 后：

可切换性：只需传入不同的实现类（WechatPayService 或 AlipayService）。
可测试性：单元测试时传入 Mock 对象,无需启动数据库或外部服务。
低耦合：类之间通过接口交互,修改实现不影响调用方。

依赖注入的三种实现方式

构造器注入（Constructor Injection）

通过构造函数的参数传递依赖，这是最推荐的方式（Spring 官方也推荐）。

public class UserService {
    private final UserRepository userRepo;
    public UserService(UserRepository userRepo) { // 显式要求依赖
        this.userRepo = userRepo;
    }
}

优点：依赖不可变，对象创建时依赖就绪，易于测试。缺点：构造函数参数过多时（超过 3 个）,可能暗示类职责过重。

Setter 注入（Setter Injection）

通过 Setter 方法在对象创建后设置依赖。

public class UserService {
    private UserRepository userRepo;
    public void setUserRepository(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

优点：可选依赖，可在对象创建后动态替换。缺点：易出现空指针问题（开发者忘记调用 setter）,依赖不一定是不可变的。

接口注入（Interface Injection）

通过接口方法注入依赖，但实际应用较少,因为代码侵入性强。

public interface IdAware {
    void setId(Long id);
}
public class User implements IdAware {
    private Long id;
    public void setId(Long id) { this.id = id; }
}

框架中的体现：Angular 的 @Injectable() 装饰器本质是一种声明式接口注入。

主流框架中的依赖注入实现

Spring Framework（Java）

@Component
public class OrderService {
    @Autowired
    private PaymentService paymentService; // 字段注入（不推荐，但常见）
    public OrderService(PaymentService paymentService) { // 构造器注入更优
        this.paymentService = paymentService;
    }
}

实现原理：Spring 通过反射读取类的构造器 / 字段上的注解，从 IoC 容器中获取依赖的 Bean 实例，并通过反射调用构造器或 setter 完成注入，容器内部维护一个 BeanDefinitionMap，存储所有 Bean 的定义信息。

Google Guice（Java）

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(PaymentService.class).to(WechatPayService.class);
    }
}

特点：无需 XML 配置，纯 Java 代码配置，性能较高,适合中小型项目。

Angular（TypeScript）

@Injectable()
export class OrderService {
  constructor(private paymentService: PaymentService) {}
}

实现原理：Angular 的 DI 系统通过 Injector 层级树管理依赖，当组件声明依赖时，Injector 从当前层级向上查找，如果有供应商（provider）则注入实例,否则抛出错误。

手写一个简易依赖注入容器

目标：实现一个简单的 IoC 容器,支持构造器注入。

代码实现（Java 伪代码）

public class SimpleContainer {
    private Map<Class<?>, Object> instances = new HashMap<>();
    // 注册依赖：绑定接口与实现
    public <T> void register(Class<T> interfaceClass, T implementation) {
        instances.put(interfaceClass, implementation);
    }
    // 获取实例：自动解析构造器依赖
    public <T> T getInstance(Class<T> clazz) {
        // 1. 获取所有构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        if (constructors.length == 0) {
            throw new RuntimeException("No public constructor found");
        }
        // 2. 默认使用第一个构造器（实际框架会选最优）
        Constructor<?> constructor = constructors[0];
        Class<?>[] paramTypes = constructor.getParameterTypes();
        Object[] params = new Object[paramTypes.length];
        // 3. 递归解析构造器参数
        for (int i = 0; i < paramTypes.length; i++) {
            params[i] = instances.get(paramTypes[i]); // 从已注册的实例中获取
            if (params[i] == null) {
                // 如果未注册，尝试递归创建（实际框架有循环依赖检测）
                params[i] = getInstance(paramTypes[i]);
            }
        }
        // 4. 通过反射创建实例
        try {
            return (T) constructor.newInstance(params);
        } catch (Exception e) {
            throw new RuntimeException("Failed to create instance", e);
        }
    }
}
// 使用示例
SimpleContainer container = new SimpleContainer();
container.register(PaymentService.class, new WechatPayService());
OrderService orderService = container.getInstance(OrderService.class);
orderService.processOrder(); // 自动注入了 WechatPayService