责任链模式(Chain of Responsibility Pattern)

这是一种链式结构的一种设计模式，比如如果当前类有义务要做某项事情的时候就必须要去完成

责任链模式的实例

假设我们的日志系统有三个报错级别，分别是ERROR，DEBUG，INFO。现在我们在做日志系统的时候有一个需求，就是当出现ERROR时要同时打印到ERROR，DEBUG，INFO的控制台上，而出现DEBUG要同时打印到DEBUG，INFO的控制台上，INFO只需要打印到INFO的控制台上。

那么我们可以用一种链式设计来完成这种事情,首先我们抽象化日志的类型。

  1. class AbstractLogger {
  2.     constructor() {
  3.         if(new.target == AbstractLogger) {
  4.             throw new Error('this class must be extends.')
  5.         }
  6.     }
  7.     setNextLogger(nextLogger){
  8.        this.nextLogger = nextLogger;
  9.     }
  10.     write(message) {}
  11.     // 对于形成链的数据，依次执行
  12.     logMessage(level, message){
  13.        if(this.level <= level){
  14.           this.write(message);
  15.        }
  16.        if(this.nextLogger !=null){
  17.           this.nextLogger.logMessage(level, message);
  18.        }
  19.     }
  20. }
  21. AbstractLogger.INFO = 1;
  22. AbstractLogger.DEBUG = 2;
  23. AbstractLogger.ERROR = 3;

然后我们实现不同错误级别日志的实体类

  1. //定义错误类型
  2. class StandardLogger extends AbstractLogger {
  3.     constructor(level){
  4.         super()
  5.         this.level = level;
  6.     }
  7.     write(message) {    
  8.        console.log("Standard Console::Logger: " + message);
  9.     }
  10. }
  11. class ErrorLogger extends AbstractLogger {
  12.     constructor(level){
  13.         super()
  14.         this.level = level;
  15.     }
  16.     write(message) {    
  17.        console.log("Error Console::Logger: " + message);
  18.     }
  19. }
  20. class FileLogger extends AbstractLogger {
  21.     constructor(level){
  22.         super()
  23.         this.level = level;
  24.     }
  25.     write(message) {    
  26.        console.log("File Console::Logger: " + message);
  27.     }
  28. }

然后我们再把它链式化

  1. function getChainOfLoggers(){
  2.     const errorLogger = new ErrorLogger(AbstractLogger.ERROR);
  3.     const fileLogger = new FileLogger(AbstractLogger.DEBUG);
  4.     const standardLogger = new StandardLogger(AbstractLogger.INFO);
  6.     errorLogger.setNextLogger(fileLogger);
  7.     fileLogger.setNextLogger(standardLogger);
  9.     return errorLogger;  
  10. }

那么我们在使用的时候就只需要使用链式化的对象即可

  1. // 实现级别高的报错依次从当前级别输出到低级别
  2. loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
  3. console.log('')
  4. loggerChain.logMessage(AbstractLogger.DEBUG,
  5.     "This is a debug level information.");
  6. console.log('')
  7. loggerChain.logMessage(AbstractLogger.ERROR,
  8.     "This is an error information.");
  9. /**
  10.  * output:
  11.  * Standard Console::Logger: This is an information.
  12.  * 
  13.  * File Console::Logger: This is a debug level information.
  14.  * Standard Console::Logger: This is a debug level information.
  15.  * 
  16.  * Error Console::Logger: This is an error information.
  17.  * File Console::Logger: This is an error information.
  18.  * Standard Console::Logger: This is an error information.
  19.  */

责任链模式的优势

当前责任人只需要关心自己应该尽什么责任，而不是要关心，自己完成责任后而发什么的其它的什么责任。避免了发送者和多个接受者耦合在一起。

上一页(代理模式)

下一页(命令模式)