设计模式ProxyStructure标签03标签04标签05

C#13：(结构型模式)Proxy 代理模式.pdf

说明：

  • 代理模式
  • 结构型模式

视频

点击查看【bilibili】

直接与间接：

人们对复杂的软件系统常有一种处理手法，即增加一层间接层，从而对系统获得一种更为灵活、满足特定需求的解决方案。

P13.代理模式-Proxy--Structure - 图1

动机(Motivate):

  1. 在面向对象系统中，有些对象由于某种原因（比如对象创建的开销很大，或者某些操作需要安全控制，或者需要进程外的访问等），直接访问会给使用者、或者系统结构带来很多麻烦。
  3. 如何在不失去透明操作对象的同时来管理/控制这些对象特有的复杂性？增加一层间接层是软件开发中常见的解决方式。

意图(Intent):

  1.    为其他对象提供一种代理以控制对这个对象的访问。  -------《设计模式》GOF

结构图(Struct):

P13.代理模式-Proxy--Structure - 图2

生活中的例子：

  1.    代理模式提供一个中介以控制对这个对象的访问。一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。<br />![](https://cdn.nlark.com/yuque/0/2021/jpeg/446847/1615447287352-7e49bdc0-ed1e-452d-84d0-b841a4dd0ba5.jpeg#align=left&display=inline&height=214&margin=%5Bobject%20Object%5D&originHeight=214&originWidth=371&size=0&status=done&style=none&width=371)

代码实例：

  1. 在软件系统 中，我们无时不在跨越障碍，当我们访问网络上一台计算机的资源时，我们正在跨越网络障碍，当我们去访问服务器上数据库时，我们又在跨越数据库访问障碍，同 时还有网络障碍。跨越这些障碍有时候是非常复杂的，如果我们更多的去关注处理这些障碍问题，可能就会忽视了本来应该关注的业务逻辑问题，Proxy模式有助于我们去解决这些问题。我们以一个简单的数学计算程序为例，这个程序只负责进行简单的加减乘除运算：
  1. public class Math
  2. {
  3.     public double Add(double x,double y)
  4.     {
  5.         return x + y;
  6.     }
  8.     public double Sub(double x,double y)
  9.     {
  10.         return x - y;
  11.     }
  13.     public double Mul(double x,double y)
  14.     {
  15.         return x * y;
  16.     }
  18.     public double Dev(double x,double y)
  19.     {
  20.         return x / y;
  21.     }
  22. }

如果说这个计算程序部署在我们本地计算机上，使用就非常之简单了，我们也就不用去考虑Proxy模式了。但现在问题是这个Math类并没有部署在我们本地，而是部署在一台服务器上，也就是说Math类根本和我们的客户程序不在同一个地址空间之内，我们现在要面对的是跨越Internet这样一个网络障碍：
P13.代理模式-Proxy--Structure - 图3
这时候调用Math类的方法就没有下面那么简单了，因为我们更多的还要去考虑网络的问题，对接收到的结果解包等一系列操作。

  1. public class App
  2. {
  3.     public static void Main()
  4.     {
  5.         Math math = new Math();
  7.         // 对接收到的结果数据进行解包
  9.         double addresult = math.Add(2,3);
  11.         double subresult = math.Sub(6,4);
  13.         double mulresult = math.Mul(2,3);
  15.         double devresult = math.Dev(2,3);
  16.     }
  17. }

为了解决由于网络等障碍引起复杂性，就引出了Proxy模式，我们使用一个本地的代理来替Math类打点一切，即为我们的系统引入了一层间接层，示意图如下：
P13.代理模式-Proxy--Structure - 图4
我们在MathProxy中对实现Math数据类的访问，让MathProxy来代替网络上的Math类，这样我们看到MathProxy就好像是本地Math类，它与客户程序处在了同一地址空间内：

  1. public class MathProxy
  2. {
  3.     private Math math = new Math();
  5.     // 以下的方法中，可能不仅仅是简单的调用Math类的方法
  7.     public double Add(double x,double y)
  8.     {
  9.         return math.Add(x,y);
  10.     }
  12.     public double Sub(double x,double y)
  13.     {
  14.         return math.Sub(x,y);
  15.     }
  17.     public double Mul(double x,double y)
  18.     {
  19.         return math.Mul(x,y);
  20.     }
  22.     public double Dev(double x,double y)
  23.     {
  24.         return math.Dev(x,y);
  25.     }
  26. }
  1. 现在可以说我们已经实现了对Math类的代理，存在的一个问题是我们在MathProxy类中调用了原实现类Math的方法，但是Math并不一定实现了所有的方法，为了强迫Math类实现所有的方法，另一方面，为了我们更加透明的去操作对象，我们在Math类和MathProxy类的基础上加上一层抽象，即它们都实现与IMath接口，示意图如下：
  3.     ![](https://cdn.nlark.com/yuque/0/2021/jpeg/446847/1615447287419-6af1a34e-f2f5-428b-aece-b76ba3f152ee.jpeg#align=left&display=inline&height=228&margin=%5Bobject%20Object%5D&originHeight=228&originWidth=493&size=0&status=done&style=none&width=493)<br />
  1. public interface IMath
  2. {
  3.     double Add(double x,double y);
  5.     double Sub(double x,double y);
  7.     double Mul(double x,double y);
  9.     double Dev(double x,double y);
  10. }
  12. Math类和MathProxy类分别实现IMath接口：
  14. public class MathProxy : IMath
  15. {
  16.     //
  17. }
  19. public class Math : IMath
  20. {
  21.     //
  22. }

此时我们在客户程序中就可以像使用Math类一样来使用MathProxy类了：

  1. public class App
  2. {
  3.     public static void Main()
  4.     {
  5.         MathProxy proxy = new MathProxy();
  7.         double addresult = proxy.Add(2,3);
  9.         double subresult = proxy.Sub(6,4);
  11.         double mulresult = proxy.Mul(2,3);
  13.         double devresult = proxy.Dev(2,3);
  14.     }
  15. }

到这儿整个使用Proxy模式的过程就完成了，回顾前面我们的解决方案，无非是在客户程序和Math类之间加了一个间接层，这也是我们比较常见的解决问题的手段之一。另外，对于程序中的接口Imath，并不是必须的，大多数情况下，我们为了保持对对象操作的透明性，并强制实现类实现代理类所要调用的所有的方法，我们会让它们实现与同一个接口。但是我们说代理类它其实只是在一定程度上代表了原来的实现类，所以它们有时候也可以不实现于同一个接口。

代理模式实现要点：

  1. 远程（Remote）代理：为一个位于不同的 地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是在本机器中，也可是在另一台机器中。远程代理又叫做大使（Ambassador）。好处是系统可以将网络的细节隐藏起来，使得客户端不必考虑网络的存在。客户完全可以认为被代理的对象是局域的而不是远程的，而代理对象承担了大部份的网络通讯工作。由于客户可能没有意识到会启动一个耗费时间的远程调用，因此客户没有必要的思想准备。
  2. 虚拟（Virtual）代理：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建。使用虚拟代理模式的好处就是代理对象可以在必要的时候才将被代理的对象加载；代理可以对加载的过程加以必要的优化。当一个模块的加载十分耗费资源的情况下，虚拟代理的好处就非常明显。
  3. Copy-on-Write代理：虚拟代理的一种。把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。
  4. 保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。保护代理的好处是它可以在运行时间对用户的有关权限进行检查，然后在核实后决定将调用传递给被代理的对象。
  5. Cache代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
  6. 防火墙（Firewall）代理：保护目标，不让恶意用户接近。
  7. 同步化（Synchronization）代理：使几个用户能够同时使用一个对象而没有冲突。
  8. 智能引用（Smart Reference）代理：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。
  • 本文作者：GeekPower - Felix Sun
  • 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！