Event-Driven Architecture：构建高解耦、可扩展的现代系统

1. 什么是事件驱动架构

1.1 概念理解

Event-Driven Architecture (EDA) 是一种软件架构模式，系统中的各个组件通过生产和消费事件进行通信，而非直接调用彼此的方法。

简单类比：

🏢 传统架构：你打电话给同事（同步等待回复）
📮 事件驱动：你发送邮件（异步处理，不必等待）

1.2 核心对比

传统请求-响应模式：

// 订单服务直接调用库存服务
function createOrder(order) {
  // 1. 创建订单
  const orderId = database.createOrder(order);

  // 2. 直接调用库存服务（紧耦合）
  inventoryService.reduceStock(order.items);

  // 3. 直接调用支付服务
  paymentService.charge(order.amount);

  // 4. 发送邮件
  emailService.sendConfirmation(order.email);

  return orderId;
}

// 问题：
// ❌ 紧耦合：订单服务依赖所有其他服务
// ❌ 同步阻塞：任一服务失败都会导致整体失败
// ❌ 难以扩展：新增流程需要修改订单服务

事件驱动模式：

// 订单服务只负责创建订单并发布事件
function createOrder(order) {
  // 1. 创建订单
  const orderId = database.createOrder(order);

  // 2. 发布事件（松耦合）
  eventBus.publish('order.created', {
    orderId,
    items: order.items,
    amount: order.amount,
    email: order.email,
    timestamp: Date.now()
  });

  return orderId;
}

// 其他服务独立监听和处理
eventBus.subscribe('order.created', (event) => {
  inventoryService.reduceStock(event.items);
});

eventBus.subscribe('order.created', (event) => {
  paymentService.charge(event.amount);
});

eventBus.subscribe('order.created', (event) => {
  emailService.sendConfirmation(event.email);
});

// 优势：
// ✅ 松耦合：各服务独立，互不依赖
// ✅ 异步处理：不阻塞主流程
// ✅ 易扩展：新增监听器即可，无需修改发布者

1.3 架构对比

传统同步调用（紧耦合）：

订单服务 ──调用──→ 库存服务
   ↓ 调用
支付服务 ←──调用── 邮件服务

问题：订单服务必须知道所有下游服务

事件驱动（松耦合）：

                  事件总线
                     │
订单服务 ──发布事件──→ │ ──订阅──→ 库存服务
                     │ ──订阅──→ 支付服务
                     │ ──订阅──→ 邮件服务
                     │ ──订阅──→ 数据分析服务（新增，无需改动订单服务）

优势：订单服务只需知道事件总线

特性	传统同步调用	事件驱动架构
耦合度	❌ 高（服务间直接依赖）	✅ 低（通过事件解耦）
扩展性	❌ 差（新增功能需修改代码）	✅ 好（新增监听器即可）
容错性	❌ 弱（一个服务失败影响全局）	✅ 强（服务独立失败重试）
响应时间	⚠️ 同步等待所有服务	✅ 快速返回，异步处理
复杂度	✅ 简单直观	⚠️ 需要事件管理机制
调试	✅ 调用链清晰	⚠️ 需要事件追踪工具

2. 核心原理与概念

2.1 事件驱动三要素

1. 事件（Event）

// 事件是不可变的数据对象
interface OrderCreatedEvent {
  eventType: 'order.created';
  eventId: string;           // 唯一标识
  timestamp: number;         // 时间戳
  version: string;           // 版本号

  // 业务数据
  data: {
    orderId: string;
    userId: string;
    items: Array<{
      productId: string;
      quantity: number;
      price: number;
    }>;
    totalAmount: number;
  };

  // 元数据
  metadata: {
    source: 'order-service';
    correlationId: string;   // 用于追踪
  };
}

2. 事件生产者（Publisher）

// 生产者发布事件，不关心谁会消费
class OrderService {
  async createOrder(orderData: OrderInput) {
    // 1. 业务逻辑
    const order = await this.db.orders.create(orderData);

    // 2. 发布事件
    await this.eventBus.publish({
      eventType: 'order.created',
      eventId: generateId(),
      timestamp: Date.now(),
      version: '1.0',
      data: order,
      metadata: {
        source: 'order-service',
        correlationId: orderData.requestId
      }
    });

    return order;
  }
}

