当前位置：首页 > 文章列表 > 文章 > java教程 > 代理模式

代理模式

来源：dev.to 2025-01-06 17:30:41 0浏览收藏

从现在开始，我们要努力学习啦！今天我给大家带来《代理模式》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

什么是代理模式？

代理模式是一种结构模式，为另一个对象提供代理或占位符来控制对其的访问。

什么时候使用它？

根据其特定目的，有不同类型的代理。但本质上，代理模式是为另一个对象提供代表。

当资源的创建成本高昂，并且您希望延迟其实例化直到实际需要时，请使用虚拟代理。
当您需要控制对对象的访问（通常基于权限或角色）时，请使用保护代理。
当您想要表示位于不同地址空间（例如，在远程服务器上）的对象并像在本地一样与其通信时，请使用远程代理。

代理模式还有更多用例。如果您有兴趣，可以在网上查一下这些代理：防火墙代理、智能参考代理、缓存代理、同步代理, 复杂性隐藏代理, 写时复制代理等

问题

我们正在开发银行系统。每个客户都可以访问任何客户的账户名和帐号（例如汇款），但存款、取款和查看余额操作只能由其账户持有人允许。
你可能认为我们可以创建两个类holder和nonholder，然后实现相应的行为。但请注意，客户既是自己银行账户的持有人，又同时不是其他银行账户的持有人。我们可以通过客户可以在运行时切换 holder 或 nonholder 的方式来实现，但这很危险，因为现在客户可以成为其他客户银行账户的持有者。

我们需要一名监护人来保护非持有人的凭证信息。你能猜出他的名字吗？这就是保护代理！

结构

在进入解决方案部分之前，让我们先检查一下通用（或静态）代理结构。

代理模式

subject 为 realsubject 和 proxy 提供了通用的接口。通过这种方式，client 并不知道他们正在与 realsubject 进行通信，但他们实际上是在与 proxy 进行交互，这就是 proxy 被称为代理或占位符的原因。当 client 调用 proxy 上的方法时，proxy 会决定是否调用 realsubject 上请求的方法，或者执行替代操作，例如拒绝请求或在加载重量级资源时显示文本。

动态代理

代理模式

动态代理是允许客户端在运行时实例化代理的代理。动态代理可以使用java api proxy (java.lang.reflect.proxy)来实现。

类图与一般的代理结构有点不同。让我们逐步浏览该图...

proxy 现在由两个类组成，proxy 和 initationhandler 类。

客户端调用代理上的方法。

proxy 将 client 调用的方法传递给 incationhandler。

incationhandler 接收来自 proxy 的方法，并决定是否调用 realsubject 上的实际方法或执行替代操作。

解决方案

抱歉让您久等了，我们来看看解决办法。
我们将实现动态保护代理。

代理模式

客户
客户端调用代理上的方法。
ibank账户
客户端通过 ibankaccount 接口与代理对话。
代理
proxy 接收来自 client 的方法调用。这些方法将传递给 incationhandler。
holderinitationhandler
holderincationhandler 处理来自帐户持有者的方法调用（调用）。帐户持有人可以访问 realsubject 上的所有方法。
非持有者调用处理程序
nonholderincationhandler 处理来自非帐户持有者的方法调用。非账户持有人无法访问某些方法，例如withdraw()。例如，如果非持有者在 proxy 上调用withdraw()，nonholderinitationhandler 将接收该调用，并阻止对 realsubject 的访问。

java实现

public interface ibankaccount {
    // anyone can access to account's name and number
    string getname();
    string getaccountnumber();

    // deposit, withdraw, viewbalance is only allowed by account holder
    void deposit(double amount);
    void withdraw(double amount);
    void viewbalance();
}

public class bankaccount implements ibankaccount {

    private string name;
    private string accountnumber;
    private double balance;

    public bankaccount(string name, string accountnumber, double balance) {
        this.name = name;
        this.accountnumber = accountnumber;
        this.balance = balance;
    }

    @override
    public string getname() {
        return name;
    }

