Blueprint

The Proxy Pattern Solution

The new code uses the Proxy Pattern (specifically a Caching Proxy). The proxy sits between the client and the costly RealVideoDownloader. Because the client talks to a stand-in object, we control how and when the real service is called.

1. How Proxy Pattern Solves the Issue

Here, the proxy (CachedVideoDownloader class) has caching logic that checks whether a video was already downloaded.

Resource Optimization: If the video is in the cache, the proxy returns the cached result. This saves time and network use.
Call Only When Needed: The real download runs only on a cache miss, so repeated requests do not trigger the costly network call.
Performance Gains: Repeated requests are answered by the proxy, so responses are faster and the whole system does less work.

2. Key Improvements

Separation of Concerns

The Benefit: RealVideoDownloader only downloads. CachedVideoDownloader handles the extra work, such as caching.
The Impact: The code is easier to maintain and test, because the download logic is not mixed with caching code.

Program to an Interface

The Benefit: Both the Proxy and the Real Subject implement the VideoDownloader interface.
The Impact: The client does not depend on a specific class. You could swap the cache for a SecurityProxy or a LoggingProxy without changing any code in the Main class.

Housekeeping & Lifecycle Management

The Benefit: The Proxy owns the RealVideoDownloader instance, so it could decide when to create it.
The Impact: Lazy Initialization is possible, but this demo does not do it. The CachedVideoDownloader constructor creates the RealVideoDownloader at once, and its field uses the concrete class, not the VideoDownloader interface. The demo shows caching only.

3. Structural Breakdown

Component	Responsibility
Service Interface (`VideoDownloader`)	The shared interface of the Real Subject and the Proxy, so either can be used in the same place.
Real Subject (`RealVideoDownloader`)	The actual object that performs the heavy or sensitive work.
Proxy (`CachedVideoDownloader`)	Controls access to the Real Subject. It can do caching, logging, or access control before or after it hands the work (delegates) to the real object.
Client (`Main`)	Uses the Real Subject or the Proxy through the same interface.

4. Comparison of "Before" vs "After"

Feature	Before (Direct Access)	After (Proxy Pattern)
Network Calls	Repeated; hits the server every time.	Reduced; hits the server only on a "cache miss" (the video is not in the cache yet).
Response Time	Always slow, because of network delay (latency).	Instant for repeated requests.
Control	None; anyone can reach the resource.	High; the proxy checks and manages access.
Scalability	Poor; too many requests can overload servers.	High; the cache lowers the load on the server.

5. Summary of the "Gatekeeper"

The Proxy Pattern works like an Assistant to a busy executive. Callers do not talk to the executive directly, which would waste the executive's time. The assistant first tries to answer. Only if the assistant does not have the answer do they interrupt the executive.

In this topic

After code1 file

After/Main.java87 linesGitHub

1package DesignPatterns.StructuralPatterns.ProxyDesignPattern.After;23import java.util.HashMap;4import java.util.Map;56/**7 * 1. THE SUBJECT INTERFACE8 * This common interface allows the Proxy and the RealSubject to be9 * used interchangeably by the client.10 */11interface VideoDownloader {12  String downloadVideo(String videoURL);13}1415/**16 * 2. THE REAL SUBJECT17 * This class contains the actual "expensive" business logic.18 * It should only be called when absolutely necessary.19 */20class RealVideoDownloader implements VideoDownloader {2122  @Override23  public String downloadVideo(String videoUrl) {24    // In a real app, this would involve complex network I/O25    System.out.println("Connecting to server and downloading: " + videoUrl);26    return "High-Quality Video Data from " + videoUrl;27  }28}2930/**31 * 3. THE PROXY (Virtual/Caching Proxy)32 * This class acts as a gatekeeper. It maintains a reference to the RealSubject33 * and controls access to it by implementing its own logic (Caching).34 */35class CachedVideoDownloader implements VideoDownloader {3637  private RealVideoDownloader realDownloader;38  private Map<String, String> cache;3940  public CachedVideoDownloader() {41    // The Proxy can manage the lifecycle of the RealSubject42    this.realDownloader = new RealVideoDownloader();43    this.cache = new HashMap<>();44  }4546  @Override47  public String downloadVideo(String videoUrl) {48    // GATEKEEPING LOGIC: Check if we already have the resource49    if (cache.containsKey(videoUrl)) {50      System.out.println(51        "PROXY: Found in cache. Returning stored content for: " + videoUrl52      );53      return cache.get(videoUrl);54    }5556    // DELEGATION: If not in cache, only then call the expensive RealSubject57    System.out.println(58      "PROXY: Cache miss for " + videoUrl + ". Delegating to RealDownloader..."59    );60    String video = realDownloader.downloadVideo(videoUrl);6162    // POST-PROCESSING: Store the result for future requests63    cache.put(videoUrl, video);64    return video;65  }66}6768/**69 * 4. THE CLIENT70 * Follows the "Program to an Interface" principle. It doesn't know71 * it's talking to a Proxy; it just knows it has a VideoDownloader.72 */73class Main {7475  public static void main(String[] args) {76    VideoDownloader videoService = new CachedVideoDownloader();7778    System.out.println("--- First Request ---");79    // This triggers the RealSubject download80    videoService.downloadVideo("https://video.com/proxy-pattern");8182    System.out.println("\n--- Second Request (Same URL) ---");83    // This is handled entirely by the Proxy; no network call occurs84    videoService.downloadVideo("https://video.com/proxy-pattern");85  }86}87

The Surrogate for Controlled Access