Instead of interacting with multiple classes directly, the client communicates with a single facade class that coordinates the required operations.
The facade hides the complexity of the subsystem and exposes only the functionality needed by the client, making the system easier to use.
The Facade Pattern is commonly used to simplify access to complex frameworks, legacy systems, third-party libraries, and multi-step workflows.
Structure
The Facade Pattern consists of the following participants.1. The Facade provides a simplified interface to the subsystem.
2. The Subsystem Classes implement the actual functionality.
3. The Client interacts only with the facade instead of individual subsystem classes.
Java Implementation
Suppose an application controls a home theater. Watching a movie requires turning on multiple devices in a specific sequence. Instead of exposing every subsystem to the client, a facade performs all the required operations.Create the subsystem classes.
public class TV {
public void on() {
System.out.println("TV turned on.");
}
}public class SoundSystem {
public void on() {
System.out.println("Sound system turned on.");
}
}public class StreamingDevice {
public void playMovie() {
System.out.println("Playing movie.");
}
}public class HomeTheaterFacade {
private final TV tv = new TV();
private final SoundSystem soundSystem = new SoundSystem();
private final StreamingDevice player = new StreamingDevice();
public void watchMovie() {
tv.on();
soundSystem.on();
player.playMovie();
}
}public class Main {
public static void main(String[] args) {
HomeTheaterFacade theater = new HomeTheaterFacade();
theater.watchMovie();
}
}TV turned on.
Sound system turned on.
Playing movie.
How It Works?
The client creates a HomeTheaterFacade and invokes a single watchMovie() method.Internally, the facade coordinates multiple subsystem classes by turning on the TV, starting the sound system, and playing the movie in the correct sequence.
The client does not need to understand how the subsystem works or the order in which operations must be performed.
This simplifies client code while allowing the subsystem classes to evolve independently of the facade.
Advantages
1. It provides a simple interface to a complex subsystem.2. It reduces coupling between the client and subsystem classes.
3. It hides implementation details from the client.
4. It improves readability and maintainability of client code.
Disadvantages
1. The facade may become overly complex if it exposes too many operations.2. Clients requiring advanced functionality may still need to access subsystem classes directly.
3. Introducing a facade adds an additional abstraction layer.
JDK Examples
The Facade Pattern appears throughout the Java ecosystem.1. The java.sql.DriverManager class provides a simple interface for obtaining database connections while coordinating multiple JDBC driver implementations.
2. The javax.faces.context.FacesContext class acts as a unified interface to various JavaServer Faces subsystems during request processing.
Summary
The Facade Pattern simplifies interaction with complex subsystems by providing a single entry point that coordinates multiple underlying components.By hiding subsystem complexity behind a unified interface, the pattern improves usability, reduces coupling, and makes client code easier to understand and maintain.
