The Proxy pattern is used to control access to an object and add functionality without modifying the object itself. 1. It supports lazy initialization by creating the real object only when needed. 2. It enforces access control to restrict unauthorized method calls. 3. It enables logging or monitoring of method interactions for performance tracking. 4. It facilitates caching to avoid redundant expensive operations. The pattern works by defining a common interface, implementing the real object, and creating a proxy class that wraps it. Real-world applications include ORMs for deferred database queries, RPCs for remote service communication, security layers for permission checks, and API gateways for managing requests. In summary, the Proxy pattern enhances behavior in a reusable and non-invasive way while keeping core logic clean.

The Proxy pattern is a structural design pattern that acts as a placeholder or surrogate for another object. It controls access to the real object, allowing you to add behavior before or after interacting with it — without changing the object’s code.

This can be useful in many situations, like lazy loading, access control, logging, and more.

When Would You Use a Proxy?

Proxies come in handy when you want to introduce some extra functionality around an object without modifying it directly. Here are a few common use cases:

• Lazy initialization (Virtual Proxy): Only create the real object when it's actually needed.
• Access control (Protection Proxy): Restrict who can call certain methods on the object.
• Logging or monitoring (Remote Proxy): Track method calls or measure performance.
• Caching results (Cache Proxy): Store previously computed results to avoid repeating expensive operations.

For example, imagine you have a large image that takes time to load. Instead of loading it immediately, you can use a proxy that only loads the image when someone tries to display it.

How Does It Work in Code?

To implement the Proxy pattern, you usually follow this structure:

• Define a common interface shared by both the real object and the proxy.
• Implement the real object that does the actual work.
• Create the proxy class that holds a reference to the real object and implements the same interface.

Here’s a basic idea in pseudocode:

class Image:
    def display(self):
        pass

class RealImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self._load_from_disk()

    def _load_from_disk(self):
        print(f"Loading {self.filename} from disk...")

    def display(self):
        print(f"Displaying {self.filename}")

class ProxyImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self.real_image = None

    def display(self):
        if self.real_image is None:
            self.real_image = RealImage(self.filename)
        self.real_image.display()

In this case, ProxyImage delays loading the image until display() is called.

Real-World Examples

You might not realize it, but proxies are used in many frameworks and libraries:

• ORMs (Object Relational Mappers): Like Django or SQLAlchemy often use proxies to delay database queries until necessary.
• Remote Procedure Calls (RPC): The client uses a proxy to talk to a remote service without knowing it's remote.
• Security layers: A protection proxy might check user permissions before executing sensitive operations.

Even in web development, API gateways can act like proxies — handling rate limiting, authentication, or routing before hitting the real backend services.

Key Takeaways

• Proxies sit between the caller and the real object.
• They allow you to extend behavior without changing the real object.
• Useful for lazy loading, security, caching, and remote access.
• Works best when both proxy and real object share the same interface.

It’s not always obvious when you need a proxy, but once you do, it can clean up your code significantly.

Basically, it's a flexible tool that helps keep your core logic clean while adding smart layers around it.

The above is the detailed content of What is the Proxy pattern?. For more information, please follow other related articles on the PHP Chinese website!