跳到主要内容

AI应用架构设计

AI应用架构设计 是构建可扩展、高性能AI应用的关键。本文将深入探讨AI应用的架构模式、设计原则和最佳实践，帮助你构建企业级的AI应用系统。

🎯 学习目标​

通过本文学习，你将掌握：

  • AI应用架构的核心概念和设计原则
  • 不同架构模式的特点和适用场景
  • 微服务架构在AI应用中的实践
  • 数据流和处理管道的设计
  • 可扩展性和性能优化策略
  • 监控、日志和运维体系

📋 目录结构​

  1. AI应用架构概述
  2. 架构设计原则
  3. 常见架构模式
  4. 微服务架构实践
  5. 数据流设计
  6. API网关设计
  7. 缓存策略
  8. 监控与日志
  9. 部署与运维
  10. 架构演进策略

🏗️ AI应用架构概述​

AI应用的特殊性​

AI应用相比传统应用有其独特的特点和挑战：

// AI应用特性分析
const AIApplicationCharacteristics = {
  // 计算密集型
  computeIntensive: {
    description: 'AI推理和训练需要大量计算资源',
    challenges: [
      'GPU/TPU资源管理',
      '计算成本控制',
      '负载均衡复杂'
    ],
    solutions: [
      '弹性扩缩容',
      '资源池化',
      '异步处理'
    ]
  },
  
  // 数据密集型
  dataIntensive: {
    description: '需要处理大量多模态数据',
    challenges: [
      '数据存储和传输',
      '数据预处理',
      '数据一致性'
    ],
    solutions: [
      '分布式存储',
      '数据管道',
      '缓存策略'
    ]
  },
  
  // 延迟敏感
  latencySensitive: {
    description: '用户对响应时间要求高',
    challenges: [
      '模型推理延迟',
      '网络传输延迟',
      '冷启动问题'
    ],
    solutions: [
      '模型优化',
      'CDN加速',
      '预热机制'
    ]
  },
  
  // 资源弹性
  resourceElastic: {
    description: '资源需求波动大',
    challenges: [
      '峰值处理',
      '成本优化',
      '资源调度'
    ],
    solutions: [
      '自动扩缩容',
      '混合云部署',
      '智能调度'
    ]
  },
  
  // 模型管理
  modelManagement: {
    description: '需要管理多个模型版本',
    challenges: [
      '模型版本控制',
      'A/B测试',
      '模型更新'
    ],
    solutions: [
      'MLOps流程',
      '灰度发布',
      '模型注册表'
    ]
  }
};

console.log('🤖 AI应用特性分析:', AIApplicationCharacteristics);

架构层次划分​

// AI应用架构层次
class AIApplicationArchitecture {
  constructor() {
    this.layers = {
      // 表现层
      presentation: {
        name: '表现层',
        components: [
          'Web前端',
          '移动应用',
          'API接口',
          '管理控制台'
        ],
        responsibilities: [
          '用户交互',
          '数据展示',
          '请求路由'
        ]
      },
      
      // 应用层
      application: {
        name: '应用层',
        components: [
          '业务逻辑服务',
          '工作流引擎',
          '任务调度器',
          '事件处理器'
        ],
        responsibilities: [
          '业务流程控制',
          '服务编排',
          '事件处理'
        ]
      },
      
      // AI服务层
      aiService: {
        name: 'AI服务层',
        components: [
          '模型推理服务',
          '训练服务',
          '特征工程服务',
          '模型管理服务'
        ],
        responsibilities: [
          'AI能力提供',
          '模型生命周期管理',
          '推理优化'
        ]
      },
      
      // 数据层
      data: {
        name: '数据层',
        components: [
          '数据存储',
          '数据处理',
          '数据管道',
          '特征存储'
        ],
        responsibilities: [
          '数据持久化',
          '数据处理',
          '特征管理'
        ]
      },
      
      // 基础设施层
      infrastructure: {
        name: '基础设施层',
        components: [
          '容器编排',
          '服务网格',
          '监控系统',
          '安全网关'
        ],
        responsibilities: [
          '资源管理',
          '服务治理',
          '运维监控'
        ]
      }
    };
  }

  getLayerDependencies() {
    return {
      presentation: ['application'],
      application: ['aiService', 'data'],
      aiService: ['data', 'infrastructure'],
      data: ['infrastructure'],
      infrastructure: []
    };
  }

