Was ist ein Fassadenmuster?

Ist Fassade eine Klasse enthält eine Menge von anderen Klassen?

Was macht es ein design-pattern? Für mich ist es wie eine normale Klasse.

Können Sie erklären mir diese Fassade Muster?

InformationsquelleAutor der Frage kevin | 2011-03-09

154

Ein design pattern ist eine Allgemeine Lösung eines immer wiederkehrenden Problems. Klassen in allen design-patterns sind ganz normale Klassen. Was wichtig ist, ist, wie Sie strukturiert sind und wie Sie gemeinsam zur Lösung einer gegebenen Aufgabe in der bestmöglichen Art und Weise.

Den Fassade design pattern vereinfacht die Schnittstelle zu einem komplexen system; denn es ist in der Regel aus allen Klassen, aus denen sich die Subsysteme des komplexen Systems.

Fassade schirmt den Benutzer von den komplexen details des Systems auf und bietet Ihnen ein simplified view es ist easy to use. Es auch decouples den code, der nutzt das system aus den Angaben der Subsysteme, so dass es leichter zu ändern, das system später.

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

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

Auch, was ist wichtig beim lernen, design-patterns ist in der Lage sein zu erkennen, welches Muster passt zu Ihrem gegebenen Problems auszuwählen, und dann verwenden Sie es ordnungsgemäß. Es ist eine sehr gemeinsame Sache zu missbrauchen, ein Muster, oder versuchen, um es zu passen zu einigen problem, nur weil Sie es wissen. Kennen Fallstricke beim lernen\design-Pattern.

InformationsquelleAutor der Antwort Unmesh Kondolikar

Wikipedia hat, ein gutes Beispiel Fassade-Muster.

