Was ist das Fassadenmuster?

Ist Fassade eine Klasse, die viele andere Klassen enthält?

Was macht es zu einem Designmuster? Für mich ist es wie eine normale Klasse.

Können Sie mir dieses Fassadenmuster erklären ?

Ein Entwurfsmuster ist eine übliche Methode zur Lösung eines wiederkehrenden Problems. Klassen in allen Entwurfsmustern sind nur normale Klassen. Wichtig ist, wie sie strukturiert sind und wie sie zusammenarbeiten, um ein bestimmtes Problem bestmöglich zu lösen.

Das Fassadenmuster vereinfacht die Schnittstelle zu einem komplexen System. weil es normalerweise aus allen Klassen besteht, aus denen die Subsysteme des komplexen Systems bestehen.

Eine Fassade schützt den Benutzer vor den komplexen Details des Systems und stellt ihm eine simplified viewdavon zur Verfügung easy to use. Es ist auch decouplesder Code, der das System aus den Details der Subsysteme verwendet, was es einfacher macht, das System später zu ändern.

http://www.dofactory.com/Patterns/PatternFacade.aspx

http://www.blackwasp.co.uk/Facade.aspx

Beim Erlernen von Entwurfsmustern ist es außerdem wichtig, zu erkennen, welches Muster zu Ihrem Problem passt, und es dann entsprechend zu verwenden. Es ist sehr häufig, ein Muster zu missbrauchen oder zu versuchen, es an ein Problem anzupassen, nur weil Sie es kennen. Seien Sie sich dieser Fallstricke bewusst, während Sie anhand von Entwurfsmustern lernen.

Wikipedia hat ein großartiges Beispiel für ein Fassadenmuster.

/* Complex parts */

class CPU {
    public void freeze() { ... }
    public void jump(long position) { ... }
    public void execute() { ... }
}

class Memory {
    public void load(long position, byte[] data) { ... }
}

class HardDrive {
    public byte[] read(long lba, int size) { ... }
}

/* Facade */

class ComputerFacade {
    private CPU processor;
    private Memory ram;
    private HardDrive hd;

    public ComputerFacade() {
        this.processor = new CPU();
        this.ram = new Memory();
        this.hd = new HardDrive();
    }

    public void start() {
        processor.freeze();
        ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
        processor.jump(BOOT_ADDRESS);
        processor.execute();
    }
}

/* Client */

class You {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.start();
    }
}

Wie in der vorherigen Antwort erläutert, bietet es eine einfache Schnittstelle zum konsumierenden Client. Zum Beispiel: "ESPN beobachten" ist die beabsichtigte Funktion. Es umfasst jedoch mehrere Schritte wie:

1. Schalten Sie bei Bedarf den Fernseher ein.
2. Überprüfen Sie die Funktion des Satelliten / Kabels.
3. Wechseln Sie bei Bedarf zu ESPN.

Die Fassade vereinfacht dies jedoch und bietet dem Kunden lediglich die Funktion "ESPN beobachten".

Facade verbirgt die Komplexität des Systems und bietet eine Schnittstelle zum Client, von der aus der Client auf das System zugreifen kann.

public class Inventory {
public String checkInventory(String OrderId) {
    return "Inventory checked";
}
}

public class Payment {
public String deductPayment(String orderID) {
    return "Payment deducted successfully";
}
}


public class OrderFacade {
private Payment pymt = new Payment();
private Inventory inventry = new Inventory();

public void placeOrder(String orderId) {
    String step1 = inventry.checkInventory(orderId);
    String step2 = pymt.deductPayment(orderId);
    System.out
            .println("Following steps completed:" + step1
                    + " & " + step2);
   }
}

public class Client {
       public static void main(String args[]){
         OrderFacade orderFacade = new OrderFacade();
         orderFacade.placeOrder("OR123456");
         System.out.println("Order processing completed");
       }
  }

Eine kurze und einfache Erklärung:

• Das Fassadenmuster bietet eine einheitliche Schnittstelle zu einer Reihe von Schnittstellen in einem Subsystem.
• Facade definiert eine übergeordnete Schnittstelle, die die Verwendung des Subsystems vereinfacht.

Versuchen Sie, das Szenario mit und ohne Fassade zu verstehen:
Wenn Sie das Geld von Konto 1 auf Konto 2 überweisen möchten, müssen Sie die beiden aufzurufenden Subsysteme von Konto 1 abheben und auf Konto 2 einzahlen.

Eine Fassade sollte nicht als eine Klasse beschrieben werden, die viele andere Klassen enthält. Es ist in der Tat eine Schnittstelle zu diesen Klassen und sollte die Verwendung der Klassen erleichtern, da sonst die Fassadenklasse unbrauchbar ist.