  validateArchitecture() {
    const dependencies = this.getLayerDependencies();
    const issues = [];
    
    // 检查循环依赖
    for (const [layer, deps] of Object.entries(dependencies)) {
      for (const dep of deps) {
        if (dependencies[dep] && dependencies[dep].includes(layer)) {
          issues.push(`循环依赖: ${layer} <-> ${dep}`);
        }
      }
    }
    
    return {
      valid: issues.length === 0,
      issues
    };
  }
}

const architecture = new AIApplicationArchitecture();
console.log('🏗️ 架构层次:', architecture.layers);
console.log('🔍 架构验证:', architecture.validateArchitecture());

📐 架构设计原则​

SOLID原则在AI架构中的应用​

// SOLID原则在AI架构中的实践
class AIArchitectureSOLID {
  constructor() {
    this.principles = {
      // 单一职责原则 (Single Responsibility Principle)
      srp: {
        name: '单一职责原则',
        description: '每个服务只负责一个特定的AI功能',
        examples: [
          '模型推理服务只负责推理',
          '数据预处理服务只负责数据处理',
          '模型管理服务只负责模型生命周期'
        ],
        benefits: [
          '降低耦合度',
          '提高可维护性',
          '便于独立扩展'
        ]
      },
      
      // 开闭原则 (Open/Closed Principle)
      ocp: {
        name: '开闭原则',
        description: '对扩展开放，对修改关闭',
        examples: [
          '通过插件机制支持新的模型类型',
          '通过配置支持新的数据源',
          '通过接口支持新的推理引擎'
        ],
        benefits: [
          '系统稳定性',
          '功能可扩展',
          '降低风险'
        ]
      },
      
      // 里氏替换原则 (Liskov Substitution Principle)
      lsp: {
        name: '里氏替换原则',
        description: '子类可以替换父类而不影响系统功能',
        examples: [
          '不同的模型实现可以互相替换',
          '不同的存储后端可以透明切换',
          '不同的推理引擎可以无缝替换'
        ],
        benefits: [
          '系统灵活性',
          '组件可替换',
          '降低依赖'
        ]
      },
      
      // 接口隔离原则 (Interface Segregation Principle)
      isp: {
        name: '接口隔离原则',
        description: '客户端不应依赖它不需要的接口',
        examples: [
          '推理接口与训练接口分离',
          '读接口与写接口分离',
          '管理接口与业务接口分离'
        ],
        benefits: [
          '接口精简',
          '降低耦合',
          '提高安全性'
        ]
      },
      
      // 依赖倒置原则 (Dependency Inversion Principle)
      dip: {
        name: '依赖倒置原则',
        description: '高层模块不应依赖低层模块，都应依赖抽象',
        examples: [
          '业务逻辑依赖AI服务接口而非具体实现',
          '应用层依赖数据访问接口而非具体数据库',
          '服务间通过消息队列解耦'
        ],
        benefits: [
          '系统解耦',
          '便于测试',
          '提高灵活性'
        ]
      }
    };
  }

  // 应用SOLID原则的架构示例
  getSOLIDArchitectureExample() {
    return {
      // 抽象层
      abstractions: {
        ModelInferenceInterface: {
          methods: ['predict', 'batchPredict', 'getModelInfo'],
          implementations: ['OpenAIInference', 'LocalModelInference', 'CloudMLInference']
        },
        DataStorageInterface: {
          methods: ['save', 'load', 'delete', 'query'],
          implementations: ['PostgreSQLStorage', 'MongoDBStorage', 'S3Storage']
        },
        FeatureExtractorInterface: {
          methods: ['extract', 'transform', 'validate'],
          implementations: ['TextFeatureExtractor', 'ImageFeatureExtractor', 'AudioFeatureExtractor']
        }
      },
      
      // 服务层
      services: {
        InferenceService: {
          dependencies: ['ModelInferenceInterface'],
          responsibilities: ['请求路由', '结果聚合', '缓存管理']
        },
        DataService: {
          dependencies: ['DataStorageInterface'],
          responsibilities: ['数据CRUD', '数据验证', '数据转换']
        },
        FeatureService: {
          dependencies: ['FeatureExtractorInterface', 'DataStorageInterface'],
          responsibilities: ['特征提取', '特征存储', '特征检索']
        }
      },
      
      // 应用层
      applications: {
        AIApplication: {
          dependencies: ['InferenceService', 'DataService', 'FeatureService'],
          responsibilities: ['业务流程编排', '用户请求处理', '结果返回']
        }
      }
    };
  }
}

