Proxy

The Proxy design pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it. This pattern is useful when you want to add an additional layer of control over an object, such as lazy initialization, access control, logging, or caching.

Key Concepts

1. Proxy: The proxy object, which controls access to the real object.

2. Real Subject: The actual object that the proxy represents.

3. Client: The object that interacts with the proxy.

### Types of Proxies

• Virtual Proxy: Controls access to a resource that is expensive to create.

• Remote Proxy: Represents an object in a different address space.

• Protection Proxy: Controls access to the original object based on access rights.

• Smart Proxy: Adds additional behavior when an object is accessed.

UML Diagram

+---------+        +-----------------+
|  Client | --->>  |    Subject      |
+---------+        +-----------------+
                         ^
                         |
                         |
+---------+        +-----------------+
|  Proxy  |------->| Real Subject    |
+---------+        +-----------------+`

--- Java Example ---

 // Subject interface
 public interface Subject {
     void request();
 }

 // Real Subject class
 public class RealSubject implements Subject {
     @Override
     public void request() {
         System.out.println("RealSubject: Handling request.");
     }
 }

 // Proxy class
 public class Proxy implements Subject {
     private RealSubject realSubject;

     @Override
     public void request() {
         if (realSubject == null) {
             realSubject = new RealSubject();
         }
         System.out.println("Proxy: Logging request.");
         realSubject.request();
     }
 }

 // Client code
 public class Client {
     public static void main(String[] args) {
         Subject proxy = new Proxy();
         proxy.request(); // Outputs: Proxy: Logging request. \n RealSubject: Handling request.
     }
 }

--- Python Example ---

 from typing import Protocol

 # Subject interface
 class Subject(Protocol):
     def request(self) -> None:
         pass

 # Real Subject class
 class RealSubject(Subject):
     def request(self) -> None:
         print("RealSubject: Handling request.")

 # Proxy class
 class Proxy(Subject):
     def __init__(self) -> None:
         self._real_subject: RealSubject | None = None

     def request(self) -> None:
         if self._real_subject is None:
             self._real_subject = RealSubject()
         print("Proxy: Logging request.")
         self._real_subject.request()

 # Client code
 if __name__ == "__main__":
     proxy = Proxy()
     proxy.request()  # Outputs: Proxy: Loggin request. \n RealSubject: Handling request.