Gestalten Sie Ihre Anwendung mit lose gekoppeltem Abstraktions-Polymorphismus

Bei der Entwicklung einer Anwendung ist es zwingend erforderlich, die Komponenten voneinander unabhängig zu halten, das ist eine lose Kopplung. Es bietet Standardisierung, Konsolidierung, Normalisierung und Steuerung Ihrer Anwendung. Eine lose gekoppelte Anwendung lässt sich leicht skalieren.

In diesem Artikel erfahren Sie anhand eines Beispiels, wie Sie Ihre Anwendung lose gekoppelt gestalten und das Maximum daraus herausholen.

Notwendigkeit einer losen Kupplung:

Angenommen, Sie rufen etwas aus Ihrer UserDatabase-Datenbank ab. Hier ist die auf der Datenschicht definierte Funktion zum Abrufen von Datenbankdatensätzen:

public class UserDatabase {
    public String getUserDetails(){
        return "User Deatils ";
    }
}

In unserer Serviceschicht erstellen wir eine Funktion, um mit unserer Datenschicht zu kommunizieren, um Datensätze abzurufen:

public class UserDatabase {
    public String getUserDetails(){
        return "User Details in DB1";
    }
}

In unserer Anwendungsschicht oder Hauptfunktion sprechen wir mit unserer Serviceschicht:

public static void main(String[] args) {
        //Tight Coupling
        UserManager userManager = new UserManager();
        System.out.println(userManager.getUserInfo());
    }

Wenn wir in dieser Anwendung versuchen, unsere Anwendung zu skalieren, wird sie durch die enge Kopplung überflüssig und schwer zu erweitern.
Deshalb ist eine lose gekoppelte Anwendung so wichtig. Im Spring Boot erreichen wir dies über Schnittstellen. Lassen Sie uns die obige App lose koppeln.

Lose Kupplung:

Lassen Sie uns eine Schnittstelle definieren, die uns eine Gesamtstruktur für die Datenschicht gibt:

public interface UserDataProvider {
    String getUserDetails();
}

Rufen Sie nun Datenbankeinträge ab, während Sie diese Schnittstelle implementieren:

public class UserDatabase implements UserDataProvider{
    @Override
    public String getUserDetails(){
        return "User Details in DB1";
    }
}

Definieren Sie nun die Serviceschicht für die Kommunikation mit der Datenschicht:

public class UserManager {
    private UserDataProvider userDataProviderr;
    public UserManager(UserDataProvider userDataProvider) {
        this.userDataProviderr = userDataProvider;
    }

    public String getUserInfo(){
        return userDataProviderr.getUserDetails();
    }
}

Hier können wir beim Einfügen eines UserDataProvider-Referenzobjekts in UserManager auf die UserDatabase-Funktion zugreifen, die diese Schnittstelle implementiert, sodass sie uns Abstraktion bietet die Ebene der Datenschicht.

Jetzt können wir über UserManager auf Datensätze zugreifen:

    UserDataProvider userDataProvider = new UserDatabase();
        UserManager userManager = new UserManager(userDataProvider);
        System.out.println(userManager.getUserInfo());

Wir können unsere Anwendung problemlos skalieren und so viele Datenbankverbindungen integrieren, wie wir möchten. Wenn wir beispielsweise eine andere Datenbank konfigurieren müssen WebServerDatabase, müssen wir nur deren Instanz erstellen, die der implementierten Schnittstelle zugewiesen ist. und dann können wir über UserManager auch darauf zugreifen. Die Verwendung einer Schnittstelle bietet uns Abstraktion, lose Kopplung und Polymorphismus (die Implementierung derselben Schnittstelle durch verschiedene Klassen bietet uns Polymorphismus).

Viel Spaß beim Programmieren :)

Das obige ist der detaillierte Inhalt vonGestalten Sie Ihre Anwendung mit lose gekoppeltem Abstraktions-Polymorphismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!