Aufschlüsselung von Abhängigkeitsinversion, IoC und DI-Python-Tutorial-php.cn

Breaking Down Dependency Inversion, IoC, and 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.

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

<code class="language-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>

Nach dem Login kopieren

TypeScript-Beispiel

<code class="language-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>

Nach dem Login kopieren

Probleme:

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

Mit DIP

Python-Beispiel

<code class="language-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)

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

Nach dem Login kopieren

TypeScript-Beispiel

<code class="language-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);
    }
}

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

Nach dem Login kopieren

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.

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

<code class="language-python">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)</code>

Nach dem Login kopieren

TypeScript-Beispiel: Ohne IoC

<code class="language-typescript">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);
    }
}</code>

Nach dem Login kopieren

Probleme ohne IoC:

Enge Kopplung.
Geringe Flexibilität.
Schwieriges Testen.

Python-Beispiel: Mit IoC

<code class="language-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>

Nach dem Login kopieren

TypeScript-Beispiel: Mit IoC

<code class="language-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>

Nach dem Login kopieren

Vorteile von IoC:

Lockere Kupplung.
Einfacher Implementierungswechsel.
Verbesserte Testbarkeit.

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:

Konstruktorinjektion
Setter-Injektion
Schnittstelleninjektion

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

<code class="language-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)

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

Nach dem Login kopieren

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

<code class="language-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);
    }
}

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

Nach dem Login kopieren

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!