Facade pattern
The facade pattern is a software-design pattern commonly used in object-oriented programming. Analogous to a facade in architecture, a facade is an object that serves as a front-facing interface masking more complex underlying or structural code. A facade can:
- improve the readability and usability of a software library by masking interaction with more complex components behind a single API
- provide a context-specific interface to more generic functionality
- serve as a launching point for a broader refactor of monolithic or tightly-coupled systems in favor of more loosely-coupled code
Overview
The Facadedesign pattern is one of the twenty-three well-known
GoF design patterns
that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.
What problems can the Facade design pattern solve?
- To make a complex subsystem easier to use, a simple interface should be provided for a set of interfaces in the subsystem.
- The dependencies on a subsystem should be minimized.
What solution does the Facade design pattern describe?
Define a
Facade object that - implements a simple interface in terms of the interfaces in the subsystem and
- may perform additional functionality before/after forwarding a request.
Facade object to minimize the dependencies on a subsystem.See also the UML class and sequence diagram below.
Usage
A Facade is used when an easier or simpler interface to an underlying object is desired. Alternatively, an adapter can be used when the wrapper must respect a particular interface and must support polymorphic behavior. A decorator makes it possible to add or alter behavior of an interface at run-time.| Pattern | Intent |
| Adapter | Converts one interface to another so that it matches what the client is expecting |
| Decorator | Dynamically adds responsibility to the interface by wrapping the original code |
| Facade | Provides a simplified interface |
The facade pattern is typically used when
- a simple interface is required to access a complex system,
- a system is very complex or difficult to understand,
- an entry point is needed to each level of layered software, or
- the abstractions and implementations of a subsystem are tightly coupled.
Structure
UML class and sequence diagram
In this UML class diagram,the
Client class doesn't access the subsystem classes directly.Instead, the
Client works through a Facade class that implements a simple interface in terms of the subsystem classes.The
Client depends only on the simple Facade interfaceand is independent of the complex subsystem.
The sequence diagram
shows the run-time interactions: The
Client object works through a
Facade object that delegates the request tothe
Class1, Class2, and Class3instances that perform the request.
UML class diagram
; Facade; Clients
Example
This is an abstract example of how a client interacts with a facade to a complex system.C++
struct CPU ;
struct HardDrive ;
struct Memory ;
class ComputerFacade ;
int main