3. 事件消费者（Subscriber）

// 消费者监听事件，独立处理业务逻辑
class InventoryService {
  constructor() {
    // 订阅事件
    this.eventBus.subscribe('order.created', this.handleOrderCreated);
  }

  async handleOrderCreated(event: OrderCreatedEvent) {
    try {
      // 处理库存扣减
      for (const item of event.data.items) {
        await this.reduceStock(item.productId, item.quantity);
      }

      // 发布库存更新事件
      await this.eventBus.publish({
        eventType: 'inventory.updated',
        // ...
      });
    } catch (error) {
      // 错误处理：重试或发布失败事件
      await this.eventBus.publish({
        eventType: 'inventory.update.failed',
        data: { originalEvent: event, error }
      });
    }
  }
}

2.2 事件传递模式

点对点（Queue）：

生产者 ──→ [消息队列] ──→ 消费者A（独占处理）

特点：每个消息只被一个消费者处理
场景：任务分发、负载均衡

发布-订阅（Topic）：

                ┌──→ 消费者A（库存服务）
生产者 ──→ [主题] ┼──→ 消费者B（支付服务）
                └──→ 消费者C（邮件服务）

特点：每个消息被所有订阅者接收
场景：事件通知、日志收集

2.3 事件处理保证

保证级别	说明	适用场景
At Most Once	最多一次，可能丢失	日志、监控（可容忍丢失）
At Least Once	至少一次，可能重复	大多数业务场景（需幂等处理）
Exactly Once	恰好一次，无丢失无重复	支付、转账（强一致性要求）

3. 应用场景

3.1 最适合的场景

✅ 电商订单处理

用户下单 → 发布 order.created
         ├→ 库存服务：扣减库存
         ├→ 支付服务：处理支付
         ├→ 物流服务：创建发货单
         ├→ 积分服务：累计积分
         └→ 通知服务：发送确认邮件

✅ 用户行为分析

用户操作 → 发布 user.action
         ├→ 实时推荐：更新推荐模型
         ├→ 数据分析：记录行为数据
         └→ A/B测试：统计实验数据

✅ IoT 设备监控

设备上报 → 发布 device.data
         ├→ 告警服务：检测异常
         ├→ 存储服务：持久化数据
         └→ 可视化：更新仪表盘

✅ 微服务解耦

服务A状态变更 → 发布事件
              ├→ 服务B：同步数据
              ├→ 服务C：触发工作流
              └→ 服务D：更新缓存

3.2 不太适合的场景

❌ 强一致性事务

银行转账：A账户 -100，B账户 +100（需原子性）
解决方案：使用 Saga 模式或分布式事务

❌ 需要立即响应的查询

查询订单详情：需要同步返回完整数据
解决方案：结合 CQRS，读写分离

❌ 简单的 CRUD 应用

博客系统、内容管理：过度设计
解决方案：传统 REST API 即可

4. 开发实战 Demo

4.1 场景：电商订单系统

我们将构建一个简化的订单处理系统，包含：

订单服务（发布事件）
库存服务（消费事件）
邮件服务（消费事件）

4.2 技术选型

轻量级方案（Node.js + EventEmitter）

mkdir event-driven-demo && cd event-driven-demo
npm init -y
npm install express uuid

4.3 核心代码实现

1. 事件总线（eventBus.js）

// eventBus.js - 简单的事件总线实现
const EventEmitter = require('events');

class EventBus extends EventEmitter {
  constructor() {
    super();
    this.events = []; // 存储事件历史（可选）
  }

  // 发布事件
  publish(eventType, data) {
    const event = {
      eventId: this.generateId(),
      eventType,
      timestamp: Date.now(),
      data,
      metadata: {
        source: data.source || 'unknown',
      }
    };

    // 存储事件历史
    this.events.push(event);

    // 触发事件
    this.emit(eventType, event);

    console.log(`[EventBus] Published: ${eventType}`, {
      eventId: event.eventId,
      data: event.data
    });

    return event;
  }

