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.