什么是代理模式？
代理模式是一种结构模式，为另一个对象提供代理或占位符来控制对其的访问。
什么时候使用它？
根据其特定目的，有不同类型的代理。但本质上，代理模式是为另一个对象提供代表。
当资源的创建成本高昂，并且您希望延迟其实例化直到实际需要时，请使用虚拟代理。
当您需要控制对对象的访问（通常基于权限或角色）时，请使用保护代理。
-
当您想要表示位于不同地址空间（例如，在远程服务器上）的对象并像在本地一样与其通信时，请使用远程代理。
代理模式还有更多用例。如果您有兴趣，可以在网上查一下这些代理：防火墙代理、智能参考代理、缓存代理、同步代理, 复杂性隐藏代理, 写时复制代理等
问题
我们正在开发银行系统。每个客户都可以访问任何客户的账户名和帐号（例如汇款），但存款、取款和查看余额操作只能由其账户持有人允许。
你可能认为我们可以创建两个类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
陷阱
- 代理增加了我们设计中类和对象的数量。
与装饰模式的比较
- 装饰器和代理都包装对象，但它们的意图不同。装饰器为对象添加小行为，而代理控制访问。
您可以在这里查看所有设计模式的实现。
github 存储库
