JavaScript 设计模式与 Node.js：策略模式、模板方法与行为模式

1. 当设计模式遇见Node.js

在软件开发的江湖里，设计模式就像武林高手的武功秘籍。当年GoF（四人帮）留下的23种设计套路，经过二十余年的实战检验，仍然是工程师们解决问题的法宝。Node.js作为单线程事件驱动架构的典型代表，在应对复杂业务场景时更需要这些成熟解决方案的加持。今天我们将重点演练三种行为型模式：策略模式、模板方法模式和观察者模式，看看它们如何在异步世界中大显身手。

2. 策略模式：可插拔的业务逻辑

2.1 模式核心思想

策略模式定义了一系列算法家族，将每个算法封装成独立类，使它们可以相互替换。这种模式就像给程序安装可替换的「技能插件」，特别适合需要动态切换业务规则的场景。

2.2 Node.js支付处理实战

// 策略接口
class PaymentStrategy {
  pay(amount) {
    throw new Error("必须实现pay方法");
  }
}

// 具体策略实现
class AlipayStrategy extends PaymentStrategy {
  pay(amount) {
    console.log(`支付宝支付：${amount}元`);
    // 实际应调用支付宝SDK
    return { code: 200, transactionId: Date.now() };
  }
}

class WechatPayStrategy extends PaymentStrategy {
  pay(amount) {
    console.log(`微信支付：${amount}元`);
    // 微信支付接口调用逻辑
    return { code: 200, transactionId: `WX_${Date.now()}` };
  }
}

// 策略上下文
class PaymentProcessor {
  constructor(strategy) {
    this.strategy = strategy;
  }

  setStrategy(strategy) {
    this.strategy = strategy;
  }

  executePayment(amount) {
    if (!this.strategy) throw new Error("未设置支付策略");
    return this.strategy.pay(amount);
  }
}

// 使用示例
const processor = new PaymentProcessor(new AlipayStrategy());
processor.executePayment(100); // 支付宝支付：100元

processor.setStrategy(new WechatPayStrategy());
processor.executePayment(200); // 微信支付：200元

2.3 模式优势分析

• 灵活性: 支付方式变更无需修改核心逻辑
• 可测试性: 每种策略都可以独立进行单元测试
• 可维护性: 新增支付渠道只需添加新策略类

特别适合：多场景支付系统、数据校验策略、动态算法切换等场景

3. 模板方法模式：构建框架的骨骼

3.1 模式运作原理

模板方法模式定义了算法的骨架，允许子类在不改变结构的情况下重写特定步骤。这就像在Node.js中创建可扩展的基类，特别适用于中间件开发和框架搭建。

3.2 Express中间件改造示例

// 抽象模板类
class MiddlewareTemplate {
  constructor() {
    if (new.target === MiddlewareTemplate) {
      throw new Error("不能实例化抽象类");
    }
  }

  // 模板方法
  execute() {
    this.before();
    this.handle();
    this.after();
  }

  before() {
    // 默认前置空实现
  }

  handle() {
    throw new Error("必须实现handle方法");
  }

  after() {
    // 默认后置空实现
  }
}

// 具体中间件实现
class LoggerMiddleware extends MiddlewareTemplate {
  before() {
    console.log("-- 请求开始 --");
  }

  handle() {
    console.log("记录请求日志");
    // 实际应处理请求对象
  }

  after() {
    console.log("-- 请求结束 --");
  }
}

// 使用示例
const logger = new LoggerMiddleware();
logger.execute();
/* 输出：
-- 请求开始 --
记录请求日志
-- 请求结束 --
*/

3.3 模式应用场景

• 构建Web框架的中间件管道
• 创建通用文件处理流程
• 实现统一的数据转换规范

与Koa中间件机制结合使用时，可以通过async/await实现更强大的流程控制。

4. 观察者模式：事件驱动架构的基石

4.1 模式工作机制

观察者模式建立对象间的一对多依赖关系，当主题对象状态变化时，所有依赖对象都会得到通知。这本质上就是Node.js事件循环机制的底层逻辑。

4.2 EventEmitter深度定制

const EventEmitter = require('events');

// 定制发布者
class StockPublisher extends EventEmitter {
  constructor() {
    super();
    this.stockPrice = 100;
  }

  updatePrice(newPrice) {
    this.stockPrice = newPrice;
    this.emit('priceChange', {
      price: this.stockPrice,
      timestamp: Date.now()
    });
  }
}

// 订阅者实现
class StockSubscriber {
  constructor(name) {
    this.name = name;
  }

  onPriceChange(data) {
    console.log(`[${this.name}] 最新股价：${data.price}`);
  }
}

// 使用示例
const publisher = new StockPublisher();
const user1 = new StockSubscriber("张经理");
const user2 = new StockSubscriber("王股民");

publisher.on('priceChange', user1.onPriceChange.bind(user1));
publisher.on('priceChange', user2.onPriceChange.bind(user2));

publisher.updatePrice(105);
/* 输出：
[张经理] 最新股价：105
[王股民] 最新股价：105
*/

4.3 实际应用场景

• WebSocket实时通信系统
• 微服务间的状态同步
• CLI工具的进度通知
• 跨模块状态共享

与Redis的Pub/Sub机制配合使用时，可以轻松实现分布式观察者模式。

5. 模式比较与选型指南

5.1 应用场景对比

5.2 实施注意事项

策略模式：

• 避免策略类过度膨胀
• 注意策略间的互斥性
• 合理使用工厂方法管理策略

模板方法：

• 严格控制模板方法的继承层级
• 合理设计钩子方法
• 注意异步流程的特殊处理

观察者模式：

• 防范循环调用
• 合理控制通知频率
• 内存泄漏预防（及时取消订阅）

6. 模式实践中的性能调优

在Node.js环境下实现这些模式时，要特别注意：

1. 内存管理：观察者模式中的订阅者应及时取消注册
2. 事件循环优化：高频更新的观察者应使用debounce策略
3. V8引擎特性：策略对象频繁创建时考虑对象池优化
4. 集群模式适配：在Cluster模式下需要特殊的模式实现

7. 新时代的演进与融合

随着TypeScript的普及和ECMAScript标准的演进，设计模式的实现方式也在进化：

• 使用装饰器实现策略模式的动态装配
• 利用AsyncIterator实现响应式观察者
• 结合Worker Threads实现并行策略处理

例如，用TypeScript接口优化策略模式：

interface PaymentStrategy {
  pay(amount: number): Promise<TransactionResult>;
}

8. 模式演进趋势展望

1. Serverless适配：设计模式在无服务器架构中的新形态
2. 微服务集成：跨服务的分布式观察者实现
3. WebAssembly应用：高性能策略算法的移植方案