Design patterns
Façade
Recherche…
Façade du monde réel (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");
}
}
Exemple de façade en java
La façade est un modèle de conception structurelle. Il cache les complexités d’un système de grande taille et fournit une interface simple au client.
Le client n'utilise que Facade et il n'est pas préoccupé par les interdépendances des sous-systèmes.
Définition de Gang of Four book:
Fournir une interface unifiée à un ensemble d'interfaces dans un sous-système. La façade définit une interface de niveau supérieur qui facilite l'utilisation du sous-système
Structure:
Exemple du monde réel:
Pensez à certains sites de réservation de voyages comme makemytrip, cleartrip, qui propose des services pour réserver des trains, des vols et des hôtels.
Extrait de code:
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){
}
}
Explication:
FlightBooking, TrainBooking and HotelBooking
sont différents sous-systèmes de grands systèmes:TravelFacade
TravelFacade
offre une interface simple pour réserver l'une des options ci-dessousFlight Booking Train Booking Hotel Booking Flight + Hotel booking Train + Hotel booking
livre API de TravelFacade appels internes en dessous des API des sous-systèmes
flightBooking.bookFlight trainBooking.bookTrain(info); hotelBooking.bookHotel(info);
De cette façon,
TravelFacade
fournit des API plus simples et plus faciles sans exposer les API du sous-système.
Applicabilité et cas d'utilisation (de Wikipedia):
- Une interface simple est nécessaire pour accéder à un système complexe.
- Les abstractions et les implémentations d'un sous-système sont étroitement liées.
- Besoin d'un point d'entrée pour chaque niveau de logiciel en couches.
- Le système est très complexe ou difficile à comprendre.