Facade Pattern

The Facade Pattern in software design provides a unified interface to a set of interfaces in a subsystem. It simplifies a complex system by providing a higher-level interface that makes it easier to use. This pattern promotes loose coupling between subsystems and improves readability and maintainability by hiding internal complexities.

// Subsystem Components
class TV {
    public void turnOn() { System.out.println("TV is ON"); }
    public void turnOff() { System.out.println("TV is OFF"); }
    public void setInput(String input) { System.out.println("TV input set to " + input); }
}

class DVDPlayer {
    public void turnOn() { System.out.println("DVD Player is ON"); }
    public void turnOff() { System.out.println("DVD Player is OFF"); }
    public void playMovie(String movie) { System.out.println("Playing movie: " + movie); }
}

class Speakers {
    public void turnOn() { System.out.println("Speakers are ON"); }
    public void turnOff() { System.out.println("Speakers are OFF"); }
    public void setVolume(int level) { System.out.println("Speakers volume set to " + level); }
}

// Facade
class HomeTheaterFacade {
    private TV tv;
    private DVDPlayer dvdPlayer;
    private Speakers speakers;

    public HomeTheaterFacade(TV tv, DVDPlayer dvdPlayer, Speakers speakers) {
        this.tv = tv;
        this.dvdPlayer = dvdPlayer;
        this.speakers = speakers;
    }

    public void watchMovie(String movie) {
        System.out.println("Setting up home theater to watch a movie...");
        tv.turnOn();
        tv.setInput("HDMI");
        dvdPlayer.turnOn();
        dvdPlayer.playMovie(movie);
        speakers.turnOn();
        speakers.setVolume(5);
        System.out.println("Enjoy the movie!");
    }

    public void endMovie() {
        System.out.println("Shutting down home theater...");
        speakers.turnOff();
        dvdPlayer.turnOff();
        tv.turnOff();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        // Create subsystem components
        TV tv = new TV();
        DVDPlayer dvdPlayer = new DVDPlayer();
        Speakers speakers = new Speakers();

        // Create facade
        HomeTheaterFacade homeTheater = new HomeTheaterFacade(tv, dvdPlayer, speakers);

        // Use facade to watch a movie
        homeTheater.watchMovie("Inception");
        System.out.println("---");
        homeTheater.endMovie();
    }
}
/*
Setting up home theater to watch a movie...
TV is ON
TV input set to HDMI
DVD Player is ON
Playing movie: Inception
Speakers are ON
Speakers volume set to 5
Enjoy the movie!
---
Shutting down home theater...
Speakers are OFF
DVD Player is OFF
TV is OFF
*/Code language: JavaScript (javascript)

Use case and Implementation

Simplifying access to complex banking operations (e.g., account creation, loan processing, transaction management) through a unified interface.

//FacadePatternDemo.java
//Define subsystems with their respective classes and methods
class AccountService {
    public void createAccount(String customerName, String accountType) {
        // Simulated logic for creating an account
        System.out.println("Account created for " + customerName + " of type " + accountType);
    }
}

class LoanService {
    public void processLoan(String customerName, double amount) {
        // Simulated logic for processing a loan
        System.out.println("Loan processed for " + customerName + " amount: " + amount);
    }
}

class TransactionService {
    public void makeTransaction(String fromAccount, String toAccount, double amount) {
        // Simulated logic for making a transaction
        System.out.println("Transaction made from " + fromAccount + " to " + toAccount + " amount: " + amount);
    }
}

//Create a Facade class that provides a unified interface
class BankingFacade {
    private AccountService accountService;
    private LoanService loanService;
    private TransactionService transactionService;

    public BankingFacade() {
        this.accountService = new AccountService();
        this.loanService = new LoanService();
        this.transactionService = new TransactionService();
    }

    public void createCustomerAccount(String customerName, String accountType) {
        accountService.createAccount(customerName, accountType);
    }

    public void processLoanRequest(String customerName, double amount) {
        loanService.processLoan(customerName, amount);
    }

    public void makeTransaction(String fromAccount, String toAccount, double amount) {
        transactionService.makeTransaction(fromAccount, toAccount, amount);
    }
}

//Client code to demonstrate the usage of the facade
public class FacadePatternDemo {
    public static void main(String[] args) {
        BankingFacade bankingFacade = new BankingFacade();
        // Client uses the facade to perform operations
        bankingFacade.createCustomerAccount("Mahesh", "Savings");
        bankingFacade.processLoanRequest("Raja", 50000.0);
        bankingFacade.makeTransaction("Lakshmi Kanth", "Checking-456", 250.0);
    }
}

/*
C:\>javac FacadePatternDemo.java

C:\>java FacadePatternDemo
Account created for Mahesh of type Savings
Loan processed for Raja amount: 50000.0
Transaction made from Lakshmi Kanth to Checking-456 amount: 250.0
*/

Pros

• Simplification: Provides a straightforward interface, hiding subsystem complexity.
• Reduced Coupling: Clients depend on the Facade rather than multiple subsystem classes.
• Improved Readability: Encapsulates complex logic in a single place, making code easier to understand.
• Maintainability: Changes to the subsystem don’t affect clients as long as the Facade interface remains unchanged.

Cons

• Limited Flexibility: The Facade may not expose all subsystem functionality, restricting advanced use cases.
• Potential God Object: A poorly designed Facade can become overly complex, handling too many responsibilities.
• Extra Layer: Adds an additional layer of abstraction, which may introduce slight overhead.

When to Use

• When you want to simplify interaction with a complex subsystem.
• When you need to reduce coupling between clients and subsystem components.
• When you want to provide a unified interface for multiple components or libraries.
• When you need to layer a system into subsystems with clear entry points.

Real-World Example

• JDBC API: Provides a simple interface for database operations, hiding the complexity of database-specific drivers.
• Order Processing System: A Facade simplifies placing an order by coordinating inventory, payment, and shipping subsystems.
• Web Frameworks: A REST API endpoint that orchestrates multiple backend services (e.g., authentication, database, logging).