观察者模式
又可以称之为发布-订阅模式，是指在对象之间定义一个一对多的依赖关系，当（一个）被依赖的对象状态发生改变的时候，自动通知（多个）所有依赖它的对象去执行相应的处理逻辑，这个处理可以是同步的，也可以是异步的。
使用场景：一个对象的改变会导致其他对象发生变化，例如：
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
其实，我觉得从实现上，两者没啥大的区别，都是添加多个处理类，然后挨个去执行，主要是适合的使用场景不一样。
职责链模式是按职责链上的类顺序同步阻塞执行，职责链上的职责类可以不放行，符合条件的职责类处理后，后面的不再执行；观察者模式则是需要挨个都通知到，可以同步也可以异步执行（外部队列处理之类）。