  // 订阅事件
  subscribe(eventType, handler) {
    this.on(eventType, async (event) => {
      try {
        console.log(`[EventBus] Handling: ${eventType}`, {
          eventId: event.eventId,
          handler: handler.name
        });
        await handler(event);
      } catch (error) {
        console.error(`[EventBus] Error handling ${eventType}:`, error);
        // 可以发布错误事件
        this.publish(`${eventType}.failed`, {
          originalEvent: event,
          error: error.message
        });
      }
    });

    console.log(`[EventBus] Subscribed: ${eventType} → ${handler.name}`);
  }

  generateId() {
    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }

  // 获取事件历史
  getEvents(filter = {}) {
    return this.events.filter(event => {
      if (filter.eventType && event.eventType !== filter.eventType) return false;
      if (filter.since && event.timestamp < filter.since) return false;
      return true;
    });
  }
}

module.exports = new EventBus();

2. 订单服务（orderService.js）

// orderService.js
const eventBus = require('./eventBus');

class OrderService {
  constructor() {
    this.orders = new Map(); // 简化：使用内存存储
  }

  async createOrder(orderData) {
    // 1. 验证订单
    if (!orderData.items || orderData.items.length === 0) {
      throw new Error('Order must have items');
    }

    // 2. 创建订单
    const order = {
      orderId: `ORD-${Date.now()}`,
      userId: orderData.userId,
      items: orderData.items,
      totalAmount: orderData.items.reduce(
        (sum, item) => sum + item.price * item.quantity,
        0
      ),
      status: 'pending',
      createdAt: Date.now()
    };

    this.orders.set(order.orderId, order);

    // 3. 发布订单创建事件
    eventBus.publish('order.created', {
      source: 'order-service',
      ...order
    });

    console.log(`[OrderService] Order created: ${order.orderId}`);
    return order;
  }

  async updateOrderStatus(orderId, status) {
    const order = this.orders.get(orderId);
    if (!order) throw new Error('Order not found');

    order.status = status;
    order.updatedAt = Date.now();

    // 发布状态更新事件
    eventBus.publish('order.status.updated', {
      source: 'order-service',
      orderId,
      status,
      previousStatus: order.status
    });

    return order;
  }

  getOrder(orderId) {
    return this.orders.get(orderId);
  }

  getAllOrders() {
    return Array.from(this.orders.values());
  }
}

module.exports = new OrderService();

3. 库存服务（inventoryService.js）

// inventoryService.js
const eventBus = require('./eventBus');

class InventoryService {
  constructor() {
    this.inventory = new Map([
      ['PROD-001', { productId: 'PROD-001', name: 'iPhone 15', stock: 100 }],
      ['PROD-002', { productId: 'PROD-002', name: 'MacBook Pro', stock: 50 }],
      ['PROD-003', { productId: 'PROD-003', name: 'AirPods Pro', stock: 200 }],
    ]);

    // 订阅订单创建事件
    eventBus.subscribe('order.created', this.handleOrderCreated.bind(this));
  }

  async handleOrderCreated(event) {
    const { orderId, items } = event.data;

    console.log(`[InventoryService] Processing order: ${orderId}`);

    // 检查库存
    for (const item of items) {
      const product = this.inventory.get(item.productId);

      if (!product) {
        console.error(`[InventoryService] Product not found: ${item.productId}`);
        eventBus.publish('inventory.check.failed', {
          source: 'inventory-service',
          orderId,
          reason: 'product_not_found',
          productId: item.productId
        });
        return;
      }

      if (product.stock < item.quantity) {
        console.error(`[InventoryService] Insufficient stock: ${item.productId}`);
        eventBus.publish('inventory.check.failed', {
          source: 'inventory-service',
          orderId,
          reason: 'insufficient_stock',
          productId: item.productId,
          available: product.stock,
          requested: item.quantity
        });
        return;
      }
    }

    // 扣减库存
    for (const item of items) {
      const product = this.inventory.get(item.productId);
      product.stock -= item.quantity;
      console.log(
        `[InventoryService] Reduced stock: ${product.name} (${product.stock} left)`
      );
    }

    // 发布库存更新成功事件
    eventBus.publish('inventory.updated', {
      source: 'inventory-service',
      orderId,
      items: items.map(item => ({
        productId: item.productId,
        quantity: item.quantity,
        remainingStock: this.inventory.get(item.productId).stock
      }))
    });
  }

