Suche…


Real World Fassade (C #)

public class MyDataExporterToExcell
{
    public static void Main()
    {
        GetAndExportExcelFacade facade = new GetAndExportExcelFacade();

        facade.Execute();
    }
}

public class GetAndExportExcelFacade
{

    // All services below do something by themselves, determine location for data,
    // get the data, format the data, and export the data
    private readonly DetermineExportDatabaseService _determineExportData = new DetermineExportDatabaseService();
    private readonly GetRawDataToExportFromDbService _getRawData = new GetRawDataToExportFromDbService();
    private readonly TransformRawDataForExcelService _transformData = new TransformRawDataForExcelService();
    private readonly CreateExcelExportService _createExcel = new CreateExcelExportService();

    // the facade puts all the individual pieces together, as its single responsibility.
    public void Execute()
    {
        var dataLocationForExport = _determineExportData.GetDataLocation();
        var rawData = _getRawData.GetDataFromDb(dataLocationForExport);
        var transformedData = _transformData.TransformRawToExportableObject(rawData);
        _createExcel.GenerateExcel("myFilename.xlsx");
    }
}

Fassadenbeispiel in Java

Fassade ist strukturelles Entwurfsmuster. Es verbirgt die Komplexität eines großen Systems und bietet eine einfache Schnittstelle zum Client.

Der Client verwendet nur Facade und macht sich keine Sorgen über die Abhängigkeiten der Subsysteme.

Definition von Gang of Four Buch:

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

Struktur:

Geben Sie hier die Bildbeschreibung ein

Beispiel aus der realen Welt:

Denken Sie an einige Reisebuchungsseiten wie Makemytrip, Cleartrip, die Dienste zur Buchung von Zügen, Flügen und Hotels anbieten.

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 großer Systeme: TravelFacade

  2. TravelFacade bietet eine einfache Schnittstelle, um eine der folgenden Optionen zu buchen

    Flight Booking
    Train Booking 
    Hotel Booking
    Flight + Hotel booking 
    Train + Hotel booking
    
  3. Buch-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 Subsystem-APIs verfügbar zu machen.

Anwendbarkeit und Anwendungsfälle (aus Wikipedia):

  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.


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow