(D): Anwendung des „Abhängigkeitsinversionsprinzips' mit Typescript und Java

Konzepte

SOLID ist ein Akronym, das fünf grundlegende Prinzipien der objektorientierten Programmierung darstellt, vorgeschlagen von Robert C. Martin – Onkel Bob. Hier können Sie mehr über seinen Artikel lesen.
Diese Prinzipien zielen darauf ab, die Struktur und Wartung des Codes zu verbessern und ihn flexibler, skalierbarer und verständlicher zu machen. Solche Prinzipien helfen dem Programmierer, besser organisierte Codes zu erstellen, Verantwortlichkeiten aufzuteilen, Abhängigkeiten zu reduzieren, den Refactoring-Prozess zu vereinfachen und die Wiederverwendung von Code zu fördern.

Das „D“ im Akronym steht für „Dependency Inversion Principle“. Der Satz, mit dem Onkel Bob dieses Prinzip definierte, war:

„High-Level-Module sollten nicht von Low-Level-Modulen abhängen. Beide sollten von Abstraktionen abhängen. Abstraktionen sollten nicht von Details abhängen. Details sollten von Abstraktionen abhängen“

Das Prinzip der Abhängigkeitsumkehr zielt darauf ab, die Kopplung zwischen den Komponenten eines Systems zu reduzieren und so eine größere Flexibilität, Wartbarkeit und Testbarkeit zu fördern.

Probleme, die DIP löst

• Enge Kopplung: Wenn ein Modul direkt von einer konkreten Implementierung abhängt, können sich Änderungen an dieser Implementierung auf andere Module auswirken.
• Schwierigkeit beim Testen: Das Testen von Codeeinheiten, die direkt an bestimmte Implementierungen gekoppelt sind, ist komplizierter, da es die Verwendung dieser konkreten Implementierungen erfordert, was die Erstellung von Mocks oder Stubs erschwert.
• Geringe Wiederverwendbarkeit: Ein Modul, das stark an konkrete Details gekoppelt ist, ist in anderen Kontexten weniger wiederverwendbar.

Praktische Anwendung

Wir werden einen Code erstellen, der für den Versand von Benachrichtigungen per E-Mail verantwortlich ist, um die Probleme und mögliche Lösungen zu ihrer Lösung zu analysieren

Java

class EmailService {
    public void sendEmail(String message) {
        System.out.println("Sending email: " + message);
    }
}

class Notification {
    private EmailService emailService;

    public Notification() {
        this.emailService = new EmailService();
    }

    public void notify(String message) {
        this.emailService.sendEmail(message);
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Notification notification = new Notification();
        notification.notify("Welcome to our service!");
    }
}

Typoskript

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

// Uso
const notification = new Notification();
notification.notify("Welcome to our service!");

Probleme:

• Die Notification-Klasse hängt direkt von einer konkreten Implementierung (EmailService) ab.
• Wenn wir den Benachrichtigungskanal ändern möchten (z. B. SMS), müssen wir den Benachrichtigungscode ändern.

Lösungen und Vorteile:

• Die Benachrichtigung muss keine Details darüber kennen, wie die Nachricht gesendet wird.
• Einfaches Ersetzen oder Hinzufügen neuer Kommunikationskanäle.
• Wir können Notification isoliert testen, ohne uns auf echte Implementierungen zu verlassen.

Java

public interface MessageService {
    void sendMessage(String message);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email: " + message);
    }
}

public class SMSService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

public class Notification {
    private final MessageService messageService;

    public Notification(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notify(String message) {
        messageService.sendMessage(message);
    }
}

// Uso
public class Main {
    public static void main(String[] args) {
        Notification emailNotification = new Notification(new EmailService());
        emailNotification.notify("Welcome via Email!");

        Notification smsNotification = new Notification(new SMSService());
        smsNotification.notify("Welcome via SMS!");
    }
}

Typoskript

interface MessageService {
    sendMessage(message: string): void;
}

class EmailService implements MessageService {
    sendMessage(message: string): void {
        console.log(`Sending email: ${message}`);
    }
}

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

class Notification {
    private messageService: MessageService;

    constructor(messageService: MessageService) {
        this.messageService = messageService;
    }

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

// Uso
const emailNotification = new Notification(new EmailService());
emailNotification.notify("Welcome via Email!");

const smsNotification = new Notification(new SMSService());
smsNotification.notify("Welcome via SMS!");

3. Unit-Tests

Java

public class MockMessageService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Mock message sent: " + message);
    }
}

// Teste com o mock
public class Main {
    public static void main(String[] args) {
        MessageService mockMessageService = new MockMessageService();
        Notification mockNotification = new Notification(mockMessageService);
        mockNotification.notify("Test message");
    }
}

Typoskript

class MockMessageService implements MessageService {
    sendMessage(message: string): void {
        console.log(`Mock message sent: ${message}`);
    }
}

// Teste com o mock
const mockNotification = new Notification(new MockMessageService());
mockNotification.notify("Test message");

Abschluss

Das Dependency Inversion Principle (DIP) ist eine grundlegende Säule für flexible und robuste Projekte. Es ermöglicht Ihnen, die Kopplung zwischen Klassen zu reduzieren, die Wiederverwendung von Code zu erleichtern und die Testbarkeit von Anwendungen zu verbessern. Indem Sie sich auf Abstraktionen verlassen, wird Ihr System anpassungsfähiger an Veränderungen und erweiterbar mit neuen Funktionen. Das Praxisbeispiel zeigte, wie kleine Designanpassungen wiederkehrende Wartungsprobleme lösen können. Die Anwendung von DIP in Verbindung mit anderen SOLID-Prinzipien sorgt für saubereren Code, der für Wachstum bereit ist. Die Übernahme dieser Konzepte ist für Entwickler, die Spitzenleistungen in der Softwarearchitektur anstreben, von entscheidender Bedeutung.

Bibliografische Referenzen

• Martin, Robert C. Agile Softwareentwicklung, Prinzipien, Muster und Praktiken. Prentice Hall, 2002.
• Thiago Leite und Carvalho. Objektorientierung. Casa do Code, 2014.

Das obige ist der detaillierte Inhalt von(D): Anwendung des „Abhängigkeitsinversionsprinzips' mit Typescript und Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!