const solidPrinciples = new AIArchitectureSOLID();
console.log('📐 SOLID原则:', solidPrinciples.principles);
console.log('🏗️ SOLID架构示例:', solidPrinciples.getSOLIDArchitectureExample());

其他重要设计原则​

// AI架构的其他重要设计原则
class AIArchitecturePrinciples {
  constructor() {
    this.principles = {
      // 可观测性原则
      observability: {
        name: '可观测性原则',
        description: '系统应该是可观测和可调试的',
        practices: [
          '全链路追踪',
          '结构化日志',
          '指标监控',
          '健康检查',
          '性能分析'
        ],
        implementation: {
          logging: '使用结构化日志记录关键事件',
          metrics: '收集业务和技术指标',
          tracing: '追踪请求在系统中的流转',
          alerting: '基于指标设置告警规则'
        }
      },
      
      // 容错性原则
      faultTolerance: {
        name: '容错性原则',
        description: '系统应该能够优雅地处理故障',
        practices: [
          '熔断器模式',
          '重试机制',
          '降级策略',
          '超时控制',
          '故障隔离'
        ],
        implementation: {
          circuitBreaker: '防止故障传播',
          retry: '智能重试策略',
          fallback: '提供降级方案',
          timeout: '设置合理超时',
          isolation: '故障域隔离'
        }
      },
      
      // 可扩展性原则
      scalability: {
        name: '可扩展性原则',
        description: '系统应该能够水平和垂直扩展',
        practices: [
          '无状态设计',
          '数据分片',
          '负载均衡',
          '异步处理',
          '缓存策略'
        ],
        implementation: {
          stateless: '服务无状态化',
          sharding: '数据水平分片',
          loadBalancing: '智能负载均衡',
          async: '异步消息处理',
          caching: '多层缓存策略'
        }
      },
      
      // 安全性原则
      security: {
        name: '安全性原则',
        description: '系统应该具备多层安全防护',
        practices: [
          '身份认证',
          '权限控制',
          '数据加密',
          '安全审计',
          '威胁检测'
        ],
        implementation: {
          authentication: 'OAuth2/JWT认证',
          authorization: 'RBAC权限控制',
          encryption: '数据传输和存储加密',
          audit: '操作审计日志',
          detection: '异常行为检测'
        }
      },
      
      // 性能优化原则
      performance: {
        name: '性能优化原则',
        description: '系统应该具备高性能和低延迟',
        practices: [
          '缓存优化',
          '数据库优化',
          '网络优化',
          '计算优化',
          '资源优化'
        ],
        implementation: {
          caching: '多级缓存策略',
          database: '索引和查询优化',
          network: 'CDN和压缩',
          compute: '并行和异步处理',
          resource: '资源池化和复用'
        }
      }
    };
  }

  // 生成架构检查清单
  generateArchitectureChecklist() {
    const checklist = [];
    
    Object.entries(this.principles).forEach(([key, principle]) => {
      principle.practices.forEach(practice => {
        checklist.push({
          category: principle.name,
          item: practice,
          description: principle.implementation[practice.toLowerCase().replace(/\s+/g, '')] || '需要实现'
        });
      });
    });
    
    return checklist;
  }

  // 评估架构成熟度
  assessArchitectureMaturity(currentImplementation) {
    const assessment = {};
    
    Object.entries(this.principles).forEach(([key, principle]) => {
      const implemented = principle.practices.filter(practice => 
        currentImplementation.includes(practice)
      );
      
      assessment[key] = {
        name: principle.name,
        score: implemented.length / principle.practices.length,
        implemented: implemented.length,
        total: principle.practices.length,
        missing: principle.practices.filter(practice => 
          !currentImplementation.includes(practice)
        )
      };
    });
    
    return assessment;
  }
}

const principles = new AIArchitecturePrinciples();
console.log('📋 架构检查清单:', principles.generateArchitectureChecklist());

// 示例：评估当前架构
const currentImplementation = [
  '全链路追踪', '结构化日志', '熔断器模式', '重试机制',
  '无状态设计', '负载均衡', '身份认证', '权限控制'
];

console.log('📊 架构成熟度评估:', principles.assessArchitectureMaturity(currentImplementation));

