您的位置 首页 编程知识

分解依赖倒置、IoC 和 DI

作者: nijia 发布: 2025年1月20日 3阅读 0评论

本文深入探讨 NestJS 依赖注入系统，并阐明依赖倒置原则 (DIP)、控制反转 (IoC) 和依赖注入 (…

分解依赖倒置、IoC 和 DI

本文深入探讨 NestJS 依赖注入系统，并阐明依赖倒置原则 (DIP)、控制反转 (IoC) 和依赖注入 (DI) 的概念及其关联。这三个概念看似相似，实则各有侧重，相互关联却又解决不同的问题。本文旨在帮助读者理清这些概念，并理解它们如何协同工作。

  1. 依赖倒置原则 (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);     } }
登录后复制

问题：

  1. 紧密耦合：Notification 直接依赖 EmlService。
  2. 难以扩展：切换到 SMSService 或 PushNotificationService 需要修改 Notification 类。

含 DIP 示例

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!")
登录后复制

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 的优势

  • 灵活性：无需修改高层模块即可替换实现。
  • 可测试性：使用模拟对象替换真实依赖项进行测试。
  • 可维护性：低层模块的更改不会影响高层模块。

  1. 控制反转 (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 的问题：

  1. 紧密耦合：Notification 类直接创建并依赖 SMSService 类。
  2. 灵活性低：切换到其他实现需要修改 Notification 类。
  3. 难以测试：模拟依赖项用于单元测试比较困难，因为依赖项是硬编码的。

使用 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 的优势：

  1. 松散耦合：类不创建其依赖项，从而减少对特定实现的依赖。
  2. 易于切换实现：用 EmailService 替换 SMSService 而无需修改核心类。
  3. 提高可测试性：在测试期间注入模拟或 Mock 依赖项。

  1. 依赖注入 (DI)

DI 是一种技术，对象从外部源接收其依赖项，而不是自己创建它们。

DI 是 IoC 的一种实现方式。它允许开发人员通过多种方式将依赖项“注入”到类中：

  1. 构造函数注入：依赖项通过构造函数传递。
  2. Setter 注入：依赖项通过公共方法设置。
  3. 接口注入：依赖项通过接口提供。

Python 示例：使用 DI 框架

使用 injector 库：

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!")
登录后复制

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的详细内容，更多请关注php中文网其它相关文章！

本文来自网络，不代表四平甲倪网络网站制作专家立场，转载请注明出处：http://www.elephantgpt.cn/6221.html
打赏 0赞

作者: nijia

相关文章

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

联系我们

联系我们

18844404989

在线咨询: QQ交谈

邮箱: 641522856@qq.com

工作时间：周一至周五，9:00-17:30，节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

关注微博
返回顶部