Ich arbeite seit fünf Jahren und verstehe das Fassadenmodell immer noch nicht!

Okay, lasst uns heute unser Thema mit euch teilen Fassadenmodus门面模式。用贴切的生活故事，以及真实项目场景来讲设计模式，最后用一句话来总结这个设计模式。

故事

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

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

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

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

门面模式概述

门面模式（Facade Pattern.

Erzählt mit passenden Lebensgeschichten und realen Projektszenarien

🎜Story🎜 🎜

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

🎜Übersicht über den Fassadenmodus🎜Facade Pattern), auch Erscheinungsmodus genannt, bietet eine einheitliche Schnittstelle für den Zugriff auf eine Gruppe von Subsystemschnittstellen. Sein Hauptmerkmal besteht darin, dass es eine Schnittstelle auf hoher Ebene definiert, um die Verwendung des Subsystems zu vereinfachen, und zum strukturellen Entwurfsmuster gehört. 🎜🎜Englisch:🎜

Stellen Sie eine einheitliche Schnittstelle zu einer Reihe von Schnittstellen in einem Subsystem bereit.

Tatsächlich verwenden wir alle das Fassadenmuster ausgiebig und absichtlich oder unbeabsichtigt. Immer wenn ein Modul auf hoher Ebene mehrere Subsysteme (mehr als zwei Klassenobjekte) planen muss, erstellen wir bewusst eine neue Klasse, um diese Subsysteme zu kapseln und eine optimierte Schnittstelle bereitzustellen, damit Module auf hoher Ebene die Funktionen dieser Subsysteme einfacher indirekt aufrufen können Subsysteme.

Fälle im Leben

Was das Fassadenmodell betrifft, gibt es viele Fälle im Leben.

Fall 1: Wenn Sie zur Bank gehen, um Geschäfte abzuwickeln, gibt es eine Rezeption, die Sie empfängt. Dann wird die Rezeption Sie fragen, welche Geschäfte Sie erledigen müssen, und er wird Sie einzeln durch die einzelnen Geschäfte führen. sodass wir nicht umherwandern und nach dem entsprechenden Geschäftsfenster suchen müssen. Dieses Rezeptionspersonal entspricht dem Fassadenmodell.

Fall 2: Wenn wir ein Haus bauen und es keinen Auftragnehmer gibt, müssen Sie selbst Zementarbeiter, Elektriker, Dekorationsarbeiter usw. finden. Wenn Sie jedoch einen Auftragnehmer haben, müssen Sie diese Aufgaben nicht ausführen. Sie können dem Auftragnehmer direkt mitteilen, dass Sie einen Elektriker für die Reparatur der Verkabelung benötigen. Dieser Auftragnehmer kann als Fassadenmodell verstanden werden.

Fall 3: controller，也可以理解为门面模式，比如说获取用户账户信息，先查UserService获取用户信息，然后查UserAccountServiceBenutzerkontoinformationen, die von unserem Backend entwickelt wurden.

Anwendbare Szenarien für den Fassadenmodus

In Softwaresystemen eignet sich der Fassadenmodus für die folgenden Anwendungsszenarien.

• Stellen Sie eine einfache Schnittstelle für den externen Zugriff auf ein komplexes Modul oder Subsystem bereit.
• Wenn Sie die Unabhängigkeit von Subsystemen verbessern möchten.
• Wenn ein Subsystem aus unvermeidbaren vorübergehenden Gründen Fehler oder Leistungsprobleme aufweist, kann über den Fassadenmodus eine High-Level-Schnittstelle bereitgestellt werden, um die direkte Interaktion zwischen dem Client und dem Subsystem zu isolieren und so eine Codeverschmutzung zu verhindern.

Gemeinsame Schreibmethode für den Fassadenmodus

Es ist besser, Code zu verwenden, um einen einfachen Fassadenmodus zu implementieren, denn was uns am besten gefällt, ist, mit der Demo zu beginnen.

Geschäftsszenario: Jetzt müssen Sie die jeweiligen Methoden der drei Dienste aufrufen:

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

Wenn der Fassadenmodus nicht eingeführt wird, ruft der Client ihn wie folgt auf:

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

Jedes Mal muss der Client viele davon erstellen Wenn es viele Dienste gibt, wäre dieser Code nicht umständlich? Es wird viel sich wiederholenden Code geben.

Laufendes Ergebnis

do ServiceA
do ServiceB
do ServiceC

Lass uns jetzt mitmachen门面模式:

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

Der Kunde wird:

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

Laufendes Ergebnis:

do ServiceA
do ServiceB
do ServiceC

Fassadenmodus UML-Diagramm

Kombiniert mit dieser UML Diagramm ist es einfacher, das Fassadenmuster zu verstehen, wenn man sich die Fälle von Bankrezeptionspersonal und Auftragnehmern anschaut.

Charaktere im Fassadenmodus

Wie Sie auf dem Bild oben sehen können, enthält der Fassadenmodus hauptsächlich 2 Charaktere.

• Erscheinungszeichen (Facade）：也叫作门面角色，是系统对外的统一接口。
• 子系统角色（Service）：可以同时有一个或多个Service。每个Service都不是一个单独的类，而是一个类的集合。Service们并不知道Facade的存在，对于Service们而言，Facade 只是另一个客户端而已（即Facade对ServiceA、ServiceB、ServiceC

Subsystemrolle (Service</code >. Each<code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05) ; Schriftfamilie: „Operator Mono“, Consolas, Monaco, Menlo, Monospace;word-break: break-all;color: rgb(239, 112, 96);“>Service ist keine separate Klasse, aber eine Sammlung von Klassen. Die Existenz von Facade, für Dienste, Facade ist nur ein weiterer Client (d. h. FacadepairServiceA, ServiceB, ServiceCtransparent).

Erweiterung des Fassadenmusters

Vorteile

● Reduzierung der Systemabhängigkeit Denken Sie darüber nach: Wenn wir den Fassadenmodus nicht verwenden, erfolgt der externe Zugriff direkt in das Subsystem, und es besteht eine starke Kopplungsbeziehung zwischen ihnen. Wenn du stirbst, werde ich sterben, und wenn du lebst, werde ich leben Eine starke Abhängigkeit ist das Ergebnis des Systemdesigns. Die Entstehung des Fassadenmusters löst dieses Problem sehr gut. Alle Abhängigkeiten sind von den Fassadenobjekten abhängig und haben nichts mit dem Subsystem zu tun. 🎜🎜● Verbesserte Flexibilität Die Abhängigkeit wird reduziert und die Flexibilität auf natürliche Weise erhöht. Unabhängig davon, wie sich das Subsystem intern ändert, können Sie sich frei bewegen, solange es keine Auswirkungen auf das Fassadenobjekt hat. 🎜

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

缺点

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

大神们是如何使用的

在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结尾的类，都是使用到了门面模式。

Referenz: Toms Designmusterkurs

Zusammenfassung

Okay, ich habe so viel über den Fassadenmodus erzählt. Haben Sie nach dem Lesen dieses Artikels das Gefühl, dass der Fassadenmodus tatsächlich sehr einfach ist? und es kann auch bei der Arbeit verwendet werden? Überlegen Sie, ob Sie es verwenden können, und gleichzeitig können Sie es auch zum Angeben bei Vorstellungsgesprächen verwenden.