Je travaille depuis cinq ans et je ne comprends toujours pas le modèle de façade !

D'accord, entrons dans notre thème. Aujourd'hui, je partage avec vous Mode façade门面模式。用贴切的生活故事，以及真实项目场景来讲设计模式，最后用一句话来总结这个设计模式。

故事

开发的朋友都知道，后端开发通常都是：

controller---servie---dao/mapper/repository

但是，我问过很多人，熟悉门面模式不？有的工作五年了都不知道。

今天老田，就带你来看看门面模式。

门面模式概述

门面模式（Facade Pattern.

Raconté avec des histoires de vie appropriées et des scénarios de projet réels

🎜Histoire🎜 🎜

controller---servie---dao/mapper/repository🎜

🎜Présentation du mode façade🎜 🎜

Fournir une interface unifiée à un ensemble d'interfaces dans un sous-système. Facade définit une interface de niveau supérieur qui rend le sous-système plus facile à utiliser

En fait, dans notre travail de codage quotidien, nous utilisons tous le modèle de façade de manière intensive et intentionnelle. ou involontairement. Chaque fois qu'un module de haut niveau doit planifier plusieurs sous-systèmes (plus de 2 objets de classe), nous créerons consciemment une nouvelle classe pour encapsuler ces sous-systèmes et fournirons une interface simplifiée afin que les modules de haut niveau puissent plus facilement appeler indirectement les fonctions de ces sous-systèmes. sous-systèmes.

Cas dans la vie

Concernant le modèle de façade, il existe de nombreux cas dans la vie.

Cas 1 : Lorsque vous vous rendez à la banque pour gérer des affaires, il y a une réception pour vous recevoir. Ensuite, la réception vous demandera quelles affaires vous devez faire, et il vous les guidera une par une, afin que nous n'ayons pas besoin de nous promener et de chercher la fenêtre commerciale correspondante. Ce personnel de réception est équivalent au modèle de façade.

Cas 2 : Quand on construit une maison, s'il n'y a pas d'entrepreneur, alors il faut trouver des cimentiers, des électriciens, des décorateurs, etc. Mais si vous avez un entrepreneur, vous n’avez aucune de ces tâches à effectuer. Vous pouvez dire directement à l’entrepreneur que vous avez besoin d’un électricien pour réparer le câblage. Cet entrepreneur peut être compris comme un modèle de façade.

Cas 3 : controller，也可以理解为门面模式，比如说获取用户账户信息，先查UserService获取用户信息，然后查UserAccountServiceInformations du compte utilisateur développées par notre backend.

Scénarios applicables pour le mode façade

Dans les systèmes logiciels, le mode façade convient aux scénarios d'application suivants.

• Fournir une interface simple pour l'accès externe à un module ou sous-système complexe.
• Lorsque vous souhaitez améliorer l'indépendance des sous-systèmes.
• Lorsqu'un sous-système peut avoir des bugs ou des problèmes liés aux performances en raison de raisons temporaires inévitables, une interface de haut niveau peut être fournie via le mode façade pour isoler l'interaction directe entre le client et le sous-système afin d'éviter la pollution du code.

Méthode d'écriture commune pour le mode façade

Il est préférable d'utiliser du code pour implémenter un mode façade simple, car ce que nous aimons le plus, c'est commencer par une démo.

Scénario métier : Vous devez maintenant appeler les méthodes respectives des trois services :

public class ServiceA {
    public void doA(){
        System.out.println("do ServiceA");
    }
}
public class ServiceB {
    public void doB(){
        System.out.println("do ServiceB");
    }
}

public class ServiceC {
    public void doC(){
        System.out.println("do ServiceC");
    }
}

Lorsque le mode façade n'est pas introduit, le client l'appelle ainsi :

public class Client {
    public static void main(String[] args) {
        ServiceA serviceA=new ServiceA();
        ServiceB serviceB=new ServiceB();
        ServiceC serviceC=new ServiceC();

        serviceA.doA();
        serviceB.doB();
        serviceC.doC();
    }
}

A chaque fois, le client doit créer beaucoup de objets de service. S'il y a de nombreux services impliqués, ce code ne serait-il pas gênant ? Il y aura beaucoup de code répétitif.