🏛️ 常见架构模式​

单体架构 vs 微服务架构​

// 架构模式对比分析
class ArchitecturePatterns {
  constructor() {
    this.patterns = {
      // 单体架构
      monolithic: {
        name: '单体架构',
        description: '所有功能模块部署在一个应用中',
        advantages: [
          '开发简单',
          '部署容易',
          '测试方便',
          '性能较好'
        ],
        disadvantages: [
          '扩展困难',
          '技术栈固定',
          '团队协作困难',
          '故障影响面大'
        ],
        suitableFor: [
          '小型团队',
          '简单应用',
          '快速原型',
          '初期项目'
        ],
        aiChallenges: [
          '模型更新困难',
          '资源分配不灵活',
          '难以支持多种AI能力'
        ]
      },
      
      // 微服务架构
      microservices: {
        name: '微服务架构',
        description: '将应用拆分为多个独立的服务',
        advantages: [
          '独立部署',
          '技术多样性',
          '团队自治',
          '故障隔离'
        ],
        disadvantages: [
          '复杂度高',
          '网络开销',
          '数据一致性',
          '运维复杂'
        ],
        suitableFor: [
          '大型团队',
          '复杂应用',
          '高可用要求',
          '快速迭代'
        ],
        aiAdvantages: [
          '模型独立更新',
          '资源弹性分配',
          '支持多种AI技术栈',
          '便于A/B测试'
        ]
      },
      
      // 服务网格架构
      serviceMesh: {
        name: '服务网格架构',
        description: '在微服务基础上增加服务间通信治理',
        advantages: [
          '流量管理',
          '安全策略',
          '可观测性',
          '故障注入'
        ],
        disadvantages: [
          '学习成本高',
          '资源开销',
          '配置复杂',
          '调试困难'
        ],
        suitableFor: [
          '大规模微服务',
          '复杂网络拓扑',
          '严格安全要求',
          '精细化治理'
        ],
        aiUseCase: [
          'AI服务流量控制',
          '模型版本路由',
          '推理请求限流',
          '安全策略执行'
        ]
      },
      
      // 无服务器架构
      serverless: {
        name: '无服务器架构',
        description: '基于函数即服务(FaaS)的架构模式',
        advantages: [
          '按需付费',
          '自动扩缩容',
          '运维简化',
          '快速部署'
        ],
        disadvantages: [
          '冷启动延迟',
          '执行时间限制',
          '状态管理困难',
          '供应商锁定'
        ],
        suitableFor: [
          '事件驱动应用',
          '间歇性工作负载',
          '快速原型',
          '成本敏感场景'
        ],
        aiChallenges: [
          '模型加载时间',
          '内存限制',
          'GPU支持有限',
          '复杂推理流程'
        ]
      }
    };
  }

  // 架构选择决策树
  getArchitectureRecommendation(requirements) {
    const {
      teamSize,
      complexity,
      scalability,
      performance,
      budget,
      timeToMarket,
      aiComplexity
    } = requirements;
    
    let score = {
      monolithic: 0,
      microservices: 0,
      serviceMesh: 0,
      serverless: 0
    };
    
    // 团队规模评分
    if (teamSize <= 5) {
      score.monolithic += 3;
      score.serverless += 2;
    } else if (teamSize <= 20) {
      score.microservices += 3;
      score.monolithic += 1;
    } else {
      score.microservices += 2;
      score.serviceMesh += 3;
    }
    
    // 复杂度评分
    if (complexity === 'low') {
      score.monolithic += 3;
      score.serverless += 2;
    } else if (complexity === 'medium') {
      score.microservices += 3;
      score.monolithic += 1;
    } else {
      score.microservices += 2;
      score.serviceMesh += 3;
    }
    
    // 可扩展性评分
    if (scalability === 'high') {
      score.microservices += 3;
      score.serviceMesh += 2;
      score.serverless += 2;
    }
    
    // AI复杂度评分
    if (aiComplexity === 'high') {
      score.microservices += 2;
      score.serviceMesh += 1;
      score.monolithic -= 1;
    }
    
    // 找出最高分的架构
    const recommended = Object.entries(score).reduce((a, b) => 
      score[a[0]] > score[b[0]] ? a : b
    )[0];
    
    return {
      recommended,
      scores: score,
      reasoning: this.getRecommendationReasoning(recommended, requirements)
    };
  }