  getInventory() {
    return Array.from(this.inventory.values());
  }
}

module.exports = new InventoryService();

4. 邮件服务（emailService.js）

// emailService.js
const eventBus = require('./eventBus');

class EmailService {
  constructor() {
    // 订阅订单创建事件
    eventBus.subscribe('order.created', this.handleOrderCreated.bind(this));

    // 订阅库存更新成功事件
    eventBus.subscribe('inventory.updated', this.handleInventoryUpdated.bind(this));

    // 订阅库存检查失败事件
    eventBus.subscribe('inventory.check.failed', this.handleInventoryFailed.bind(this));
  }

  async handleOrderCreated(event) {
    const { orderId, userId, totalAmount } = event.data;

    console.log(`[EmailService] Sending order confirmation email`);
    console.log(`  To: user-${userId}@example.com`);
    console.log(`  Subject: 订单确认 - ${orderId}`);
    console.log(`  Content: 您的订单已创建，总金额 ¥${totalAmount}`);

    // 模拟发送邮件延迟
    await this.sleep(100);

    console.log(`[EmailService] ✅ Email sent for order: ${orderId}`);
  }

  async handleInventoryUpdated(event) {
    const { orderId } = event.data;

    console.log(`[EmailService] Sending inventory update notification`);
    console.log(`  Subject: 订单 ${orderId} 库存已确认`);

    await this.sleep(100);

    console.log(`[EmailService] ✅ Inventory email sent`);
  }

  async handleInventoryFailed(event) {
    const { orderId, reason } = event.data;

    console.log(`[EmailService] Sending failure notification`);
    console.log(`  Subject: 订单 ${orderId} 库存不足`);
    console.log(`  Reason: ${reason}`);

    await this.sleep(100);

    console.log(`[EmailService] ✅ Failure email sent`);
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

module.exports = new EmailService();

5. HTTP API（server.js）

// server.js
const express = require('express');
const orderService = require('./orderService');
const inventoryService = require('./inventoryService');
const emailService = require('./emailService');
const eventBus = require('./eventBus');

const app = express();
app.use(express.json());

// 创建订单
app.post('/orders', async (req, res) => {
  try {
    const order = await orderService.createOrder(req.body);
    res.json({
      success: true,
      data: order,
      message: '订单创建成功，正在处理中...'
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      error: error.message
    });
  }
});

// 查询订单
app.get('/orders/:orderId', (req, res) => {
  const order = orderService.getOrder(req.params.orderId);
  if (!order) {
    return res.status(404).json({ error: 'Order not found' });
  }
  res.json({ success: true, data: order });
});

// 查询所有订单
app.get('/orders', (req, res) => {
  const orders = orderService.getAllOrders();
  res.json({ success: true, data: orders });
});

// 查询库存
app.get('/inventory', (req, res) => {
  const inventory = inventoryService.getInventory();
  res.json({ success: true, data: inventory });
});

// 查询事件历史
app.get('/events', (req, res) => {
  const events = eventBus.getEvents(req.query);
  res.json({ success: true, data: events });
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`\n🚀 Event-Driven Demo Server running on http://localhost:${PORT}`);
  console.log(`\n📚 API Endpoints:`);
  console.log(`  POST   /orders          - 创建订单`);
  console.log(`  GET    /orders          - 查询所有订单`);
  console.log(`  GET    /orders/:id      - 查询订单详情`);
  console.log(`  GET    /inventory       - 查询库存`);
  console.log(`  GET    /events          - 查询事件历史\n`);
});

6. 测试脚本（test.js）

// test.js
const http = require('http');

function request(method, path, body = null) {
  return new Promise((resolve, reject) => {
    const options = {
      hostname: 'localhost',
      port: 3000,
      path,
      method,
      headers: {
        'Content-Type': 'application/json'
      }
    };

    const req = http.request(options, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => {
        try {
          resolve(JSON.parse(data));
        } catch (e) {
          resolve(data);
        }
      });
    });

    req.on('error', reject);

    if (body) {
      req.write(JSON.stringify(body));
    }

    req.end();
  });
}

