php设计模式 Strategy(策略模式)

抽象策略(Strategy）角色：定义所有支持的算法的公共接口。通常是以一个接口或抽象来实现。Context使用这个接口来调用其ConcreteStrategy定义的算法。

具体策略(ConcreteStrategy)角色：以Strategy接口实现某具体算法。

环境(Context)角色：持有一个Strategy类的引用，用一个ConcreteStrategy对象来配置

核心代码

    <?php
    interface Strategy { // 抽象策略角色，以接口实现
      public function algorithmInterface(); // 算法接口
    }

    class ConcreteStrategyA implements Strategy { // 具体策略角色A 
      public function algorithmInterface() {}
    }

    class ConcreteStrategyB implements Strategy { // 具体策略角色B 
      public function algorithmInterface() {}
    }

    class ConcreteStrategyC implements Strategy { // 具体策略角色C
      public function algorithmInterface() {}
    }

    class Context { // 环境角色
      private $_strategy;
      public function __construct(Strategy $strategy) {
        $this->_strategy = $strategy;
      } 
      public function contextInterface() {
        $this->_strategy->algorithmInterface();
      }
    }

    // client
    $strategyA = new ConcreteStrategyA();
    $context = new Context($strategyA);
    $context->contextInterface();

    $strategyB = new ConcreteStrategyB();
    $context = new Context($strategyB);
    $context->contextInterface();

    $strategyC = new ConcreteStrategyC();
    $context = new Context($strategyC);
    $context->contextInterface();

其他代码

    <?php 
    /** 
    * 策略模式(Strategy.php) 
    * 
    * 定义一系列算法,把它们一个个封装起来,并且使它们可相互替换,使用得算法的变化可独立于使用它的客户 
    * 
    */ 

    // ---以下是一系列算法的封闭---- 
    interface CacheTable 
    { 
    public function get($key); 
    public function set($key,$value); 
    public function del($key); 
    } 

    // 不使用缓存 
    class NoCache implements CacheTable 
    { 
    public function __construct(){ 
    echo "Use NoCache<br/>"; 
    } 

    public function get($key) 
    { 
    return false; 
    } 

    public function set($key,$value) 
    { 
    return true; 
    } 

    public function del($key) 
    { 
    return false; 
    } 
    } 

    // 文件缓存 
    class FileCache implements CacheTable 
    { 
    public function __construct() 
    { 
    echo "Use FileCache<br/>"; 
    // 文件缓存构造函数 
    } 

    public function get($key) 
    { 
    // 文件缓存的get方法实现 
    } 

    public function set($key,$value) 
    { 
    // 文件缓存的set方法实现 
    } 

    public function del($key) 
    { 
    // 文件缓存的del方法实现 
    } 
    } 

    // TTServer 
    class TTCache implements CacheTable 
    { 
    public function __construct() 
    { 
    echo "Use TTCache<br/>"; 
    // TTServer缓存构造函数 
    } 

    public function get($key) 
    { 
    // TTServer缓存的get方法实现 
    } 

    public function set($key,$value) 
    { 
    // TTServer缓存的set方法实现 
    } 

    public function del($key) 
    { 
    // TTServer缓存的del方法实现 
    } 
    } 

    // -- 以下是使用不用缓存的策略 ------ 
    class Model 
    { 
    private $_cache; 
    public function __construct() 
    { 
    $this->_cache = new NoCache(); 
    } 

    public function setCache($cache) 
    { 
    $this->_cache = $cache; 
    } 
    } 

    class UserModel extends Model 
    { 
    } 

    class PorductModel extends Model 
    { 
    public function __construct() 
    { 
    $this->_cache = new TTCache(); 
    } 
    } 

    // -- 实例一下 --- 
    $mdlUser = new UserModel(); 
    $mdlProduct = new PorductModel(); 
    $mdlProduct->setCache(new FileCache()); // 改变缓存策略 
    ?>

具体的大家可以多关注一下脚本之家以前发布的文章