Proxy Pattern: Controlling Access to an Object

// VIOLATION: every ProductPage loads the full-resolution image eagerly,
// even if the user never scrolls down to see it.
class ProductPage {
    private final HighResImage image;
 
    ProductPage(String imagePath) {
        this.image = new HighResImage(imagePath); // expensive disk I/O, every single time
    }
 
    void render() {
        // ... renders text, price, reviews ...
        // image.display() only called if user scrolls to the gallery section
    }
}
 
class HighResImage {
    HighResImage(String path) {
        loadFromDisk(path); // slow: decodes a 20MB file
    }
    void display() { /* ... */ }
    private void loadFromDisk(String path) { /* ... */ }
}

interface Image {
    void display();
}
 
class HighResImage implements Image {
    private final String path;
 
    HighResImage(String path) {
        this.path = path;
        loadFromDisk(path); // expensive — but now only runs when THIS class is instantiated
    }
 
    public void display() { /* render pixels already in memory */ }
    private void loadFromDisk(String path) { /* decode 20MB file */ }
}
 
// Same interface as HighResImage — clients can't tell the difference
class ImageProxy implements Image {
    private final String path;
    private HighResImage realImage; // null until actually needed
 
    ImageProxy(String path) {
        this.path = path; // cheap — no disk I/O yet
    }
 
    public void display() {
        if (realImage == null) {
            realImage = new HighResImage(path); // construct on first real use
        }
        realImage.display();
    }
}
 
class ProductPage {
    private final Image image;
 
    ProductPage(String imagePath) {
        this.image = new ImageProxy(imagePath); // instant — no disk I/O at construction
    }
 
    void render() {
        // ... renders text, price, reviews ...
        // image.display() called only if/when the gallery section actually renders
    }
}

interface DocumentService {
    Document get(String docId);
    void delete(String docId);
}
 
class RealDocumentService implements DocumentService {
    public Document get(String docId) { /* fetch from store */ return new Document(docId); }
    public void delete(String docId) { /* actually delete */ }
}
 
// Same interface — enforces authorization before delegating
class ProtectedDocumentService implements DocumentService {
    private final RealDocumentService realService;
    private final CurrentUser currentUser;
 
    ProtectedDocumentService(RealDocumentService realService, CurrentUser currentUser) {
        this.realService = realService;
        this.currentUser = currentUser;
    }
 
    public Document get(String docId) {
        return realService.get(docId); // read access: anyone
    }
 
    public void delete(String docId) {
        if (!currentUser.hasRole("ADMIN")) {
            throw new AccessDeniedException("delete requires ADMIN role");
        }
        realService.delete(docId);
    }
}

interface InventoryService {
    int checkStock(String sku);
}
 
// Client code calls this exactly like a local object
class InventoryServiceRemoteProxy implements InventoryService {
    private final HttpClient httpClient;
    private final String remoteBaseUrl;
 
    InventoryServiceRemoteProxy(HttpClient httpClient, String remoteBaseUrl) {
        this.httpClient = httpClient;
        this.remoteBaseUrl = remoteBaseUrl;
    }
 
    public int checkStock(String sku) {
        // marshalling, network call, unmarshalling — all hidden from the caller
        HttpResponse response = httpClient.get(remoteBaseUrl + "/stock/" + sku);
        return parseStockLevel(response);
    }
 
    private int parseStockLevel(HttpResponse response) { /* deserialize JSON */ return 0; }
}
 
// Calling code has NO idea this is a network call:
class OrderService {
    private final InventoryService inventory; // could be local or remote — indistinguishable
 
    OrderService(InventoryService inventory) { this.inventory = inventory; }
 
    boolean canFulfill(String sku, int qty) {
        return inventory.checkStock(sku) >= qty;
    }
}

interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
 
class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;
 
    LoggingInvocationHandler(Object target) { this.target = target; }
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Calling " + method.getName());
        try {
            return method.invoke(target, args); // delegate to the real object via reflection
        } finally {
            System.out.println("Finished " + method.getName());
        }
    }
}
 
// Usage: generates a proxy class implementing DocumentService at runtime — no DocumentServiceProxy .java file needed
DocumentService real = new RealDocumentService();
DocumentService proxy = (DocumentService) Proxy.newProxyInstance(
    DocumentService.class.getClassLoader(),
    new Class<?>[]{DocumentService.class},
    new LoggingInvocationHandler(real));
 
proxy.get("doc-1"); // prints "Calling get" / "Finished get", then delegates