Design patterns
Facade
Zoeken…
Echte wereld gevel (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");
}
}
Gevelvoorbeeld in Java
Gevel is een structureel ontwerppatroon. Het verbergt de complexiteit van een groot systeem en biedt een eenvoudige interface voor de client.
Client gebruikt alleen Facade en maakt zich geen zorgen over de onderlinge afhankelijkheden van subsystemen.
Definitie uit het boek Gang of Four:
Bied een uniforme interface voor een set interfaces in een subsysteem. Façade definieert een interface op een hoger niveau die het subsysteem gebruiksvriendelijker maakt
Structuur:
Voorbeeld uit de echte wereld:
Denk aan een aantal boekingswebsites voor reizen, zoals makemytrip, cleartrip die diensten biedt om treinen, vluchten en hotels te boeken.
Codefragment:
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){
}
}
Uitleg:
FlightBooking, TrainBooking and HotelBooking
zijn verschillende subsystemen van een groot systeem:TravelFacade
TravelFacade
biedt een eenvoudige interface om een van onderstaande opties te boekenFlight Booking Train Booking Hotel Booking Flight + Hotel booking Train + Hotel booking
book API van TravelFacade roept intern onderstaande API's van subsystemen aan
flightBooking.bookFlight trainBooking.bookTrain(info); hotelBooking.bookHotel(info);
Op deze manier biedt
TravelFacade
een eenvoudigere en gemakkelijkere API zonder subsysteem-API's.
Toepasselijkheid en use cases (van Wikipedia):
- Een eenvoudige interface is vereist om toegang te krijgen tot een complex systeem.
- De abstracties en implementaties van een subsysteem zijn nauw gekoppeld.
- Een toegangspunt nodig voor elk niveau van gelaagde software.
- Systeem is erg complex of moeilijk te begrijpen.