es6 class中责任链模式与AOP结合

责任链模式大家应该都清楚，比如JS中的冒泡，Java中的拦截器、过滤器，都运用到了责任链模式。

可以看我之前的文章介绍责任链的：https://www.cnblogs.com/wuguanglin/p/ChainofResponsibilityPattern.html

我们在遇到一个请求，经过多个节点处理的时候就可以考虑使用责任链模式降低代码耦合度。

纯责任链模式

在es6 class语法下，我们可能会写出下面这样的代码：

'use strict';
 
class HandlerFactory {
  createHandler() {
    const aaa = new AaaHandler();
    const bbb = new BbbHandler();
    const ccc = new CccHandler();
    const ddd = new DddHandler();
    const eee = new EeeHandler();
    aaa.setNext(bbb);
    bbb.setNext(ccc);
    ccc.setNext(ddd);
    ddd.setNext(eee);
    return aaa;
  }
}
 
class Handler {
  setNext(_handler) {
    this.nextHandler = _handler;
  }
  handleMsg(msg) {}
}
class AaaHandler extends Handler {
  handleMsg(msg) {
    if (msg < 0.2) {
      console.log('AaaHandler处理了：' + msg);
    } else {
      this.nextHandler.handleMsg(msg);
    }
  }
}
 
class BbbHandler extends Handler {
  handleMsg(msg) {
    if (msg < 0.3) {
      console.log('BbbHandler处理了：' + msg);
    } else {
      this.nextHandler.handleMsg(msg);
    }
  }
}
 
class CccHandler extends Handler {
  handleMsg(msg) {
    if (msg < 0.5) {
      console.log('CccHandler处理了：' + msg);
    } else {
      this.nextHandler.handleMsg(msg);
    }
  }
}
 
class DddHandler extends Handler {
  handleMsg(msg) {
    if (msg < 0.6) {
      console.log('DddHandler处理了：' + msg);
    } else {
      this.nextHandler.handleMsg(msg);
    }
  }
}
 
class EeeHandler extends Handler {
  handleMsg(msg) {
    if (msg < 0.8) {
      console.log('EeeHandler处理了：' + msg);
    } else {
      console.log('没有handler可以处理了：' + msg);
    }
  }
}
 
const handlerFactory = new HandlerFactory();
const handler = handlerFactory.createHandler();
handler.handleMsg(Math.random());
 

代码的大概意思就是构建了一个msg处理链。但是我们可以看到这种实现方式还是觉得有点不太完美，不完美的地方在哪呢？

就是在于不断的setNext()设置下一个处理者，每个处理者的后继者都是由它自己维护的，也就是整个链条的关系是由所有的处理者共同维护的。所以这里可以优化，我们可以通过AOP（切面编程）的思想来把责任链抽象出来，解除链条与处理者的耦合关系。

非纯责任链模式

Talk is cheap,Show me the code

'use strict';
 
class HandlerChainFactory {
  createHandlerChain() {
    const handlers = [];
    handlers.push(new AaaHandler());
    handlers.push(new BbbHandler());
    handlers.push(new CccHandler());
    handlers.push(new DddHandler());
    handlers.push(new EeeHandler());
    return new HandlerChain(handlers);
  }
}
 
class HandlerChain {
  constructor(handlers) {
    this.handlers = handlers;
  }
  handleMsg(msg) {
    if (this.handlers.length) {
      const handler = this.handlers.shift();
      handler.handleMsg(msg, this);
    } else {
      console.log('没有handler：' + msg);
    }
  }
}
 
class AaaHandler {
  handleMsg(msg, chain) {
    if (msg < 0.2) {
      console.log('AaaHandler处理了：' + msg);
    } else {
      chain.handleMsg(msg);
    }
  }
}
 
class BbbHandler {
  handleMsg(msg, chain) {
    if (msg < 0.3) {
      console.log('BbbHandler处理了：' + msg);
    } else {
      chain.handleMsg(msg);
    }
  }
}
 
class CccHandler {
  handleMsg(msg, chain) {
    if (msg < 0.5) {
      console.log('CccHandler处理了：' + msg);
    } else {
      chain.handleMsg(msg);
    }
  }
}
 
class DddHandler {
  handleMsg(msg, chain) {
    if (msg < 0.6) {
      console.log('DddHandler处理了：' + msg);
    } else {
      chain.handleMsg(msg);
    }
  }
}
 
class EeeHandler {
  handleMsg(msg, chain) {
    if (msg < 0.8) {
      console.log('EeeHandler处理了：' + msg);
    } else {
      console.log('没有handler可以处理了：' + msg);
    }
  }
}
 
const handlerChainFactory = new HandlerChainFactory();
const handleChain = handlerChainFactory.createHandlerChain();
handleChain.handleMsg(Math.random());

可以看到，改进后的责任链模式，代码更加清晰了，希望对大家有帮助。