In Bezug auf Ihre Fragen:

Ist Facade eine Klasse, die viele andere Klassen enthält?

Ja. Es ist ein Wrapper für viele Subsysteme in der Anwendung.

Was macht es zu einem Designmuster? Für mich ist es wie eine normale Klasse

Auch alle Entwurfsmuster sind normale Klassen. @ Unmesh Kondolikar hat diese Frage zu Recht beantwortet.

Können Sie mir diese Fassade erklären? Ich bin neu im Entwerfen von Mustern.

Laut GoF wird das Fassadenmuster wie folgt definiert:

Stellen Sie eine einheitliche Schnittstelle für eine Reihe von Schnittstellen in einem Subsystem bereit. Facade Pattern definiert eine übergeordnete Schnittstelle, die die Verwendung des Subsystems vereinfacht

Das Fassadenmuster wird normalerweise verwendet, wenn:

1. Für den Zugriff auf ein komplexes System ist eine einfache Schnittstelle erforderlich.
2. Die Abstraktionen und Implementierungen eines Subsystems sind eng miteinander verbunden.
3. Benötigen Sie einen Einstiegspunkt für jede Ebene der mehrschichtigen Software.
4. Das System ist sehr komplex oder schwer zu verstehen.

Nehmen wir ein echtes Wortbeispiel für die Cleartrip- Website.

Diese Website bietet Buchungsmöglichkeiten

1. Flüge
2. Hotels
3. Flüge + Hotels

Code-Auszug:

import java.util.*;

public class TravelFacade{
    FlightBooking flightBooking;
    TrainBooking trainBooking;
    HotelBooking hotelBooking;

    enum BookingType {
        Flight,Train,Hotel,Flight_And_Hotel,Train_And_Hotel;
    }; 

    public TravelFacade(){
        flightBooking = new FlightBooking();
        trainBooking = new TrainBooking();
        hotelBooking = new HotelBooking();        
    }
    public void book(BookingType type, BookingInfo info){
        switch(type){
            case Flight:
                // book flight;
                flightBooking.bookFlight(info);
                return;
            case Hotel:
                // book hotel;
                hotelBooking.bookHotel(info);
                return;
            case Train:
                // book Train;
                trainBooking.bookTrain(info);
                return;
            case Flight_And_Hotel:
                // book Flight and Hotel
                flightBooking.bookFlight(info);
                hotelBooking.bookHotel(info);
                return;
             case Train_And_Hotel:
                // book Train and Hotel
                trainBooking.bookTrain(info);
                hotelBooking.bookHotel(info);
                return;                
        }
    }
}
class BookingInfo{
    String source;
    String destination;
    Date    fromDate;
    Date     toDate;
    List<PersonInfo> list;
}
class PersonInfo{
    String name;
    int       age;
    Address address;
}
class Address{

}
class FlightBooking{
    public FlightBooking(){

    }
    public void bookFlight(BookingInfo info){

    }
}
class HotelBooking{
    public HotelBooking(){

    }
    public void bookHotel(BookingInfo info){

    }
}
class TrainBooking{
    public TrainBooking(){

    }
    public void bookTrain(BookingInfo info){

    }
}

Erläuterung:

1. FlightBooking, TrainBooking and HotelBooking sind verschiedene Subsysteme des großen Systems: TravelFacade

2. TravelFacade bietet eine einfache Oberfläche, um eine der folgenden Optionen zu buchen

   Flight Booking
   Train Booking 
   Hotel Booking
   Flight + Hotel booking 
   Train + Hotel booking
   

3. Die Buch-API von TravelFacade ruft intern die folgenden APIs von Subsystemen auf

   flightBooking.bookFlight
   trainBooking.bookTrain(info);
   hotelBooking.bookHotel(info);
   

4. Auf diese Weise wird TravelFacadeeine einfachere und einfachere API bereitgestellt, ohne dass Subsystem-APIs verfügbar gemacht werden müssen.

Wichtige Erkenntnisse : (aus dem journaldev- Artikel von Pankaj Kumar )

1. Das Fassadenmuster ist eher ein Helfer für Clientanwendungen
2. Fassadenmuster können an jedem Punkt der Entwicklung angewandt werden, in der Regel , wenn die Anzahl der Schnittstellen wachsen und das System wird comple x .
3. Subsystem-Schnittstellen kennen Facade nicht und sollten keinen Verweis auf die Facade-Schnittstelle haben
4. Das Fassadenmuster sollte für ähnliche Arten von Schnittstellen angewendet werden . Der Zweck besteht darin, eine einzelne Schnittstelle anstelle mehrerer Schnittstellen bereitzustellen, die ähnliche Aufgaben ausführen

Schauen Sie sich zum besseren Verständnis auch den Artikel zur Quellenherstellung an .