/* 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();
    }
}

InformationsquelleAutor der Antwort egezer

33

Als in der vorherigen Antwort erläutert, es bietet eine einfache Schnittstelle, um die Konsum-client.
Zum Beispiel: "watch ESPN" ist die beabsichtigte Funktion. Aber es umfasst mehrere Schritte, wie:
1. Schalter auf TV, wenn erforderlich;
2. Check für Sat - /- Kabel funktionieren;
3. Schalter auf ESPN, wenn erforderlich.
Aber die Fassade vereinfacht diese und geben Sie einfach "watch ESPN" - Funktion an den client.

InformationsquelleAutor der Antwort Aravind

Fassade verbirgt die Komplexität des Systems und bietet eine Schnittstelle für die Clients, von dem der client Zugriff auf das system.

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

InformationsquelleAutor der Antwort KaviK

10

Einer Fassade sollte nicht beschrieben werden als eine Klasse enthält eine Menge von anderen Klassen. Es ist in der Tat ein interface dieser Klassen und die Verwendung der Klassen leichter, ansonsten ist die Fassade-Klasse nutzlos ist.

InformationsquelleAutor der Antwort llMll
6

Dem Fassade-pattern ist ein wrapper für viele weitere Schnittstellen in ein Ergebnis zu produzieren, eine einfachere Schnittstelle.

Design patterns sind nützlich, wie Sie zu lösen wiederkehrende Probleme und im Allgemeinen vereinfachen-code. In einem team von Entwicklern, Stimmen zu, verwenden Sie das gleiche Muster haben, es verbessert die Effizienz und das Verständnis bei der Pflege der jeweils anderen code.

Lesen Sie mehr über Muster:

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

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

InformationsquelleAutor der Antwort Aim Kai
5

Einer zusätzlichen Verwendung des Fassade-Musters könnte es sein, reduzieren Sie die Lernkurve des Teams. Lassen Sie mich Ihnen ein Beispiel geben:

Lassen Sie uns annehmen, dass Ihre Anwendung muss für die Interaktion mit MS Excel, indem die in die COM-Objektmodell von Excel. Einer Ihrer team-Mitglieder kennt alle Excel-APIs und erstellt er die Fassade auf die Spitze, erfüllt alle grundlegenden Szenarien der Anwendung. Kein anderes Mitglied im team brauchen, um zu verbringen Zeit auf das lernen Excel-API. Das team kann mit der Fassade ohne wissen der Interna bzw. alle MS-Excel-Objekte beteiligt, die in Erfüllung Szenario. Ist es nicht toll?

So, es stellt eine vereinfachte und einheitliche Schnittstelle zu einem komplexen Subsystem.

InformationsquelleAutor der Antwort Anand Patel
5

Einer Fassade stellt eine vereinfachte Funktionen, die meist genannt werden und die Umsetzung verbirgt die Komplexität, die Kunden sonst zu tun haben. Im Allgemeinen ist die Implementierung verwendet mehrere Pakete, Klassen und Funktionen. Gut geschrieben Fassaden machen den direkten Zugriff von anderen Klassen selten. Wenn ich zum Beispiel Besuch von einem Geldautomaten zurückzuziehen, eine gewisse Menge. Die ATM verbirgt, ob es geht direkt an die eigene bank oder wird es über eine Verhandlungslösung Netzwerk für eine externe bank. Das ATM wirkt wie eine Fassade konsumieren mehrere Geräte und sub-Systeme, die als client muss ich nicht direkt behandeln.

InformationsquelleAutor der Antwort ManojPatra
4

Fassade ist eine Klasse mit einer Funktionalität, die liegt zwischen ein toolkit und eine vollständige Anwendung bietet eine vereinfachte Verwendung der Klassen in einem Paket oder Teilsystem. Die Absicht des Fassade-Musters, ist ein interface, das macht ein subsystem einfach zu bedienen.
-- Auszug aus buchen Design Patterns in C#.

InformationsquelleAutor der Antwort Sean Hunter
3

Weiteres Beispiel der Fassade:
sagen, dass Ihre Anwendung eine Verbindung zur Datenbank und anzeigen der Ergebnisse auf der Benutzeroberfläche. Sie können Fassade, um Ihre Anwendung konfigurierbar ist, wie in laufen mit der Datenbank oder mit mock-Objekten. So machen Sie alle die Datenbank-Aufrufe an die Fassade-Klasse, wo Sie gelesen werden, app-config und entscheiden, um das Feuer der db-Abfrage oder geben Sie das mock-Objekt. diese Art der Anwendung db wird unabhängig in dem Fall die db nicht verfügbar ist.

InformationsquelleAutor der Antwort aishu
3

Ein design pattern ist eine Allgemeine, wiederverwendbare Lösung für ein Häufig auftretendes problem in einem gegebenen Kontext im software-design.

Die Fassade design pattern ist ein strukturelles Muster definiert eine Weise, die für das erstellen von Beziehungen zwischen Klassen oder Entitäten. Die Fassade design pattern wird verwendet, um zu definieren, die eine vereinfachte Schnittstelle zu einem komplexeren subsystem.

Dem Fassade-Muster ist ideal beim arbeiten mit einer großen Anzahl von voneinander abhängigen Klassen oder Klassen, die erfordern die Verwendung von mehreren Methoden, vor allem, wenn Sie kompliziert zu bedienen ist oder zu schwierig zu verstehen. Die Fassade-Klasse ist ein "wrapper", enthält eine Reihe von Elementen, die leicht zu verstehen und einfach zu bedienen. Diese Mitglieder Zugriff auf das subsystem im Namen der Fassade Benutzer, verstecken die details der Implementierung.

Die Fassade design pattern ist besonders nützlich, wenn die Verpackung Subsysteme, die sind schlecht konzipiert, aber nicht umgestaltet werden, weil der Quellcode nicht verfügbar ist oder die vorhandene Schnittstelle ist weit verbreitet. Manchmal können Sie sich entscheiden, mehr als eine Fassade zu bieten Teilmengen von Funktionen für verschiedene Zwecke.

Ein Beispiel für die Verwendung des Fassade-Musters ist für die Integration in eine web-site mit einer business-Anwendung. Die vorhandene software kann große Mengen von business-Logik zugegriffen werden muss, die in einer bestimmten Art und Weise. Die Website erfordern möglicherweise nur eingeschränkten Zugriff auf die Geschäftslogik. Zum Beispiel, die Website möglicherweise erforderlich, um zu zeigen, ob ein Element für den Verkauf erreicht hat, einen begrenzten Bestand. Die IsLowStock Methode der Fassade-Klasse könnte einen booleschen Wert zurück, um dies anzugeben. Hinter den kulissen, diese Methode verstecken, die Komplexität der Verarbeitung der aktuellen physischen Bestand, die eingehenden Lager, die zugewiesenen Elemente und die niedrigen Lagerbestände für jedes Element.

InformationsquelleAutor der Antwort Program-Me-Rev
3

Fassade beschreibt die Kapselung eines komplexen Subsystems innerhalb einer einzigen interface-Objekt. Dies verringert die Lernkurve notwendig, um erfolgreich eine Hebelwirkung auf das subsystem. Es fördert auch die Entkopplung des Teilsystems aus der potenziell vielen Kunden. Auf der anderen Seite, wenn die Fassade ist der einzige Zugangspunkt für das Teilsystem, es schränkt die Funktionen und die Flexibilität, dass "power-user" benötigen.

InformationsquelleAutor der Antwort
3

Bezug auf Ihre Fragen:

Fassade ist eine Klasse enthält eine Menge von anderen Klassen?

Ja. Es ist ein wrapper für viele sub-Systeme in der Anwendung.

Was macht es ein design-pattern? Für mich ist es wie eine normale Klasse

Alle design-patterns sind auch die normalen Klassen. @Unmesh Kondolikar richtig beantwortet diese Abfrage.

Können Sie erklären mir über diese Fassade, ich bin neu in design-patterns.

Gemäß GoF, Fassade design pattern ist defind als :

Bieten eine vereinheitlichte Schnittstelle für einen Satz von Schnittstellen eines Subsystems. Fassade-Muster definiert eine übergeordnete Schnittstelle, die das subsystem einfacher zu benutzen

Den Fassade Muster wird normalerweise verwendet, wenn:
1. Eine einfache Schnittstelle, erforderlich für den Zugriff auf ein Komplexes system.
2. Die Abstraktionen und Implementierungen eines Subsystems sind eng gekoppelt.
3. Brauchen einen Einstiegspunkt in jede Ebene der geschichteten software.
4. System ist sehr Komplex und schwierig zu verstehen.
Nehmen wir ein Wort, das Beispiel von cleartrip website.

Diese website bietet Optionen zum Buch
1. Flüge
2. Hotels
3. Flüge + Hotels
Code-snippet:
```
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){

    }
}
```
Erklärung:
1. FlightBooking, TrainBooking and HotelBooking sind verschiedene sub-Systeme von großen system : TravelFacade
2. TravelFacade bietet eine einfache Schnittstelle zum Buch eine der nachfolgenden Optionen
```
Flight Booking
Train Booking 
Hotel Booking
Flight + Hotel booking 
Train + Hotel booking
```
3. Buch-API von TravelFacade ruft intern unter APIs von sub-Systemen
```
flightBooking.bookFlight
trainBooking.bookTrain(info);
hotelBooking.bookHotel(info);
```
4. In dieser Weise TravelFacade bietet eine einfachere und API-out aussetzen sub-system-APIs.
Ausbeute : ( aus journaldev Artikel von Pankaj Kumar)
1. Fassade-Muster ist mehr wie ein Helfer für client-Anwendungen
2. Fassade-pattern angewendet werden kann an jedem Punkt der Entwicklung, in der Regel wenn die Anzahl der Schnittstellen wachsen und system bekommt entscx.
3. Subsystem-Schnittstellen sind sich nicht bewusst von der Fassade und Sie sollte keine Referenz auf die Fassade-Schnittstelle
4. Fassade-pattern angewendet werden sollte, für eine ähnliche Art von SchnittstellenIhr Zweck ist die Bereitstellung einer einzigen Schnittstelle, anstatt mehrere Schnittstellen, die die ähnliche Art des jobs
Haben Sie einen Blick auf sourcemaking Artikel auch für ein besseres Verständnis.

InformationsquelleAutor der Antwort Ravindra babu
3

Eine kurze und einfache Erklärung:
- Fassade-Muster bietet eine vereinheitlichte Schnittstelle für einen Satz von interface(s)
  in einem subsystem werden.
- Fassade definiert eine übergeordnete Schnittstelle, die die subsystem
  einfacher zu verwenden.
Versuchen zu verstehen, das Szenario mit und ohne Fassade:

Wenn Sie wollen, um das Geld aus accout1 zu account2 dann die beiden Subsystemen aufgerufen werden, vom account1 und Einzahlung auf account2.

InformationsquelleAutor der Antwort Arun Raaj
2

Alle design patterns sind einige Klassen angeordnet, in die eine oder andere Art, die Anzüge eine bestimmte Anwendung. Der Zweck des Fassade Musters ist zu verstecken die Komplexität einer operation oder Operationen. Können Sie ein Beispiel sehen und lernen Fassade-Muster aus http://preciselyconcise.com/design_patterns/facade.php

InformationsquelleAutor der Antwort Sai Sunder
1

Es ist im Grunde single window clearance system.Ordnen Sie jede Arbeit delegieren, um bestimmten Methode in einer anderen Klasse.

InformationsquelleAutor der Antwort Saurabh
1

Wahrscheinlich die beste Erklärung des Fassade Muster (und viele andere)
http://www.jakowicz.com/facade-pattern-in-php/

InformationsquelleAutor der Antwort ymakux
1

Fassade Design Pattern kommt unter Strukturellen Design-Muster. In der kurzen Fassade bedeutet das äußere Erscheinungsbild. Es bedeutet in der Fassade design pattern wir etwas verstecken und zeigen nur das, was tatsächlich-client benötigt.
Lesen Sie mehr im blog unter:
http://www.sharepointcafe.net/2017/03/facade-design-pattern-in-aspdotnet.html

InformationsquelleAutor der Antwort user1694660
1

Dem Fassade-Muster bietet eine vereinheitlichte Schnittstelle, um die subsystem-interface-Gruppe. Die Fassade definiert eine high-level-Schnittstelle, die vereinfacht die Arbeit mit dem subsystem.

InformationsquelleAutor der Antwort Taras Melnyk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.