Résultat d'exécution

do ServiceA
do ServiceB
do ServiceC

Rejoignons-nous maintenant门面模式 :

public class Facade {
    //是不是很像我们controller里注入各种service?
    private ServiceA serviceA = new ServiceA();
    private ServiceB serviceB = new ServiceB();
    private ServiceC serviceC = new ServiceC();

    public void doA() {
        serviceA.doA();
    }

    public void doB() {
        serviceB.doB();
    }

    public void doC() {
        serviceC.doC();
    }
}

Le client devient :

public class Client {
    public static void main(String[] args) {
        //轻轻松松的搞定，只需要创建门面这个对象即可
        Facade facade=new Facade();
        facade.doA();
        facade.doB();
        facade.doC();
    }
}

Résultat d'exécution :

do ServiceA
do ServiceB
do ServiceC

Diagramme UML en mode façade

Combiné avec cet UML Dans ce diagramme, il est plus facile de comprendre le modèle de façade en examinant les cas du personnel de la réception des banques et des sous-traitants.

Personnages en mode façade

Comme vous pouvez le voir sur l'image ci-dessus, le mode façade contient principalement 2 personnages.

• Caractère d'apparence (Façade) : Également appelé rôle de façade, il s’agit de l’interface externe unifiée du système. Facade）：也叫作门面角色，是系统对外的统一接口。
• 子系统角色（Service）：可以同时有一个或多个Service。每个Service都不是一个单独的类，而是一个类的集合。Service们并不知道Facade的存在，对于Service们而言，Facade 只是另一个客户端而已（即Facade对ServiceA、ServiceB、ServiceC

● 提高安全性 　　想让你访问子系统的哪些业务就开通哪些逻辑，不在门面上开通的方法，你休想访问到 。

缺点

• 当增加子系统和扩展子系统行为时，可能容易带来未知风险。
• 不符合开闭原则。
• 某些情况下，可能违背单一职责原则。

大神们是如何使用的

在Spring中也是有大量使用到门面模式，比如说

org.springframework.jdbc.support.JdbcUtils

再来看看其中的方法

public static void closeConnection(@Nullable Connection con) {
    con.close();
}
public static Object extractDatabaseMetaData(DataSource dataSource, DatabaseMetaDataCallback action)
   throws MetaDataAccessException {
    Connection con = null;
  try {
   con = DataSourceUtils.getConnection(dataSource);
   DatabaseMetaData metaData = con.getMetaData();
   if (metaData == null) {
      //.....
   }
   return action.processMetaData(metaData);
  }
}
......

都是给我封装好了方法，对于我们开发者来说，我只面向JdbcUtils这一个类就好了，我不用去管Connection、ResultSet等是怎么创建的，需要的时候，我调用JdbcUtils的对应方法即可获得对应的对象。

在Mybatis中也是用到了门面模式，比如：

org.apache.ibatis.session.Configuration

在Configuration中以new开头的方法，比如：

public Executor newExecutor(Transaction transaction) {
    return newExecutor(transaction, defaultExecutorType);
}
public MetaObject newMetaObject(Object object) {
    return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
}

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    ...
    return parameterHandler;
}

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
      ResultHandler resultHandler, BoundSql boundSql) {
   ...
    return resultSetHandler;
}

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement）{
   ...
}

对于调用这些方法的地方，他并不知道是怎么new出来的对象，只管使用就行了。

在Tomcat中也有门面模式，比如：

org.apache.catalina.connector.RequestFacade

从名字就知道它用了门面模式。它封装了非常多的request操作，也整合了很多servlet-api以外的内容，给用户使用提供了很大便捷。同样，Tomcat针对Response和Session也封装了对应的ResponseFacade类和StandardSessionFacade类，感兴趣的小伙伴可以深入了解一下。

PS：基本上所有以Facade结尾的类，都是使用到了门面模式。

Référence : Cours de modèle de conception de Tom

Résumé

D'accord, j'ai tellement partagé sur le mode façade Après avoir lu cet article, pensez-vous que le mode façade est en fait très simple, et il peut également être utilisé au travail ? Demandez-vous si vous pouvez l'utiliser, et en même temps, vous pouvez également l'utiliser pour vous vanter lors des entretiens.