D - Principe d'inversion de dépendance (DIP)-javaDidacticiel-php.cn

D - Dependency Inversion Principle(DIP)

Bevor Sie DIP (Dependency Inversion Principle) verstehen, ist es wichtig zu wissen, was High-Level- und Low-Level-Module und Abstraktionen sind.

High-Level-Modul:

Ein High-Level-Modul bezieht sich auf die Teile einer Anwendung, die Kernfunktionen oder Geschäftslogik verwalten. Diese Module übernehmen normalerweise größere und kritischere Funktionen der Anwendung. High-Level-Module führen im Allgemeinen umfassendere und komplexere Aufgaben aus und sind möglicherweise auf andere Module angewiesen, um ihre Arbeit zu erledigen.

Zum BeispielWenn Sie eine E-Commerce-Anwendung erstellen, wäre das Auftragsverwaltungssystem ein High-Level-Modul. Es übernimmt wichtige Aufgaben wie die Annahme von Bestellungen, deren Bearbeitung, die Verwaltung von Lieferungen usw.

Low-Level-Modul:

Low-Level-Module sind hingegen für spezifische und kleinere Aufgaben zuständig. Diese Module arbeiten auf einer grundlegenden Ebene der Anwendung und führen detailliertere Arbeiten aus, z. B. das Speichern von Daten in der Datenbank, das Konfigurieren von Netzwerkeinstellungen usw. Low-Level-Module unterstützen normalerweise die High-Level-Module bei der Ausführung ihrer Aufgaben.

Um mit dem E-Commerce-Beispiel fortzufahren: Die Payment Gateway-Integration wäre ein Low-Level-Modul. Seine Aufgabe besteht insbesondere darin, Zahlungen abzuwickeln, was im Vergleich zu den umfassenderen Funktionalitäten des Auftragsverwaltungssystems eine speziellere Aufgabe ist.

Abstraktion:

Einfach ausgedrückt bezieht sich Abstraktion auf eine allgemeine Idee oder Darstellung eines Systems oder Prozesses. Es definiert, was passieren soll, gibt aber nicht an, wie es passieren wird. Es konzentriert sich auf die wesentliche Funktionalität, ohne sich mit den zugrunde liegenden Implementierungsdetails zu befassen.

Beispiel:

Stellen Sie sich vor, Sie würden ein Auto fahren. Das Konzept des Autofahrens (d. h. Abstraktion) umfasst:

Auto starten
Auto anhalten

Die Abstraktion gibt jedoch nicht an, wie diese Aktionen ausgeführt werden. Es sagt Ihnen nicht, um welche Art von Auto es sich handelt, welche Art von Motor es hat oder welche spezifischen Mechanismen das Auto starten oder stoppen. Es vermittelt nur eine allgemeine Vorstellung davon, was getan werden muss.

Abstraktion im Softwaredesign:

Abstraktion bedeutet im Softwaredesign die Erstellung eines allgemeinen Vertrags oder einer Struktur mithilfe einer Schnittstelle oder einer abstrakten Klasse, die eine Reihe von Regeln oder Aktionen definiert, die spezifische Implementierung dieser Aktionen jedoch getrennt bleibt. Auf diese Weise können Sie definieren, was getan werden muss, ohne anzugeben, wie es erledigt werden soll.

Beispiel:

Sie könnten ein PaymentInterface haben, das eine Methode zur Verarbeitung von Zahlungen deklariert. Die Schnittstelle gibt an, dass eine Zahlung verarbeitet werden muss, definiert jedoch nicht, wie die Zahlung verarbeitet wird. Dies kann über verschiedene Implementierungen wie PayPal, Stripe oder andere Zahlungsmethoden erfolgen.

Im Wesentlichen konzentriert sich die Abstraktion auf die allgemeine Funktionalität, während die Implementierung flexibel bleibt, sodass sie in Zukunft einfacher geändert oder erweitert werden kann.

