Design patterns
ファサード

実世界のファサード（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");
    }
}

Javaのファサードの例

ファサードは構造設計パターンです。これは、大規模なシステムの複雑さを隠し、クライアントとの簡単なインタフェースを提供します。

クライアントはFacadeのみを使用し、サブシステムの相互依存関係は心配しません。

Gang of Fourの定義：

サブシステム内のインターフェイスセットへの統合インターフェイスを提供します。 Façadeは、サブシステムを使いやすくするための高水準のインタフェースを定義しています

構造：

実世界の例：

makemytrip、列車、航空券、ホテルの予約サービスを提供するcleartripのような旅行予約サイトを考えてみましょう。

コードスニペット：

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

説明：

1. FlightBooking, TrainBooking and HotelBookingは大規模システムの異なるサブシステムです： TravelFacade

2. TravelFacadeは以下のオプションの1つを予約する簡単なインターフェイスを提供します

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

3. TravelFacadeのブックAPIは、内部でサブシステムのAPIを呼び出す

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

4. このように、 TravelFacadeは、サブシステムAPIを公開することTravelFacade 、より簡単で簡単なAPIを提供します。

適用可能性とユースケース（ウィキペディア）：

1. 複雑なシステムにアクセスするには、単純なインターフェースが必要です。
2. サブシステムの抽象化と実装は緊密に結合されています。
3. 階層化されたソフトウェアの各レベルへのエントリポイントが必要です。
4. システムは非常に複雑で理解しにくいです。