it-swarm.com.de

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 Fassaden- Muster erklären?

181
kevin

Ein Entwurfsmuster ist ein gängiger Weg, um ein wiederkehrendes Problem zu lösen. 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 Entwurfsmuster Fassade vereinfacht die Schnittstelle zu einem komplexen System. weil es sich normalerweise aus allen Klassen zusammensetzt, aus denen die Teilsysteme des komplexen Systems bestehen.

Eine Fassade schützt den Benutzer vor den komplexen Details des Systems und versieht ihn mit einem simplified view davon das ist easy to use. Es ist auch decouples der Code, der das System aus den Details der Subsysteme verwendet, wodurch es einfacher wird, das System später zu ändern.

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

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

Wichtig beim Erlernen von Entwurfsmustern ist es auch, zu erkennen, welches Muster zu Ihrem Problem passt, und es dann entsprechend zu verwenden. Es ist eine sehr häufige Sache, 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 die Verwendung von Entwurfsmustern erlernen.

179

Wikipedia hat ein großartiges Beispiel für 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();
    }
}
92
Erdem Gezer

Wie in der vorherigen Antwort erläutert, bietet es eine einfache Schnittstelle für den konsumierenden Client. Zum Beispiel: "watch ESPN" ist die beabsichtigte Funktion. Aber es beinhaltet mehrere Schritte wie:

  1. Schalten Sie bei Bedarf den Fernseher ein.
  2. Überprüfen Sie, ob der Satellit/das Kabel funktioniert.
  3. Wechseln Sie bei Bedarf zu ESPN.

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

40
Aravind

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");
       }
  }
28
KaviK

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 Konto1 auf Konto2 überweisen möchten, müssen Sie die beiden aufzurufenden Subsysteme von Konto1 abziehen und auf Konto2 einzahlen.

with and without facade

15
Arun Raaj

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 wird.

10
llMll

Bezüglich Ihrer 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 etwas über diese Fassade erzählen? Ich bin neu im Entwerfen von Mustern.

Laut GoF lautet das Fassadenmuster wie folgt:

Bereitstellung einer einheitlichen Schnittstelle für eine Reihe von Schnittstellen in einem Subsystem. Facade Pattern definiert eine übergeordnete Schnittstelle, die die Bedienung des Subsystems erleichtert

Das Muster Fassade 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 geschichteten Software.
  4. Das System ist sehr komplex oder schwer zu verstehen.

Nehmen wir ein echtes Word-Beispiel für die cleartrip Website.

Diese Website bietet Optionen zum Buchen

  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 eines 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. book API von TravelFacade ruft intern unter APIs von Subsystemen auf

    flightBooking.bookFlight
    trainBooking.bookTrain(info);
    hotelBooking.bookHotel(info);
    
  4. Auf diese Weise stellt TravelFacade eine einfachere und einfachere API bereit, ohne dass Subsystem-APIs verfügbar gemacht werden.

Key takeaways: (from journaldev article by Pankaj Kumar)

  1. Das Fassadenmuster ähnelt eher einem Helfer für Client-Anwendungen
  2. Fassadenmuster können zu jedem Zeitpunkt der Entwicklung angewendet werden, normalerweise wenn die Anzahl der Schnittstellen wächst und das System fertig wird = x.
  3. Subsystem-Schnittstellen kennen Facade nicht und sie sollten keinen Verweis auf die Facade-Schnittstelle haben
  4. Fassadenmuster sollten für ähnliche Arten von Schnittstellen angewendet werden, sein Zweck ist es, eine einzelne Schnittstelle anstatt mehrerer Schnittstellen bereitzustellen das macht die ähnliche Art von Jobs

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

7
Ravindra babu

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. Eines 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 sich mit dem Erlernen der Excel-API befassen. Das Team kann die Fassade nutzen, ohne die Einbauten 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 vereinheitlichte Schnittstelle über einem komplexen Teilsystem.

6
Anand Patel

Das Fassadenmuster ist eine Hülle für viele andere Schnittstellen, sodass eine einfachere Schnittstelle entsteht.

