Proxy Design Pattern

The Proxy Design Pattern is a structural design pattern.

The Proxy Design Pattern acts as a middleman between the client (user) and the actual object.

Instead of interacting directly with the original object, the client talks to the proxy, which controls access.

The proxy can:

• Add extra logic before calling the original object (e.g., security checks, logging).

• Add extra logic after calling the original object (e.g., caching, cleanup).

Think of it as a gatekeeper that manages how and when the original object is accessed.

Key Components:

1. Subject (Interface or Abstract Class)

package DesignPatterns.structural.proxy.atm;

public interface BankAccount {
    public void deposit(double amount);
    public void withdraw(double amount);
    public void checkBalance();
}

2. Real Object (RealSubject)

package DesignPatterns.structural.proxy.atm;

public class RealBankAccount implements  BankAccount{
    private double balance;

    public RealBankAccount(double initialBalance) {
        this.balance = initialBalance;
    }
    @Override
    public void deposit(double amount) {
        System.out.println("Current Balance : Rupees " + balance);
        this.balance+=amount;
        System.out.println("Balance: " + amount + " Deposited" + " Total Balance: " + balance);


    }


    @Override
    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: Rupees" + amount + ", Remaining Balance: Rupees" + balance);
        } else {
            System.out.println("Insufficient funds!");
        }
    }

    @Override
    public void checkBalance() {
        System.out.println("Your current balance is: Rupees" + balance);
    }
}

3. Proxy (Proxy Class)

package DesignPatterns.structural.proxy.atm;

public class BankProxy implements  BankAccount{
    private RealBankAccount realBankAccount;
    private Boolean isAuthenticated;
    BankProxy(Boolean isAuthenticated, double initialBalance) {
        this.isAuthenticated = isAuthenticated;
        realBankAccount = new RealBankAccount(initialBalance);
    }

    @Override
    public void withdraw(double amount) {
        if (isAuthenticated) {
            realBankAccount.withdraw(amount);
        } else {
            System.out.println("Access Denied! Please authenticate first.");
        }

    }

    @Override
    public void deposit(double amount) {
        realBankAccount.deposit(amount);

    }

    @Override
    public void checkBalance() {
        if (isAuthenticated) {
            realBankAccount.checkBalance();
        } else {
            System.out.println("Access Denied! Please authenticate first.");
        }

    }
}

4. Client

package DesignPatterns.structural.proxy.atm;

public class Client {
    public static void main(String[] args) {
        BankAccount secureAccount = new BankProxy(true, 10000);
        BankAccount unsecureAccount = new BankProxy(false, 10000);
        secureAccount.deposit(2000);
        unsecureAccount.deposit(3000);
        secureAccount.withdraw(3000);
        unsecureAccount.withdraw(5000);
        secureAccount.checkBalance();
        unsecureAccount.checkBalance();
    }

}

Pros (Advantages)

Cons (Disadvantages)

When to Use Proxy Pattern

1. Use when you need on-demand loading (e.g., heavy images or database connections).

2. Use when implementing security controls or access restrictions.

3. Use when adding caching, logging, or performance optimizations without modifying the original object.

Remote Proxy vs Virtual Proxy

Both are types of Proxy Design Patterns, but they serve different purposes. Here's a clear comparison: