对一个链表类的研究分析

<?php
/**
 * 用一系列类试图处理一个请求request,
 * 这些类之间是一个松散的耦合,
 * 唯一共同点是在他们之间传递request
 */

/**
 *handler接口
 */
interface handler{
    /**
     * 执行请求处理
     *
     * @param request $_todo
     */
    public function exec(request $_todo);
  
    /**
     * 指定下一个处理者
     *
     * @param handler $_next
     */
    public function next(handler $_next);
}

/**
 * 定义一个request对象
 *
 */
interface request{
    public function exec();
}

/**
 * 定义一仲请求 --code 代码编写
 *
 */
class requestCode implements request{
    public function exec(){
        echo "toCode";
    }
}

/**
 * 定义一仲请求 --design 程序设计
 *
 */
class requestDesign implements request{
    public function exec(){
        echo "toDesign";
    }
}

/**
 * 定义一种“代码编写"这个请求的处理方法
 *
 */
class toCode implements handler{
    private $_next = null;
    /**
     * 设定下一个处理者
     *
     * @param handler $_next
     */
    public function next(handler $_next){ //diaoyong handler jiekou xia de $next bianliang
        $this->_next = $_next;
    }
  
    /**
     * 处理具体请求
     *
     * @param request $_todo
     */
    public function exec(request $_todo){
        /**
         * 处理特定的请求
         * 如果对象不能处理 则交付给下一个对象处理
         * 如本例是处理requestCode类型的请求 如果$_todo是requestCode的实例的话则执行处理，不是的话交给下一个
         */
        if($_todo instanceof requestCode){
            echo "程序编写";
            $_todo->exec();
        }elseif(null != $this->_next){
            $this->_next->exec($_todo);
        }
    }
}

/**
 * 定义一种“程序设计"这个请求的处理方法
 *
 */
class toDesign implements handler {
    private $_next = null;
    public function next(handler $_next){
        $this->_next = $_next;
    }
  
    public function exec(request $_todo){
        if($_todo instanceof requestDesign){
            echo "程序设计";
            $_todo->exec();
        }elseif(null != $this->_next){
            $this->_next->exec($_todo);
        }
    }
}

/**
 * 测试
 *
 */
class test{
    public function run(){
        /**
         * 实例化一个code
         */
        $code   = new toCode();
      
        /**
         * 实例化一个desgin
         */
        $design = new toDesign();
      
        /**
         * 当然 首先设计，设计完干吗？编写代码！
         */
        $design->next($code);
        print_r($design);
      
      
        /**
         * 放入一个请求
         * 请求是代码编写
         * 所以会由toCode的实例执行并跳出职责连
         */
        $design->exec(new requestCode());
        $design->exec(new requestDesign());
    }
}

$test = new test();
$test->run();


/*流程分析:
STEP1: $test=new test(), $test->run()(创建了两个实例: $code(as toCode), $design(as toDesign)
Step2: $design->next($code) (执行toDesign->next 方法,使$design->next=$code
Step3: $design->exec(new requestCode())
  1: new requestCode() (实例化 requestCode, 假设as $a)
  2. $design->exec($a) (执行toDesign->exec($a),
  3. 因为(! ($a instanceof requestDesign)) 所以执行$design->next->exec($a), $design->next即$code
  4. $code->exec($a) 因为($a instanceof requestCode), echo '程序编写', $a->exec() (echo 'toCode')
Step4:  $design->exec(new requestDesign())
  1. $b=new requestDesign()
  2. $design->exec($b)
  3. echo '程序设计', $b->exec(), echo 'toDesign'*/

/* 模式思想：
职责链 模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。如果可以，该请求被处理，或进程停止。您可以为系统添加或移除处理程序，而不影响其他处理程序。

     例如：如果A?〉B?〉C都可以处理请求，按照这个顺序，A处理请求或者在不知B是否可以处理这个请求的情况下递给B。接受到请求的B可以处理这个请求或者传递给C。
当C收到请求时，这个请求可以被C处理或者没有经过任何处理而结束。换句话说，提交的处理链表中的请求在到达链表尾前，可以不被任何处理。＊／

/* class toCode: function next设置内置下一步的链接 this->next,
                 function exec 根据传递的class类型确定下一步的动作，如果符合条件则执行，否则选择下一步的链接执行 （same as class to Design)
class test: $design=new toDesign() 实例化
            $design->next($code)设定$code为链表的下一步
            $design->exec(new requestCode())通过传递requestCode对象变量决定下一步的动作 */