Proxy Method Design Pattern in Java
Last Updated : 11 Jan, 2024
A Proxy Method or Proxy Design Pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it. This pattern involves creating a new class, known as the proxy, which acts as an intermediary between a client and the real object. The proxy object controls access to the real object, allowing you to add additional functionality, such as lazy loading, access control, logging, or caching, without changing the actual object's code.
Important Topics for the Proxy Method Design Pattern in Java
Example of Proxy Method Design Pattern in Java
Problem Statement:
We have to create a simple banking application with a proxy to control access to the real bank account.
Key Concepts of Proxy Method Design Pattern in Java
- Subject Interface (or Abstract Class): This is the common interface or abstract class that both the RealSubject (the real object) and the Proxy implement. It defines the operations that the Proxy will control access to.
- RealSubject: This is the real object that the Proxy represents. It implements the Subject interface. It provides the actual implementation of the operations declared in the Subject interface.
- Proxy: The Proxy class implements the Subject interface as well. It holds a reference to the RealSubject and controls access to it. The Proxy may provide additional functionality before or after assigning the operation to the RealSubject.
- Client: The client code interacts with the Proxy as if it were the real object. The client is unaware of whether it's using the real object or a proxy.
Step wise Step Implementation of above Proxy Method Design Pattern in Java:
"BankAccount" (Subject Interface): This is the subject interface that both the real and proxy objects will implement. It declares three methods: "deposit", "withdraw," and "getBalance".
Java // Subject interface interface BankAccount { void deposit(double amount); void withdraw(double amount); double getBalance(); }
"RealBankAccount" (RealSubject) Class: "RealBankAccount" is the real subject class implementing the "BankAccount" interface. It maintains a balance and provides implementations for the deposit, withdraw, and getBalance methods.
Java // RealSubject class class RealBankAccount implements BankAccount { private double balance; @Override public void deposit(double amount) { balance += amount; System.out.println("Deposited: " + amount); } @Override public void withdraw(double amount) { if (balance >= amount) { balance -= amount; System.out.println("Withdrawn: " + amount); } else { System.out.println("Insufficient funds!"); } } @Override public double getBalance() { return balance; } }
"SecureBankAccountProxy" (Proxy) Class: "SecureBankAccountProxy" is the proxy class implementing the BankAccount interface. It contains a reference to the real bank account ("RealBankAccount") and requires a password for authentication during instantiation. The "authenticate" method checks the password and initializes the real bank account if authentication is successful. The "deposit", "withdraw", and "getBalance" methods delegate to the corresponding methods of the real bank account.
Java // Proxy class class SecureBankAccountProxy implements BankAccount { private RealBankAccount realBankAccount; private String password; public SecureBankAccountProxy(String password) { this.password = password; authenticate(); } private void authenticate() { if (password.equals("secret")) { realBankAccount = new RealBankAccount(); System.out.println("Authentication successful."); } else { System.out.println("Authentication failed. Access denied."); } } @Override public void deposit(double amount) { if (realBankAccount != null) { realBankAccount.deposit(amount); } } @Override public void withdraw(double amount) { if (realBankAccount != null) { realBankAccount.withdraw(amount); } } @Override public double getBalance() { return (realBankAccount != null) ? realBankAccount.getBalance() : 0.0; } }
"ProxyBankExample" Class (Client): "ProxyBankExample" is the client code that demonstrates the usage of the proxy. It creates an instance of "SecureBankAccountProxy" and performs deposit, withdrawal, and balance retrieval operations.
Java // Client code public class ProxyBankExample { public static void main(String[] args) { // Using the proxy to access the real bank account BankAccount account = new SecureBankAccountProxy("secret"); // Operations account.deposit(1000); account.withdraw(500); double balance = account.getBalance(); System.out.println("Current Balance: " + balance); } } Below is the complete combined code of the above example:
To run this code correctly, copy this code and save it in a file named "ProxyBankExample.java".
Java // Subject interface interface BankAccount { void deposit(double amount); void withdraw(double amount); double getBalance(); } // RealSubject class class RealBankAccount implements BankAccount { private double balance; @Override public void deposit(double amount) { balance += amount; System.out.println("Deposited: " + amount); } @Override public void withdraw(double amount) { if (balance >= amount) { balance -= amount; System.out.println("Withdrawn: " + amount); } else { System.out.println("Insufficient funds!"); } } @Override public double getBalance() { return balance; } } // Proxy class class SecureBankAccountProxy implements BankAccount { private RealBankAccount realBankAccount; private String password; public SecureBankAccountProxy(String password) { this.password = password; authenticate(); } private void authenticate() { if (password.equals("secret")) { realBankAccount = new RealBankAccount(); System.out.println("Authentication successful."); } else { System.out.println("Authentication failed. Access denied."); } } @Override public void deposit(double amount) { if (realBankAccount != null) { realBankAccount.deposit(amount); } } @Override public void withdraw(double amount) { if (realBankAccount != null) { realBankAccount.withdraw(amount); } } @Override public double getBalance() { return (realBankAccount != null) ? realBankAccount.getBalance() : 0.0; } } // Client code public class ProxyBankExample { public static void main(String[] args) { // Using the proxy to access the real bank account BankAccount account = new SecureBankAccountProxy("secret"); // Operations account.deposit(1000); account.withdraw(500); double balance = account.getBalance(); System.out.println("Current Balance: " + balance); } } OutputAuthentication successful. Deposited: 1000.0 Withdrawn: 500.0 Current Balance: 500.0
Diagrammatical Representation of the Proxy Method Design Pattern in Java
In this representation:
- "BankAccount" is the subject interface with "deposit", "withdraw", and "getBalance" methods.
- "RealBankAccount" is the real subject implementing "BankAccount".
- "SecureBankAccountProxy" is the proxy implementing "BankAccount". It contains a reference to a "RealBankAccount" object.
- "ProxyBankExample" is the client code creating an instance of "SecureBankAccountProxy" and performing operations on it.
The arrows represent the relationships between the classes:
- The "SecureBankAccountProxy" class contains a reference to a "RealBankAccount" object.
- The client code "ProxyBankExample" interacts with the "SecureBankAccountProxy", which may assign operations to the "RealBankAccount".
Use Cases of Proxy Method Design Pattern in Java
- Lazy Loading: You can use a proxy to implement lazy loading, where the real object is created and initialized only when it is accessed for the first time. This is beneficial when creating the real object is resource-intensive or time-consuming.
- Logging: Proxy can be employed for logging method calls, providing a way to log information such as the method name, parameters, and results. This can be helpful for debugging or auditing purposes.
- Caching: You can use a proxy to implement caching mechanisms. The proxy can check whether the result of a method call is already cached and return the cached result instead of invoking the real object.
- Virtual Proxy: A virtual proxy can be used to represent expensive objects, such as large images or complex calculations, without loading them into memory until they are actually needed.
- Protection Proxy: This type of proxy controls access to sensitive operations. For instance, you might use a protection proxy to check if the client has the necessary permissions before allowing a specific operation.
- Remote Proxy: A remote proxy can be employed when dealing with distributed systems. It acts as a local representative for an object that resides in a different address space, providing a way to interact with it remotely.
- Monitoring and Metrics: Gather metrics or monitoring data by intercepting method calls. This can be used to collect information about the usage patterns of specific functionalities.
Advantages of the Proxy Method Design Pattern in Java
- Improved Performance: Proxies improves the performance by controlling the loading and initialization of objects, especially in scenarios where certain operations are resource-intensive.
- Separation of Concerns: The Proxy Design Pattern promotes a separation of concerns by isolating the proxy-specific functionality from the real object's implementation. This enhances code modularity and maintainability.
- Easy Testing: Proxies can be used to create mock objects for testing purposes. This facilitates unit testing by isolating the unit under test from its dependencies, making it easier to control and verify behavior.
- Dynamic Behavior: Proxies can dynamically alter the behavior of the real object without changing its code. This allows additional functionalities, such as logging or monitoring, without modifying the original implementation.
- Reduced Resource Usage: Virtual proxies restricts the creation of expensive objects until they are needed. This reduces resource consumption and optimizes memory usage.
- Enhanced Security: Proxy objects can add an additional layer of security by implementing authentication, authorization, or other security-related checks before allowing access to the real object.
Disadvantages of the Proxy Method Design Pattern in Java
- Complexity: Introducing proxies can make the codebase complex, especially if multiple types of proxies are involved.
- Overhead: Proxies may result in extra overhead, especially if there is significant logic in the proxy class, such as logging, monitoring, or security checks. This overhead might impact the overall performance of the system.
- Increased Development Time: Introducing proxies might require additional development time and effort. Developers need to carefully design and implement the proxy logic, and this can be time-consuming.
- Misuse or Overuse: There is a risk of misusing or overusing the Proxy Design Pattern. If proxies are applied unnecessarily, it might lead to unnecessary complexity and decreased code readability.
- Potential Security Risks: Security-related proxies might introduce new risks if not implemented correctly. For example, a security proxy might unintentionally allow unauthorized access.
- Maintenance Challenges: If not designed and documented properly, the maintenance of proxies and their interactions with real objects can become difficult. Changes to one part of the system may require updating multiple proxy classes.
- Difficulty in Debugging: The presence of proxy layers can make debugging more challenging, because to find and fix problems, developers must navigate both proxy and real object behaviour.
Conclusion
The Proxy Method Design Pattern in Java is a valuable tool for enhancing control, security, and performance in software systems. When applied correctly and carefully, this pattern provides a modular and flexible approach to extending or modifying the behavior of objects. The pattern provides an effective mechanism for controlling access, optimizing performance, and adding functionalities without directly altering the original object.
Similar Reads
Proxy Method Design Pattern in Javascript
The Proxy Method Design Pattern in JavaScript involves creating a proxy object that controls access to another object, allowing you to define custom behavior for operations like property access and method calls. This pattern is useful for adding features such as logging, validation, and access contr
8 min read
Strategy Method Design Pattern in Java
Strategy method or Strategy Design Pattern is a behavioral design pattern in Java that defines a family of algorithms, encapsulates each algorithm, and makes them interchangeable. It lets the client algorithm vary independently from the objects that use it. This pattern is useful when you have a fam
11 min read
Template Method Design Pattern in Java
Template Design Pattern or Template Method is the behavioral design pattern that defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure. This pattern falls under the category of the "behavioral" design patter
10 min read
Memento Design Pattern in Java
The Memento design pattern in Java is a behavioral design pattern used to capture and restore the internal state of an object without exposing its implementation details. Important Topics for Memento Design Pattern in Java What is the Memento Design Pattern in Java?Components of Memento Design Patte
9 min read
Facade Method Design Pattern in Java
Facade Method Design Pattern is a structural design pattern that provides a simplified interface to a complex subsystem. It acts as a "front door," concealing the internal complexity of the subsystem and making it easier for clients to interact with it. In this article, we will get to know about wha
9 min read
Mediator Design Pattern in Java
The mediator design pattern defines an object that encapsulates how a set of objects interact. The Mediator is a behavioral pattern (like the Observer or the Visitor pattern) because it can change the program's running behavior. We are used to see programs that are made up of a large number of class
4 min read
Bridge Method Design Pattern in Java
The Bridge Design Pattern is a structural design pattern that decouples an abstraction from its implementation so that the two can vary independently. This pattern is useful when both the abstractions and their implementations should be extensible by subclassing. The Bridge pattern allows us to avoi
6 min read
Command Method Design Pattern in Java
The Command Design Pattern in Java is a behavioral design pattern that turns a request into a stand-alone object, allowing parameterization of clients with different requests, queuing of requests, and support for undoable operations(action or a series of actions that can be reversed or undone in a s
10 min read
Prototype Design Pattern in Java
The Prototype Design Pattern in Java is a creational pattern that enables the creation of new objects by copying an existing object. Prototype allows us to hide the complexity of making new instances from the client. The concept is to copy an existing object rather than create a new instance from sc
9 min read
Observer Method Design Pattern in Java
Observer Design Pattern is a behavioral design pattern where an object, known as the subject, maintains a list of its dependents, called observers, that are notified of any changes in the subject's state. This pattern is often used to implement distributed event handling systems. Important Topics fo
11 min read