es6 语法学习 - 责任链模式

es6 语法学习 - 责任链模式

一、基本概念

责任链模式（Chain of Responsibility）是一种行为设计模式，它允许你将请求沿着处理者链进行传递。每个处理者都对请求进行某些处理，并且可以决定是否将请求传递给链中的下一个处理者。这个模式使得你可以动态地添加或删除处理者，并改变请求的传递顺序。

二、 优点

• 降低耦合度：责任链模式将请求发送者和接收者解耦
• 增强可扩展性：可以动态地添加或修改处理链，调整处理顺序。
• 提高灵活性：每个处理者只负责处理自己关心的请求

三、缺点

• 性能问题：依次经过责任链上的每个处理者，处理链过长可能会影响系统的性能。
• 复杂性增加：责任链模式可能会引入过多的类和对象，增加系统的复杂性和理解难度。
• 请求可能漏掉：责任链没有正确配置或者最后一个处理者没有处理请求，导致问题无法得到解决。

四、使用场景

• 日志记录系统：根据日志级别将日志消息传递给不同的日志记录器。
• 多级审批系统：如请假审批、采购审批等，根据审批者的权限和级别将审批请求传递给下一个级别的审批者。
• 事件处理系统：根据事件类型将事件传递给不同的处理器进行处理。

五、示例代码

在 JavaScript 中，我们可以使用 ES6 的类和函数来实现责任链模式。以下是一个简单的例子，展示了如何使用责任链模式来处理不同级别的日志消息。

// 日志级别枚举
const LogLevel = {
  ERROR: 'ERROR',
  WARN: 'WARN',
  INFO: 'INFO',
  DEBUG: 'DEBUG',
};

// 日志处理者基类
class LogHandler {
  constructor(level) {
    this.level = level;
    this.nextHandler = null;
  }

  setNextHandler(handler) {
    this.nextHandler = handler;
  }

  // 具体的处理逻辑，由子类实现
  handle(log) {
    if (this.nextHandler) {
      return this.nextHandler.handle(log);
    }
    return false; // 如果没有处理者，返回false表示未处理
  }
}

// 具体处理者：错误日志处理者
class ErrorLogHandler extends LogHandler {
  constructor() {
    super(LogLevel.ERROR);
  }

  handle(log) {
    console.log(log);
    if (log.level === LogLevel.ERROR) {
      console.error(`ErrorLogHandler: ${log.message}`);
      return true; // 表示已处理
    }
    return super.handle(log); // 传递给下一个处理者
  }
}

// 具体处理者：警告日志处理者
class WarnLogHandler extends LogHandler {
  constructor() {
    super(LogLevel.WARN);
  }

  handle(log) {
    if (log.level === LogLevel.WARN) {
      console.warn(`WarnLogHandler: ${log.message}`);
      return true; // 表示已处理
    }
    return super.handle(log); // 传递给下一个处理者
  }
}

// 具体处理者：信息日志处理者
class InfoLogHandler extends LogHandler {
  constructor() {
    super(LogLevel.INFO);
  }

  handle(log) {
    if (log.level === LogLevel.INFO) {
      console.info(`InfoLogHandler: ${log.message}`);
      return true; // 表示已处理
    }
    return super.handle(log); // 传递给下一个处理者
  }
}

// 具体处理者：调试日志处理者（可选，作为链的末尾）
class DebugLogHandler extends LogHandler {
  constructor() {
    super(LogLevel.DEBUG);
  }

  handle(log) {
    if (log.level === LogLevel.DEBUG) {
      console.debug(`DebugLogHandler: ${log.message}`);
      return true; // 表示已处理
    }
    // 在这个例子中，没有下一个处理者，所以返回false
    return false; // 表示未处理（但在这个链的末尾，这实际上不会发生）
  }
}

// 使用责任链模式
const errorHandler = new ErrorLogHandler();
const warnHandler = new WarnLogHandler();
const infoHandler = new InfoLogHandler();
const debugHandler = new DebugLogHandler();

// 设置处理者链
errorHandler.setNextHandler(warnHandler);
warnHandler.setNextHandler(infoHandler);
infoHandler.setNextHandler(debugHandler);

// 创建日志并传递给链
const logs = [
  { level: LogLevel.ERROR, message: 'This is an error message' },
  { level: LogLevel.WARN, message: 'This is a warning message' },
  { level: LogLevel.INFO, message: 'This is an info message' },
  { level: LogLevel.DEBUG, message: 'This is a debug message' },
  { level: 'UNKNOWN', message: 'This is an unknown level message' }, // 不会被处理
];

logs.forEach((log) => errorHandler.handle(log));