Understanding the Facade Design Pattern in Java

-

The Facade Design Pattern is a structural design pattern that provides a simplified interface to a complex system such as a library, framework, or a set of classes. It hides the complexities of the system and provides the client with an easier way to access functionalities.

What is the Facade Design Pattern?

The Facade Pattern offers a unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystem easier to use by encapsulating the interactions with multiple classes behind a single facade class.

Real-World Analogy: Food Delivery App

Consider a food delivery app like Zomato. The app serves as a facade that simplifies interactions between customers, restaurants, delivery teams, and delivery partners. Instead of customers interacting separately with all these entities, the app provides a single interface to place an order, which internally manages the complex processes like order preparation, assignment of delivery persons, and delivery.

Key Components

  • Subsystem Classes: Classes that handle actual business logic (e.g., Restaurant, DeliveryTeam, DeliveryBoy).
  • Facade Class: Provides a simplified interface wrapping the subsystem functionalities.
  • Client: Interacts with the subsystem through the facade.

Java Code Example

// Subsystem Class - Restaurant
public class Restaurant {
    public void prepareOrder() {
        System.out.println("Preparing order at the restaurant.");
    }
}

// Subsystem Class - DeliveryTeam
public class DeliveryTeam {
    public void assignDeliveryBoy() {
        System.out.println("Assigning delivery boy to the order.");
    }
}

// Subsystem Class - DeliveryBoy
public class DeliveryBoy {
    public void deliverOrder() {
        System.out.println("Delivering the order to the customer.");
    }
}

// Facade Class
public class ZomatoFacade {
    private Restaurant restaurant;
    private DeliveryTeam deliveryTeam;
    private DeliveryBoy deliveryBoy;

    public ZomatoFacade() {
        this.restaurant = new Restaurant();
        this.deliveryTeam = new DeliveryTeam();
        this.deliveryBoy = new DeliveryBoy();
    }

    public void placeOrder() {
        restaurant.prepareOrder();
        deliveryTeam.assignDeliveryBoy();
        deliveryBoy.deliverOrder();
    }
}

Using the Facade in Client Code

public class FacadePatternDemo {
    public static void main(String[] args) {
        ZomatoFacade zomato = new ZomatoFacade();
        zomato.placeOrder();
    }
}

How It Works

The client interacts with a single ZomatoFacade class instead of multiple subsystem classes. The facade manages the order preparation and delivery process internally, providing a clean interface to the client.

Advantages of Facade Pattern

  • Simplifies client interaction with complex subsystems.
  • Reduces dependencies between client and subsystem classes.
  • Promotes loose coupling and better maintainability.

Summary

The Facade Design Pattern is an effective way to manage complexity by exposing a simplified, high-level interface. It is widely used in enterprise applications where integration with complex libraries or frameworks is needed while maintaining code simplicity.

If this post helped clarify the Facade Pattern, feel free to ask questions or leave your feedback in the comments. Follow for more Java design patterns insights!

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more