Reactive on PlumePHP

事件驱动架构与领域事件：构建松耦合的响应式系统

Mon, 18 May 2026 11:45:00 +0800

事件驱动架构概述

事件驱动架构（EDA）是一种通过事件的产生、检测和消费来实现系统组件间松耦合通信的架构风格。

事件驱动架构优势：
┌─────────────────────────────────────────┐
│ ✓ 松耦合：生产者不知道消费者是谁 │
│ ✓ 可扩展：新增消费者不影响现有系统 │
│ ✓ 审计追踪：完整的事件历史记录 │
│ ✓ 时间解耦：异步处理，提高响应速度 │
│ ✓ 弹性：失败可重试，不影响主流程 │
└─────────────────────────────────────────┘

领域事件设计

事件定义

// src/domain/events/baseEvent.ts
export interface DomainEvent {
 eventId: string;
 eventType: string;
 aggregateId: string;
 aggregateType: string;
 timestamp: Date;
 version: number;
 metadata?: Record<string, any>;
}

// src/domain/events/orderEvents.ts
export class OrderCreatedEvent implements DomainEvent {
 readonly eventId: string;
 readonly eventType = 'OrderCreated';
 readonly aggregateType = 'Order';
 readonly timestamp: Date;
 readonly version = 1;
 
 constructor(
 public readonly aggregateId: string,
 public readonly userId: string,
 public readonly items: OrderItem[],
 public readonly totalAmount: number,
 public readonly shippingAddress: Address,
 metadata?: Record<string, any>
 ) {
 this.eventId = generateUUID();
 this.timestamp = new Date();
 this.metadata = metadata;
 }
}

export class OrderConfirmedEvent implements DomainEvent {
 readonly eventId: string;
 readonly eventType = 'OrderConfirmed';
 readonly aggregateType = 'Order';
 readonly timestamp: Date;
 readonly version = 1;
 
 constructor(
 public readonly aggregateId: string,
 public readonly confirmedAt: Date,
 public readonly estimatedDelivery: Date,
 metadata?: Record<string, any>
 ) {
 this.eventId = generateUUID();
 this.timestamp = new Date();
 this.metadata = metadata;
 }
}

export class OrderCancelledEvent implements DomainEvent {
 readonly eventId: string;
 readonly eventType = 'OrderCancelled';
 readonly aggregateType = 'Order';
 readonly timestamp: Date;
 readonly version = 1;
 
 constructor(
 public readonly aggregateId: string,
 public readonly reason: string,
 public readonly cancelledBy: string,
 metadata?: Record<string, any>
 ) {
 this.eventId = generateUUID();
 this.timestamp = new Date();
 this.metadata = metadata;
 }
}

export class OrderShippedEvent implements DomainEvent {
 readonly eventId: string;
 readonly eventType = 'OrderShipped';
 readonly aggregateType = 'Order';
 readonly timestamp: Date;
 readonly version = 1;
 
 constructor(
 public readonly aggregateId: string,
 public readonly trackingNumber: string,
 public readonly carrier: string,
 public readonly shippedAt: Date,
 metadata?: Record<string, any>
 ) {
 this.eventId = generateUUID();
 this.timestamp = new Date();
 this.metadata = metadata;
 }
}

聚合根发布事件

// src/domain/entities/Order.ts
import { DomainEvent } from '../events/baseEvent';
import { OrderCreatedEvent, OrderConfirmedEvent, OrderCancelledEvent } from '../events/orderEvents';

export class Order {
 private domainEvents: DomainEvent[] = [];
 
 constructor(
 public readonly id: string,
 public userId: string,
 public items: OrderItem[],
 public totalAmount: number,
 public shippingAddress: Address,
 public status: OrderStatus = 'PENDING',
 public createdAt: Date = new Date()
 ) {}
 
 static create(
 userId: string,
 items: OrderItem[],
 shippingAddress: Address
 ): Order {
 const totalAmount = items.reduce(
 (sum, item) => sum + item.price * item.quantity,
 0
 );
 
 const order = new Order(
 generateUUID(),
 userId,
 items,
 totalAmount,
 shippingAddress
 );
 
 // 发布领域事件
 order.addDomainEvent(
 new OrderCreatedEvent(
 order.id,
 userId,
 items,
 totalAmount,
 shippingAddress,
 { correlationId: generateCorrelationId() }
 )
 );
 
 return order;
 }
 
 confirm(estimatedDelivery: Date): void {
 if (this.status !== 'PENDING') {
 throw new BusinessRuleError('Only pending orders can be confirmed');
 }
 
 this.status = 'CONFIRMED';
 
 this.addDomainEvent(
 new OrderConfirmedEvent(
 this.id,
 new Date(),
 estimatedDelivery
 )
 );
 }
 