Was ist das Abhängigkeitsinversionsprinzip (DIP)?

Gemäß dem Dependency Inversion Principle (DIP) sollten High-Level-Module nicht direkt von Low-Level-Modulen abhängen. Stattdessen sollten beide auf Abstraktionen wie Schnittstellen oder abstrakten Klassen basieren. Dadurch können sowohl High-Level- als auch Low-Level-Module unabhängig voneinander arbeiten, was das System flexibler macht und die Auswirkungen von Änderungen verringert.

Vereinfachte Erklärung:

Stellen Sie sich vor, Sie haben eine Anwendung mit mehreren Funktionen. Wenn eine Funktion direkt von einer anderen abhängig ist, erfordert die Änderung einer Funktion Änderungen in vielen Teilen des Codes. Das DIP schlägt vor, dass Sie anstelle einer direkten Abhängigkeit dafür sorgen sollten, dass verschiedene Teile Ihrer Anwendung über eine gemeinsame Schnittstelle oder Abstraktion funktionieren. Auf diese Weise kann jedes Modul unabhängig funktionieren und Änderungen an einer Funktion haben nur minimale Auswirkungen auf den Rest des Systems.

Zwei wichtige Punkte von DIP:

High-Level-Module sollten nicht von Low-Level-Modulen abhängen. Stattdessen sollten sich beide auf Abstraktionen verlassen.
Es sollte eine Abhängigkeit von Abstraktionen bestehen, nicht von konkreten (spezifischen Implementierungen).

Beispiel:

Erwägen Sie ein Zahlungssystem, bei dem Sie sowohl PayPal als auch Stripe als Zahlungsmethoden verwenden können. Wenn Sie direkt mit PayPal oder Stripe arbeiten, würde das spätere Hinzufügen eines neuen Zahlungsgateways umfangreiche Codeänderungen in Ihrer gesamten Anwendung erfordern.

Wenn Sie jedoch DIP folgen, würden Sie eine allgemeine Zahlungsschnittstelle verwenden. Sowohl PayPal als auch Stripe würden diese Schnittstelle implementieren. Wenn Sie also in Zukunft ein neues Zahlungsgateway hinzufügen möchten, müssen Sie lediglich die vorhandene Schnittstelle implementieren, was den Prozess erheblich vereinfacht.

En suivant ce principe, DIP améliore la maintenabilité et la flexibilité de votre code, permettant des adaptations et des extensions plus fluides sans perturbations majeures.

Exemple 1 :

Considérons une application dans laquelle vous devez démarrer et arrêter différents types de véhicules. Vous pouvez créer une interface Vehicle qui sert d'abstraction. N'importe quel véhicule peut implémenter cette interface pour fournir sa propre fonctionnalité.

Code Java :

 // Abstraction: Vehicle interface
interface Vehicle {
    void start();
    void stop();
}

// Car class implements Vehicle interface
class Car implements Vehicle {
    public void start() {
        System.out.println("Car started");
    }

    public void stop() {
        System.out.println("Car stopped");
    }
}

// Bike class implements Vehicle interface
class Bike implements Vehicle {
    public void start() {
        System.out.println("Bike started");
    }

    public void stop() {
        System.out.println("Bike stopped");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car(); // Car as Vehicle
        car.start();
        car.stop();

        Vehicle bike = new Bike(); // Bike as Vehicle
        bike.start();
        bike.stop();
    }
}

Copier après la connexion

Explication:

Ici, Vehicle sert d'abstraction qui spécifie quelles actions doivent être effectuées (c'est-à-dire démarrer et arrêter), mais il ne définit pas comment ces actions doivent être exécutées. Les classes Auto et Bike mettent en œuvre ces méthodes selon leur propre logique. Cette conception permet l'ajout facile de nouveaux types de véhicules, tels que les camions, sans modifier le code existant.

Ajout d'un nouveau véhicule : camion
Pour ajouter un nouveau véhicule, il vous suffit de créer une classe Truck qui implémente l'interface Vehicle et fournit sa propre implémentation des méthodes start() et stop().

