PHP设计模式之委托模式（Delegation）了解下

ゝ一世哀愁。 2022-05-10 11:36 125阅读 0赞

这个委托模式呢，就是通过分配或委托其他对象，它能够去除核心对象中的判决和复杂的功能性。来看一个经典的应用场景：

> 1.  设计了一个cd类，类中有mp3播放模式，和mp4播放模式
> 2.  改进前，使用cd类的播放模式，需要在实例化的类中去判断选择什么方式的播放模式
> 3.  改进后，播放模式当做一个参数传入playList函数中，就自动能找到对应需要播放的方法。

来看下未改进之前的cd类，这时候选择播放模式是一种痛苦的事情，如下：

<?php
    //委托模式-去除核心对象中的判决和复杂的功能性
    //使用委托模式之前，调用cd类，选择cd播放模式是复杂的选择过程
    class cd {
    	protected $cdInfo = array(); 
    	
    	public function addSong($song) {
    		$this->cdInfo[$song] = $song;
    	}
    	
    	public function playMp3($song) {
    		return $this->cdInfo[$song] . '.mp3';
    	}
    	
    	public function playMp4($song) {
    		return $this->cdInfo[$song] . '.mp4';
    	}
    }
    $oldCd = new cd;
    $oldCd->addSong("1");
    $oldCd->addSong("2");
    $oldCd->addSong("3");
    $type = 'mp3';
    if ($type == 'mp3') {
    	$oldCd->playMp3();
    } else {
    	$oldCd->playMp4();
    }

接下来，通过委托模式，改进cd类，如下：

<?php
    //委托模式-去除核心对象中的判决和复杂的功能性
    //改进cd类
    class cdDelegate {
    	protected $cdInfo = array(); 
    	
    	public function addSong($song) {
    		$this->cdInfo[$song] = $song;
    	}
    	
    	public function play($type, $song) {
    		$obj = new $type;
    		return $obj->playList($this->cdInfo, $song);
    	}
    }
     
    class mp3 {
    	public function playList($list) {
    		return $list[$song];
    	}
    }
     
    class mp4 {
    	public function playList($list) {
    		return $list[$song];
    	}
    }
     
    $newCd = new cd;
    $newCd->addSong("1");
    $newCd->addSong("2");
    $newCd->addSong("3");
    $type = 'mp3';
    $oldCd->play('mp3', '1'); //只要传递参数就能知道需要选择何种播放模式

来看另外一个实例：

class Bank{
        protected $info;
    
        /*
        设置基本信息
        @param string $type 类型。例如"RMB"
        @param int $money 利率。例如"0.4%"
        */
        public function updateBrankInfo($type,$money){
            $this->info[$type]=$money;
        }
    
        /*
        相关操作（包括存款、取款操作）
        @param int $branktype  操作类型
        */
        public function brankWithdraw($branktype){
            $obj=new $branktype;
            return $obj->brankMain($this->info);
        }
    }
    /*
    委托接口
    */
    interface Delegate{
        /*
        操作方法：
        实现该接口必须实现的方法
        */
        public function brankMain($info);
    }
    
    /*
    存款操作类
    */
    class brankDeposit implements Delegate{
        /*
        存款操作
        */
        public function brankMain($info){
            echo $info['deposit'];
        }
    } 
    
    /*
    取款操作类
    */
    class brankWithdraw implements Delegate{
        /*
        取款操作
        */
        public function brankMain($info){
            echo $info['withdraw'];
        }
    }
    /*
    客户端测试代码：
    */
    $bank=new Bank();
    $bank->updateBrankInfo("deposit","4000");
    $bank->updateBrankInfo("withdraw","2000");
    $bank->brankWithdraw("brankDeposit");
    echo "<br>";
    $bank->brankWithdraw("brankWithdraw");

在传统方式下，我们需要判断当前操作是取款操作还是存款操作，然后就要分别调用Bank类中的取款操作和存款操作，但是，在委托模式下，我们将不需要客户端的判断操作，对客户端来说，需要什么操作，直接传入操作类型即可，Bank类可自动判断操作类型，返回相应操作的操作结果。

当我们的操作类型非常多的时候，在客户端用if else判断无疑是很可怕的，再假如我们在很多地方都要有这块判断代码，我们需要对这些地方的判断代码都进行修改(加入后来添加的判断)，而采用委托模式，我们仅仅需要在新添加的地方添加相应需要的类型即可，不需要改动其它地方的客户端代码(很大程度上提高了代码的复用性)。

我们要知道，这个委托模式，它是软件设计模式中的一项基本技巧，在这个模式中，有两个对象参与处理同一个请求，然后，接受请求的对象将请求委托给另一个对象来处理。现在许多其他的模式,如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。

在这个委托模式之后，还有一个动态委托的概念，它来自于Jakarta 字节码工程库 (Byte-Code Engineering Library, BCEL)，这个动态委托能够分析存在的类,并且对于接口,抽象类,甚至运行时的具体类来说,它能够生成以字节编码委托类。不过，动态委托最多只能委托一个类,但是能够代理多个接口。

上述限制来自于Java的单继承模式，也就是一个Java类最多只有一个父类。

既然生成的委托类把被委托类作为它的父类,那么指定多个被委托类是不合理的。如果没有指定被委托类,那么缺省的父类就是Object。

我们来看下根据PHP 反射机制实现动态代理的实例：

<?php
    class Fruit
    {
      function callFruit()
      {
        print "Generate an Apple";
      }
    }
    class FruitDelegator
    {
     private $targets;
      function __construct()
      {
        $this->target[] = new Fruit();
      }
      
      function __call($name, $args)
      {
        foreach ($this->target as $obj)
        {
          $r = new ReflectionClass($obj);
          if ($method = $r->getMethod($name))
          {
            if ($method->isPublic() && !$method->isAbstract())
            {
              return $method->invoke($obj, $args);
            }
          }
        }
      }
    }
    $obj = new FruitDelegator();
    $obj->callFruit();
    // 运行结果
    // Generate an Apple
    ?>

上述代码主要是通过代理类FruitDelegator来代替Fruit类来实现他的办法，在来看另外一个类似的代码：

<?php
    class Color
    {
      function callColor()
      {
        print "Generate Red";
      }
    }
     
    class ColorDelegator
    {
      private $targets;
       
      function addObject($obj)
      {
        $this->target[] = $obj;
      }
       
      function __call($name, $args)
      {
        foreach ($this->target as $obj)
        {
          $r = new ReflectionClass($obj);
          if ($method = $r->getMethod($name))
          {
            if ($method->isPublic() && !$method->isAbstract())
            {
              return $method->invoke($obj, $args);
            }
          }
        }
      }
    }
    $obj = new ColorDelegator();
    $obj->addObject(new Color());
    $obj->callColor();
    ?>

好啦，本次记录就到这里了。

如果感觉不错的话，请多多点赞支持哦。。。