Proxy pattern in LLD - System Design Exercise

Design: Proxy Pattern Implementation

Design and implement the proxy pattern for a generic service object. Out of scope are specific business logic of the real object and network communication details.

Functional Requirements

FR1: Provide a surrogate or placeholder for another object to control access to it

FR2: Support lazy initialization to delay object creation until needed

FR3: Allow access control to restrict or log requests to the real object

FR4: Enable caching of expensive operations to improve performance

FR5: Maintain the same interface as the real object for seamless substitution

Non-Functional Requirements

NFR1: The proxy should not change the interface of the real object

NFR2: Must handle concurrent access safely if used in multithreaded environments

NFR3: Should add minimal overhead to method calls

NFR4: Support scalability for multiple proxy instances

NFR5: Latency for proxy operations should be under 50ms for typical calls

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Subject interface defining common methods

Real subject implementing actual business logic

Proxy class implementing the same interface and controlling access

Client interacting only with the subject interface

Design Patterns

Decorator pattern for adding responsibilities dynamically

Adapter pattern for interface compatibility

Singleton pattern if proxy manages a single resource

Lazy initialization for deferred object creation

Reference Architecture

Client
  |
  v
Proxy (implements Subject interface)
  |
  v
Real Subject (implements Subject interface)

Components

Subject Interface

Abstract Interface or Base Class

Defines common methods for Real Subject and Proxy to implement

Real Subject

Concrete Class

Implements actual business logic and operations

Proxy

Concrete Class

Controls access to Real Subject, adds lazy loading, caching, or access control

Client

Any

Uses Subject interface to interact with Real Subject via Proxy transparently

Request Flow

1. Client calls method on Proxy object via Subject interface

2. Proxy checks if Real Subject is initialized; if not, creates it (lazy initialization)

3. Proxy optionally checks permissions or logs the request (access control)

4. Proxy forwards the method call to Real Subject

5. Real Subject executes the method and returns result

6. Proxy optionally caches the result before returning to Client

7. Client receives the result as if directly from Real Subject

Database Schema

Not applicable for Proxy pattern design as it focuses on object interaction and control rather than data storage.

Scaling Discussion

Bottlenecks

Proxy object becoming a performance bottleneck if it adds heavy processing

Concurrency issues if multiple clients access the proxy and real subject simultaneously

Memory overhead if many proxy instances hold references to real objects

Latency increase due to additional proxy layer

Complexity in managing lifecycle of real objects behind proxies

Solutions

Optimize proxy logic to minimize overhead and avoid blocking operations

Use thread-safe patterns or synchronization inside proxy for concurrent access

Implement proxy pooling or reuse to reduce memory footprint

Use asynchronous calls or caching to reduce latency impact

Clearly define ownership and lifecycle management policies for real objects

Interview Tips

Time: Spend 10 minutes explaining the problem and proxy pattern concept, 15 minutes designing the components and data flow, and 10 minutes discussing scaling and trade-offs.

Explain the purpose of the proxy pattern as a control layer

Describe different types of proxies and their use cases

Show how proxy and real subject share the same interface

Discuss lazy initialization and access control benefits

Highlight potential bottlenecks and how to mitigate them

Emphasize clean separation of concerns and interface transparency

Practice

1.

What is the main purpose of the Proxy pattern in system design?

easy

A. To replace the real object permanently with a new one

B. To control access to an object by using a placeholder

C. To directly modify the real object's data

D. To create multiple instances of an object

Solution

1. Step 1: Understand the Proxy pattern role

   The Proxy pattern acts as a stand-in or placeholder to control access to another object.

2. Step 2: Compare options with the pattern definition

   Only To control access to an object by using a placeholder correctly describes controlling access using a placeholder, which matches the Proxy pattern.

3. Final Answer:

   To control access to an object by using a placeholder -> Option B

4. Quick Check:

   Proxy pattern = control access placeholder [OK]

Hint: Proxy controls access via placeholder, not object creation [OK]

Common Mistakes:

• Confusing Proxy with Singleton pattern
• Thinking Proxy modifies the real object directly
• Assuming Proxy replaces the real object permanently

2.

Which of the following is the correct way to declare a proxy class that implements the same interface as the real object?

interface Image {
    void display();
}

// Which proxy class declaration is correct?

easy

A. interface ImageProxy implements Image { void display(); }

