Krankenhausbeispiel

Moderne Softwaresysteme sind relativ komplex. Eine übliche Vorgehensweise für Designer, mit komplexen Systemen umzugehen, ist „Teile und herrsche“: ein System in mehrere kleinere Subsysteme aufzuteilen. Betrachtet man ein Krankenhaus als Subsystem, kann dieses System entsprechend den Funktionen der Abteilungen in Anmeldung, Ambulanz, Preisgestaltung, Laboruntersuchung, Bezahlung, Medikamentenabholung usw. unterteilt werden. Patienten, die eine Behandlung suchen, müssen sich mit diesen Abteilungen befassen, so wie der Client eines Subsystems mit den verschiedenen Klassen des Subsystems umgeht – es ist keine einfache Aufgabe.

Zuerst muss sich der Patient anmelden, dann geht er in die Ambulanz. Wenn der Arzt eine Laboruntersuchung anordnet, muss der Patient zuerst einen Kostenvoranschlag einholen, dann die Gebühr bezahlen und kann erst danach zur Laborabteilung für die Untersuchung gehen. Nach der Untersuchung kehrt er in den Ambulanzraum zurück. Die obige Abbildung beschreibt die Erfahrung des Patienten im Krankenhaus; die Kästen in der Abbildung stellen das Krankenhaus dar. Die Möglichkeit, diese Unannehmlichkeit zu beheben, besteht darin, das Fassadenmuster einzuführen. Das Krankenhaus kann eine Stelle für einen Empfangsmitarbeiter einrichten, und der Empfangsmitarbeiter ist dafür verantwortlich, im Namen des Patienten Anmeldungen, Preisauskünfte, Zahlungen, Medikamentenabholungen usw. vorzunehmen. Dieser Empfangsmitarbeiter ist die Verkörperung des Fassadenmusters. Der Patient kontaktiert nur den Empfangsmitarbeiter, und der Empfangsmitarbeiter interagiert mit den verschiedenen Abteilungen.

Struktur des Fassadenmusters

Das Fassadenmuster hat keine verallgemeinerte Klassendiagrammbeschreibung; die beste Art, es zu beschreiben, ist eigentlich, es anhand eines Beispiels zu veranschaulichen.

Da das Strukturdiagramm des Facade-Musters zu abstrakt ist, möchte ich es etwas konkreter machen. Angenommen, es gibt drei Module im Subsystem, nämlich ModuleA, ModuleB und ModuleC, die jeweils über eine Beispielmethode verfügen. Dann sieht das Gesamtstrukturdiagramm dieses Beispiels wie folgt aus: In diesem Objektdiagramm erscheinen zwei Rollen:
  • Facade-Rolle:Der Client kann Methoden dieser Rolle aufrufen. Diese Rolle kennt die Funktionen und Verantwortlichkeiten der relevanten Subsysteme. Unter normalen Umständen delegiert diese Rolle alle Anfragen des Clients an die entsprechenden Subsysteme.
  • SubSystem-Rolle:Es kann gleichzeitig ein oder mehrere Subsysteme geben. Jedes Subsystem ist keine einzelne Klasse, sondern eine Sammlung von Klassen (zum Beispiel besteht das obige Subsystem aus drei Klassen: ModuleA, ModuleB und ModuleC). Jedes Subsystem kann direkt vom Client oder von der Facade-Rolle aufgerufen werden. Das Subsystem weiß nichts von der Existenz der Facade; für das Subsystem ist die Facade nur ein weiterer Client.

Quellcode

Klassen in der SubSystem-Rolle:

public class ModuleA {
    //示意方法
    public void testA(){
        System.out.println("调用ModuleA中的testA方法");
    }
}
public class ModuleB {
    //示意方法
    public void testB(){
        System.out.println("调用ModuleB中的testB方法");
    }
}
public class ModuleC {
    //示意方法
    public void testC(){
        System.out.println("调用ModuleC中的testC方法");
    }
}

Facade-Rollenklasse:

public class Facade {
    //示意方法,满足客户端需要的功能
    public void test(){
        ModuleA a = new ModuleA();
        a.testA();
        ModuleB b = new ModuleB();
        b.testB();
        ModuleC c = new ModuleC();
        c.testC();
    }
}

Client-Rollenklasse:

public class Client {
 
    public static void main(String[] args) {
        
        Facade facade = new Facade();
        facade.test();
    }
 
}

Die Facade-Klasse ist im Wesentlichen gleichbedeutend mit der äußeren Schnittstelle der Module A, B und C. Mit dieser Facade-Klasse muss der Client nicht selbst die Module A, B und C im Subsystem aufrufen, noch muss er die internen Implementierungsdetails des Systems kennen, ja nicht einmal die Existenz der Module A, B und C. Der Client muss nur mit der Facade-Klasse interagieren, wodurch eine bessere Entkopplung zwischen dem Client und den Modulen A, B und C im Subsystem erreicht wird und die Nutzung des Systems für den Client einfacher wird.

