Proxy Design Pattern

// Subject interface
public interface Image {
    void display();
    String getFilename();
}

// Real Subject — expensive to create
public class HighResolutionImage implements Image {
    private final String filename;
    private final byte[] imageData;

    public HighResolutionImage(String filename) {
        this.filename = filename;
        this.imageData = loadFromDisk(filename); // EXPENSIVE!
        System.out.println("Loaded image: " + filename + " (" + imageData.length + " bytes)");
    }

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

    @Override
    public String getFilename() {
        return filename;
    }

    private byte[] loadFromDisk(String filename) {
        // Simulate expensive I/O operation
        try { Thread.sleep(3000); } catch (InterruptedException e) {}
        return new byte[10_000_000]; // 10MB image
    }
}

// Virtual Proxy — defers loading until display() is called
public class ImageProxy implements Image {
    private final String filename;
    private HighResolutionImage realImage; // lazy-loaded

    public ImageProxy(String filename) {
        this.filename = filename;
        // NO loading here — that's the point!
    }

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

    @Override
    public String getFilename() {
        return filename; // No need to load image for this
    }
}

// Client
public class DocumentViewer {
    public static void main(String[] args) {
        // Images are NOT loaded yet — just proxies
        List<Image> images = List.of(
            new ImageProxy("photo1.png"),
            new ImageProxy("photo2.png"),
            new ImageProxy("photo3.png")
        );

        // Only loads when user actually views
        System.out.println("Document opened. Scrolling to image 2...");
        images.get(1).display(); // Only THIS image gets loaded
    }
}

// Subject interface
public interface Document {
    void read();
    void write(String content);
    void delete();
}

// Real Subject
public class SensitiveDocument implements Document {
    private String content;
    private final String name;

    public SensitiveDocument(String name, String content) {
        this.name = name;
        this.content = content;
    }

    @Override
    public void read() {
        System.out.println("Reading document '" + name + "': " + content);
    }

    @Override
    public void write(String content) {
        this.content = content;
        System.out.println("Document '" + name + "' updated.");
    }

    @Override
    public void delete() {
        System.out.println("Document '" + name + "' deleted.");
    }
}

// Protection Proxy — enforces role-based access
public class DocumentProxy implements Document {
    private final SensitiveDocument realDocument;
    private final User currentUser;

    public DocumentProxy(SensitiveDocument doc, User currentUser) {
        this.realDocument = doc;
        this.currentUser = currentUser;
    }

    @Override
    public void read() {
        if (currentUser.hasPermission(Permission.READ)) {
            realDocument.read();
        } else {
            throw new SecurityException("Access denied: READ permission required");
        }
    }

    @Override
    public void write(String content) {
        if (currentUser.hasPermission(Permission.WRITE)) {
            realDocument.write(content);
        } else {
            throw new SecurityException("Access denied: WRITE permission required");
        }
    }

    @Override
    public void delete() {
        if (currentUser.hasRole(Role.ADMIN)) {
            realDocument.delete();
        } else {
            throw new SecurityException("Access denied: ADMIN role required");
        }
    }
}

// Supporting classes
public enum Permission { READ, WRITE, DELETE }
public enum Role { VIEWER, EDITOR, ADMIN }

public class User {
    private final String name;
    private final Role role;
    private final Set<Permission> permissions;

    public User(String name, Role role, Set<Permission> permissions) {
        this.name = name;
        this.role = role;
        this.permissions = permissions;
    }

    public boolean hasPermission(Permission p) { return permissions.contains(p); }
    public boolean hasRole(Role r) { return this.role == r; }
}

// Subject interface
public interface WeatherService {
    WeatherData getWeather(String city);
}

// Real Subject — makes expensive API call
public class RealWeatherService implements WeatherService {
    @Override
    public WeatherData getWeather(String city) {
        System.out.println("Calling external weather API for: " + city);
        // Simulate HTTP call to weather API
        return new WeatherData(city, 72.0, "Sunny");
    }
}

// Caching Proxy — avoids repeated API calls
public class CachingWeatherProxy implements WeatherService {
    private final RealWeatherService realService;
    private final Map<String, CacheEntry> cache = new ConcurrentHashMap<>();
    private final Duration cacheTtl;

    public CachingWeatherProxy(Duration cacheTtl) {
        this.realService = new RealWeatherService();
        this.cacheTtl = cacheTtl;
    }

    @Override
    public WeatherData getWeather(String city) {
        CacheEntry entry = cache.get(city);

        if (entry != null && !entry.isExpired(cacheTtl)) {
            System.out.println("Cache HIT for: " + city);
            return entry.data();
        }

        System.out.println("Cache MISS for: " + city);
        WeatherData data = realService.getWeather(city);
        cache.put(city, new CacheEntry(data, Instant.now()));
        return data;
    }

    private record CacheEntry(WeatherData data, Instant timestamp) {
        boolean isExpired(Duration ttl) {
            return Instant.now().isAfter(timestamp.plus(ttl));
        }
    }
}

// Usage
public class App {
    public static void main(String[] args) {
        WeatherService service = new CachingWeatherProxy(Duration.ofMinutes(5));

        service.getWeather("NYC"); // Cache MISS — calls API
        service.getWeather("NYC"); // Cache HIT — returns cached
        service.getWeather("LA");  // Cache MISS — calls API
    }
}

// Java's built-in dynamic proxy mechanism
public class LoggingProxyFactory {

    @SuppressWarnings("unchecked")
    public static <T> T createLoggingProxy(T target, Class<T> interfaceType) {
        return (T) Proxy.newProxyInstance(
            interfaceType.getClassLoader(),
            new Class<?>[]{ interfaceType },
            new LoggingHandler(target)
        );
    }

    private static class LoggingHandler implements InvocationHandler {
        private final Object target;
        private static final Logger log = LoggerFactory.getLogger(LoggingHandler.class);

        LoggingHandler(Object target) {
            this.target = target;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long start = System.nanoTime();
            log.info("Calling: {}.{}({})", target.getClass().getSimpleName(),
                     method.getName(), Arrays.toString(args));

            try {
                Object result = method.invoke(target, args);
                long elapsed = (System.nanoTime() - start) / 1_000_000;
                log.info("Completed: {}.{} in {}ms",
                         target.getClass().getSimpleName(), method.getName(), elapsed);
                return result;
            } catch (InvocationTargetException e) {
                log.error("Exception in {}.{}: {}",
                          target.getClass().getSimpleName(), method.getName(),
                          e.getTargetException().getMessage());
                throw e.getTargetException();
            }
        }
    }
}

// Usage
UserService realService = new UserServiceImpl();
UserService proxiedService = LoggingProxyFactory.createLoggingProxy(realService, UserService.class);
proxiedService.findById(1L); // Automatically logged!