Faites en sorte que votre application soit faiblement couplée-Abstraction-PolyMorphisme

Lors du développement d'une application, il est obligatoire de garder les composants indépendants les uns des autres, c'est ce qu'est un couplage lâche. Il assure la standardisation, la consolidation, la normalisation et la gouvernance de votre application. Une application faiblement couplée est facile à faire évoluer.

Dans cet article : Vous apprendrez, à l'aide d'un exemple, comment rendre votre application faiblement couplée et en tirer le meilleur parti.

Besoin d'un couplage lâche :

Disons que vous récupérez quelque chose de votre base de données UserDatabase, voici la fonction définie par la couche de données pour récupérer les enregistrements de la base de données :

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

Dans notre couche de service, créons une fonction pour communiquer avec notre couche de données afin de récupérer des enregistrements :

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

Dans notre couche application ou fonction principale, nous parlerons à notre couche service :

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

Dans cette application, lorsque nous essayons de faire évoluer notre application, un couplage étroit la rendra redondante et difficile à développer.
C'est pourquoi une application faiblement couplée est si importante. Au Spring Boot, nous y parvenons à l'aide d'interfaces. Faisons en sorte que l'application ci-dessus soit faiblement couplée.

Couplage lâche :

Définissons une interface qui nous donnera une structure globale pour la couche de données :

public interface UserDataProvider {
    String getUserDetails();
}

Récupérez maintenant les enregistrements de la base de données tout en implémentant cette interface :

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

Définissez maintenant la couche de service pour communiquer avec la couche de données :

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

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

Ici, en injectant un objet de référence UserDataProvider dans UserManager, nous pourrons accéder à la fonction UserDatabase qui implémente cette interface afin qu'elle nous fournisse une abstraction à le niveau de la couche de données.

Nous pouvons désormais accéder aux enregistrements via UserManager :

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

Nous pouvons facilement faire évoluer notre application et intégrer autant de connexions à la base de données que nous le souhaitons si nous devons configurer une autre base de données par exemple WebServerDatabase, il nous suffit de créer son instance affectée à l'interface implémentée, puis via UserManager nous pouvons également y accéder. L'utilisation d'une interface nous fournit l'abstraction, le couplage lâche et le polymorphisme (l'implémentation de la même interface par différentes classes nous fournit le polymorphisme).

Joyeux codage :)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!