Understanding the Facade Design Pattern in PHP with an Online Shopping Cart Example

Hello developers! Today I will introduce a convenient design pattern in PHP: the Facade pattern. It can make your code easier to manage and use. I will explain what the Facade pattern is, why it is valuable, and demonstrate it with an example.

What is the Facade Pattern?

The Facade pattern is a structural design pattern that provides a unified interface to access subsystems. It acts as a bridge between client code and the internal complexity of subsystems, promoting loose coupling and modular code.

Why Use the Facade Pattern?

You may wonder why to use it. Here are some compelling reasons:

Simplify complexity: The Facade offers a simplified, easy‑to‑understand interface for complex systems, allowing clients to use functionality without knowing internal workings.

Encapsulate subsystems: It hides the inner workings of subsystems, decoupling client code from them, which makes the code easier to understand, maintain, and extend.

Enhance maintainability: Changes to subsystems can be made without affecting client code, making the codebase more resilient and adaptable.

Real‑world Example: Online Shopping Cart

Let’s see a practical application by building an online shopping cart system in PHP.

Step 1: Create Subsystems

In our cart system we have three main components:

Inventory system: checks product availability.

Pricing system: calculates total price.

Checkout system: processes orders.

Here are simplified versions of these classes:

<code>class InventorySystem {
    public function checkAvailability($productId, $quantity) {
        // Check if product is available.
    }
}

class PricingSystem {
    public function calculatePrice($productId, $quantity) {
        // Calculate total price.
    }
}

class CheckoutSystem {
    public function processOrder($product) {
        // Process the order.
    }
}
</code>

Step 2: Create Facade

Now we create a ShoppingCartFacade to simplify client interaction with the subsystems:

<code>class ShoppingCartFacade {
    private $inventory;
    private $pricing;
    private $checkout;

    public function __construct() {
        $this->inventory = new InventorySystem();
        $this->pricing   = new PricingSystem();
        $this->checkout  = new CheckoutSystem();
    }

    public function checkout($cart) {
        foreach ($cart as $product) {
            $productId = $product['id'];
            $quantity  = $product['quantity'];

            if ($this->inventory->checkAvailability($productId, $quantity)) {
                $totalPrice = $this->pricing->calculatePrice($productId, $quantity);
                $this->checkout->processOrder([
                    'id'       => $productId,
                    'quantity' => $quantity,
                    'price'    => $totalPrice
                ]);
            } else {
                echo "Product ID: $productId is unavailable.";
            }
        }
    }
}
</code>

Step 3: Use the Facade

With the ShoppingCartFacade , the client can interact with the cart through a simple interface without needing to understand subsystem complexities. It simplifies the checkout process:

<code>$cartFacade = new ShoppingCartFacade();

$cart = [
    ['id' => 1, 'quantity' => 2],
    ['id' => 2, 'quantity' => 1],
    ['id' => 3, 'quantity' => 5],
];

$cartFacade->checkout($cart);
</code>

The Facade pattern is a powerful tool in the design‑pattern toolbox. It can simplify complex systems, making code more modular and maintainable. In our example we applied it to an online shopping cart system, providing a clear and simple way to handle interactions with subsystems.

The Facade pattern acts like a friendly interface for complex code, making it easier to use and maintain. Try it in your project and experience how it streamlines development.