十二、结构型（署理模式）

署理模式（Proxy Pattern）

概念
署理模式（Proxy Pattern）是一种结构型操持模式，署理对象在不改变目的对象功能的条件下，通过控制对目的对象的访问，来实现耽误加载、权限控制、日志纪录等功能。署理模式可以通过提供一个中介对象，来控制客户端和实际目的对象之间的交互。

---

应用场景

• 长途署理（Remote Proxy）：为位于差别地点空间的对象提供署理，办理长途调用题目。典范的例子是RMI（Remote Method Invocation），通过署理对象举行长途方法调用。
  
• 假造署理（Virtual Proxy）：为某些须要较高开销的对象提供署理，耽误其加载和创建。好比，大型图片或文档的加载可以通过假造署理来举行，只有认真正须要时才创建实际对象。
  
• 掩护署理（Protection Proxy）：用于控制对对象的访问权限。署理对象查抄调用者是否具有访问权限，只有在权限答应时，才华访问目的对象。
  
• 智能引用署理（Smart Reference Proxy）：在访问对象时参加一些附加操纵，如统计实际对象的引用次数、纪录日志、查抄锁等。
  
• 缓存署理（Caching Proxy）：署理可以缓存某些盘算结果或操纵结果，使得后续的雷同哀求不须要重复盘算，提拔体系性能。
  

---

留意点

• 署理类和实际类必须实现雷同的接口：署理类的操持应与目的类保持划一，使得客户端在利用署理类时与利用实际类没有差别。
  
• 性能开销：只管署理模式可以增长功能，但也大概增长体系开销，尤其是长途署理涉及到网络传输时。
  
• 恰当复杂的控制场景：署理模式尤其恰当在须要控制访问、管理复杂操纵、或添加额外处理处罚逻辑的场景中利用。
  

---

焦点要素

• Subject（抽象主题脚色）：界说署理类和目的类的共同接口，使得署理类和目的类可以被客户端通过雷同的方式调用。
  
• RealSubject（真实主题脚色）：界说目的对象，实现真实的业务逻辑。
  
• Proxy（署理脚色）：负责控制对真实主题对象的访问，通常会引用一个真实主题对象，并通过实现抽象主题接口来署理其操纵。
  

---

Java代码完备示例
代码示例：静态署理

1. // 抽象接口，定义真实主题和代理共同的行为
2. interface Subject {
3.     void request();
4. }
6. // 真实主题，实现实际的业务逻辑
7. class RealSubject implements Subject {
8.     @Override
9.     public void request() {
10.         System.out.println("真实主题执行请求");
11.     }
12. }
14. // 代理类，控制对真实主题的访问
15. class Proxy implements Subject {
16.     private RealSubject realSubject;
18.     @Override
19.     public void request() {
20.         // 代理可以在调用真实对象之前执行一些额外操作
21.         if (realSubject == null) {
22.             realSubject = new RealSubject();
23.         }
24.         System.out.println("代理：在调用真实对象前的额外操作");
25.         realSubject.request();
26.         System.out.println("代理：在调用真实对象后的额外操作");
27.     }
28. }
30. // 客户端
31. public class Client {
32.     public static void main(String[] args) {
33.         Subject proxy = new Proxy();
34.         proxy.request();
35.     }
36. }

复制代码

输出结果：

1. 代理：在调用真实对象前的额外操作
2. 真实主题执行请求
3. 代理：在调用真实对象后的额外操作

复制代码

---

各种变形用法完备示例

• 假造署理（Virtual Proxy）
  假造署理的重要目的是推迟大开销对象的创建，直到须要利用时才创建。典范例子是耽误加载大型图片或文档。
  代码示例：
  1. interface Image {
  2.     void display();
  3. }
  5. // 真实的图像类，实际加载图片
  6. class RealImage implements Image {
  7.     private String fileName;
  9.     public RealImage(String fileName) {
  10.         this.fileName = fileName;
  11.         loadFromDisk();
  12.     }
  14.     private void loadFromDisk() {
  15.         System.out.println("加载图片: " + fileName);
  16.     }
  18.     @Override
  19.     public void display() {
  20.         System.out.println("显示图片: " + fileName);
  21.     }
  22. }
  24. // 虚拟代理类
  25. class ProxyImage implements Image {
  26.     private RealImage realImage;
  27.     private String fileName;
  29.     public ProxyImage(String fileName) {
  30.         this.fileName = fileName;
  31.     }
  33.     @Override
  34.     public void display() {
  35.         if (realImage == null) {
  36.             realImage = new RealImage(fileName);
  37.         }
  38.         realImage.display();
  39.     }
  40. }
  42. // 客户端
  43. public class VirtualProxyClient {
  44.     public static void main(String[] args) {
  45.         Image image = new ProxyImage("test.jpg");
  47.         // 图片首次显示时加载
  48.         image.display();
  49.         System.out.println("");
  51.         // 第二次调用时不需要加载
  52.         image.display();
  53.     }
  54. }

  复制代码
  输出结果：
  1. 加载图片: test.jpg
  2. 显示图片: test.jpg
  4. 显示图片: test.jpg

  复制代码
• 动态署理（Dynamic Proxy）
  动态署理是在运行时创建署理类，而不是在编译时创建。在Java中，可以利用java.lang.reflect.Proxy类来实现动态署理，署理类可以动态署理接口界说的全部方法。
  代码示例：
  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.lang.reflect.Proxy;
  5. // 定义抽象接口
  6. interface Service {
  7.     void operation();
  8. }
  10. // 实现接口的真实类
  11. class RealService implements Service {
  12.     @Override
  13.     public void operation() {
  14.         System.out.println("执行实际操作");
  15.     }
  16. }
  18. // 动态代理处理器
  19. class DynamicProxyHandler implements InvocationHandler {
  20.     private Object target;
  22.     public DynamicProxyHandler(Object target) {
  23.         this.target = target;
  24.     }
  26.     @Override
  27.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  28.         System.out.println("动态代理：在方法执行前");
  29.         Object result = method.invoke(target, args);
  30.         System.out.println("动态代理：在方法执行后");
  31.         return result;
  32.     }
  33. }
  35. // 客户端
  36. public class DynamicProxyClient {
  37.     public static void main(String[] args) {
  38.         RealService realService = new RealService();
  39.         Service proxyInstance = (Service) Proxy.newProxyInstance(
  40.             realService.getClass().getClassLoader(),
  41.             realService.getClass().getInterfaces(),
  42.             new DynamicProxyHandler(realService)
  43.         );
  45.         proxyInstance.operation();
  46.     }
  47. }

  复制代码
  输出结果：
  1. 动态代理：在方法执行前
  2. 执行实际操作
  3. 动态代理：在方法执行后

  复制代码
• 掩护署理（Protection Proxy）
  掩护署理用于控制访问权限，可以通过署理来查抄调用者是否具备权限，只有在通过查抄时，才华调用目的对象的方法。
  代码示例：
  1. interface BankAccount {
  2.     void deposit(double amount);
  3.     void withdraw(double amount);
  4. }
  6. class RealBankAccount implements BankAccount {
  7.     private double balance;
  9.     public RealBankAccount(double balance) {
  10.         this.balance = balance;
  11.     }
  13.     @Override
  14.     public void deposit(double amount) {
  15.         balance += amount;
  16.         System.out.println("存款成功，当前余额: " + balance);
  17.     }
  19.     @Override
  20.     public void withdraw(double amount) {
  21.         if (balance >= amount) {
  22.             balance -= amount;
  23.             System.out.println("取款成功，当前余额: " + balance);
  24.         } else {
  25.             System.out.println("余额不足，取款失败");
  26.         }
  27.     }
  28. }
  30. // 保护代理类
  31. class ProtectionProxy implements BankAccount {
  32.     private RealBankAccount realBankAccount;
  33.     private String userRole;
  35.     public ProtectionProxy(String userRole, double initialBalance) {
  36.         this.userRole = userRole;
  37.         realBankAccount = new RealBankAccount(initialBalance);
  38.     }
  40.     @Override
  41.     public void deposit(double amount) {
  42.         realBankAccount.deposit(amount);
  43.     }
  45.     @Override
  46.     public void withdraw(double amount) {
  47.         if ("ADMIN".equals(userRole)) {
  48.             realBankAccount.withdraw(amount);
  49.         } else {
  50.             System.out.println("无权限取款");
  51.         }
  52.     }
  53. }
  55. // 客户端
  56. public class ProtectionProxyClient {
  57.     public static void main(String[] args) {
  58.         BankAccount adminAccount = new ProtectionProxy("ADMIN", 1000);
  59.         adminAccount.withdraw(500);
  61.         BankAccount userAccount = new ProtectionProxy("USER", 1000);
  62.         userAccount.withdraw(500);
  63.     }
  64. }

  复制代码
  输出结果：
  1. 取款成功，当前余额: 500.0
  2. 无权限取款

  复制代码

---

总结
署理模式通过引入署理类为目的对象提供额外的功能或控制。它实用于耽误加载、权限控制、日志纪录、长途调用等场景。署理模式可以分为静态署理和动态署理，而且具有多种变体，如假造署理、掩护署理、长途署理等。