Entwurfsmuster sind nützlich, da sie wiederkehrende Probleme lösen und im Allgemeinen den Code vereinfachen. In einem Team von Entwicklern, die sich darauf einigen, die gleichen Muster zu verwenden, werden Effizienz und Verständnis bei der Pflege des jeweils anderen Codes verbessert.

Lesen Sie mehr über Muster:

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

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

6
Aim Kai

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 werden in der Implementierung mehrere Pakete, Klassen und Funktionen verwendet. 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 sich, ob er direkt an die eigene Bank geht oder über ein ausgehandeltes Netzwerk für eine externe Bank. Der Geldautomat verhält sich wie eine Fassade, die mehrere Geräte und Subsysteme verbraucht, mit denen ich mich als Kunde nicht direkt befassen muss.

5
ManojPatra

Facade beschreibt das Einkapseln eines komplexen Subsystems in ein einzelnes Schnittstellenobjekt. Dies reduziert die Lernkurve, die erforderlich ist, um das Subsystem erfolgreich einzusetzen. Es fördert auch die Entkopplung des Subsystems von seinen potenziell vielen Clients. Wenn die Fassade andererseits 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

4
user6102894

Es gibt ein sehr gutes Beispiel aus der Praxis für das Muster - The car starter engine.

Als Fahrer schalten wir einfach den Schlüssel ein und das Auto wird gestartet. So einfach wie möglich. Hinter den Kulissen sind viele andere Autosysteme beteiligt (z. B. Batterie, Motor, Kraftstoff usw.), damit das Auto erfolgreich gestartet werden kann. Sie sind jedoch hinter dem Anlasser verborgen.

Wie Sie sehen, ist der Autostarter die Fassade. Es gibt uns eine benutzerfreundliche Oberfläche, ohne dass wir uns um die Komplexität aller anderen Fahrzeugsysteme sorgen müssen.

Fassen wir zusammen:

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

4
Jordan Enev

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

4
Sean Hunter

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 Facade verwenden, um Ihre Anwendung konfigurierbar zu machen, z. B. bei Ausführung mit einer Datenbank oder mit Scheinobjekten. Sie führen also alle Datenbankaufrufe für die Fassadenklasse durch, in der sie die Anwendungskonfiguration 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.

4
aishu

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

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

Das Fassadenmuster ist ideal, wenn mit einer großen Anzahl voneinander abhängiger Klassen gearbeitet wird oder Klassen, die die Verwendung mehrerer Methoden erfordern, insbesondere wenn die Verwendung kompliziert oder schwer verständlich ist. Die Fassadenklasse ist ein "Wrapper", der eine Reihe von Elementen enthält, die leicht verständlich und einfach zu verwenden sind. Diese Mitglieder greifen im Namen des Fassadennutzers 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, mehrere Fassaden 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 kann 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 zugeordneten Artikel und des niedrigen Bestands für jeden Artikel verbergen.

3
Program-Me-Rev

Es wird einfach ein Wrapper erstellt, um mehrere Methoden aufzurufen. Sie haben eine A-Klasse mit Methode x() und y() und B-Klasse mit Methode k() und z (). Sie möchten x, y, z gleichzeitig aufrufen. Dazu erstellen Sie mit dem Facade-Muster einfach eine Facade-Klasse und erstellen eine Methode, beispielsweise xyz (). Anstatt jede Methode aufzurufen (x, y und z). einzeln 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 Datenzugriffsebene.

2
Jeff Schreib

Alle Entwurfsmuster sind Klassen, die auf die eine oder andere Weise angeordnet sind und zu einer bestimmten Anwendung passen. Der Zweck des Fassadenmusters besteht darin, die Komplexität eines Vorgangs oder von Vorgängen zu verbergen. Sie können ein Beispiel sehen und Fassadenmuster lernen von http://preciselyconcise.com/design_patterns/facade.php

2
Sai Sunder

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

1
user1694660

Es handelt sich im Grunde genommen um ein einzelnes Fensterfreigabesystem. Sie weisen alle Arbeiten zu, die an eine bestimmte Methode in einer anderen Klasse delegiert werden.

1
Saurabh

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

1
Taras Melnyk