  getRecommendationReasoning(architecture, requirements) {
    const pattern = this.patterns[architecture];
    const reasons = [];
    
    // 基于需求生成推荐理由
    if (requirements.teamSize <= 5) {
      reasons.push('小团队适合简单架构');
    }
    
    if (requirements.complexity === 'low') {
      reasons.push('低复杂度项目无需过度设计');
    }
    
    if (requirements.scalability === 'high') {
      reasons.push('高可扩展性需求');
    }
    
    if (requirements.aiComplexity === 'high') {
      reasons.push('复杂AI场景需要灵活架构');
    }
    
    return {
      pattern: pattern.name,
      reasons,
      advantages: pattern.advantages,
      considerations: pattern.disadvantages
    };
  }
}

const patterns = new ArchitecturePatterns();

// 示例：获取架构推荐
const requirements = {
  teamSize: 15,
  complexity: 'high',
  scalability: 'high',
  performance: 'high',
  budget: 'medium',
  timeToMarket: 'medium',
  aiComplexity: 'high'
};

const recommendation = patterns.getArchitectureRecommendation(requirements);
console.log('🎯 架构推荐:', recommendation);

事件驱动架构​

// 事件驱动架构实现
class EventDrivenArchitecture {
  constructor() {
    this.eventBus = new Map();
    this.subscribers = new Map();
    this.eventStore = [];
    this.sagaManager = new SagaManager();
  }

  // 事件发布
  publish(eventType, eventData, metadata = {}) {
    const event = {
      id: this.generateEventId(),
      type: eventType,
      data: eventData,
      metadata: {
        timestamp: new Date().toISOString(),
        source: metadata.source || 'unknown',
        version: metadata.version || '1.0',
        correlationId: metadata.correlationId || this.generateCorrelationId(),
        ...metadata
      }
    };
    
    // 存储事件
    this.eventStore.push(event);
    
    // 通知订阅者
    const subscribers = this.subscribers.get(eventType) || [];
    subscribers.forEach(async (subscriber) => {
      try {
        await subscriber.handler(event);
        console.log(`✅ 事件处理成功: ${eventType} -> ${subscriber.name}`);
      } catch (error) {
        console.error(`❌ 事件处理失败: ${eventType} -> ${subscriber.name}:`, error);
        
        // 发布错误事件
        this.publish('event.processing.failed', {
          originalEvent: event,
          subscriber: subscriber.name,
          error: error.message
        });
      }
    });
    
    console.log(`📢 事件已发布: ${eventType}`);
    return event;
  }

  // 事件订阅
  subscribe(eventType, handler, options = {}) {
    const subscriber = {
      id: this.generateSubscriberId(),
      name: options.name || 'anonymous',
      handler,
      options
    };
    
    if (!this.subscribers.has(eventType)) {
      this.subscribers.set(eventType, []);
    }
    
    this.subscribers.get(eventType).push(subscriber);
    console.log(`🔔 订阅事件: ${eventType} -> ${subscriber.name}`);
    
    return subscriber.id;
  }

  // 取消订阅
  unsubscribe(eventType, subscriberId) {
    const subscribers = this.subscribers.get(eventType);
    if (subscribers) {
      const index = subscribers.findIndex(s => s.id === subscriberId);
      if (index !== -1) {
        subscribers.splice(index, 1);
        console.log(`🔕 取消订阅: ${eventType}`);
      }
    }
  }

  // 事件重放
  replay(eventType, fromTimestamp = null) {
    const events = this.eventStore.filter(event => {
      const matchType = event.type === eventType;
      const matchTime = !fromTimestamp || 
        new Date(event.metadata.timestamp) >= new Date(fromTimestamp);
      return matchType && matchTime;
    });
    
    console.log(`🔄 重放事件: ${eventType}, 数量: ${events.length}`);
    
    events.forEach(event => {
      const subscribers = this.subscribers.get(eventType) || [];
      subscribers.forEach(subscriber => {
        if (subscriber.options.replayable !== false) {
          subscriber.handler(event);
        }
      });
    });
  }

