# data[].attributes.headline
                                                           Das Entwurfsmuster Facade - Tim Schützle, Dennis Godec im Rahmen von Ausgewählte Aspekte des Software Engineering 1

# data[].attributes.subject
                                                           Das Entwurfsmuster Facade - Tim Schützle, Dennis Godec im Rahmen von Ausgewählte Aspekte des Software Engineering 1

# data[].attributes.headline
Beispiel für die Anwendung des Musters in Java

# data[].attributes.subject
Beispiel für die Anwendung des Musters in Java

# data[].attributes.body
JOptionPane ist eine Fassade für Dialogfenster in Java. Mit den Methoden showMessageDialog() und showInputDialog() stellt sie dem Client eine einfache Schnittstelle zur Erstellung von Dialogfenstern zur Verfügung. Der Client muss dabei keine Kenntnis von den verwendeten Swingkomponenten (z.B. Frame), Layoutmanagern (z.B. BorderLayout) und Listener (z.B Actionlistener) haben.

# data[].attributes.body
Vereinfachte Schnittstelle und verstecken der Komplexität: Der Client kann ein komplexes System einfacher verwenden ohne die Klassen des Subsystems zu kennen. Über eine Schnittstelle kann er das System bedienen ohne die volle Funktionalität dahinter zu kennen.
Entkopplung des Client vom Subsystem: Da der Client nur noch gegen die Fassade arbeitet, ist er unabhängig von Änderungen und Anpassungen im Subsystem.
Änderungsstabilität, leicht erweiterbar und geringerer Änderungsaufwand:
Durch die Entkopplung,  beeinträchtigen Änderungen die im Subsystem erfolgen, nicht den Client sondern höchstens die Fassade. Die Schnittstelle der Fassade nach außen bleibt aber bei Änderungen unbetroffen. Ohne zwischengeschaltete Schnittstelle müsste immer der Client mit angepasst werden.

# data[].attributes.body
Zusätzliche Indirektionsstufe: Zusätzliche Schicht (die Fassade selbst) muss implementiert werden. Führt zu zusätzlicher Rechenzeit für Methoden- und Funktionsaufrufe, Speicherzugriffe etc.
Implementierung aufwändig: Hoher Implementierungsaufwand ist mit dem erstellen einer Fassade verbunden. Besonders wenn es darum geht so eine Schnittstelle in bereits bestehenden Code einzufügen.
Hoher Abhängigkeitsgrad von der Facade-Schnittstelle: Wenn es Probleme mit der Schnittstelle gibt, geht unter Umständen gar nichts mehr. Zudem kann es zu zusätzlichen Performanceproblemen kommen wenn zuviel Funktionalität in der Schnittstelle geschrieben wird.

# data[].attributes.body
Generell greifen die Anwendungsfälle und Einsatzgebiete auf die Vorteile zurück.
Anwendungsfälle sind sinnvoll bei:
- angestrebter Reduzierung der Abhängigkeiten zwischen dem Client und dem benutzten Subsystem:
- einer Schichtenunterteilung des Systems. Die Schichten kommunizieren nur noch über Fassaden, die den Zugang zum Subsystem darstellen. Somit wird das System unterteilt und die Abhängigkeiten zwischen den Teilsystemen gesenkt.
- zur Verfügung stellen einer vereinfachten Schnittstelle um ein kompliziertes Subsystem zu bedienen.

# data[].attributes.body
Fassade
Facade
Business Facade

# data[].attributes.body
Stellt man sich die Funktionalität eines Auto-Motors vor, so müssen (selbst wenn man es vereinfacht) viele Dinge zusammenspielen.

Ein Code-Beispiel in dem nun alles aktiviert werden muss, sieht so aus:

airFlowController.takeAir()
fuelInjector.on()
fuelInjector.inject()
starter.start()
coolingController.setTemperatureUpperLimit(DEFAULT_COOLING_TEMP)
coolingController.run()
catalyticConverter.on()

und für das Abschalten der Luftzufuhr, der Injektoren und des Kühlsystems sind ähnlich viele Schritte nötig.
Stellt man sich nun vor, dass dies ein vom Nutzer zu verwendendes System darstellt, würde es sehr komplex werden, da es sich lediglich um eine Funktionalität handelt.