Implementierung des Facade-Musters

Die Verwendung des Facade-Musters bietet außerdem einen zusätzlichen Vorteil: Methoden können selektiv offengelegt werden. Die in einem Modul definierten Methoden können in zwei Teile unterteilt werden: Ein Teil ist für die Verwendung außerhalb des Subsystems bestimmt, der andere Teil für gegenseitige Aufrufe zwischen internen Modulen des Subsystems. Mit der Facade-Klasse müssen Methoden, die für gegenseitige Aufrufe zwischen internen Modulen des Subsystems verwendet werden, nicht außerhalb des Subsystems offengelegt werden.

Definieren Sie beispielsweise die Module A, B und C wie folgt.

public class ModuleA {
    /**
     * 提供给子系统外部使用的方法
     */
    public void a1(){};
    
    /**
     * 子系统内部模块之间相互调用时使用的方法
     */
    private void a2(){};
    private void a3(){};
}
public class ModuleB {
    /**
     * 提供给子系统外部使用的方法
     */
    public void b1(){};
    
    /**
     * 子系统内部模块之间相互调用时使用的方法
     */
    private void b2(){};
    private void b3(){};
}
public class ModuleC {
    /**
     * 提供给子系统外部使用的方法
     */
    public void c1(){};
    
    /**
     * 子系统内部模块之间相互调用时使用的方法
     */
    private void c2(){};
    private void c3(){};
}
public class ModuleFacade {
    
    ModuleA a = new ModuleA();
    ModuleB b = new ModuleB();
    ModuleC c = new ModuleC();
    /**
     * 下面这些是A、B、C模块对子系统外部提供的方法
     */
    public void a1(){
        a.a1();
    }
    public void b1(){
        b.b1();
    }
    public void c1(){
        c.c1();
    }
}

Auf diese Weise kann das Definieren einer ModuleFacade-Klasse interne Details wirksam abschirmen und verhindern, dass der Client einige Methoden entdeckt, die er beim Aufrufen der Module-Klasse nicht kennen muss. Beispielsweise müssen die Methoden a2() und a3() dem Client nicht bekannt sein; andernfalls würden dadurch sowohl interne Details offengelegt als auch der Client verwirrt. Für den Client müsste er sich möglicherweise sogar überlegen, wofür die Methoden a2() und a3() verwendet werden. Tatsächlich dienen die Methoden a2() und a3() der Interaktion zwischen internen Modulen und waren nie für außerhalb des Subsystems gedacht, daher ist es besser, den Client nicht über sie zu informieren.

Wie viele Facade-Klassen kann ein System haben?

Im Facade-Muster wird normalerweise nur eine Facade-Klasse benötigt, und diese Facade-Klasse hat nur eine Instanz; mit anderen Worten, sie ist eine Singleton-Klasse. Natürlich bedeutet das nicht, dass es im gesamten System nur eine Facade-Klasse gibt; es bedeutet lediglich, dass es für jedes Subsystem nur eine Facade-Klasse gibt. Oder, wenn ein System mehrere Subsysteme hat, hat jedes Subsystem eine Facade-Klasse, und das gesamte System kann mehrere Facade-Klassen haben.

Hinzufügen neuen Verhaltens zum Subsystem

  

Anfänger denken oft, dass durch das Erben von einer Facade-Klasse neues Verhalten zum Subsystem hinzugefügt werden kann. Das ist falsch. Der Zweck des Facade-Musters ist es, einen zentralisierten und vereinfachten Kommunikationskanal für das Subsystem bereitzustellen, und es kann dem Subsystem kein neues Verhalten hinzufügen. Zum Beispiel ist der Rezeptionist in einem Krankenhaus kein medizinisches Personal, und der Rezeptionist kann Patienten keine medizinischen Leistungen erbringen.

Vorteile des Fassadenmusters

Lose Kopplung: Das Facade-Muster lockert die Kopplungsbeziehung zwischen Client und Subsystem, wodurch sich die Module innerhalb des Subsystems einfacher erweitern und warten lassen.

Einfach und benutzerfreundlich: Das Facade-Muster macht das Subsystem einfacher zu verwenden. Der Client muss die interne Implementierung des Subsystems nicht mehr verstehen und auch nicht mit vielen Modulen innerhalb des Subsystems interagieren; er muss nur mit der Facade-Klasse interagieren.

Bessere Unterteilung der Zugriffsebenen: Der sinnvolle Einsatz von Facade kann uns helfen, Zugriffsebenen besser zu unterteilen. Einige Methoden sind für außerhalb des Systems bestimmt, andere für die interne Verwendung. Die Funktionen, die nach außen offengelegt werden müssen, in der Facade zu konzentrieren, erleichtert Clients die Nutzung und verbirgt zudem wirksam interne Details.

Ursprüngliche URL: https://blog.csdn.net/jason0539/article/details/22775311