 cancel(reason: string, cancelledBy: string): void {
 if (this.status === 'SHIPPED') {
 throw new BusinessRuleError('Cannot cancel shipped order');
 }
 
 this.status = 'CANCELLED';
 
 this.addDomainEvent(
 new OrderCancelledEvent(
 this.id,
 reason,
 cancelledBy
 )
 );
 }
 
 // 获取并清除领域事件
 pullDomainEvents(): DomainEvent[] {
 const events = [...this.domainEvents];
 this.domainEvents = [];
 return events;
 }
 
 private addDomainEvent(event: DomainEvent): void {
 this.domainEvents.push(event);
 }
}

// src/application/services/OrderApplicationService.ts
export class OrderApplicationService {
 constructor(
 private orderRepository: OrderRepository,
 private eventPublisher: EventPublisher
 ) {}
 
 async createOrder(command: CreateOrderCommand): Promise<string> {
 // 1. 创建聚合根
 const order = Order.create(
 command.userId,
 command.items,
 command.shippingAddress
 );
 
 // 2. 保存到数据库（事务）
 await this.orderRepository.save(order);
 
 // 3. 发布领域事件
 const events = order.pullDomainEvents();
 await this.eventPublisher.publishAll(events);
 
 return order.id;
 }
 
 async confirmOrder(orderId: string, estimatedDelivery: Date): Promise<void> {
 const order = await this.orderRepository.findById(orderId);
 if (!order) {
 throw new NotFoundError('Order', orderId);
 }
 
 order.confirm(estimatedDelivery);
 await this.orderRepository.save(order);
 
 const events = order.pullDomainEvents();
 await this.eventPublisher.publishAll(events);
 }
}

事件总线实现

内存事件总线

// src/infrastructure/events/InMemoryEventBus.ts
import { EventEmitter } from 'events';
import { DomainEvent } from '../../domain/events/baseEvent';

type EventHandler = (event: DomainEvent) => Promise<void>;

export class InMemoryEventBus {
 private emitter: EventEmitter;
 
 constructor() {
 this.emitter = new EventEmitter();
 this.emitter.setMaxListeners(100); // 增加监听器数量限制
 }
 
 subscribe(eventType: string, handler: EventHandler): void {
 this.emitter.on(eventType, async (event: DomainEvent) => {
 try {
 await handler(event);
 } catch (error) {
 console.error(`Error handling event ${eventType}:`, error);
 // 可以发送到死信队列
 }
 });
 }
 
 async publish(event: DomainEvent): Promise<void> {
 this.emitter.emit(event.eventType, event);
 }
 
 async publishAll(events: DomainEvent[]): Promise<void> {
 for (const event of events) {
 await this.publish(event);
 }
 }
}

// 使用示例
const eventBus = new InMemoryEventBus();

// 订阅订单创建事件
eventBus.subscribe('OrderCreated', async (event: OrderCreatedEvent) => {
 await inventoryService.reserveStock(event.aggregateId, event.items);
});

eventBus.subscribe('OrderCreated', async (event: OrderCreatedEvent) => {
 await notificationService.sendOrderConfirmation(event.userId, event.aggregateId);
});

// 订阅订单确认事件
eventBus.subscribe('OrderConfirmed', async (event: OrderConfirmedEvent) => {
 await warehouseService.prepareShipment(event.aggregateId);
});

Kafka事件总线

// src/infrastructure/events/KafkaEventBus.ts
import { Kafka, Producer, Consumer, EachMessagePayload } from 'kafkajs';
import { DomainEvent } from '../../domain/events/baseEvent';

export class KafkaEventBus {
 private producer: Producer;
 private consumers: Map<string, Consumer> = new Map();
 private topic: string;
 
 constructor(
 private brokers: string[],
 private clientId: string,
 topic: string = 'domain-events'
 ) {
 const kafka = new Kafka({
 clientId,
 brokers
 });
 
 this.producer = kafka.producer();
 this.topic = topic;
 }
 
 async connect(): Promise<void> {
 await this.producer.connect();
 console.log('Kafka producer connected');
 }
 
 async publish(event: DomainEvent): Promise<void> {
 await this.producer.send({
 topic: this.topic,
 messages: [
 {
 key: event.aggregateId,
 value: JSON.stringify(event),
 headers: {
 eventType: event.eventType,
 aggregateType: event.aggregateType,
 timestamp: event.timestamp.toISOString()
 }
 }
 ]
 });
 
 console.log(`Published event: ${event.eventType} for ${event.aggregateId}`);
 }
 