async function runTests() {
  console.log('🧪 Testing Event-Driven Architecture Demo\n');

  // 1. 查询初始库存
  console.log('1️⃣ 查询初始库存...');
  const inventory = await request('GET', '/inventory');
  console.log(JSON.stringify(inventory.data, null, 2));

  await sleep(1000);

  // 2. 创建订单（成功场景）
  console.log('\n2️⃣ 创建订单（库存充足）...');
  const order1 = await request('POST', '/orders', {
    userId: 'user-123',
    items: [
      { productId: 'PROD-001', quantity: 2, price: 6999 },
      { productId: 'PROD-003', quantity: 1, price: 1999 }
    ]
  });
  console.log(JSON.stringify(order1, null, 2));

  await sleep(2000);

  // 3. 查询更新后的库存
  console.log('\n3️⃣ 查询更新后的库存...');
  const updatedInventory = await request('GET', '/inventory');
  console.log(JSON.stringify(updatedInventory.data, null, 2));

  await sleep(1000);

  // 4. 创建订单（库存不足场景）
  console.log('\n4️⃣ 创建订单（库存不足）...');
  const order2 = await request('POST', '/orders', {
    userId: 'user-456',
    items: [
      { productId: 'PROD-002', quantity: 100, price: 14999 }
    ]
  });
  console.log(JSON.stringify(order2, null, 2));

  await sleep(2000);

  // 5. 查询事件历史
  console.log('\n5️⃣ 查询事件历史...');
  const events = await request('GET', '/events');
  console.log(`Total events: ${events.data.length}`);
  events.data.forEach(event => {
    console.log(`  - ${event.eventType} (${new Date(event.timestamp).toISOString()})`);
  });

  console.log('\n✅ 测试完成！');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// 等待服务器启动后执行测试
setTimeout(runTests, 1000);

4.4 运行 Demo

1. 启动服务器

node server.js

2. 运行测试（新终端）

node test.js

3. 手动测试

# 创建订单
curl -X POST http://localhost:3000/orders \
  -H "Content-Type: application/json" \
  -d '{
    "userId": "user-789",
    "items": [
      {"productId": "PROD-001", "quantity": 1, "price": 6999}
    ]
  }'

# 查询库存
curl http://localhost:3000/inventory

# 查询事件
curl http://localhost:3000/events

4.5 观察输出

[EventBus] Published: order.created
[OrderService] Order created: ORD-1634567890123

[EventBus] Handling: order.created → handleOrderCreated
[InventoryService] Processing order: ORD-1634567890123
[InventoryService] Reduced stock: iPhone 15 (98 left)

[EventBus] Published: inventory.updated
[EventBus] Handling: order.created → handleOrderCreated
[EmailService] Sending order confirmation email
[EmailService] ✅ Email sent

[EventBus] Handling: inventory.updated → handleInventoryUpdated
[EmailService] Sending inventory update notification
[EmailService] ✅ Inventory email sent

5. 主流框架对比

5.1 消息队列 / 事件总线

框架	类型	特点	适用场景	语言
Apache Kafka	分布式流平台	高吞吐、持久化、分区	大数据、日志收集、流处理	Java/Scala
RabbitMQ	消息队列	灵活路由、易用、成熟	微服务通信、任务队列	Erlang
Redis Streams	内存流	快速、简单、轻量	实时消息、轻量级事件	C
AWS EventBridge	云服务	无服务器、托管、集成AWS	云原生应用、Serverless	云服务
NATS	云原生消息	轻量、高性能、云原生	微服务、IoT、边缘计算	Go
Apache Pulsar	分布式消息	多租户、地理复制	大规模分布式系统	Java

5.2 Node.js 事件库

库	Star	特点	适用场景
EventEmitter2	⭐ 1.3k	通配符、命名空间、TTL	进程内事件总线
Bull	⭐ 15k	基于 Redis、延迟任务、优先级	任务队列、定时任务
BullMQ	⭐ 5k	Bull 升级版、更快、TypeScript	现代任务队列
NestJS	⭐ 65k	完整框架、内置事件、微服务	企业级 Node.js 应用