public class MotorFacade {

private static int DEFAULT_COOLING_TEMP = 90;
private static int MAX_ALLOWED_TEMP = 50;
private FuelInjector fuelInjector = new FuelInjector();
private AirFlowController airFlowController = new AirFlowController();
private Starter starter = new Starter();
private CoolingController coolingController = new CoolingController();
private CatalyticConverter catalyticConverter = new CatalyticConverter();

public void starteMotor() {
fuelInjector.on();
airFlowController.takeAir();
fuelInjector.on();
fuelInjector.inject();
starter.start();
coolingController.setTemperatureUpperLimit(DEFAULT_COOLING_TEMP);
coolingController.run();
catalyticConverter.on();
}

public void stoppeMotor() {
fuelInjector.off();
catalyticConverter.off();
coolingController.cool(MAX_ALLOWED_TEMP);
coolingController.stop();
airFlowController.off();
}
}

public class Nutzklasse {

MotorFacade facade;
facade = new MotorFacade();

facade.starteMotor();
.....
facade.stoppeMotor();
}

So könnte der Aufbau einer RemoteFacade inklusive EJB aussehen.

@Remote
public interface RemoteMotorFacade {

public void starteMotor();

public void stoppeMotor();
}

@Stateless
public class NutzKlasseFacade implements RemoteMotorFacade {

private static int DEFAULT_COOLING_TEMP = 90;
private static int MAX_ALLOWED_TEMP = 50;
private FuelInjector fuelInjector = new FuelInjector();
private AirFlowController airFlowController = new AirFlowController();
private Starter starter = new Starter();
private CoolingController coolingController = new CoolingController();
private CatalyticConverter catalyticConverter = new CatalyticConverter();

@Override
public void starteMotor() {
fuelInjector.on();
airFlowController.takeAir();
fuelInjector.on();
fuelInjector.inject();
starter.start();
coolingController.setTemperatureUpperLimit(DEFAULT_COOLING_TEMP);
coolingController.run();
catalyticConverter.on();
}

@Override
public void stoppeMotor() {
fuelInjector.off();
catalyticConverter.off();
coolingController.cool(MAX_ALLOWED_TEMP);
coolingController.stop();
airFlowController.off();
}

}

# data[].attributes.headline
Beispiel für die Anwendung des Musters in der Praxis

# data[].attributes.subject
Beispiel für die Anwendung des Musters in der Praxis

# data[].attributes.body
Stellt eine einheitliche Schnittstelle (Interface) für eine Menge von Schnittstellen des Subsystems zur Verfügung. Führt eine Strukturierungsebene oberhalb von Klassen ein. Ziel ist die Minimierung der Kopplung.
Durch die einheitliche Schnittstelle wird nicht nur die Komplexität versteckt (Hiding Complexity), sondern auch der Zugang beziehungsweise die Verwendung des Systems vereinfacht.

Um sich als User mit einem System, dass viele Klassen und Abhängigkeiten innehält, vertraut zu machen und die Funktionalität zu verstehen, bedarf es Zeit und spezifisches Wissen.
Die Facade dient als "Vermittler" zwischen Client und Subsystem.
Das schwer zu verstehende beziehungsweise komplexe Subsystem wird gekapselt.
Die Clientaufrufe werden über die Facade an das Subsystem deligiert und dort verarbeitet.
Somit benötigt der User/Client kein Verständnis oder Wissen des darunterliegenden Subsystems.

Des Weiteren wird das Subsystem beziehungsweise Teile davon austauschbar gemacht.
Die Facade beinhaltet optimalerweise keinerlei Abhängigkeiten. System- beziehungsweise Firmeninterne sind oft nicht vermeidbar, aber diese stehen nicht im Weg.
Wenn die eigentliche Problemstellung (z.B Berechnung von Feiertagen) mittels einer Abhängigkeit gelöst wird, dann findet sich diese lediglich im Subsystem. Sollte also die verwendete Bibliothek irgendwann auslaufen oder fehlerhaft sein, so ist keine Shotgun Surgery (viele Stellen in der Codebasis abändern) nötig. Die eigentliche Code-Basis beziehungsweise der Großteil des Codes beschäftigt sich nicht mit der eigentlichen Ermittlung der Feiertage. Somit kann die Abhängigkeit rausgeschmissen, eine neue eingefügt werden und letztendlich müssen nur wenige Zeilen Code abgeändert werden.

Das hat auch zur Folge, dass die Facade nicht angefasst/angepasst werden muss und somit muss nur das neue/abgeänderte Subsystem neu in die Produktion eingespeist werden.

Neben der Möglichkeit eines Users, kann auch von anderen Systemen oder Anwendungen über die Facade auf das Subsystem zugegriffen werden.