Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

Size: px

Start display at page:

Download "Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use."

August Walton
6 years ago
Views:

1 Facade 1 Intent Prvide a unified interface t a set f interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier t use. Mtivatin Applicability Use the Facade pattern when yu want t prvide a simple interface t a cmplex subsystem. there are many dependencies between clients and the implementatin classes f an abstractin. Intrduce a facade t decuple the subsystem frm clients and ther subsystems, thereby prmting subsystem independence and prtability. yu want t layer yur subsystems. Use a facade t define an entry pint t each subsystem level. If subsystems are dependent, then yu can simplify the dependencies between them by making them cmmunicate with each ther slely thrugh their facades.

2 Structure 2 Participants Facade (Cmpiler) knws which subsystem classes are respnsible fr a request. delegates client requests t apprpriate subsystem bjects. subsystem classes (Scanner, Parser, PrgramNde, etc.) implement subsystem functinality. handle wrk assigned by the Facade bject. have n knwledge f the facade; that is, they keep n references t it. Cllabratins Clients cmmunicate with the subsystem by sending requests t Facade, which frwards them t the apprpriate subsystem bject(s). Althugh the subsystem bjects perfrm the actual wrk, the facade may have t d wrk f its wn t translate its interface t subsystem interfaces. Clients that use the facade dn't have t access its subsystem bjects directly. Cnsequences The Facade pattern ffers the fllwing benefits: 1. It shields clients frm subsystem cmpnents reducing the number f bjects that clients deal with. making the subsystem easier t use 2. It prmtes weak cupling between the subsystem and its clients. Facades help layer a system and the dependencies between bjects. Reducing cmpilatin dependencies with facades can limit the recmpilatin needed fr a small change in an imprtant subsystem. A facade can als simplify prting systems t ther platfrms, because it's less likely that building ne subsystem requires building all thers.

3 3 3. It desn't prevent applicatins frm using subsystem classes if they need t. Thus yu can chse between ease f use and generality. Implementatin 1. Reducing client-subsystem cupling. The cupling between clients and the subsystem can be reduced even further by making Facade an abstract class with cncrete subclasses fr different implementatins f a subsystem. An alternative t subclassing is t cnfigure a Facade bject with different subsystem bjects. T custmize the facade, simply replace ne r mre f its subsystem bjects. 2. Public versus private subsystem classes. A subsystem is analgus t a class in that bth have interfaces, and bth encapsulate smething a class encapsulates state and peratins, while a subsystem encapsulates classes. We can think f the public and private interface f a subsystem. The public interface t a subsystem cnsists f classes that all clients can access. The private interface is just fr subsystem extenders. The Facade class is part f the public interface. Sample Cde class Scanner { Scanner(istream&); virtual ~Scanner(); virtual Tken& Scan(); private: istream& _inputstream; class Parser { Parser(); virtual ~Parser(); virtual vid Parse(Scanner&, PrgramNdeBuilder&);

4 class PrgramNdeBuilder { PrgramNdeBuilder(); 4 virtual PrgramNde* NewVariable( cnst char* variablename ) cnst; virtual PrgramNde* NewAssignment( PrgramNde* variable, PrgramNde* expressin ) cnst; virtual PrgramNde* NewReturnStatement( PrgramNde* value ) cnst; virtual PrgramNde* NewCnditin( PrgramNde* cnditin, PrgramNde* truepart, PrgramNde* falsepart ) cnst; PrgramNde* GetRtNde(); private: PrgramNde* _nde; class PrgramNde { // prgram nde manipulatin virtual vid GetSurcePsitin(int& line, int& index); // child manipulatin virtual vid Add(PrgramNde*); virtual vid Remve(PrgramNde*); virtual vid Traverse(CdeGeneratr&); prtected: PrgramNde(); class CdeGeneratr { virtual vid Visit(StatementNde*); virtual vid Visit(ExpressinNde*); prtected: CdeGeneratr(BytecdeStream&); prtected: BytecdeStream& _utput; vid ExpressinNde::Traverse (CdeGeneratr& cg) { cg.visit(this); ListIteratr i(_children); fr (i.first();!i.isdne(); i.next()) { i.currentitem()-traverse(cg); class Cmpiler { Cmpiler(); virtual vid Cmpile(istream&, BytecdeStream&);

5 5 vid Cmpiler::Cmpile (istream& input, BytecdeStream& utput) { Scanner scanner(input); PrgramNdeBuilder builder; Parser parser; parser.parse(scanner, builder); RISCCdeGeneratr generatr(utput); PrgramNde* parsetree = builder.getrtnde(); parsetree-traverse(generatr); Knwn Uses The Chices perating system uses facades t cmpse many framewrks int ne. Dmain as its façade representing an address space. MemryObject represents a data stre. MemryObjectCache caches the data f MemryObjects in physical memry. AddressTranslatin encapsulates the address translatin hardware. Related Patterns Abstract Factry can be used with Facade t prvide an interface fr creating subsystem bjects in a subsystem-independent way. Abstract Factry can als be used as an alternative t Facade t hide platfrm-specific classes. Mediatr vs. Facade in that it abstracts functinality f existing classes. Mediatr's purpse is t abstract arbitrary cmmunicatin between clleague bjects, ften centralizing functinality that desn't belng in any ne f them. A mediatr's clleagues are aware f and cmmunicate with the mediatr instead f cmmunicating with each ther directly. In cntrast, a facade merely abstracts the interface t subsystem bjects t make them easier t use; it desn't define new functinality, and subsystem classes dn't knw abut it. Usually nly ne Facade bject is required. Thus Facade bjects are ften Singletns.

Proliferating interconnections tend to reduce object reuse. It can be difficult to change the system's behavior in any significant way.

Proliferating interconnections tend to reduce object reuse. It can be difficult to change the system's behavior in any significant way. Mediatr 1 Intent Define an bject that encapsulates hw a set f bjects interact. Mediatr prmtes lse cupling by keeping bjects frm referring t each ther explicitly, and it lets yu vary their interactin independently.