观察者模式和职责链模式(PHP)

观察者模式

又可以称之为发布-订阅模式，是指在对象之间定义一个一对多的依赖关系，当（一个）被依赖的对象状态发生改变的时候，自动通知（多个）所有依赖它的对象去执行相应的处理逻辑，这个处理可以是同步的，也可以是异步的。

使用场景：一个对象的改变会导致其他对象发生变化，例如：
1、新用户注册成功后，需要执行给用户发送系统通知、发送促销信息、自动签到逻辑等多个操作。
2、订单支付成功后，需要有记录操作日志、推送物流系统、发送短信通知、赠送优惠券、推送其他优惠信息等多套处理。

//接口定义
interface Subject{
    public function registerObserver(Observer $observer) ;
    public function removeObserver(Observer $observer) ;
    public function notifyObserver(Message $message) ;
}
interface Observer{
    public function update(Message $message) ;
}
//定义观察者一
class ConCreateObserverOne implements Observer {
    public function update(Message $message) {
        //TODO 获取消息通知，执行自己的逻辑处理
        echo "ConCreateObserverOne is notified~\r\n" ;
    }
}
//定义观察者二
class ConCreateObserverTwo implements Observer {
    public function update(Message $message) {
        //TODO 获取消息通知，执行自己的逻辑处理
        echo "ConCreateObserverTwo is notified~\r\n" ;
    }
}
//观察者模式主体实现
class ConcreateSubject implements Subject {
    //观察者集合
    private $observers = [] ;
    //注册观察者
    public function registerObserver(Observer $observer){
        $this->observers[] = $observer ;
    }
    //移除观察者
    public function removeObserver(Observer $observer){
        foreach ($this->observers as $key => $item) {
            if ($item == $observer) {
                unset($this->observers[$key]) ;
                return true ;
            }
        }
        return false ;
    }
    //通知观察者
    public function notifyObserver(Message $message){
        foreach($this->observers as $item) {
            $item->update($message) ;
        }
    }
}
//发生变更
class Message{
    //TODO
}
//Demo
$subject = new ConcreateSubject() ;
$subject->registerObserver(new ConCreateObserverOne());
$subject->registerObserver(new ConCreateObserverTwo()) ;
$subject->notifyObserver(new Message()) ;

职责链模式

将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求，这些接收请求的对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。
如果处理器链上的某个处理器能够处理这个请求，那就不再继续往下传递请求了。在实际使用上，还有一种变体，那就是请求会被所有的处理器都处理一遍，不在中途终止。
使用场景：
1、框架中HTTP请求的拦截处理，需实现一串的处理逻辑，如鉴权、限流、参数验证等。
2、UGC系统中的敏感词过滤功能，需要处理常规敏感词库、特殊敏感词库、临时敏感词库等多套词库处理的情况。

在实现上有链表和数组这两种常用方式。链表方式的实现：

//定义处理器
abstract class Handler {
    protected $next = null ;
    public function setNext($next) {
        $this->next = $next ;
    }
    //结合模板模式合并处理器中通用的if逻辑判断
    public final function handle() {
        $handled = $this->dohandle() ;
        //链条中的处理器有返回true的则停止执行，这个判断也可以去掉
        if (!$handled && $this->next != null ) {
            $this->next->handle() ;
        }
    }
    public abstract function dohandle() ;
}
class HandlerA extends Handler {
    public function dohandle() {
        $handled = false ;
        //@TODO
        echo "HandlerA success~~~ \r\n" ;
        return $handled ;
    }
}
class HandlerB extends Handler {
    public function dohandle() {
        $handled = false ;
        //@TODO
        echo "HandlerB success~~~ \r\n" ;
        return $handled ;
    }
}
//职责链模式主体实现
class HandlerChain {
    private $head = null ;
    private $tail = null ;
    //添加处理器
    public function addHandler($handler) {
        $handler->setNext(null) ;
        if ($this->head == null) {
            $this->head = $handler ;
            $this->tail = $handler ;
            return true ;
        }
        $this->tail->setNext($handler) ;
        $this->tail = $handler ;
    }
    //执行链条对象的处理
    public function handle() {
        if ($this->head != null) {
            $this->head->handle() ;
        }
    }
}
//使用
class Application {
    public function main() {
        $chain = new Handlerchain() ;
        $chain->addHandler(new HandlerA()) ;
        $chain->addHandler(new HandlerB()) ;
        return $chain->handle() ;
    }
}
$demo = new Application() ;
$demo->main() ;

数组方式的实现：

//定义处理器
interface Ihandler {
    public function handle() ;
}
class HandlerA implements Ihandler {
    public function handle() {
        $handled = false ;
        //@TODO
        echo "HandlerA success~~~ \r\n" ;
        return $handled ;
    }
}
class HandlerB implements Ihandler {
    public function handle() {
        $handled = true ;
        //@TODO
        echo "HandlerB success~~~ \r\n" ;
        return $handled ;
    }
}
//职责链模式主体实现
class HandlerChain {
    private $handlers = [] ;
    public function addHandler($handler) {
        $this->handlers[] = $handler ;
    }
    public function handle() {
        foreach ($this->handlers as $handler) {
            $handled = $handler->handle() ;
            //设置职责链中的处理器，符合其一则退出执行，让handle() 返回ture 
            if ($handled) {
                break ;
            }
        }
    }
}
//使用同上~~~

观察者和职责链模式的区别

两者都属于行为型设计模式，目的是将不同的行为代码解耦，在观察者模式里，是将观察者和被观察者的代码解耦。在职责链模式里，是将不同的职责类逻辑解耦。

对比逻辑图.png

其实，我觉得从实现上，两者没啥大的区别，都是添加多个处理类，然后挨个去执行，主要是适合的使用场景不一样。
职责链模式是按职责链上的类顺序同步阻塞执行，职责链上的职责类可以不放行，符合条件的职责类处理后，后面的不再执行；观察者模式则是需要挨个都通知到，可以同步也可以异步执行（外部队列处理之类）。