Das Fassadenmuster ist eine Hülle für viele andere Schnittstellen, um eine einfachere Schnittstelle zu erhalten.

Entwurfsmuster sind nützlich, da sie wiederkehrende Probleme lösen und den Code im Allgemeinen vereinfachen. In einem Entwicklerteam, das sich bereit erklärt, dieselben Muster zu verwenden, werden Effizienz und Verständnis verbessert, wenn der Code des jeweils anderen gepflegt wird.

Versuchen Sie, mehr Muster zu lesen:

Fassadenmuster: http://www.dofactory.com/Patterns/PatternFacade.aspx#_self1

oder allgemeiner: http://www.dofactory.com/Patterns/Patterns.aspx

Eine zusätzliche Verwendung des Fassadenmusters könnte darin bestehen, die Lernkurve Ihres Teams zu verkürzen. Lassen Sie mich Ihnen ein Beispiel geben:

Nehmen wir an, dass Ihre Anwendung mit MS Excel interagieren muss, indem Sie das von Excel bereitgestellte COM-Objektmodell verwenden. Einer Ihrer Teammitglieder kennt alle Excel-APIs und erstellt darüber eine Fassade, die alle grundlegenden Szenarien der Anwendung erfüllt. Kein anderes Mitglied des Teams muss Zeit mit dem Erlernen der Excel-API verbringen. Das Team kann die Fassade verwenden, ohne die Interna oder alle MS Excel-Objekte zu kennen, die an der Erfüllung eines Szenarios beteiligt sind. Ist es nicht toll?

Somit bietet es eine vereinfachte und einheitliche Schnittstelle über einem komplexen Subsystem.

Ein weiteres Beispiel für eine Fassade: Angenommen, Ihre Anwendung stellt eine Verbindung zur Datenbank her und zeigt die Ergebnisse auf der Benutzeroberfläche an. Sie können die Fassade verwenden, um Ihre Anwendung konfigurierbar zu machen, z. B. beim Ausführen mithilfe einer Datenbank oder mit Scheinobjekten. Sie führen also alle Datenbankaufrufe an die Fassadenklasse durch, wo sie die App-Konfiguration liest und entscheidet, die Datenbankabfrage auszulösen oder das Scheinobjekt zurückzugeben. Auf diese Weise wird die Anwendung db-unabhängig, falls db nicht verfügbar ist.

Eine Fassade enthüllt vereinfachte Funktionen, die meistens aufgerufen werden, und die Implementierung verbirgt die Komplexität, mit der sich Kunden sonst befassen müssten. Im Allgemeinen verwendet die Implementierung mehrere Pakete, Klassen und Funktionen. Gut geschriebene Fassaden machen den direkten Zugriff auf andere Klassen selten. Zum Beispiel, wenn ich einen Geldautomaten besuche und einen Betrag abhebe. Der Geldautomat verbirgt, ob er direkt zur eigenen Bank geht oder über ein ausgehandeltes Netzwerk für eine externe Bank. Der Geldautomat wirkt wie eine Fassade, die mehrere Geräte und Subsysteme verbraucht, mit denen ich mich als Kunde nicht direkt befassen muss.

Es gibt ein sehr gutes Beispiel aus der Praxis für das Muster - den Autostarter .

Als Fahrer schalten wir einfach den Schlüssel ein und das Auto startet. So einfach wie möglich. Hinter den Kulissen sind viele andere Autosysteme beteiligt (wie Batterie, Motor, Kraftstoff usw.), damit das Auto erfolgreich startet, aber sie sind hinter dem Anlasser versteckt.

Wie Sie sehen können, ist der Autostarter die Fassade. Es gibt uns eine einfach zu bedienende Oberfläche, ohne uns um die Komplexität aller anderen Autosysteme sorgen zu müssen.

Fassen wir zusammen:

Das Fassadenmuster vereinfacht und verbirgt die Komplexität großer Codeblöcke oder APIs und bietet eine übersichtlichere, verständlichere und benutzerfreundlichere Oberfläche.

Eine Fassade ist eine Klasse mit einer Funktionalität, die zwischen einem Toolkit und einer vollständigen Anwendung liegt und eine vereinfachte Verwendung der Klassen in einem Paket oder Subsystem bietet. Mit dem Fassadenmuster soll eine Schnittstelle bereitgestellt werden, die die Verwendung eines Subsystems vereinfacht. - Auszug aus dem Buch Design Patterns in C #.

In Facade wird die Kapselung eines komplexen Subsystems in einem einzelnen Schnittstellenobjekt erläutert. Dies reduziert die Lernkurve, die erforderlich ist, um das Subsystem erfolgreich zu nutzen. Es fördert auch die Entkopplung des Subsystems von seinen potenziell vielen Clients. Wenn andererseits die Fassade der einzige Zugangspunkt für das Subsystem ist, werden die Funktionen und die Flexibilität eingeschränkt, die "Hauptbenutzer" möglicherweise benötigen.