5.3 技术选型建议

轻量级应用（< 10万 QPS）

// 使用 Redis + Bull
import Queue from 'bull';

const orderQueue = new Queue('order-processing', {
  redis: { host: 'localhost', port: 6379 }
});

// 生产者
orderQueue.add({ orderId: '123', items: [...] });

// 消费者
orderQueue.process(async (job) => {
  await processOrder(job.data);
});

中型系统（10万 - 100万 QPS）

// 使用 RabbitMQ + amqplib
const amqp = require('amqplib');

const conn = await amqp.connect('amqp://localhost');
const channel = await conn.createChannel();

// 发布
await channel.assertExchange('orders', 'topic');
channel.publish('orders', 'order.created', Buffer.from(JSON.stringify(order)));

// 订阅
await channel.assertQueue('inventory-service');
channel.bindQueue('inventory-service', 'orders', 'order.*');
channel.consume('inventory-service', handleMessage);

大规模系统（> 100万 QPS）

// 使用 Kafka + KafkaJS
const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'order-service',
  brokers: ['kafka1:9092', 'kafka2:9092']
});

// 生产者
const producer = kafka.producer();
await producer.send({
  topic: 'order-events',
  messages: [{ value: JSON.stringify(order) }]
});

// 消费者
const consumer = kafka.consumer({ groupId: 'inventory-group' });
await consumer.subscribe({ topic: 'order-events' });
await consumer.run({
  eachMessage: async ({ message }) => {
    await handleOrder(JSON.parse(message.value));
  }
});

6. 最佳实践

6.1 事件设计原则

✅ 好的事件设计

{
  // 明确的事件类型（过去式）
  eventType: 'order.created',

  // 唯一ID + 时间戳
  eventId: 'evt_abc123',
  timestamp: 1634567890123,

  // 版本控制
  version: '1.0',

  // 完整的业务数据（自包含）
  data: {
    orderId: 'ORD-001',
    userId: 'user-123',
    items: [...],
    totalAmount: 15997
  },

  // 元数据
  metadata: {
    source: 'order-service',
    correlationId: 'req-xyz',  // 用于追踪
    causationId: 'evt-abc'     // 触发此事件的事件
  }
}

❌ 不好的事件设计

{
  type: 'create',           // ❌ 不明确
  id: '123',                // ❌ 缺少时间戳
  order: {                  // ❌ 数据不完整
    id: 'ORD-001'           // ❌ 需要查询才能获取完整信息
  }
}

6.2 幂等性处理

问题：消息可能重复投递

// ❌ 非幂等操作
async function handleOrderCreated(event) {
  await db.inventory.decrement({ productId: 'PROD-001' }, { by: 1 });
  // 重复执行会多次扣减库存！
}

解决方案：记录已处理的事件

// ✅ 幂等操作
async function handleOrderCreated(event) {
  // 1. 检查是否已处理
  const processed = await db.processedEvents.findOne({
    eventId: event.eventId
  });

  if (processed) {
    console.log('Event already processed, skipping');
    return;
  }

  // 2. 处理业务逻辑 + 记录事件（原子性）
  await db.transaction(async (trx) => {
    await trx.inventory.decrement({ productId: 'PROD-001' }, { by: 1 });
    await trx.processedEvents.insert({ eventId: event.eventId, processedAt: Date.now() });
  });
}

6.3 错误处理与重试

重试策略

class EventHandler {
  async handleWithRetry(event, maxRetries = 3) {
    let attempt = 0;

    while (attempt < maxRetries) {
      try {
        await this.process(event);
        return; // 成功
      } catch (error) {
        attempt++;

        if (attempt >= maxRetries) {
          // 超过重试次数，发送到死信队列
          await this.sendToDeadLetterQueue(event, error);
          throw error;
        }

        // 指数退避
        const delay = Math.pow(2, attempt) * 1000;
        await this.sleep(delay);
      }
    }
  }

  async sendToDeadLetterQueue(event, error) {
    await eventBus.publish('event.processing.failed', {
      originalEvent: event,
      error: error.message,
      failedAt: Date.now()
    });
  }
}

