https://padlet.com/schuetzlito/facade Alles zur Fassade en-us 2020-12-14 12:29:53 UTC 2023-02-15 00:41:46 UTC hello@padlet.com schuetzlito https://padlet.com/schuetzlito/facade/wish/1015594645 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.]]> 2020-12-14 12:15:05 UTC https://padlet.com/schuetzlito/facade/wish/1015594645 schuetzlito https://padlet.com/schuetzlito/facade/wish/1015600301

]]> 2020-12-14 12:18:42 UTC https://padlet.com/schuetzlito/facade/wish/1015600301 schuetzlito https://padlet.com/schuetzlito/facade/wish/1015613153 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();
    }

}


]]> 2020-12-14 12:26:20 UTC https://padlet.com/schuetzlito/facade/wish/1015613153 schuetzlito https://padlet.com/schuetzlito/facade/wish/1015631345 Fassade
Facade
Business Facade]]> 2020-12-14 12:36:05 UTC https://padlet.com/schuetzlito/facade/wish/1015631345 schuetzlito https://padlet.com/schuetzlito/facade/wish/1015661049 2020-12-14 12:50:49 UTC https://padlet.com/schuetzlito/facade/wish/1015661049 schuetzlito https://padlet.com/schuetzlito/facade/wish/1016347958 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.]]> 2020-12-14 15:33:43 UTC https://padlet.com/schuetzlito/facade/wish/1016347958 schuetzlito https://padlet.com/schuetzlito/facade/wish/1016359125 2020-12-14 15:35:52 UTC https://padlet.com/schuetzlito/facade/wish/1016359125 schuetzlito https://padlet.com/schuetzlito/facade/wish/1016367715 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.]]> 2020-12-14 15:37:33 UTC https://padlet.com/schuetzlito/facade/wish/1016367715 schuetzlito https://padlet.com/schuetzlito/facade/wish/1016368008 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.]]> 2020-12-14 15:37:36 UTC https://padlet.com/schuetzlito/facade/wish/1016368008 schuetzlito https://padlet.com/schuetzlito/facade/wish/1016755158 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.]]> 2020-12-14 16:50:16 UTC https://padlet.com/schuetzlito/facade/wish/1016755158 dennisgo https://padlet.com/schuetzlito/facade/wish/1019682092 2020-12-15 12:48:41 UTC https://padlet.com/schuetzlito/facade/wish/1019682092