 async subscribe(
 eventType: string,
 groupId: string,
 handler: (event: DomainEvent) => Promise<void>
 ): Promise<void> {
 const kafka = new Kafka({
 clientId: this.clientId,
 brokers: this.brokers
 });
 
 const consumer = kafka.consumer({ groupId });
 await consumer.connect();
 await consumer.subscribe({ topic: this.topic, fromBeginning: false });
 
 await consumer.run({
 eachMessage: async ({ topic, partition, message }: EachMessagePayload) => {
 const eventTypeHeader = message.headers?.eventType?.toString();
 
 if (eventTypeHeader === eventType) {
 const event = JSON.parse(message.value?.toString() || '{}');
 
 try {
 await handler(event);
 } catch (error) {
 console.error(`Error handling event ${eventType}:`, error);
 // 发送到死信队列或重试
 throw error;
 }
 }
 }
 });
 
 this.consumers.set(`${eventType}-${groupId}`, consumer);
 console.log(`Subscribed to ${eventType} with group ${groupId}`);
 }
 
 async disconnect(): Promise<void> {
 await this.producer.disconnect();
 
 for (const consumer of this.consumers.values()) {
 await consumer.disconnect();
 }
 
 console.log('Kafka disconnected');
 }
}

// 使用示例
const eventBus = new KafkaEventBus(
 ['kafka1:9092', 'kafka2:9092'],
 'order-service'
);

await eventBus.connect();

// 发布事件
await eventBus.publish(orderCreatedEvent);

// 订阅事件
await eventBus.subscribe(
 'OrderCreated',
 'inventory-service-group',
 async (event) => {
 await inventoryService.reserveStock(event.aggregateId, event.items);
 }
);

事件溯源（Event Sourcing）

事件存储

// src/infrastructure/persistence/EventStore.ts
import { Pool } from 'pg';
import { DomainEvent } from '../../domain/events/baseEvent';

export class PostgresEventStore {
 constructor(private pool: Pool) {
 this.initializeSchema();
 }
 
 private async initializeSchema(): Promise<void> {
 await this.pool.query(`
 CREATE TABLE IF NOT EXISTS events (
 event_id UUID PRIMARY KEY,
 event_type VARCHAR(255) NOT NULL,
 aggregate_id UUID NOT NULL,
 aggregate_type VARCHAR(255) NOT NULL,
 event_data JSONB NOT NULL,
 metadata JSONB,
 version INTEGER NOT NULL,
 created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
 UNIQUE(aggregate_id, version)
 );
 
 CREATE INDEX IF NOT EXISTS idx_events_aggregate 
 ON events(aggregate_id, version);
 
 CREATE INDEX IF NOT EXISTS idx_events_type 
 ON events(event_type, created_at);
 `);
 }
 