  generateEventId() {
    return `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  generateSubscriberId() {
    return `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  generateCorrelationId() {
    return `corr_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  // 获取事件统计
  getEventStats() {
    const stats = {
      totalEvents: this.eventStore.length,
      eventTypes: {},
      subscribers: {}
    };
    
    // 统计事件类型
    this.eventStore.forEach(event => {
      stats.eventTypes[event.type] = (stats.eventTypes[event.type] || 0) + 1;
    });
    
    // 统计订阅者
    this.subscribers.forEach((subs, eventType) => {
      stats.subscribers[eventType] = subs.length;
    });
    
    return stats;
  }
}

// Saga管理器（处理分布式事务）
class SagaManager {
  constructor() {
    this.sagas = new Map();
    this.sagaSteps = new Map();
  }

  // 定义Saga
  defineSaga(sagaName, steps) {
    this.sagaSteps.set(sagaName, steps);
    console.log(`📋 定义Saga: ${sagaName}`);
  }

  // 启动Saga
  startSaga(sagaName, initialData, correlationId) {
    const steps = this.sagaSteps.get(sagaName);
    if (!steps) {
      throw new Error(`Saga not found: ${sagaName}`);
    }
    
    const saga = {
      id: this.generateSagaId(),
      name: sagaName,
      correlationId,
      status: 'running',
      currentStep: 0,
      data: initialData,
      completedSteps: [],
      startTime: new Date().toISOString()
    };
    
    this.sagas.set(saga.id, saga);
    console.log(`🚀 启动Saga: ${sagaName} (${saga.id})`);
    
    this.executeNextStep(saga.id);
    return saga.id;
  }

  // 执行下一步
  async executeNextStep(sagaId) {
    const saga = this.sagas.get(sagaId);
    if (!saga || saga.status !== 'running') {
      return;
    }
    
    const steps = this.sagaSteps.get(saga.name);
    if (saga.currentStep >= steps.length) {
      // Saga完成
      saga.status = 'completed';
      saga.endTime = new Date().toISOString();
      console.log(`✅ Saga完成: ${saga.name} (${sagaId})`);
      return;
    }
    
    const step = steps[saga.currentStep];
    
    try {
      console.log(`⚡ 执行Saga步骤: ${step.name}`);
      const result = await step.execute(saga.data);
      
      saga.completedSteps.push({
        stepIndex: saga.currentStep,
        stepName: step.name,
        result,
        timestamp: new Date().toISOString()
      });
      
      saga.currentStep++;
      saga.data = { ...saga.data, ...result };
      
      // 继续下一步
      this.executeNextStep(sagaId);
      
    } catch (error) {
      console.error(`❌ Saga步骤失败: ${step.name}:`, error);
      
      // 开始补偿
      await this.compensate(sagaId, error);
    }
  }

  // 补偿操作
  async compensate(sagaId, error) {
    const saga = this.sagas.get(sagaId);
    saga.status = 'compensating';
    saga.error = error.message;
    
    console.log(`🔄 开始补偿: ${saga.name} (${sagaId})`);
    
    // 逆序执行补偿操作
    for (let i = saga.completedSteps.length - 1; i >= 0; i--) {
      const completedStep = saga.completedSteps[i];
      const steps = this.sagaSteps.get(saga.name);
      const step = steps[completedStep.stepIndex];
      
      if (step.compensate) {
        try {
          await step.compensate(completedStep.result, saga.data);
          console.log(`↩️ 补偿完成: ${step.name}`);
        } catch (compensateError) {
          console.error(`❌ 补偿失败: ${step.name}:`, compensateError);
        }
      }
    }
    
    saga.status = 'failed';
    saga.endTime = new Date().toISOString();
    console.log(`❌ Saga失败: ${saga.name} (${sagaId})`);
  }

  generateSagaId() {
    return `saga_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  // 获取Saga状态
  getSagaStatus(sagaId) {
    return this.sagas.get(sagaId);
  }

  // 获取所有Saga统计
  getSagaStats() {
    const stats = {
      total: this.sagas.size,
      running: 0,
      completed: 0,
      failed: 0,
      compensating: 0
    };
    
    this.sagas.forEach(saga => {
      stats[saga.status]++;
    });
    
    return stats;
  }
}

// AI工作流事件示例
class AIWorkflowEvents {
  constructor(eventBus) {
    this.eventBus = eventBus;
    this.setupEventHandlers();
  }

  setupEventHandlers() {
    // 数据预处理完成事件
    this.eventBus.subscribe('data.preprocessed', async (event) => {
      console.log('🔄 数据预处理完成，开始特征提取');
      
      // 触发特征提取
      this.eventBus.publish('feature.extraction.requested', {
        dataId: event.data.dataId,
        preprocessedData: event.data.result
      }, {
        correlationId: event.metadata.correlationId
      });
    }, { name: 'FeatureExtractionTrigger' });
    
    // 特征提取完成事件
    this.eventBus.subscribe('feature.extracted', async (event) => {
      console.log('🎯 特征提取完成，开始模型推理');
      
      // 触发模型推理
      this.eventBus.publish('model.inference.requested', {
        features: event.data.features,
        modelId: event.data.modelId
      }, {
        correlationId: event.metadata.correlationId
      });
    }, { name: 'ModelInferenceTrigger' });
    
    // 模型推理完成事件
    this.eventBus.subscribe('model.inference.completed', async (event) => {
      console.log('✅ 模型推理完成，保存结果');
      
      // 保存推理结果
      this.eventBus.publish('result.save.requested', {
        inferenceResult: event.data.result,
        requestId: event.data.requestId
      }, {
        correlationId: event.metadata.correlationId
      });
    }, { name: 'ResultSaver' });
  }

  // 启动AI工作流
  startAIWorkflow(inputData) {
    const correlationId = this.eventBus.generateCorrelationId();
    
    console.log('🚀 启动AI工作流');
    
    this.eventBus.publish('data.preprocessing.requested', {
      inputData,
      requestId: `req_${Date.now()}`
    }, {
      correlationId,
      source: 'AIWorkflow'
    });
    
    return correlationId;
  }
}

// 使用示例
const eventBus = new EventDrivenArchitecture();
const aiWorkflow = new AIWorkflowEvents(eventBus);

// 模拟事件处理器
eventBus.subscribe('data.preprocessing.requested', async (event) => {
  console.log('🔄 开始数据预处理');
  
  // 模拟异步处理
  setTimeout(() => {
    eventBus.publish('data.preprocessed', {
      dataId: event.data.requestId,
      result: { processed: true, data: event.data.inputData }
    }, {
      correlationId: event.metadata.correlationId
    });
  }, 1000);
}, { name: 'DataPreprocessor' });

// 启动工作流
const workflowId = aiWorkflow.startAIWorkflow({ text: 'Hello, AI!' });
console.log('📊 事件统计:', eventBus.getEventStats());

module.exports = {
  ArchitecturePatterns,
  EventDrivenArchitecture,
  SagaManager,
  AIWorkflowEvents
};

🎯 学习检验​

理论理解检验​

  1. 架构原则：能否理解和应用SOLID等设计原则？
  2. 架构模式：能否选择合适的架构模式？
  3. 事件驱动：能否设计事件驱动的AI工作流？
  4. 可扩展性：能否设计可扩展的AI应用架构？

实践能力检验​

  1. 架构设计：能否设计完整的AI应用架构？
  2. 服务拆分：能否合理拆分AI应用的服务？
  3. 数据流设计：能否设计高效的数据处理流程？
  4. 监控体系：能否构建完整的监控和运维体系？

🚀 实践项目建议​

基础实战项目​

  1. AI聊天应用架构：设计可扩展的AI聊天应用
  2. 图像处理服务架构：构建图像AI处理的微服务架构
  3. 推荐系统架构：设计实时推荐系统的架构
  4. AI工作流引擎：构建事件驱动的AI工作流系统

高级综合项目​

  1. 企业AI平台：构建企业级的AI能力平台
  2. 多租户AI服务：设计支持多租户的AI服务架构
  3. AI模型管理平台：构建完整的MLOps平台
  4. 智能运维系统：基于AI的运维监控和自动化系统

📚 延伸阅读​

技术文档​

  1. "Building Microservices" - 微服务架构设计
  2. "Designing Data-Intensive Applications" - 数据密集型应用设计
  3. "Site Reliability Engineering" - 站点可靠性工程
  4. "Clean Architecture" - 整洁架构

开源项目​

  1. Kubernetes - 容器编排平台
  2. Istio - 服务网格
  3. Apache Kafka - 分布式流处理平台
  4. Prometheus - 监控和告警系统

💡 学习提示：AI应用架构设计需要综合考虑业务需求、技术约束和团队能力。建议从简单的架构开始，逐步演进到复杂的分布式架构。重视可观测性和容错性的设计，这对AI应用尤其重要。实践中要关注性能优化和成本控制，合理选择技术栈和部署方案。