Code Java pour camion :


class Truck implements Vehicle {
    public void start() {
        System.out.println("Truck started");
    }
    public void stop() {
        System.out.println("Truck stopped");
    }
}

Copier après la connexion

Utilisation du camion dans la classe principale sans aucun changement :
Désormais, pour inclure le Truck dans la classe Main, vous pouvez créer une instance de Truck et l'utiliser comme véhicule. Aucune modification n'est nécessaire dans la classe Main ou dans toute autre partie du code.

Code Java pour la classe principale :


<p>public class Main {<br>
    public static void main(String[] args) {<br>
        Vehicle car = new Car(); // Car as Vehicle<br>
        car.start();<br>
        car.stop();</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext">    Vehicle bike = new Bike(); // Bike as Vehicle
    bike.start();
    bike.stop();

    // Adding Truck
    Vehicle truck = new Truck(); // Truck as Vehicle
    truck.start();
    truck.stop();
}

Copier après la connexion

}

Sortie :
Copier le code
La voiture a démarré
Voiture arrêtée
Vélo démarré
Vélo arrêté
Camion démarré
Camion arrêté

Explanation:

Here, the Truck has been added without making any changes to the existing code. The Truck class simply implements its own versions of the start() and stop() functions according to the Vehicle interface. There was no need to modify the Main class or any other part of the application. This demonstrates how the Dependency Inversion Principle (DIP) promotes flexibility and maintainability in code.

Benefits of DIP:

By adhering to the Dependency Inversion Principle, the system remains extensible and maintainable through the use of abstractions.

Importance of DIP:

In this context, Car, Bike, and Truck do not depend directly on the Main class. Instead, the Main class relies solely on the Vehicle abstraction. This means that if a new vehicle type is introduced, there is no need to make changes to the Main class. As a result, the code is much easier to maintain, and adaptability is significantly enhanced.

This approach not only reduces the risk of introducing bugs during modifications but also encourages better design practices by promoting loose coupling between components.

Example 2:

Let's say you want to create a notification system that can send different types of notifications, such as Email, SMS, or Push Notifications. If you directly rely on the Email or SMS classes, adding a new notification method would require changes throughout your code, violating the Dependency Inversion Principle (DIP).

Solution:

We will create an abstraction called Notifier, which will only specify what needs to be done (send notification) without defining how to do it. Different notifier classes (Email, SMS, Push) will implement this functionality in their own way.

Explanation:

Why DIP is Important Here:

To add a new notification method (like WhatsApp), we simply need to create a new class that implements Notifier, and the rest of the code will remain unchanged.

Example 3:

Let’s say you are creating an e-commerce site where payments need to be processed using various payment gateways (like PayPal and Stripe). If you directly rely on PayPal or Stripe, making changes or adding a new gateway would require significant alterations to your code, violating the Dependency Inversion Principle (DIP).

Solution:

We will create an abstraction called PaymentGateway. Any payment gateway will operate according to this abstraction, so adding a new gateway will not require changes to other parts of the code.

Explanation:

DIP is Important Here:

If you need to add a new payment gateway, you simply create a new class that implements the PaymentGateway, and there will be no changes to the core code. This makes the code more maintainable and flexible.

DIP কেন গুরুত্বপূর্ণ?

1. Maintainability: নতুন কিছু যোগ করতে বা পরিবর্তন করতে হলে বড় কোড পরিবর্তন করতে হয় না। DIP মেনে abstraction ব্যবহার করে সিস্টেমকে সহজে মেইনটেইন করা যায়।

2. Flexibility: নতুন ফিচার যোগ করা অনেক সহজ হয়ে যায় কারণ high-level module এবং low-level module আলাদা থাকে।

3. Scalability: DIP এর মাধ্যমে সিস্টেমে নতুন ফিচার বা ফাংশনালিটি যোগ করা সহজ এবং দ্রুত করা যায়।

