Szukaj…


Fasada świata rzeczywistego (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");
    }
}

Przykład fasady w java

Fasada to wzór konstrukcyjny. Ukrywa złożoność dużego systemu i zapewnia prosty interfejs dla klienta.

Klient używa tylko Fasady i nie martwi się o zależności między podsystemami.

Definicja z książki Gang of Four:

Zapewnić ujednolicony interfejs dla zestawu interfejsów w podsystemie. Fasada definiuje interfejs wyższego poziomu, który ułatwia korzystanie z podsystemu

Struktura:

wprowadź opis zdjęcia tutaj

Przykład ze świata rzeczywistego:

Pomyśl o niektórych stronach rezerwacji podróży, takich jak makemytrip, cleartrip, który oferuje usługi rezerwacji pociągów, lotów i hoteli.

Fragment kodu:

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){
    
    }
}

Wyjaśnienie:

  1. FlightBooking, TrainBooking and HotelBooking to różne podsystemy dużego systemu: TravelFacade

  2. TravelFacade oferuje prosty interfejs do rezerwacji jednej z poniższych opcji

    Flight Booking
    Train Booking 
    Hotel Booking
    Flight + Hotel booking 
    Train + Hotel booking
    
  3. Book API z TravelFacade wywołuje wewnętrznie poniżej API podsystemów

    flightBooking.bookFlight
    trainBooking.bookTrain(info);
    hotelBooking.bookHotel(info);
    
  4. W ten sposób TravelFacade zapewnia prostsze i łatwiejsze API bez ujawniania API podsystemu.

Przypadki zastosowania i użycia (z Wikipedii):

  1. Aby uzyskać dostęp do złożonego systemu, wymagany jest prosty interfejs.
  2. Abstrakcje i implementacje podsystemu są ściśle powiązane.
  3. Potrzebujesz punktu wejścia do każdego poziomu oprogramowania warstwowego.
  4. System jest bardzo złożony lub trudny do zrozumienia.


Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow