当前位置：首页 > PHP教程 > php高级应用 > 列表

一文读懂php设计模式之代理模式

发布:smiling　来源: PHP粉丝网 　添加日期：2022-07-19 11:48:34　浏览: 评论：0　

代理模式属于结构性设计模式，针对类与对象组合在一起的经典结构。代理模式也是一种使用较多的设计模式，需要我们重点掌握，他可以在不改变目标对象的情况下，添加一些额外的功能。

定义

代理模式（Proxy）为其他对象提供一种代理以控制对这个对象的访问。使用代理模式创建代理对象，让代理对象控制目标对象的访问（目标对象可以是远程的对象、创建开销大的对象或需要安全控制的对象），并且可以在不改变目标对象的情况下添加一些额外的功能。

问题

目前系统关于用户登录注册的业务，有一个Login类。伪代码如下：

  1. class UserLogin 
  2.  
  3. { 
  4.  
  5.     // …… 省略属性和部分方法 
  6.  
  7.       
  8.  
  9.     public function login ($name, $pass) 
  10.  
  11.     { 
  12.  
  13.         // 登录业务 
  14.  
  15.     } 
  16.  
  17.       
  18.  
  19.     public function reg ($name, $pass) 
  20.  
  21.     { 
  22.  
  23.         // 注册业务 
  24.  
  25.     } 
  26.  
  27. } 

现在，我们想在用户登录和注册的业务中添加一个功能——限流，让客户端调用该方法的频次限制在一秒钟最多5次。现在，我们来实现该功能，伪代码如下：

  1. class UserLogin 
  2.  
  3. { 
  4.  
  5.     // …… 省略属性和部分方法 
  6.  
  7.       
  8.  
  9.     public function login ($name, $pass) 
  10.  
  11.     { 
  12.  
  13.         // 限流 
  14.  
  15.         $limit = new Limit(); 
  16.  
  17.         if ($limit->restrict()) { 
  18.  
  19.             // …… 
  20.  
  21.         } 
  22.  
  23.           
  24.  
  25.         // 登录业务 
  26.  
  27.     } 
  28.  
  29.       
  30.  
  31.     public function reg ($name, $pass) 
  32.  
  33.     { 
  34.  
  35.         // 限流 
  36.  
  37.         $limit = new Limit(); 
  38.  
  39.         if ($limit->restrict()) { 
  40.  
  41.             // …… 
  42.  
  43.         } 
  44.  
  45.           
  46.  
  47.         // 注册业务 
  48.  
  49.     } 
  50.  
  51. } 

大家看看上面的代码，它有几个问题，首先，限流代码侵入到业务代码中，跟业务代码高度耦合。其次，限流和业务代码无关，违背单一职责原则。

实现

接下来，我们用代理模式重写上面的代码，重写后的代码如下所示：

  1. interface IUserLogin 
  2.  
  3. { 
  4.  
  5.     function login (); 
  6.  
  7.     function register (); 
  8.  
  9. } 
  10.  
  11.  
  12.  
  13. class UserLogin implements IUserLogin 
  14.  
  15. { 
  16.  
  17.     // …… 省略属性和部分方法 
  18.  
  19.       
  20.  
  21.     public function reg ($uname, $pass) 
  22.  
  23.     { 
  24.  
  25.         // 注册业务 
  26.  
  27.     } 
  28.  
  29.       
  30.  
  31.     public function login ($uname, $pass) 
  32.  
  33.     { 
  34.  
  35.         // 登录业务 
  36.  
  37.     } 
  38.  
  39. } 
  40.  
  41.  
  42.  
  43. class UserLoginProxy implements IUserLogin 
  44.  
  45. { 
  46.  
  47.     private $limit = null; 
  48.  
  49.     private $login = null; 
  50.  
  51.       
  52.  
  53.     public function __construct(Limit $limit, Login $login) 
  54.  
  55.     { 
  56.  
  57.         $this->limit = $limit; 
  58.  
  59.         $this->login = $login; 
  60.  
  61.     } 
  62.  
  63.       
  64.  
  65.     public function login($uname, $pass) 
  66.  
  67.     { 
  68.  
  69.         if ($this->limit->restrict()) { 
  70.  
  71.             // ... 
  72.  
  73.         } 
  74.  
  75.         return $this->login->login($uname, $pass); 
  76.  
  77.     } 
  78.  
  79.       
  80.  
  81.     public function register($uname, $pass) 
  82.  
  83.     { 
  84.  
  85.         if ($this->limit->restrict()) { 
  86.  
  87.             // ... 
  88.  
  89.         } 
  90.  
  91.         return $this->login->register($uname, $pass); 
  92.  
  93.     } 
  94.  
  95. } 

上面的方法是基于接口而非实现编程的设计思想，但如果原始类并没有定义接口，或者这个类并不是我们开发和维护的，那么要怎么实现代理模式呢？

对于这种外部类的扩展，我们一般采用继承的方法来实现。

  1. class UserLogin 
  2.  
  3. { 
  4.  
  5.     public function reg ($uname, $pass) 
  6.  
  7.     { 
  8.  
  9.         // 注册业务 
  10.  
  11.     } 
  12.  
  13.       
  14.  
  15.     public function login ($uname, $pass) 
  16.  
  17.     { 
  18.  
  19.         // 登录业务 
  20.  
  21.     } 
  22.  
  23. } 
  24.  
  25.  
  26.  
  27. class UserLoginProxy extends Login 
  28.  
  29. { 
  30.  
  31.     private $limit = null; 
  32.  
  33.       
  34.  
  35.     public function __construct(Limit $limit, Login $login) 
  36.  
  37.     { 
  38.  
  39.         $this->limit = $limit; 
  40.  
  41.         $this->login = $login; 
  42.  
  43.     } 
  44.  
  45.       
  46.  
  47.     public function login($uname, $pass) 
  48.  
  49.     { 
  50.  
  51.         if ($this->limit->restrict()) { 
  52.  
  53.             // ... 
  54.  
  55.         } 
  56.  
  57.         return parent::login($uname, $pass); 
  58.  
  59.     } 
  60.  
  61.       
  62.  
  63.     public function reg($uname, $pass) 
  64.  
  65.     { 
  66.  
  67.         if ($this->limit->restrict()) { 
  68.  
  69.             // ... 
  70.  
  71.         } 
  72.  
  73.         return parent::register($uname, $pass); 
  74.  
  75.     } 
  76.  
  77. } 

大家看看上面的代码，是不是还有什么问题？你会发现

  1. if ($this->limit->restrict()) { 
  2.  
  3.     // ... 
  4.  
  5. } 

这段相似的代码，出现了两次。现在我们只是给两个方法添加了限流功能，如果UserLogin类有10个方法，每个方法我们都想要添加限流的功能，那么我们就需要重复复制10次该段代码。如果，我们想要给10给类中所有方法都添加限流功能，每个类中都有10个方法，那么上面的限流代码将会重复100次。

当然，你会说我可以将限流的代码封装到一个函数里不就解决了上述问题么？但还有一个问题解决不了，原始类里每个方法在代理类中都要重新实现一遍。就像上面原始类里有reg、login方法，代理类里也有reg、login方法。

动态代理

如何解决上述的问题，我们可以借助动态代理来解决。想要使用动态代理，就要理解并使用PHP中的反射机制。

php具有完整的反射 API，添加了对类、接口、函数、方法和扩展进行反向工程的能力。 此外，反射 API 提供了方法来取出函数、类和方法中的文档注释。关于php的反射相关知识，这里就不详述了，大家可以自行查阅相关信息。

注意，使用反射对性能消耗很大，一般情况下请不要使用。

下面我们来展示如何用反射实现动态代理，伪代码如下：

  1. class UserLogin 
  2.  
  3. { 
  4.  
  5.     public function reg ($uname, $pass) 
  6.  
  7.     { 
  8.  
  9.         // 注册业务 
  10.  
  11.         echo '注册业务' . PHP_EOL; 
  12.  
  13.     } 
  14.  
  15.     public function login ($uname, $pass) 
  16.  
  17.     { 
  18.  
  19.         // 登录业务 
  20.  
  21.         echo '登录业务' . PHP_EOL; 
  22.  
  23.     } 
  24.  
  25. } 
  26.  
  27. class LimitProxy 
  28.  
  29. { 
  30.  
  31.     // 用来保存多个实例对象 
  32.  
  33.     private $target = []; 
  34.  
  35.     public function __construct(Object $obj) 
  36.  
  37.     { 
  38.  
  39.         $this->target[] = $obj; 
  40.  
  41.     } 
  42.  
  43.     public function __call($name, $arguments) 
  44.  
  45.     { 
  46.  
  47.         foreach ($this->target as $obj) { 
  48.  
  49.             $ref = new \ReflectionClass($obj); 
  50.  
  51.             if ($method = $ref->getMethod($name)) { 
  52.  
  53.                 if ($method->isPublic() && !$method->isAbstract()) { 
  54.  
  55.                     // 限流 
  56.  
  57.                     echo "这里是限流业务处理" . PHP_EOL; 
  58.  
  59.                     $result = $method->isStatic() ? $method->invoke(null, $obj, ...$arguments) : $method->invoke($obj, ...$arguments); 
  60.  
  61.                     return $result; 
  62.  
  63.                 } 
  64.  
  65.             } 
  66.  
  67.         } 
  68.  
  69.     } 
  70.  
  71. } 

测试代码如下：

  1. $login = new Login(); 
  2.  
  3. $loginProxy = new LimitProxy($login); 
  4.  
  5. $loginProxy->reg('gwx', '111111'); 
  6.  
  7. $loginProxy->login('james', '111111111'); 

应用场景

访问控制 （保护代理）。 比如系统有一个订单的模块，原本该模块也有权限控制，但现在我们希望只针对指定ip的客户端可以访问，那么我们可以使用代理模式。

本地执行远程服务 （远程代理）适用于服务对象位于远程服务器上的情形。

在业务代码中开发一些非功能性的需求，比如：限流、统计、日志记录

缓存方面的应用，比如添加一个缓存代理，当缓存存在时，就调用缓存代理获取缓存的数据，当缓存不存在时，就调用原始接口。

Tags: php设计模式 php代理模式

分享到：

相关文章

推荐文章

热门文章

最新评论文章