6.4 事件版本管理

// 事件演化：v1 → v2
const eventHandlers = {
  'order.created': {
    'v1': async (event) => {
      // 旧版本处理
      const { orderId, items } = event.data;
      // ...
    },

    'v2': async (event) => {
      // 新版本：新增 shippingAddress 字段
      const { orderId, items, shippingAddress } = event.data;
      // ...
    }
  }
};

// 根据版本路由
async function handleEvent(event) {
  const handler = eventHandlers[event.eventType]?.[event.version];
  if (!handler) {
    throw new Error(`No handler for ${event.eventType} v${event.version}`);
  }
  await handler(event);
}

6.5 监控与追踪

// 添加追踪信息
class TracingEventBus {
  publish(eventType, data, context = {}) {
    const event = {
      eventId: generateId(),
      eventType,
      data,
      metadata: {
        correlationId: context.correlationId || generateId(),
        causationId: context.causationId,
        timestamp: Date.now(),
        source: context.source
      }
    };

    // 记录指标
    metrics.increment('events.published', { eventType });

    // 分布式追踪
    const span = tracer.startSpan('event.publish', {
      tags: { 'event.type': eventType }
    });

    this.emit(eventType, event);

    span.finish();
    return event;
  }
}

7. 挑战与解决方案

7.1 常见挑战

挑战	问题	解决方案
事件顺序	事件乱序到达	使用顺序号、分区保证顺序
最终一致性	数据延迟同步	CQRS、补偿事务（Saga）
重复消费	同一事件被处理多次	幂等性设计、去重表
消息丢失	事件未能持久化	持久化队列、确认机制
调试困难	异步流程难以追踪	分布式追踪（Jaeger）、事件溯源
事务一致性	跨服务事务失败	Saga 模式、两阶段提交

7.2 Saga 模式示例

// 订单 Saga：协调多个服务的事务
class OrderSaga {
  async execute(orderData) {
    const sagaId = generateId();
    const compensations = []; // 补偿操作栈

    try {
      // 1. 创建订单
      const order = await this.createOrder(orderData);
      compensations.push(() => this.cancelOrder(order.orderId));

      // 2. 扣减库存
      await this.reduceInventory(order.items);
      compensations.push(() => this.restoreInventory(order.items));

      // 3. 处理支付
      await this.processPayment(order.totalAmount);
      compensations.push(() => this.refundPayment(order.totalAmount));

      // 4. 创建发货单
      await this.createShipment(order);

      // 全部成功
      console.log('Saga completed successfully');
      return order;

    } catch (error) {
      // 执行补偿操作（逆序）
      console.log('Saga failed, executing compensations...');
      for (const compensate of compensations.reverse()) {
        try {
          await compensate();
        } catch (compError) {
          console.error('Compensation failed:', compError);
        }
      }
      throw error;
    }
  }
}

7.3 调试技巧

事件可视化工具

// 简单的事件流可视化
class EventVisualizer {
  constructor(eventBus) {
    this.events = [];

    eventBus.onAny((eventType, event) => {
      this.events.push({
        eventType,
        timestamp: Date.now(),
        data: event
      });
      this.printEventFlow();
    });
  }

  printEventFlow() {
    console.log('\n📊 Event Flow:');
    this.events.slice(-10).forEach((evt, idx) => {
      const time = new Date(evt.timestamp).toISOString();
      console.log(`  ${idx + 1}. [${time}] ${evt.eventType}`);
    });
  }
}

总结

核心要点

解耦优先：通过事件解耦服务，提升系统灵活性
异步处理：快速响应用户，后台异步处理业务
幂等设计：确保重复消费不会产生副作用
监控追踪：完善的日志和追踪系统必不可少

适合你吗？

✅ 适合使用 EDA 的情况：

微服务架构
需要高扩展性
多系统集成
实时数据处理

❌ 暂时不适合的情况：

简单的单体应用
强一致性要求高
团队缺乏分布式经验

学习路径

理解概念：掌握发布-订阅模式
动手实践：完成本文 Demo
选择工具：根据场景选择消息队列
深入模式：学习 CQRS、Event Sourcing、Saga
生产实践：监控、追踪、容错