Design patterns
Fasad

Fasad i verklig värld (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");
    }
}

Fasadexempel i java

Fasad är konstruktionsmönster. Det döljer komplexiteten i stora system och ger ett enkelt gränssnitt för klienten.

Klienten använder endast Fasad och är inte orolig för beroenden mellan delsystemen.

Definition från Gang of Four-boken:

Ge ett enhetligt gränssnitt till en uppsättning gränssnitt i ett delsystem. Fasad definierar ett gränssnitt på högre nivå som gör delsystemet lättare att använda

Strukturera:

Exempel på verklig värld:

Tänk på några resebokningssidor som makemytrip, cleartrip som erbjuder tjänster för att boka tåg, flyg och hotell.

Kodavsnitt:

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

Förklaring:

1. FlightBooking, TrainBooking and HotelBooking är olika FlightBooking, TrainBooking and HotelBooking i stora system: TravelFacade

2. TravelFacade erbjuder ett enkelt gränssnitt för att boka ett av alternativen nedan

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

3. boka API från TravelFacade internt anropar under API: er för undersystem

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

4. På detta sätt tillhandahåller TravelFacade enklare och enklare API utan exponering av subsystem-API: er.

Fall och användningsfall (från Wikipedia):

1. Ett enkelt gränssnitt krävs för att komma åt ett komplext system.
2. Abstraktionerna och implementeringarna av ett delsystem är tätt kopplade.
3. Behöver en startpunkt till varje nivå av skiktad mjukvara.
4. Systemet är mycket komplicerat eller svårt att förstå.