Patterns in der Softwareentwicklung: Das Strukturpattern Fassade

07.11.2022 12:42 Uhr Rainer Grimm

(Bild: Roberto Rizzi / Shutterstock.com)

Die Fassade bietet eine vereinfachte Schnittstelle zu einem komplexen System an. Es gehört zu den Strukturmustern.

Patterns sind eine wichtige Abstraktion in der modernen Softwareentwicklung. Sie bieten eine klar definierte Terminologie, eine saubere Dokumentation und das Lernen von den Besten. Das klassische Buch "Design Patterns: Elements of Reusable Object-Oriented Software" (kurz Design Patterns), das ich in meiner Serie über Muster vorstelle, enthält 23 Muster. Die Fassade ist ein Strukturmuster. und hat einen Zweck: eine vereinfachte Schnittstelle zu einem komplexen System zu schaffen.

Eine Fassade definiert eine übergeordnete Schnittstelle, die die Nutzung des Subsystems erleichtert. Die Absicht der übergeordneten Schnittstelle ist es, nicht alle Anwendungsfälle des komplexen Systems zu unterstützen, sondern nur die wichtigsten. Trotz der Fassade für die vereinfachte Schnittstelle ist es oft noch möglich, das komplexe System direkt zu nutzen.

Die Fassade ist ein idealer Startpunkt, um komplexe Systeme durch die Einführung von Schichten zu entkoppeln. Außerdem kann es als Ausgangspunkt für die Abschaffung der alten Schnittstelle verwendet werden

Hier sind die Fakten:

Fassade

Zweck

Bietet eine vereinfachte Schnittstelle zu einer Reihe von Schnittstellen

Anwendungsfall

Vereinfachter Zugang zu einem komplexen System
Ein komplexes System enthält viele Abhängigkeiten, die durch die Fassade entkoppelt werden
Einführung von Schichten innerhalb eines komplexen Systems; die Schicht hilft, dass komplexe System zu entkoppeln

Struktur

Facade

Bietet die vereinfachte Schnittstelle an
Delegiert Anfragen an die Subsysteme

Package

Implementiert die Funktionalität
Weiß nichts über die Fassade

Beispiel

Das folgende Beispiel stammt aus dem Wikibuch C++Programming: code patterns design [1].

// from https://en.wikibooks.org/wiki/C%2B%2B_Programming/Code/\
                Design_Patterns#Facade

#include <string>
#include <iostream>

using namespace std;

class Alarm                                                 // (2)
{
public:
	void alarmOn()
	{
		cout << "Alarm is on and house is secured"<<endl;
	}

	void alarmOff()
	{
		cout << "Alarm is off and you can go into the house"<<endl;
	}
};

class Ac                                                    // (3)
{
public:
	void acOn()
	{
		cout << "Ac is on"<<endl;
	}

	void acOff()
	{
		cout << "AC is off"<<endl;
	}
};

class Tv                                                    // (4)
{
public:
	void tvOn()
	{
		cout << "Tv is on"<<endl;
	}

	void tvOff()
	{
		cout << "TV is off"<<endl;
	}
};

class HouseFacade                                           // (1)
{
	Alarm alarm;
	Ac ac;
	Tv tv;

public:
	HouseFacade(){}

	void goToWork()                                          // (5) 
	{
		ac.acOff();
		tv.tvOff();
		alarm.alarmOn();
	}

	void comeHome()                                          // (6)
	{
		alarm.alarmOff();
		ac.acOn();
		tv.tvOn();
	}
};

int main()
{
	HouseFacade hf;

	// Rather than calling 100 different on and off functions
	// thanks to facade I only have 2 functions...
	hf.goToWork();
	hf.comeHome();
}

Die Klasse HouseFacade (1) vereinfacht die Verwendung der Klassen Alarm, Ac und TV (2 bis 4). Die vereinfachte Schnittstelle besteht aus den beiden Mitgliedsfunktionen goToWork (5) und comeHome (6). Beide Mitgliedsfunktionen kapseln nicht nur die zugrunde liegenden Mitgliedsfunktionen der ursprünglichen Schnittstelle, sondern garantieren auch, dass die Mitgliedsfunktionen in der richtigen Reihenfolge aufgerufen werden.

Abschließend ist hier die Ausgabe des Programms:

Die Fassade ist wahrscheinlich das am häufigsten verwendete Entwurfsmuster.

Bekannte Verwendungen

Im Allgemeinen kommt die Fassade zum Einsatz, wenn eine Funktion aufgerufen wird, die einen Aufruf des Betriebssystems auslöst. Hier sind ein paar Beispiele:

Die Container der Standard Template Library verwalten ihren Speicher automatisch.
Die Threading-API löst Aufrufe der zugrunde liegenden Threading-Infrastruktur wie pthread [2]oder win32 Threads [3] aus.
Die parallele STL ruft die zugrunde liegende Infrastruktur wie die Threading Building Blocks [4] (TBB) oder die Parallel Patterns Library [5] (PPL) auf.
Die Dateisystembibliothek [6] ist eine Abstraktion über der zugrunde liegenden betriebssystemspezifischen Dateisystembibliothek.
Es gibt weitere betriebssystemspezifische Abstraktionen. Hier sind einige davon: die Chrono-Bibliothek [7], die Zufallsbibliothek [8] oder die Formatierungsbibliothek [9].

Verwandte Muster

Das Adaptor-Muster [10]passt eine bestehende Schnittstelle an, während die Fassade eine neue, vereinfachte Schnittstelle schafft.
Eine abstrakte Fabrik [11] ist eine alternative Möglichkeit, ein Subsystem auf transparente Weise zu abstrahieren.
Das Vermittlermuster [12] koordiniert die Organisation zwischen Objekten, aber die Fassade schafft eine neue, vereinfachte Schnittstelle.
Das Singleton-Muster [13] kann als einziger Zugangspunkt zu einem komplexen Subsystem dienen.

Vor- und Nachteile

Vorteile

Die Komplexität des Codes kann vor dem Anwender verborgen werden.
Die missbräuchliche Nutzung des komplexen Systems wird drastisch reduziert: "Make interfaces easy to use correctly and hard to use incorrectly." von Scott Meyer in seinem Artikel "The Most Important Design Guideline?".
Es erleichtert es, ein komplexes System auf eine andere Plattform zu portieren, da Anwender nur von der Fassade abhängig sind.

Nachteile

Eine Fassade kann zu viele Verantwortlichkeiten besitzen und immer mehr zu dem Antipattern God Object [14] mutieren.
Die Fassade ist dem Singleton-Muster ziemlich ähnlich. Beide bieten einen einzigen Zugangspunkt zu einem komplexen System. Folglich gelten die Vor- und Nachteile des Singleton-Musters auch für das Fassade-Muster. Mehr über die Vor- und Nachteile des Singleton-Musters finden sich in meinem letzten Artikel: "Patterns in der Softwareentwicklung: Die Vor- und Nachteile des Singleton-Musters [15]".

Wie geht's weiter?

In meinem nächsten Artikel stelle ich das verbleibende Strukturmuster aus dem Buch "Design Patterns: Elements of Reusable Object-Oriented Software [16]" genauer vor: das Proxy-Muster. Das Proxy-Muster [17] wird als Platzhalter für den Zugriff auf ein anderes Objekt verwendet. ( [18])

URL dieses Artikels:
https://www.heise.de/-7331425

Links in diesem Artikel:
[1] https://en.wikibooks.org/wiki/C%2B%2B_Programming/Code/Design_Patterns#Facade
[2] https://en.wikipedia.org/wiki/Pthreads
[3] http://www.cs.rpi.edu/courses/fall06/netprog/WindowsThreads.html
[4] https://en.wikipedia.org/wiki/Threading_Building_Blocks
[5] https://learn.microsoft.com/en-us/cpp/parallel/concrt/parallel-patterns-library-ppl?view=msvc-170
[6] https://en.cppreference.com/w/cpp/filesystem
[7] https://en.cppreference.com/w/cpp/chrono
[8] https://en.cppreference.com/w/cpp/numeric
[9] https://en.cppreference.com/w/cpp/utility/format
[10] https://en.wikipedia.org/wiki/Adapter_pattern
[11] https://en.wikipedia.org/wiki/Abstract_factory_pattern
[12] https://en.wikipedia.org/wiki/Mediator_pattern
[13] https://en.wikipedia.org/wiki/Singleton_pattern
[14] https://en.wikipedia.org/wiki/God_object
[15] https://heise.de/-7274558
[16] https://en.wikipedia.org/wiki/Design_Patterns
[17] https://en.wikipedia.org/wiki/Proxy_pattern
[18] mailto:rainer@grimm-jaud.de