Aufschlüsselung von Abhängigkeitsinversion, IoC und DI

Die Erkundung des Abhängigkeitsinjektionssystems von NestJS führte zu einem tieferen Einblick in die Abhängigkeitsinversion, die Umkehrung der Kontrolle und die Abhängigkeitsinjektion. Obwohl diese Konzepte scheinbar ähnlich sind, bieten sie unterschiedliche Lösungen für unterschiedliche Probleme. Diese Erklärung dient als persönliche Auffrischung und hoffentlich als hilfreicher Leitfaden für andere, die sich mit diesen Begriffen auseinandersetzen.

---

1. Abhängigkeitsinversionsprinzip (DIP)

Definition: High-Level-Module sollten nicht von Low-Level-Modulen abhängen; beide sollten auf Abstraktionen beruhen. Abstraktionen sollten nicht von Details abhängen; Details sollten von Abstraktionen abhängen.

Was das bedeutet:

In Software kapseln High-Level-Module die Kerngeschäftslogik, während Low-Level-Module spezifische Implementierungen (Datenbanken, APIs usw.) verwalten. Ohne DIP sind High-Level-Module direkt auf Low-Level-Module angewiesen, wodurch eine enge Kopplung entsteht, die die Flexibilität beeinträchtigt, Tests und Wartung erschwert und das Ersetzen oder Erweitern von Low-Level-Details erschwert.

DIP kehrt diese Beziehung um. Anstelle einer direkten Steuerung sind sowohl High-Level- als auch Low-Level-Module auf eine gemeinsame Abstraktion (Schnittstelle oder abstrakte Klasse) angewiesen.

---

Ohne DIP

Python-Beispiel

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-Beispiel

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);
    }
}

---

Probleme:

1. Enge Kopplung: Notification hängt direkt von EmailService ab.
2. Eingeschränkte Erweiterbarkeit: Der Wechsel zu SMSService erfordert eine Änderung von Notification.

---

Mit DIP

Python-Beispiel

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)

# Usage
email_service = EmailService()
notification = Notification(email_service)
notification.notify("Hello, Dependency Inversion!")

---

TypeScript-Beispiel

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);
    }
}

// Usage
const emailService = new EmailService();
const notification = new Notification(emailService);
notification.notify("Hello, Dependency Inversion!");

Vorteile von DIP:

• Flexibilität: Implementierungen einfach austauschen.
• Testbarkeit: Verwenden Sie Mocks zum Testen.
• Wartbarkeit: Änderungen an Low-Level-Modulen haben keine Auswirkungen auf High-Level-Module.

---

2. Inversion of Control (IoC)

IoC ist ein Designprinzip, bei dem die Abhängigkeitskontrolle auf ein externes System (Framework) verlagert wird, anstatt innerhalb der Klasse verwaltet zu werden. Traditionell erstellt und verwaltet eine Klasse ihre Abhängigkeiten. IoC kehrt dies um – eine externe Entität fügt Abhängigkeiten ein.

---

Python-Beispiel: Ohne IoC

class SMSService:
    def send_message(self, message):
        print(f"Sending SMS: {message}")

class Notification:
    def __init__(self):
        self.sms_service = SMSService()  # Dependency created internally

    def notify(self, message):
        self.sms_service.send_message(message)

---

TypeScript-Beispiel: Ohne IoC

class SMSService {
    sendMessage(message: string): void {
        console.log(`Sending SMS: ${message}`);
    }
}

class Notification {
    private smsService: SMSService;

    constructor() {
        this.smsService = new SMSService(); // Dependency created internally
    }

    notify(message: string): void {
        this.smsService.sendMessage(message);
    }
}

---

Probleme ohne IoC:

1. Enge Kopplung.
2. Geringe Flexibilität.
3. Schwieriges Testen.

---

Python-Beispiel: Mit IoC

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-Beispiel: Mit IoC

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);
    }
}

---

Vorteile von IoC:

1. Lockere Kupplung.
2. Einfacher Implementierungswechsel.
3. Verbesserte Testbarkeit.

---

3. Abhängigkeitsinjektion (DI)

DI ist eine Technik, bei der ein Objekt seine Abhängigkeiten von einer externen Quelle erhält. Es handelt sich um eine praktische Implementierung von IoC, bei der Abhängigkeiten eingefügt werden über:

1. Konstruktorinjektion
2. Setter-Injektion
3. Schnittstelleninjektion

---

Python-Beispiel: DI Framework (unter Verwendung der injector-Bibliothek)

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)

# Usage
email_service = EmailService()
notification = Notification(email_service)
notification.notify("Hello, Dependency Inversion!")

---

TypeScript-Beispiel: DI Framework (unter Verwendung der tsyringe-Bibliothek)

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);
    }
}

// Usage
const emailService = new EmailService();
const notification = new Notification(emailService);
notification.notify("Hello, Dependency Inversion!");

---

Vorteile von DI:

• Vereinfachtes Testen.
• Verbesserte Skalierbarkeit.
• Verbesserte Wartbarkeit.

Diese ausführliche Erklärung verdeutlicht die Beziehungen und Unterschiede zwischen DIP, IoC und DI und betont ihre individuellen Beiträge zum Aufbau robuster und wartbarer Software.

Das obige ist der detaillierte Inhalt vonAufschlüsselung von Abhängigkeitsinversion, IoC und DI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!