Java implements Proxy pattern
The Proxy pattern is a structural design pattern that allows you to control access to another object by creating a proxy object. The proxy object acts as a mediator between the client and the target object, allowing for additional behavior to be added. This pattern provides a more Loose coupling way to control access to target objects.
Applicable scenarios:
1. Accessing a remote object: By using a proxy object, the specific implementation details of the remote object can be hidden, and the client only needs to interact with the proxy object.
2. Accessing an object that takes a long time to obtain: The proxy object can provide some other operations before the client waits for the target object to be ready.
3. Implement permission control: Proxy objects can perform permission checks before clients request access to the target object to ensure that only legitimate users can access it.
Benefits:
1. The Proxy pattern enhances the security of the system, and the access to the target object can be controlled through the proxy object.
2. Proxy pattern can improve the performance of the system. By implementing some caching mechanisms in proxy objects, it can reduce direct access to target objects and improve response speed.
3. The Proxy pattern can enhance the target object and expand its behavior.
The following is a complete sample code for implementing the Proxy pattern using Java:
//Defined target interface
interface Image {
void display();
}
//Target object
class RealImage implements Image {
private String filename;
public RealImage(String filename) {
this.filename = filename;
LoadFromDisk()// Load images during initialization
}
private void loadFromDisk() {
System.out.println("Loading image from disk: " + filename);
}
public void display() {
System.out.println("Displaying image: " + filename);
}
}
//Proxy Object
class ImageProxy implements Image {
private String filename;
private RealImage image;
public ImageProxy(String filename) {
this.filename = filename;
}
public void display() {
if (image == null) {
image = new RealImage(filename);
}
image.display();
}
}
//Client code
public class ProxyPatternExample {
public static void main(String[] args) {
Image image = new ImageProxy("sample.jpg");
image.display();
}
}
In the above code, the 'Image' interface is the target interface, the 'RealImage' is the specific implementation of the target object, and the 'ImageProxy' is the proxy object. The client code accesses the target object by creating a proxy object, which creates the real object when needed and calls its methods. The advantage of doing so is that the client does not directly interact with the target object, but instead controls access and enhances functionality through proxy objects.