    @override
    public string getaccountnumber() {
        return accountnumber;
    }

    @override
    public void deposit(double amount) {
        balance += amount;
        system.out.println(name + " deposit $" + amount);
    }

    @override
    public void withdraw(double amount) {
        balance -= amount;
        system.out.println(name + " withdraw $" + amount);
    }

    @override
    public void viewbalance() {
        system.out.println(name + "'s balance: $" + balance);
    }
}

public class holderinvocationhandler implements invocationhandler {

    private ibankaccount account;

    public holderinvocationhandler(ibankaccount account) {
        this.account = account;
    }

    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        try {
            return method.invoke(account, args);
        } catch (invocationtargetexception e) {
            e.printstacktrace();
        }
        return null;
    }
}

public class nonholderinvocationhandler implements invocationhandler {

    private ibankaccount account;

    public nonholderinvocationhandler(ibankaccount account) {
        this.account = account;
    }

    @override
    public object invoke(object proxy, method method, object[] args) throws illegalaccessexception {
        try {
            // anyone can access to other person's name and account number
            if (method.getname().startswith("get")) {
                method.invoke(account, args);
            } else {
                // other methods like deposit() are not allowed by anyone but account holder
                throw new illegalaccessexception();
            }
        } catch (invocationtargetexception e) {
            e.printstacktrace();
        }
        return null;
    }
}

public class bankaccounttestdrive {

    public static void main(string[] args) {
        bankaccounttestdrive test = new bankaccounttestdrive();
        test.drive();
    }

    public void drive() {
        // instantiate real subject
        ibankaccount alex = new bankaccount("alex", "123-abc-456", 500.0);

        system.out.println("-- testing access via holder proxy --");
        ibankaccount holderproxy = getholderproxy(alex); // create proxy
        // holder proxy allows everything
        system.out.println("account name: " + holderproxy.getname());
        system.out.println("account number: " + holderproxy.getaccountnumber());
        holderproxy.deposit(100.0);
        holderproxy.withdraw(50.0);
        holderproxy.viewbalance();

        system.out.println("-- testing access via non-holder proxy --");
        ibankaccount nonholderproxy = getnonholderproxy(alex); // create proxy
        // non holder proxy allows getting name and account number
        system.out.println("account name: " + holderproxy.getname());
        system.out.println("account number: " + holderproxy.getaccountnumber());
        // non holder proxy doesn't allow accessing credential info
        try {
            nonholderproxy.deposit(200.0);
        } catch (exception e) {
            system.out.println("can't deposit from non-holder proxy");
        }
        try {
            nonholderproxy.withdraw(50.0);
        } catch (exception e) {
            system.out.println("can't withdraw from non-holder proxy");
        }
        try {
            nonholderproxy.viewbalance();
        } catch (exception e) {
            system.out.println("can't view balance from non-holder proxy");
        }
    }

    // this method takes a ibankaccount object (real subject) and returns a proxy for it.
    // because proxy has the same interface as the subject, this method returns ibankaccount.
    ibankaccount getholderproxy(ibankaccount account) {
        // call static method newproxyinstance on java api proxy
        return (ibankaccount) proxy.newproxyinstance(
                account.getclass().getclassloader(), // pass class loader
                account.getclass().getinterfaces(), // proxy needs to implement the interfaces that real subject implements
                new holderinvocationhandler(account)); // pass real subject into the constructor of the invocation handler.
    }

    ibankaccount getnonholderproxy(ibankaccount account) {
        return (ibankaccount) proxy.newproxyinstance(
                account.getclass().getclassloader(),
                account.getclass().getinterfaces(),
                new nonholderinvocationhandler(account));
    }
}

输出：

-- Testing access via holder proxy --
Account name: Alex
Account number: 123-abc-456
Alex deposit $100.0
Alex withdraw $50.0
Alex's balance: $550.0
-- Testing access via non-holder proxy --
Account name: Alex
Account number: 123-abc-456
Can't deposit from non-holder proxy
Can't withdraw from non-holder proxy
Can't view balance from non-holder proxy