Proxy Design Pattern in Java

The Proxy Design Pattern in Java is a structural design pattern that allows you to provide a surrogate or placeholder for another object. The proxy object acts as an intermediary between the client and the real object, controlling access to the real object and providing additional functionality if necessary.

In other words, the Proxy Design Pattern provides a way to create a wrapper or proxy object that mimics the behavior of the real object, but can also add extra functionality, such as caching or security checks. The client interacts with the proxy object, which in turn interacts with the real object behind the scenes.

Some common use cases for the Proxy Design Pattern include:

Remote proxies: In a distributed system, a remote proxy can be used to represent an object that resides on a remote machine. The proxy object can handle the communication between the client and the remote object, making it easier to manage network communication and security.
Virtual proxies: A virtual proxy can be used to represent a large or resource-intensive object that may take a long time to create. The proxy object can be created quickly and provide a lightweight representation of the real object, while the real object is only created when needed.
Protection proxies: A protection proxy can be used to control access to a sensitive or private object. The proxy object can handle authentication and authorization checks before allowing the client to access the real object.

Properties of Proxy Design Pattern

The Proxy Design Pattern in Java has several properties:

Separation of concerns: The Proxy Design Pattern separates the concerns of the client and the real object, providing an intermediary object to handle communication between them.
Encapsulation: The Proxy object encapsulates the real object and provides a controlled interface for the client.
Flexibility: The Proxy Design Pattern allows for flexibility in the implementation, as the proxy object can be customized to provide additional functionality, such as caching or security checks.
Reduced resource usage: The Proxy Design Pattern can reduce resource usage, as the real object can be created only when needed, and the proxy object can handle caching or other optimizations.
Remote access: The Proxy Design Pattern can be used to provide access to remote objects, as the proxy object can handle communication between the client and the remote object.
Improved performance: The Proxy Design Pattern can improve performance in certain situations, such as when a virtual proxy is used to represent a large or resource-intensive object.

Implementation of Proxy Design Pattern

Here is an example implementation of the Proxy Design Pattern in Java:

First, we define an interface for the subject, which will be implemented by the real object and the proxy object:

public interface Subject {
    public void request();
}

Next, we define the real object that implements the subject interface:

public class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

We also define the proxy object, which wraps the real object:

public class Proxy implements Subject {
    private RealSubject realSubject;

    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        System.out.println("Proxy: Preparing request.");
    }

    private void postRequest() {
        System.out.println("Proxy: Post-processing request.");
    }
}

In the proxy object, we maintain a reference to the real object and call its methods when necessary. We also add additional functionality by implementing preRequest() and postRequest() methods.

Finally, we can test the implementation by creating a client and calling the request() method on the proxy object:

public class Client {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.request();
    }
}

When we run the client, we should see the following output:

Proxy: Preparing request.
RealSubject: Handling request.
Proxy: Post-processing request.

This output shows that the proxy object handles the preparation and post-processing of the request, while the real object handles the actual request.

Share on Facebook

Save