本文深入探讨 NestJS 依赖注入系统，并阐明依赖倒置原则 (DIP)、控制反转 (IoC) 和依赖注入 (DI) 的概念及其关联。这三个概念看似相似，实则各有侧重，相互关联却又解决不同的问题。本文旨在帮助读者理清这些概念，并理解它们如何协同工作。
-
依赖倒置原则 (DIP)
定义：
高层模块不应该依赖于低层模块；两者都应该依赖于抽象。抽象不应该依赖于细节；细节应该依赖于抽象。
含义解读
在软件开发中，高层模块负责核心业务逻辑，而低层模块处理具体的实现细节（例如文件系统、数据库或 API）。若无 DIP，高层模块直接依赖于低层模块，导致紧密耦合，从而：
- 降低灵活性。
- 复杂化测试和维护。
- 难以替换或扩展低层细节。
DIP 颠覆了这种依赖关系。高层和低层模块都依赖于共享的抽象（接口或抽象类），而不是高层模块直接控制低层实现。
无 DIP 示例
Python 示例
<code class="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)</code>
TypeScript 示例
<code class="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);
}
}</code>
问题：
-
紧密耦合：
Notification直接依赖EmailService。 -
难以扩展：切换到
SMSService或PushNotificationService需要修改Notification类。
含 DIP 示例
Python 示例
<code class="python">from abc import ABC, abstractmethod
class MessageService(ABC):
@abstractmethod
def send_message(self, message):
pass
class 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!")</code>
TypeScript 示例
<code class="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!");</code>
DIP 的优势
- 灵活性：无需修改高层模块即可替换实现。
- 可测试性：使用模拟对象替换真实依赖项进行测试。
- 可维护性：低层模块的更改不会影响高层模块。
-
控制反转 (IoC)
IoC 是一种设计原则，依赖项的创建和管理由外部系统或框架控制，而不是在类内部进行。
传统编程中，类自行创建和管理依赖项。IoC 将这种控制反转——外部实体（例如框架或容器）管理依赖项，并在需要时注入。
无 IoC 示例
在无 IoC 的场景中，类自行创建和管理依赖项，导致紧密耦合。
Python 示例：无 IoC
<code class="python">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!")</code>
TypeScript 示例：无 IoC
<code class="typescript">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!");</code>
无 IoC 的问题：
- 紧密耦合：
Notification类直接创建并依赖SMSService类。 - 灵活性低：切换到其他实现需要修改
Notification类。 - 难以测试：模拟依赖项用于单元测试比较困难，因为依赖项是硬编码的。
使用 IoC
在使用 IoC 的示例中，依赖关系的管理责任转移到外部系统或框架，实现松散耦合并增强可测试性。
Python 示例：使用 IoC
<code class="python">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!")</code>
TypeScript 示例：使用 IoC
<code class="typescript">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!");</code>
IoC 的优势：
- 松散耦合：类不创建其依赖项，从而减少对特定实现的依赖。
- 易于切换实现：用
EmailService替换SMSService而无需修改核心类。 - 提高可测试性：在测试期间注入模拟或 Mock 依赖项。
-
依赖注入 (DI)
DI 是一种技术，对象从外部源接收其依赖项，而不是自己创建它们。
DI 是 IoC 的一种实现方式。它允许开发人员通过多种方式将依赖项“注入”到类中：
- 构造函数注入：依赖项通过构造函数传递。
- Setter 注入：依赖项通过公共方法设置。
- 接口注入：依赖项通过接口提供。
Python 示例：使用 DI 框架
使用 injector 库：
<code class="python">from injector import Injector, inject
class 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!")
</code>
TypeScript 示例：使用 DI 框架
使用 tsyringe：
<code class="typescript">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!");</code>
DI 的优势：
- 简化测试：轻松使用模拟对象替换依赖项。
- 提高可扩展性：添加新的实现而无需修改现有代码。
- 增强可维护性：减少系统某一部分变更的影响。