Quelle: https://sourcemaking.com/design_patterns/facade

Ein Entwurfsmuster ist eine allgemeine wiederverwendbare Lösung für ein häufig auftretendes Problem in einem bestimmten Kontext des Softwareentwurfs.

Das Fassadenentwurfsmuster ist ein Strukturmuster, da es eine Art und Weise zum Erstellen von Beziehungen zwischen Klassen oder Entitäten definiert. Das Fassadenentwurfsmuster wird verwendet, um eine vereinfachte Schnittstelle zu einem komplexeren Subsystem zu definieren.

Das Fassadenmuster ist ideal, wenn Sie mit einer großen Anzahl von voneinander abhängigen Klassen arbeiten oder mit Klassen, die die Verwendung mehrerer Methoden erfordern, insbesondere wenn sie kompliziert zu verwenden oder schwer zu verstehen sind. Die Fassadenklasse ist ein "Wrapper", der eine Reihe von Elementen enthält, die leicht zu verstehen und einfach zu verwenden sind. Diese Mitglieder greifen im Namen des Fassadenbenutzers auf das Subsystem zu und verbergen die Implementierungsdetails.

Das Fassadenentwurfsmuster ist besonders nützlich, wenn Subsysteme verpackt werden, die schlecht gestaltet sind, aber nicht überarbeitet werden können, weil der Quellcode nicht verfügbar ist oder die vorhandene Schnittstelle häufig verwendet wird. Manchmal können Sie sich dafür entscheiden, mehr als eine Fassade zu implementieren, um Teilmengen von Funktionen für verschiedene Zwecke bereitzustellen.

Ein Beispiel für die Verwendung des Fassadenmusters ist die Integration einer Website in eine Geschäftsanwendung. Die vorhandene Software kann große Mengen an Geschäftslogik enthalten, auf die auf bestimmte Weise zugegriffen werden muss. Die Website erfordert möglicherweise nur eingeschränkten Zugriff auf diese Geschäftslogik. Beispielsweise muss auf der Website möglicherweise angezeigt werden, ob ein zum Verkauf stehender Artikel einen begrenzten Lagerbestand erreicht hat. Die IsLowStock-Methode der Fassadenklasse könnte einen Booleschen Wert zurückgeben, um dies anzuzeigen. Hinter den Kulissen könnte diese Methode die Komplexität der Verarbeitung des aktuellen physischen Bestands, des eingehenden Bestands, der zugewiesenen Artikel und des niedrigen Lagerbestands für jeden Artikel verbergen.

Alle Entwurfsmuster sind einige Klassen, die auf die eine oder andere Weise angeordnet sind und für eine bestimmte Anwendung geeignet sind. Der Zweck des Fassadenmusters besteht darin, die Komplexität einer Operation oder von Operationen zu verbergen. Sie können ein Beispiel sehen und das Fassadenmuster unter http://preciselyconcise.com/design_patterns/facade.php lernen

Es wird einfach ein Wrapper erstellt, um mehrere Methoden aufzurufen. Sie haben eine A-Klasse mit Methode x () und y () und eine B-Klasse mit Methode k () und z (). Sie möchten x, y, z gleichzeitig aufrufen. Dazu erstellen Sie mithilfe des Fassadenmusters einfach eine Fassadenklasse und erstellen eine Methode, z. B. xyz (). Anstatt jede Methode (x, y und z) einzeln aufzurufen, rufen Sie einfach die Wrapper-Methode (xyz ()) der Fassadenklasse auf, die diese Methoden aufruft.

Ein ähnliches Muster ist das Repository, jedoch hauptsächlich für die Datenzugriffsschicht.

Es handelt sich im Grunde genommen um ein System zur Freigabe einzelner Fenster. Sie weisen jede Arbeit, die delegiert wird, einer bestimmten Methode in einer anderen Klasse zu.

Das Fassadenentwurfsmuster fällt unter das Strukturentwurfsmuster. Kurz gesagt bedeutet Fassade das äußere Erscheinungsbild. Dies bedeutet, dass wir im Fassadenmuster etwas verbergen und nur zeigen, was der Kunde tatsächlich benötigt. Lesen Sie mehr im folgenden Blog: http://www.sharepointcafe.net/2017/03/facade-design-pattern-in-aspdotnet.html

Das Fassadenmuster bietet eine einheitliche Schnittstelle zur Schnittstellengruppe des Subsystems. Die Fassade definiert eine übergeordnete Schnittstelle, die die Arbeit mit dem Subsystem vereinfacht.