Proxy

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

// RealSubject — expensive to create
public class RealImage implements Image {
    private final String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk(); // expensive — disk I/O
    }

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

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

// ── VIRTUAL PROXY — lazy initialisation ─────────────────────────────
public class LazyImageProxy implements Image {
    private RealImage realImage; // null until first use
    private final String filename;

    public LazyImageProxy(String filename) {
        this.filename = filename; // cheap — no disk load yet
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename); // load only on first call
        }
        realImage.display(); // delegate
    }
}

// ── PROTECTION PROXY — access control ───────────────────────────────
public class ProtectedImageProxy implements Image {
    private final RealImage realImage;
    private final String    userRole;

    public ProtectedImageProxy(String filename, String role) {
        this.realImage = new RealImage(filename);
        this.userRole  = role;
    }

    public void display() {
        if (!userRole.equals("ADMIN") && !userRole.equals("USER")) {
            throw new SecurityException("Access denied for role: " + userRole);
        }
        System.out.println("[ACCESS LOG] user=" + userRole);
        realImage.display();
    }
}

// ── CACHING PROXY — memoisation ──────────────────────────────────────
public interface DataService {
    String fetchData(String query);
}

public class CachingDataProxy implements DataService {
    private final DataService            realService;
    private final Map<String, String>  cache = new HashMap<>();

    public CachingDataProxy(DataService real) { this.realService = real; }

    public String fetchData(String query) {
        if (cache.containsKey(query)) {
            System.out.println("[CACHE HIT] " + query);
            return cache.get(query);
        }
        String result = realService.fetchData(query); // expensive DB call
        cache.put(query, result);
        return result;
    }
}

// ── Dynamic Proxy (Java built-in) ────────────────────────────────────
public class LoggingHandler implements InvocationHandler {
    private final Object target;
    public LoggingHandler(Object target) { this.target = target; }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("[LOG] Calling: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("[LOG] Done: " + method.getName());
        return result;
    }
}

// Client creates a JDK dynamic proxy
Image proxy = (Image) Proxy.newProxyInstance(
    Image.class.getClassLoader(),
    new Class[]{ Image.class },
    new LoggingHandler(new RealImage("photo.jpg"))
);
proxy.display(); // logs before and after

// ❌ BREAKING — race condition in Virtual Proxy
public void display() {
    if (realImage == null) {              // Thread A and B both see null
        realImage = new RealImage(file); // both create — double init!
    }
    realImage.display();
}

// ✅ FIX — double-checked locking with volatile
private volatile RealImage realImage;

public void display() {
    if (realImage == null) {
        synchronized (this) {
            if (realImage == null) {          // second check inside lock
                realImage = new RealImage(filename);
            }
        }
    }
    realImage.display();
}

// ❌ BREAKING — stale cache, no invalidation
public String fetchData(String q) {
    if (cache.containsKey(q)) return cache.get(q); // never expires!
    String r = real.fetchData(q); cache.put(q, r); return r;
}

// ✅ FIX — TTL-based cache entry
record CacheEntry(String value, long expiresAt) {}
private final Map<String, CacheEntry> cache = new HashMap<>();
private static final long TTL_MS = 60_000;

public String fetchData(String q) {
    CacheEntry entry = cache.get(q);
    if (entry != null && System.currentTimeMillis() < entry.expiresAt()) {
        return entry.value(); // ✅ only serve if not expired
    }
    String r = real.fetchData(q);
    cache.put(q, new CacheEntry(r, System.currentTimeMillis() + TTL_MS));
    return r;
}

// ❌ BREAKING — Spring self-invocation bypasses proxy
public class OrderService {
    public void placeOrder() {
        processPayment(); // ❌ calls this.processPayment() — bypasses @Transactional proxy!
    }
    @Transactional
    public void processPayment() { /* transaction never starts */ }
}

// ✅ FIX — call through the proxy
public class OrderService {
    @Autowired private OrderService self; // inject own proxy

    public void placeOrder() {
        self.processPayment(); // ✅ goes through Spring proxy — @Transactional fires
    }
    @Transactional
    public void processPayment() { /* transaction starts correctly */ }
}