4. Decoupling: High-level module এবং low-level module সরাসরি একে অপরের উপর নির্ভর না করে abstraction এর মাধ্যমে কাজ করে, যা সিস্টেমের dependencies কমিয়ে দেয়।

Dependency Inversion Principle(DIP) in React

The Dependency Inversion Principle (DIP) can make React applications more modular and maintainable. The core idea of DIP is that high-level components should not depend on low-level components or specific implementations; instead, they should work with a common rule or structure (abstraction).

To implement this concept in React, we typically use props, context, or custom hooks. As a result, components are not directly tied to specific data or logic but operate through abstractions, which facilitates easier changes or the addition of new features in the future.

Example:

By adhering to DIP, your components remain reusable, flexible, and maintainable.

Example 1: Authentication Service

You are building a React application where users need to log in using various authentication services (like Firebase and Auth0). If you directly work with Firebase or Auth0, changing the service would require significant code modifications.

Solution:

By using the AuthService abstraction and adhering to the Dependency Inversion Principle (DIP), you can create an authentication system that allows different authentication services to work together.

Explanation:

This design pattern adheres to the Dependency Inversion Principle (DIP), promoting flexibility and maintainability in the application.

Example 2: API Service Layer with Functional Components

You are making various API calls using fetch or Axios. If you work directly with fetch or Axios, changing the API service would require numerous code changes.

Solution:

We will create an abstraction called ApiService, which will adhere to the Dependency Inversion Principle (DIP) for making API calls. This way, if the service changes, the components will remain unchanged.

Explanation:

Example 3: Form Validation with Functional Components

You have created a React app where form validation is required. If you write the validation logic directly inside the component, any changes to the validation logic would require modifications throughout the code.

Solution:

We will create an abstraction called FormValidator. Different validation libraries (such as Yup or custom validation) will work according to this abstraction.

Explanation:

Disadvantages of Dependency Inversion Principle (DIP):

While the Dependency Inversion Principle (DIP) is a highly beneficial design principle, it also comes with some limitations or disadvantages. Below are some of the key drawbacks of using DIP:

1. Increased Complexity: Following DIP requires creating additional interfaces or abstract classes. This increases the structure's complexity, especially in smaller projects. Directly using low-level modules makes the code simpler, but adhering to DIP requires introducing multiple abstractions, which can add complexity.

2. Overhead of Managing Dependencies: Since high-level and low-level modules are not directly connected, additional design patterns like dependency injection or context are needed to manage dependencies. This increases the maintenance overhead of the project.

3. Unnecessary for Small Projects: In smaller projects or in cases with fewer dependencies or low complexity, using DIP can be unnecessary. Implementing DIP creates additional abstractions that make the code more complicated, while directly using low-level modules can be simpler and more effective.

4. Performance Overhead: By introducing abstractions between high-level and low-level modules, there can be some performance overhead, especially if there are many abstraction layers. Each abstraction adds extra processing, which can slightly impact performance.

5. Misuse of Abstraction: Excessive or incorrect use of abstraction can reduce the readability and maintainability of the code. If abstractions are not thoughtfully implemented, they can create more disadvantages than the intended benefits of DIP.

6. Harder to Debug: Due to the use of abstractions and interfaces, debugging can become more challenging. Without directly working with the implementation, identifying where a problem originates from can take more time.

7. Dependency Injection Tools Required: Implementing DIP often requires using dependency injection frameworks or tools, which take time and effort to learn. Additionally, the use of these frameworks increases the complexity of the project.

Conclusion:

Although DIP is a powerful and beneficial principle, it does have its limitations. In smaller projects or less complex contexts, adhering to DIP may be unnecessary. Therefore, proper analysis is needed to determine when and where to apply this principle for the best results.

? Connect with me on LinkedIn:

I regularly share insights on JavaScript, Node.js, React, Next.js, software engineering, data structures, algorithms, and more. Let’s connect, learn, and grow together!