Achieve Ultimate Excellence

Proxy Design Pattern - Control access with Lazy Initialization

5 min read

Introduction

In the world of software design, design patterns play a crucial role in promoting maintainable, scalable, and flexible code. One such design pattern that can significantly enhance the structure and behavior of an application is the Proxy design pattern. The Proxy pattern falls under the category of structural design patterns and is used to provide a surrogate or placeholder for another object to control access, add additional functionality, or implement lazy initialization.

Understanding the Proxy Design Pattern

The Proxy design pattern involves the creation of a surrogate object, known as the proxy, to represent the real object. Clients interact with the proxy object, which, in turn, handles requests and manages access to the real object. This provides a level of indirection, allowing the proxy to add extra functionalities before or after the actual method call.

Key Participants in the Proxy Design Pattern

Subject: This is the common interface or abstract class shared by both the real subject and the proxy. It defines the common operations that the real subject and proxy can perform.
Real Subject: This is the real object that the proxy represents. The real subject implements the Subject interface and defines the actual functionality.
Proxy: The proxy object implements the Subject interface and maintains a reference to the real subject. It acts as an intermediary between the client and the real subject, controlling access and providing additional functionalities if required.

Benefits of Using the Proxy Design Pattern

Controlled Access: Proxies allow you to control access to sensitive or resource-intensive objects. You can implement access control logic in the proxy, ensuring that only authorized clients can access the real subject.
Lazy Initialization: Proxy objects are useful when you want to defer the creation of the real subject until it is genuinely needed. This can be beneficial for expensive object creation or when dealing with resources like database connections.
Additional Functionality: Proxies can add extra functionality, such as logging, caching, or security checks, without modifying the real subject's code. This promotes the principle of separation of concerns and keeps the real subject focused on its core functionality.

Java Implementation of the Proxy Design Pattern

Let's illustrate the Proxy pattern with a simple example in Java. We'll create a virtual image proxy that loads an actual image from disk only when needed.

Step 1: Define the Subject interface

interface Image {
    void display();
}

Step 2: Implement the Real Subject

class RealImage implements Image {
    private final String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        System.out.println("Loading " + filename + " from disk.");
    }

    @Override
    public void display() {
        System.out.println("Displaying " + filename);
    }
}

Step 3: Create the Proxy

class ProxyImage implements Image {
    private final String filename;
    private RealImage realImage;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

Step 4: Using the Proxy and Real Subject

public class Main {
    public static void main(String[] args) {
        Image image = new ProxyImage("example.jpg");

        // The real image is only loaded when it's needed
        image.display();

        // The real image won't be loaded again, as it's already cached
        image.display();
    }
}

Output:

Loading example.jpg from disk.
Displaying example.jpg
Displaying example.jpg

Explanation

In the example above, we have created a virtual image proxy using the Proxy design pattern. The RealImage class represents the actual image, and the ProxyImage class acts as a proxy for the real image. When a client calls the display() method on the proxy object, the proxy checks if the real image has been loaded. If not, it creates a new instance of the RealImage class and loads the image from disk. Otherwise, it simply delegates the display to the already loaded RealImage instance.

Conclusion

The Proxy design pattern is a powerful tool in the software developer's toolkit, providing enhanced control and flexibility in managing object access and behavior. By employing proxies, you can optimize resource usage, implement lazy initialization, and add additional functionalities without modifying the original code. Understanding and utilizing design patterns like the Proxy pattern can lead to more maintainable, efficient, and scalable software systems.

Article By,