本文深入探讨 NestJS 依赖注入系统，并阐明依赖倒置原则 (DIP)、控制反转 (IoC) 和依赖注入 (DI) 的概念及其关联。这三个概念看似相似，实则各有侧重，相互关联却又解决不同的问题。本文旨在帮助读者理清这些概念，并理解它们如何协同工作。
- 依赖倒置原则 (DIP)
定义：
高层模块不应该依赖于低层模块；两者都应该依赖于抽象。抽象不应该依赖于细节；细节应该依赖于抽象。含义解读
在软件开发中，高层模块负责核心业务逻辑，而低层模块处理具体的实现细节（例如文件系统、数据库或 API）。若无 DIP，高层模块直接依赖于低层模块，导致紧密耦合，从而：
降低灵活性。复杂化测试和维护。难以替换或扩展低层细节。
DIP 颠覆了这种依赖关系。高层和低层模块都依赖于共享的抽象（接口或抽象类），而不是高层模块直接控制低层实现。
无 DIP 示例Python 示例
class EmailService: def send_email(self, message): print(f"Sending email: {message}")class Notification: def __init__(self): self.email_service = EmailService() def notify(self, message): self.email_service.send_email(message)
TypeScript 示例
class EmailService { sendEmail(message: string): void { console.log(`Sending email: ${message}`); }}class Notification { private emailService: EmailService; constructor() { this.emailService = new EmailService(); } notify(message: string): void { this.emailService.sendEmail(message); }}
问题：
- 紧密耦合：Notification 直接依赖 EmailService。难以扩展：切换到 SMSService 或 PushNotificationService 需要修改 Notification 类。
含 DIP 示例Python 示例
from abc import ABC, abstractmethodclass MessageService(ABC): @abstractmethod def send_message(self, message): passclass EmailService(MessageService): def send_message(self, message): print(f"Sending email: {message}")class Notification: def __init__(self, message_service: MessageService): self.message_service = message_service def notify(self, message): self.message_service.send_message(message)# 使用示例email_service = EmailService()notification = Notification(email_service)notification.notify("Hello, Dependency Inversion!")
TypeScript 示例
interface MessageService { sendMessage(message: string): void;}class EmailService implements MessageService { sendMessage(message: string): void { console.log(`Sending email: ${message}`); }}class Notification { private messageService: MessageService; constructor(messageService: MessageService) { this.messageService = messageService; } notify(message: string): void { this.messageService.sendMessage(message); }}// 使用示例const emailService = new EmailService();const notification = new Notification(emailService);notification.notify("Hello, Dependency Inversion!");
DIP 的优势灵活性：无需修改高层模块即可替换实现。可测试性：使用模拟对象替换真实依赖项进行测试。可维护性：低层模块的更改不会影响高层模块。
- 控制反转 (IoC)
IoC 是一种设计原则，依赖项的创建和管理由外部系统或框架控制，而不是在类内部进行。
传统编程中，类自行创建和管理依赖项。IoC 将这种控制反转——外部实体（例如框架或容器）管理依赖项，并在需要时注入。
无 IoC 示例
在无 IoC 的场景中，类自行创建和管理依赖项，导致紧密耦合。
Python 示例：无 IoC
class SMSService: def send_message(self, message): print(f"Sending SMS: {message}")class Notification: def __init__(self): self.sms_service = SMSService() def notify(self, message): self.sms_service.send_message(message)# 使用示例notification = Notification()notification.notify("Hello, tightly coupled dependencies!")
TypeScript 示例：无 IoC
class SMSService { sendMessage(message: string): void { console.log(`Sending SMS: ${message}`); }}class Notification { private smsService: SMSService; constructor() { this.smsService = new SMSService(); } notify(message: string): void { this.smsService.sendMessage(message); }}// 使用示例const notification = new Notification();notification.notify("Hello, tightly coupled dependencies!");
无 IoC 的问题：
- 紧密耦合：Notification 类直接创建并依赖 SMSService 类。灵活性低：切换到其他实现需要修改 Notification 类。难以测试：模拟依赖项用于单元测试比较困难，因为依赖项是硬编码的。
使用 IoC
在使用 IoC 的示例中，依赖关系的管理责任转移到外部系统或框架，实现松散耦合并增强可测试性。
Python 示例：使用 IoC
class SMSService: def send_message(self, message): print(f"Sending SMS: {message}")class Notification: def __init__(self, message_service): self.message_service = message_service def notify(self, message): self.message_service.send_message(message)# IoC: 依赖项由外部控制sms_service = SMSService()notification = Notification(sms_service)notification.notify("Hello, Inversion of Control!")
TypeScript 示例：使用 IoC
class SMSService { sendMessage(message: string): void { console.log(`Sending SMS: ${message}`); }}class Notification { private messageService: SMSService; constructor(messageService: SMSService) { this.messageService = messageService; } notify(message: string): void { this.messageService.sendMessage(message); }}// IoC: 依赖项由外部控制const smsService = new SMSService();const notification = new Notification(smsService);notification.notify("Hello, Inversion of Control!");
IoC 的优势：
- 松散耦合：类不创建其依赖项，从而减少对特定实现的依赖。易于切换实现：用 EmailService 替换 SMSService 而无需修改核心类。提高可测试性：在测试期间注入模拟或 Mock 依赖项。
- 依赖注入 (DI)
DI 是一种技术，对象从外部源接收其依赖项，而不是自己创建它们。
DI 是 IoC 的一种实现方式。它允许开发人员通过多种方式将依赖项“注入”到类中：
- 构造函数注入：依赖项通过构造函数传递。Setter 注入：依赖项通过公共方法设置。接口注入：依赖项通过接口提供。
Python 示例：使用 DI 框架
使用 injector 库：
from injector import Injector, injectclass EmailService: def send_message(self, message): print(f"Email sent: {message}")class Notification: @inject def __init__(self, email_service: EmailService): self.email_service = email_service def notify(self, message): self.email_service.send_message(message)# DI 容器injector = Injector()notification = injector.get(Notification)notification.notify("This is Dependency Injection in Python!")
TypeScript 示例：使用 DI 框架
使用 tsyringe：
import "reflect-metadata";import { injectable, inject, container } from "tsyringe";@injectable()class EmailService { sendMessage(message: string): void { console.log(`Email sent: ${message}`); }}@injectable()class Notification { constructor(@inject(EmailService) private emailService: EmailService) {} notify(message: string): void { this.emailService.sendMessage(message); }}// DI 容器const notification = container.resolve(Notification);notification.notify("This is Dependency Injection in TypeScript!");
DI 的优势：
简化测试：轻松使用模拟对象替换依赖项。提高可扩展性：添加新的实现而无需修改现有代码。增强可维护性：减少系统某一部分变更的影响。
以上就是分解依赖倒置、IoC 和 DI的详细内容，更多请关注范的资源库其它相关文章！
转载请注明：范的资源库 » 分解依赖倒置、IoC和DI