 async saveEvents(
 aggregateId: string,
 events: DomainEvent[],
 expectedVersion: number
 ): Promise<void> {
 const client = await this.pool.connect();
 
 try {
 await client.query('BEGIN');
 
 // 乐观锁检查
 const currentVersion = await this.getAggregateVersion(client, aggregateId);
 
 if (currentVersion !== expectedVersion) {
 throw new ConcurrencyError(
 `Expected version ${expectedVersion}, but got ${currentVersion}`
 );
 }
 
 // 保存事件
 for (const event of events) {
 await client.query(
 `INSERT INTO events 
 (event_id, event_type, aggregate_id, aggregate_type, 
 event_data, metadata, version, created_at)
 VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
 [
 event.eventId,
 event.eventType,
 event.aggregateId,
 event.aggregateType,
 JSON.stringify(event),
 event.metadata ? JSON.stringify(event.metadata) : null,
 event.version,
 event.timestamp
 ]
 );
 }
 
 await client.query('COMMIT');
 } catch (error) {
 await client.query('ROLLBACK');
 throw error;
 } finally {
 client.release();
 }
 }
 
 async loadEvents(aggregateId: string): Promise<DomainEvent[]> {
 const result = await this.pool.query(
 `SELECT event_data FROM events 
 WHERE aggregate_id = $1 
 ORDER BY version ASC`,
 [aggregateId]
 );
 
 return result.rows.map(row => {
 const eventData = row.event_data;
 return this.deserializeEvent(eventData);
 });
 }
 
 private async getAggregateVersion(
 client: any,
 aggregateId: string
 ): Promise<number> {
 const result = await client.query(
 `SELECT MAX(version) as version FROM events WHERE aggregate_id = $1`,
 [aggregateId]
 );
 
 return result.rows[0]?.version || 0;
 }
 
 private deserializeEvent(eventData: any): DomainEvent {
 // 根据eventType反序列化为具体的事件类
 const eventMap = {
 'OrderCreated': OrderCreatedEvent,
 'OrderConfirmed': OrderConfirmedEvent,
 'OrderCancelled': OrderCancelledEvent,
 // ...
 };
 
 const EventClass = eventMap[eventData.eventType];
 if (!EventClass) {
 throw new Error(`Unknown event type: ${eventData.eventType}`);
 }
 
 return Object.assign(new EventClass(), eventData);
 }
}

// src/domain/aggregates/EventSourcedOrder.ts
export class EventSourcedOrder {
 private version: number = 0;
 
 constructor(
 public readonly id: string,
 public userId: string = '',
 public items: OrderItem[] = [],
 public totalAmount: number = 0,
 public status: OrderStatus = 'PENDING',
 private changes: DomainEvent[] = []
 ) {}
 
 // 从事件流重建状态
 loadFromHistory(events: DomainEvent[]): void {
 for (const event of events) {
 this.apply(event, false);
 }
 }
 
 // 创建新订单
 static create(
 userId: string,
 items: OrderItem[],
 shippingAddress: Address
 ): EventSourcedOrder {
 const order = new EventSourcedOrder(generateUUID());
 
 const totalAmount = items.reduce(
 (sum, item) => sum + item.price * item.quantity,
 0
 );
 
 const event = new OrderCreatedEvent(
 order.id,
 userId,
 items,
 totalAmount,
 shippingAddress
 );
 
 order.apply(event, true);
 
 return order;
 }
 
 confirm(estimatedDelivery: Date): void {
 if (this.status !== 'PENDING') {
 throw new BusinessRuleError('Only pending orders can be confirmed');
 }
 
 const event = new OrderConfirmedEvent(
 this.id,
 new Date(),
 estimatedDelivery
 );
 
 this.apply(event, true);
 }
 
 // 应用事件
 private apply(event: DomainEvent, isNew: boolean): void {
 switch (event.eventType) {
 case 'OrderCreated':
 const createdEvent = event as OrderCreatedEvent;
 this.userId = createdEvent.userId;
 this.items = createdEvent.items;
 this.totalAmount = createdEvent.totalAmount;
 this.status = 'PENDING';
 break;
 
 case 'OrderConfirmed':
 this.status = 'CONFIRMED';
 break;
 
 case 'OrderCancelled':
 this.status = 'CANCELLED';
 break;
 }
 
 this.version++;
 
 if (isNew) {
 this.changes.push(event);
 }
 }
 
 // 获取未保存的变更
 getChanges(): DomainEvent[] {
 return this.changes;
 }
 
 clearChanges(): void {
 this.changes = [];
 }
}

// src/application/services/EventSourcedOrderService.ts
export class EventSourcedOrderService {
 constructor(
 private eventStore: PostgresEventStore,
 private eventPublisher: EventPublisher
 ) {}
 
 async createOrder(command: CreateOrderCommand): Promise<string> {
 const order = EventSourcedOrder.create(
 command.userId,
 command.items,
 command.shippingAddress
 );
 
 const changes = order.getChanges();
 
 await this.eventStore.saveEvents(order.id, changes, 0);
 await this.eventPublisher.publishAll(changes);
 
 order.clearChanges();
 
 return order.id;
 }
 
 async confirmOrder(orderId: string, estimatedDelivery: Date): Promise<void> {
 const events = await this.eventStore.loadEvents(orderId);
 
 if (events.length === 0) {
 throw new NotFoundError('Order', orderId);
 }
 
 const order = new EventSourcedOrder(orderId);
 order.loadFromHistory(events);
 
 const currentVersion = events.length;
 
 order.confirm(estimatedDelivery);
 
 const changes = order.getChanges();
 await this.eventStore.saveEvents(orderId, changes, currentVersion);
 await this.eventPublisher.publishAll(changes);
 }
}

CQRS（命令查询职责分离）

// src/application/commands/OrderCommands.ts
export interface Command {
 commandId: string;
 timestamp: Date;
}

export class CreateOrderCommand implements Command {
 readonly commandId = generateUUID();
 readonly timestamp = new Date();
 
 constructor(
 public readonly userId: string,
 public readonly items: OrderItem[],
 public readonly shippingAddress: Address
 ) {}
}

// src/application/queries/OrderQueries.ts
export interface OrderReadModel {
 id: string;
 userId: string;
 items: OrderItem[];
 totalAmount: number;
 status: string;
 createdAt: Date;
 customerName?: string;
 productNames?: string[];
}

export class GetOrderQuery {
 constructor(public readonly orderId: string) {}
}

export class GetUserOrdersQuery {
 constructor(
 public readonly userId: string,
 public readonly page: number = 1,
 public readonly pageSize: number = 20
 ) {}
}

// src/infrastructure/persistence/OrderReadModelProjector.ts
export class OrderReadModelProjector {
 constructor(private readDb: Pool) {
 this.initializeSchema();
 }
 
 private async initializeSchema(): Promise<void> {
 await this.readDb.query(`
 CREATE TABLE IF NOT EXISTS order_read_models (
 id UUID PRIMARY KEY,
 user_id UUID NOT NULL,
 items JSONB NOT NULL,
 total_amount DECIMAL NOT NULL,
 status VARCHAR(50) NOT NULL,
 customer_name VARCHAR(255),
 product_names TEXT[],
 created_at TIMESTAMP WITH TIME ZONE NOT NULL,
 updated_at TIMESTAMP WITH TIME ZONE NOT NULL
 );
 
 CREATE INDEX IF NOT EXISTS idx_orders_user 
 ON order_read_models(user_id, created_at DESC);
 
 CREATE INDEX IF NOT EXISTS idx_orders_status 
 ON order_read_models(status);
 `);
 }
 
 async project(event: DomainEvent): Promise<void> {
 switch (event.eventType) {
 case 'OrderCreated':
 await this.handleOrderCreated(event as OrderCreatedEvent);
 break;
 case 'OrderConfirmed':
 await this.updateOrderStatus(event.aggregateId, 'CONFIRMED');
 break;
 case 'OrderCancelled':
 await this.updateOrderStatus(event.aggregateId, 'CANCELLED');
 break;
 }
 }
 
 private async handleOrderCreated(event: OrderCreatedEvent): Promise<void> {
 // 查询客户信息
 const customer = await this.readDb.query(
 'SELECT name FROM users WHERE id = $1',
 [event.userId]
 );
 
 // 查询产品名称
 const productIds = event.items.map(item => item.productId);
 const products = await this.readDb.query(
 'SELECT id, name FROM products WHERE id = ANY($1)',
 [productIds]
 );
 
 const productNames = products.rows.map(p => p.name);
 
 await this.readDb.query(
 `INSERT INTO order_read_models 
 (id, user_id, items, total_amount, status, customer_name, product_names, created_at, updated_at)
 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $8)`,
 [
 event.aggregateId,
 event.userId,
 JSON.stringify(event.items),
 event.totalAmount,
 'PENDING',
 customer.rows[0]?.name || 'Unknown',
 productNames,
 event.timestamp
 ]
 );
 }
 
 private async updateOrderStatus(orderId: string, status: string): Promise<void> {
 await this.readDb.query(
 `UPDATE order_read_models 
 SET status = $1, updated_at = NOW() 
 WHERE id = $2`,
 [status, orderId]
 );
 }
}

// src/application/queries/OrderQueryService.ts
export class OrderQueryService {
 constructor(private readDb: Pool) {}
 
 async getOrder(query: GetOrderQuery): Promise<OrderReadModel | null> {
 const result = await this.readDb.query(
 'SELECT * FROM order_read_models WHERE id = $1',
 [query.orderId]
 );
 
 return result.rows[0] || null;
 }
 
 async getUserOrders(query: GetUserOrdersQuery): Promise<{
 orders: OrderReadModel[];
 total: number;
 }> {
 const offset = (query.page - 1) * query.pageSize;
 
 const [ordersResult, countResult] = await Promise.all([
 this.readDb.query(
 `SELECT * FROM order_read_models 
 WHERE user_id = $1 
 ORDER BY created_at DESC 
 LIMIT $2 OFFSET $3`,
 [query.userId, query.pageSize, offset]
 ),
 this.readDb.query(
 'SELECT COUNT(*) FROM order_read_models WHERE user_id = $1',
 [query.userId]
 )
 ]);
 
 return {
 orders: ordersResult.rows,
 total: parseInt(countResult.rows[0].count)
 };
 }
}

// 订阅事件并投影
const projector = new OrderReadModelProjector(readDb);

eventBus.subscribe('OrderCreated', 'read-model-projector', async (event) => {
 await projector.project(event);
});

eventBus.subscribe('OrderConfirmed', 'read-model-projector', async (event) => {
 await projector.project(event);
});

eventBus.subscribe('OrderCancelled', 'read-model-projector', async (event) => {
 await projector.project(event);
});

总结

事件驱动架构的核心价值：

GraphQL订阅与实时更新：构建响应式数据流架构

Wed, 18 Feb 2026 14:30:00 +0800

引言

GraphQL订阅为应用提供了实时数据推送能力，相比传统轮询方式更高效、更及时。本文将深入讲解GraphQL订阅的架构设计与实战实现。

GraphQL订阅核心概念

GraphQL订阅工作流：
┌─────────┐ ┌─────────┐
│ Client │ │ Server │
└────┬────┘ └────┬────┘
 │ │
 │ 1. WebSocket连接建立 │
 │ ─────────────────────────▶ │
 │ │
 │ 2. 发送订阅请求 │
 │ subscription { │
 │ messageAdded { │
 │ id content userId │
 │ } │
 │ } │
 │ ─────────────────────────▶ │
 │ │
 │ 3. 服务器确认订阅 │
 │ ◀───────────────────────── │
 │ │
 │ 4. 数据变更时推送 │
 │ { data: { │
 │ messageAdded: {...} │
 │ }} │
 │ ◀───────────────────────── │
 │ │
 │ 5. 继续推送... │
 │ ◀───────────────────────── │
 │ │
 │ 6. 客户端取消订阅 │
 │ ─────────────────────────▶ │
 │ │
 │ 7. 关闭连接 │
 │ ─────────────────────────▶ │

Apollo Server实现

基础订阅设置

// schema.js
const { gql } = require('apollo-server');

const typeDefs = gql`
 type Message {
 id: ID!
 content: String!
 userId: ID!
 createdAt: String!
 }

 type Query {
 messages(channelId: ID!): [Message!]!
 }

 type Mutation {
 addMessage(channelId: ID!, content: String!): Message!
 }

 type Subscription {
 messageAdded(channelId: ID!): Message!
 userTyping(channelId: ID!): User!
 channelUpdated(channelId: ID!): Channel!
 }
`;

module.exports = typeDefs;

// resolvers.js
const { PubSub } = require('graphql-subscriptions');

const pubsub = new PubSub();

const MESSAGE_ADDED = 'MESSAGE_ADDED';
const USER_TYPING = 'USER_TYPING';
const CHANNEL_UPDATED = 'CHANNEL_UPDATED';

const resolvers = {
 Query: {
 messages: async (_, { channelId }, { dataSources }) => {
 return dataSources.messageAPI.getMessagesByChannel(channelId);
 },
 },

 Mutation: {
 addMessage: async (_, { channelId, content }, { user, dataSources }) => {
 const message = await dataSources.messageAPI.createMessage({
 channelId,
 content,
 userId: user.id,
 });

 // 发布事件
 pubsub.publish(`${MESSAGE_ADDED}.${channelId}`, {
 messageAdded: message,
 });

 return message;
 },
 },

 Subscription: {
 messageAdded: {
 subscribe: (_, { channelId }, { user }) => {
 // 权限检查
 if (!user.hasAccessToChannel(channelId)) {
 throw new Error('Unauthorized');
 }

 return pubsub.asyncIterator([`${MESSAGE_ADDED}.${channelId}`]);
 },
 },

 userTyping: {
 subscribe: (_, { channelId }) => {
 return pubsub.asyncIterator([`${USER_TYPING}.${channelId}`]);
 },
 },
 },
};

module.exports = resolvers;

服务器配置

// server.js
const { ApolloServer } = require('apollo-server-express');
const { createServer } = require('http');
const { execute, subscribe } = require('graphql');
const { SubscriptionServer } = require('subscriptions-transport-ws');
const express = require('express');

const typeDefs = require('./schema');
const resolvers = require('./resolvers');

async function startServer() {
 const app = express();
 
 const server = new ApolloServer({
 typeDefs,
 resolvers,
 context: ({ req, connection }) => {
 // HTTP请求上下文
 if (req) {
 return {
 user: getUserFromToken(req.headers.authorization),
 };
 }
 // WebSocket连接上下文
 if (connection) {
 return {
 user: connection.context.user,
 };
 }
 },
 });

 await server.start();
 server.applyMiddleware({ app });

 const httpServer = createServer(app);

 // WebSocket服务器
 SubscriptionServer.create(
 {
 schema: server.schema,
 execute,
 subscribe,
 onConnect: (connectionParams, webSocket) => {
 // 验证连接
 if (connectionParams.authToken) {
 const user = validateToken(connectionParams.authToken);
 return { user };
 }
 throw new Error('Missing auth token');
 },
 onDisconnect: (webSocket, context) => {
 console.log('Client disconnected');
 },
 },
 {
 server: httpServer,
 path: server.graphqlPath,
 }
 );

 const PORT = process.env.PORT || 4000;
 httpServer.listen(PORT, () => {
 console.log(`🚀 Server ready at http://localhost:${PORT}${server.graphqlPath}`);
 console.log(`🚀 Subscriptions ready at ws://localhost:${PORT}${server.graphqlPath}`);
 });
}

startServer();

Redis PubSub扩展

分布式PubSub

// redis-pubsub.js
const { RedisPubSub } = require('graphql-redis-subscriptions');
const Redis = require('ioredis');

const options = {
 host: process.env.REDIS_HOST || 'localhost',
 port: process.env.REDIS_PORT || 6379,
 retryStrategy: (times) => {
 return Math.min(times * 50, 2000);
 },
};

const pubsub = new RedisPubSub({
 publisher: new Redis(options),
 subscriber: new Redis(options),
});

module.exports = pubsub;

// 使用Redis PubSub
const pubsub = require('./redis-pubsub');

const MESSAGE_ADDED = 'MESSAGE_ADDED';

const resolvers = {
 Subscription: {
 messageAdded: {
 subscribe: (_, { channelId }) => {
 // 使用模式匹配订阅多个频道
 return pubsub.asyncIterator([
 `${MESSAGE_ADDED}.${channelId}`,
 ]);
 },
 resolve: (payload) => {
 return payload.messageAdded;
 },
 },
 },
};

Go实现

GraphQL订阅服务器

package main

import (
 "context"
 "log"
 "net/http"
 "sync"
 
 "github.com/99designs/gqlgen/graphql/handler"
 "github.com/99designs/gqlgen/graphql/handler/transport"
 "github.com/99designs/gqlgen/graphql/playground"
 "github.com/gorilla/websocket"
)

type PubSub struct {
 mu sync.RWMutex
 subscribers map[string][]chan interface{}
}

func NewPubSub() *PubSub {
 return &PubSub{
 subscribers: make(map[string][]chan interface{}),
 }
}

func (ps *PubSub) Subscribe(topic string) chan interface{} {
 ps.mu.Lock()
 defer ps.mu.Unlock()
 
 ch := make(chan interface{}, 10)
 ps.subscribers[topic] = append(ps.subscribers[topic], ch)
 return ch
}

func (ps *PubSub) Unsubscribe(topic string, ch chan interface{}) {
 ps.mu.Lock()
 defer ps.mu.Unlock()
 
 subs := ps.subscribers[topic]
 for i, sub := range subs {
 if sub == ch {
 ps.subscribers[topic] = append(subs[:i], subs[i+1:]...)
 close(ch)
 break
 }
 }
}

func (ps *PubSub) Publish(topic string, data interface{}) {
 ps.mu.RLock()
 defer ps.mu.RUnlock()
 
 for _, ch := range ps.subscribers[topic] {
 select {
 case ch <- data:
 default:
 // 频道已满，跳过
 }
 }
}

// Resolver实现
type Resolver struct {
 pubsub *PubSub
}

func (r *Resolver) MessageAdded(ctx context.Context, channelID string) (<-chan *Message, error) {
 ch := r.pubsub.Subscribe("message_added." + channelID)
 
 messageCh := make(chan *Message, 10)
 
 go func() {
 defer close(messageCh)
 for {
 select {
 case <-ctx.Done():
 r.pubsub.Unsubscribe("message_added."+channelID, ch)
 return
 case data := <-ch:
 if msg, ok := data.(*Message); ok {
 messageCh <- msg
 }
 }
 }
 }()
 
 return messageCh, nil
}

func (r *Resolver) AddMessage(ctx context.Context, channelID, content string) (*Message, error) {
 user := getUserFromContext(ctx)
 
 msg := &Message{
 ID: generateID(),
 Content: content,
 UserID: user.ID,
 CreatedAt: time.Now(),
 }
 
 // 保存到数据库
 if err := saveMessage(msg); err != nil {
 return nil, err
 }
 
 // 发布事件
 r.pubsub.Publish("message_added."+channelID, msg)
 
 return msg, nil
}

// 服务器启动
func main() {
 pubsub := NewPubSub()
 resolver := &Resolver{pubsub: pubsub}
 
 srv := handler.New(gqlgen.NewExecutableSchema(gqlgen.Config{
 Resolvers: resolver,
 }))
 
 // 添加WebSocket传输
 srv.AddTransport(&transport.Websocket{
 Upgrader: websocket.Upgrader{
 CheckOrigin: func(r *http.Request) bool {
 return true
 },
 },
 InitFunc: func(ctx context.Context, initPayload *transport.InitPayload) (context.Context, error) {
 // 验证连接
 token := initPayload.Get("authToken")
 user, err := validateToken(token)
 if err != nil {
 return ctx, err
 }
 return context.WithValue(ctx, "user", user), nil
 },
 })
 
 srv.AddTransport(transport.POST{})
 
 http.Handle("/", playground.Handler("GraphQL", "/query"))
 http.Handle("/query", srv)
 
 log.Println("Server running on :8080")
 log.Fatal(http.ListenAndServe(":8080", nil))
}

客户端实现

React + Apollo Client

// client.js
import { ApolloClient, InMemoryCache, split, HttpLink } from '@apollo/client';
import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
import { createClient } from 'graphql-ws';
import { getMainDefinition } from '@apollo/client/utilities';

const httpLink = new HttpLink({
 uri: 'http://localhost:4000/graphql',
});

const wsLink = new GraphQLWsLink(
 createClient({
 url: 'ws://localhost:4000/graphql',
 connectionParams: {
 authToken: localStorage.getItem('token'),
 },
 })
);

const splitLink = split(
 ({ query }) => {
 const definition = getMainDefinition(query);
 return (
 definition.kind === 'OperationDefinition' &&
 definition.operation === 'subscription'
 );
 },
 wsLink,
 httpLink
);

const client = new ApolloClient({
 link: splitLink,
 cache: new InMemoryCache(),
});

// MessageList.jsx
import { useSubscription, useQuery, gql } from '@apollo/client';

const GET_MESSAGES = gql`
 query GetMessages($channelId: ID!) {
 messages(channelId: $channelId) {
 id
 content
 userId
 createdAt
 }
 }
`;

const MESSAGE_ADDED = gql`
 subscription MessageAdded($channelId: ID!) {
 messageAdded(channelId: $channelId) {
 id
 content
 userId
 createdAt
 }
 }
`;

function MessageList({ channelId }) {
 const { data, loading } = useQuery(GET_MESSAGES, {
 variables: { channelId },
 });

 useSubscription(MESSAGE_ADDED, {
 variables: { channelId },
 onData: ({ data: { messageAdded } }) => {
 // 更新缓存
 client.cache.modify({
 fields: {
 messages(existingMessages = []) {
 const newMessageRef = client.cache.writeFragment({
 data: messageAdded,
 fragment: gql`
 fragment NewMessage on Message {
 id
 content
 userId
 createdAt
 }
 `,
 });
 return [...existingMessages, newMessageRef];
 },
 },
 });
 },
 });

 if (loading) return <div>Loading...</div>;

 return (
 <div className="message-list">
 {data.messages.map((message) => (
 <div key={message.id} className="message">
 <p>{message.content}</p>
 <span>{message.createdAt}</span>
 </div>
 ))}
 </div>
 );
}

高级特性

事件过滤

// 带过滤的订阅
const resolvers = {
 Subscription: {
 messageAdded: {
 subscribe: withFilter(
 (_, { channelId }) => pubsub.asyncIterator([MESSAGE_ADDED]),
 (payload, variables) => {
 // 只推送给特定频道的订阅者
 return payload.messageAdded.channelId === variables.channelId;
 }
 ),
 },

 // 多条件过滤
 notificationReceived: {
 subscribe: withFilter(
 () => pubsub.asyncIterator([NOTIFICATION]),
 (payload, variables, context) => {
 const notification = payload.notificationReceived;
 return (
 notification.userId === context.user.id &&
 notification.type === variables.type
 );
 }
 ),
 },
 },
};

订阅认证与授权

// 中间件认证
const authMiddleware = async (resolve, parent, args, context, info) => {
 if (!context.user) {
 throw new AuthenticationError('Must authenticate');
 }

 // 检查用户是否有权限订阅
 const hasPermission = await checkPermission(
 context.user,
 info.fieldName,
 args
 );

 if (!hasPermission) {
 throw new ForbiddenError('Not authorized');
 }

 return resolve(parent, args, context, info);
};

// 应用中间件
const resolvers = {
 Subscription: {
 messageAdded: {
 subscribe: authMiddleware,
 },
 },
};

总结

GraphQL订阅最佳实践

场景	推荐方案	原因
聊天应用	WebSocket + Redis PubSub	实时性高，支持多实例
实时通知	事件过滤 + 权限控制	精准推送，安全可控
协作编辑	CRDT + 订阅	冲突解决，实时同步
数据仪表板	节流 + 批量更新	减少推送频率

关键原则

使用分布式PubSub：Redis/Kafka支持多实例部署
实现认证授权：WebSocket连接和订阅都需要验证
事件过滤：避免无关数据推送
连接管理：监控活跃连接数，防止资源耗尽
错误处理：优雅处理连接断开和重连
性能优化：节流、批量更新、连接复用

Reactive on PlumePHP

事件驱动架构与领域事件：构建松耦合的响应式系统

事件驱动架构概述

领域事件设计

事件定义

聚合根发布事件

事件总线实现

内存事件总线

Kafka事件总线

事件溯源（Event Sourcing）

事件存储

CQRS（命令查询职责分离）

总结

GraphQL订阅与实时更新：构建响应式数据流架构

引言

GraphQL订阅核心概念

Apollo Server实现

基础订阅设置

服务器配置

Redis PubSub扩展

分布式PubSub

Go实现

GraphQL订阅服务器

客户端实现

React + Apollo Client

高级特性

事件过滤

订阅认证与授权

总结

GraphQL订阅最佳实践

关键原则

延伸阅读