B. class ImageProxy extends Image { void display() { /* control access */ } }

C. class ImageProxy { void display() { /* control access */ } }

D. class ImageProxy implements Image { void display() { /* control access */ } }

Solution

1. Step 1: Recall interface implementation syntax

   In many languages, a class implements an interface using the 'implements' keyword, not 'extends'.

2. Step 2: Check each option's correctness

   class ImageProxy implements Image { void display() { /* control access */ } } correctly declares a class implementing the interface. class ImageProxy extends Image { void display() { /* control access */ } } wrongly uses 'extends' for an interface. class ImageProxy { void display() { /* control access */ } } misses interface implementation. interface ImageProxy implements Image { void display(); } wrongly declares an interface implementing another interface.

3. Final Answer:

   class ImageProxy implements Image { void display() { /* control access */ } } -> Option D

4. Quick Check:

   Proxy class implements interface = class ImageProxy implements Image { void display() { /* control access */ } } [OK]

Hint: Proxy class must implement interface, not extend it [OK]

Common Mistakes:

• Using 'extends' instead of 'implements' for interfaces
• Not implementing the interface at all
• Declaring proxy as an interface instead of a class

3.

Given the following code snippet, what will be the output?

class RealImage {
    void display() { System.out.println("Displaying real image"); }
}

class ProxyImage {
    RealImage realImage;
    void display() {
        if (realImage == null) {
            realImage = new RealImage();
        }
        realImage.display();
    }
}

ProxyImage proxy = new ProxyImage();
proxy.display();
proxy.display();

medium

A. Displaying real image
Displaying real image

B. Displaying real image

C. No output

D. NullPointerException

Solution

1. Step 1: Analyze the first call to display()

   Since realImage is null initially, it is created and then display() prints "Displaying real image".

2. Step 2: Analyze the second call to display()

   realImage is no longer null, so display() is called directly again, printing the same message.

3. Final Answer:

   Displaying real image Displaying real image -> Option A

4. Quick Check:

   Lazy loading calls display twice [OK]

Hint: Proxy lazy loads real object, so display prints twice [OK]

Common Mistakes:

• Assuming display prints only once
• Expecting NullPointerException due to uninitialized realImage
• Thinking proxy suppresses output

4.

Identify the error in the following proxy implementation and select the fix:

class Proxy {
    RealObject real;
    void request() {
        real.request();
    }
}

medium

A. Remove the proxy and call RealObject directly

B. Change method name from request() to execute()

C. Initialize 'real' before calling request()

D. Make 'real' a static variable

Solution

1. Step 1: Identify the problem in the code

   The proxy calls real.request() but 'real' is never initialized, causing a NullPointerException.

2. Step 2: Determine the correct fix

   Initializing 'real' before calling request() ensures the real object exists and avoids errors.

3. Final Answer:

   Initialize 'real' before calling request() -> Option C

4. Quick Check:

   Uninitialized real causes error; initialize it [OK]

Hint: Always initialize real object before proxy calls it [OK]

Common Mistakes:

• Ignoring null initialization error
• Changing method names unnecessarily
• Removing proxy defeats pattern purpose

5.

You are designing a system where loading a large image file is expensive. You want to use the Proxy pattern to improve performance by loading the image only when needed. Which of the following design choices best applies the Proxy pattern for this scenario?

hard

A. Create a proxy class that holds the image filename and loads the real image only when display() is called

B. Load the real image immediately when the proxy is created to avoid delays

C. Use a proxy that duplicates the image data to speed up access

D. Replace the real image with a smaller thumbnail permanently

Solution

1. Step 1: Understand the problem context

   Loading large images is expensive, so delaying loading until necessary improves performance.

2. Step 2: Match design choices to Proxy pattern benefits

   Create a proxy class that holds the image filename and loads the real image only when display() is called uses lazy loading by deferring real image loading until display() is called, which fits Proxy pattern use.

3. Final Answer:

   Create a proxy class that holds the image filename and loads the real image only when display() is called -> Option A

4. Quick Check:

   Lazy loading with proxy = Create a proxy class that holds the image filename and loads the real image only when display() is called [OK]

Hint: Proxy delays expensive load until needed (lazy loading) [OK]

Common Mistakes:

• Loading real object immediately defeats proxy benefit
• Duplicating data wastes resources
• Replacing with thumbnail changes object behavior