Decorator and Proxy Patterns

# CHAPTER 12

Decorator and Proxy Patterns #

1. Introduction #

2. Learning Objectives #

• Identify the "Class Explosion" problem caused by static inheritance.

• Define the intent and structural mechanics of the Decorator Pattern.

• Understand the concept of "Object Wrappers."

• Differentiate between a Decorator (adding behavior) and a Proxy (controlling access).

• Implement a lazy-loading Virtual Proxy to optimize performance.

3. The Decorator Pattern (The Wrapper) #

• The Concept: Think of wearing clothes. You are the base object. When it gets cold, you wrap yourself in a Sweater (a Decorator). The Sweater adds the "Warmth" behavior. You don't have to genetically alter your DNA (Inheritance) to become warm; you just add a wrapper at runtime.

• The Mechanics: The Decorator class implements the exact same interface as the base object it is wrapping. This means the client code cannot tell the difference between the base object and the decorated object.

4. The Proxy Pattern (The Bodyguard) #

• The Concept: A credit card is a Proxy for a bank account. It implements the same interface (making payments), but it controls access (checking PINs, preventing overdrafts) without you needing to carry stacks of physical cash.

• Types of Proxies:

• *Virtual Proxy (Lazy Loading):* If an object is massive (like a high-res image), the Proxy takes its place and delays loading the actual image into memory until the exact second it is needed on screen.

• *Protection Proxy:* Checks access rights before allowing a method to be called (e.g., verifying a user is an Admin before executing deleteDatabase()).

5. Decorator vs. Proxy (The Difference) #

• Decorator: Adds *new* features or behaviors to an object dynamically. (e.g., Taking a base Notification object and wrapping it to also send an SMS).

• Proxy: Controls *access* to an object without changing its behavior. (e.g., Taking a base Database object and intercepting calls to check for authentication).

6. UML Diagram #

[ Client ] ---> [ <<Interface>> Component ] <-----------------
                         ^                                   |
           -----------------------------                     | (Contains)
           |                           |                     |
[ Concrete Component ]          [ Base Decorator ] -----------
   + execute()                    - wrappee: Component
                                  + execute() { wrappee->execute() }
                                       ^
                                       |
                              [ Concrete Decorator ]
                              + execute() { 
                                  super->execute();
                                  doExtraStuff(); 
                                }

7. Code Example: Decorator (PHP) #

<?php
// --- 1. The Common Interface ---
interface Notifier {
    public function send($message);
}

// --- 2. The Base Component ---
class EmailNotifier implements Notifier {
    public function send($message) {
        echo "Sending EMAIL: $message\n";
    }
}

// --- 3. The Base Decorator ---
// It implements the interface AND contains an object of that interface.
abstract class NotifierDecorator implements Notifier {
    protected $wrappee; // The object being wrapped

    public function __construct(Notifier $notifier) {
        $this->wrappee = $notifier;
    }

    public function send($message) {
        $this->wrappee->send($message);
    }
}

// --- 4. Concrete Decorators (Adding dynamic behavior) ---
class SMSDecorator extends NotifierDecorator {
    public function send($message) {
        parent::send($message); // Execute the inner wrapper's logic
        echo "Sending SMS: $message\n"; // Add NEW behavior
    }
}

class SlackDecorator extends NotifierDecorator {
    public function send($message) {
        parent::send($message);
        echo "Sending SLACK message: $message\n";
    }
}

// --- 5. Client Code ---
echo "--- Base Email ---\n";
$notifier = new EmailNotifier();
$notifier->send("Server is down!"); 
// Outputs: Sending EMAIL

echo "\n--- Wrapped in SMS and Slack ---\n";
// We nest the wrappers like Russian dolls.
// The client still just calls send() once!
$superNotifier = new SlackDecorator(new SMSDecorator(new EmailNotifier()));
$superNotifier->send("Server is critically down!");
// Outputs: 
// Sending EMAIL
// Sending SMS
// Sending SLACK message
?>

8. Best Practices #

• Middleware is a Decorator: If you have ever used modern web frameworks (Express.js, Laravel), you have used Middleware. Middleware is simply the Decorator pattern. A basic HTTP Request object is wrapped in an Authentication Decorator, then wrapped in a Logging Decorator, forming a pipeline.

9. Common Mistakes #

• Identity Crisis: Because the Decorator wraps the original object, if you write code that checks the exact class type (e.g., if ($obj instanceof EmailNotifier)), it will fail when the object is wrapped inside an SMSDecorator. You must program strictly to the Interface (if ($obj instanceof Notifier)).

10. Mini Project: Build a Protection Proxy #

1. 1. The Target: Create a Database interface and a RealDatabase class with a query() method.

1. 2. The Proxy: Create a DatabaseProxy class that implements Database and wraps RealDatabase.

1. 3. The Logic: Add a $role property to the Proxy constructor. In the Proxy's query() method, write an if statement. If $role == 'admin', forward the call to the RealDatabase. If not, throw an "Access Denied" exception.

11. Practice Exercises #

1. 1. Define the "Class Explosion" problem associated with static inheritance. How does the Decorator pattern resolve this using Composition?

1. 2. Explain the architectural difference in intent between a Decorator and a Proxy, despite their identical structural UML.

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain how modern web framework "Middleware" (like HTTP request interception) is an implementation of the Decorator pattern.

• Q: Walk me through the mechanics of a "Virtual Proxy." How does placing a Proxy in front of an expensive resource optimize memory and CPU usage in an enterprise application?

• Q: On a whiteboard, draw the "Russian Nesting Doll" architecture of a Decorator pattern. Explain how a single method call cascades down through multiple layers of wrappers to reach the base component.

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #