CPP-Summit-2020 学习:Modern C++ 整洁代码最佳实践(软件架构部分)

CPP-Summit-2020 学习:Modern C++ 整洁代码最佳实践(软件架构部分)

一、什么是软件架构？

“软件架构（Software Architecture）”在业界确实没有一个唯一标准定义。正如你说的——在大街上问一百个人，可能会有一百零一种说法。
但从学术界和工程实践来看，可以抽象为一句话：

软件架构 = 系统的高层结构 + 关键决策 + 约束关系
更正式一点，可以理解为：
S o f t w a r e   A r c h i t e c t u r e = S t r u c t u r e + I n t e r a c t i o n + C o n s t r a i n t s + P r i n c i p l e s Software\ Architecture = Structure + Interaction + Constraints + Principles Software Architecture=Structure+Interaction+Constraints+Principles
也可以表示为一种映射关系：
A r c h i t e c t u r e : R e q u i r e m e n t s → S y s t e m   S t r u c t u r e Architecture : Requirements \rightarrow System\ Structure Architecture:Requirements→System Structure
即：

• 输入：需求（功能需求 + 非功能需求）
• 输出：系统结构（模块划分 + 通信方式 + 部署方式 + 技术选型）

二、架构关注的核心问题

架构不是“写代码”，而是解决系统级问题：

1. 系统如何分层？
2. 模块如何拆分？
3. 如何通信？
4. 数据如何流动？
5. 如何保证扩展性？
6. 如何保证性能？
7. 如何保证可靠性？
   架构主要解决的是“复杂度问题”。
   我们可以把系统复杂度抽象成：
   C o m p l e x i t y = f ( S i z e , C o u p l i n g , C o n c u r r e n c y , D i s t r i b u t i o n ) Complexity = f(Size, Coupling, Concurrency, Distribution) Complexity=f(Size,Coupling,Concurrency,Distribution)
   其中：

• Size：规模
• Coupling：耦合度
• Concurrency：并发
• Distribution：分布式程度
  架构设计的目标就是：
  M i n i m i z e   C o m p l e x i t y   w h i l e   S a t i s f y i n g   R e q u i r e m e n t s Minimize\ Complexity\ while\ Satisfying\ Requirements Minimize Complexity while Satisfying Requirements

三、“剑宗”和“气宗”的两大门派

这是一个非常形象的比喻。

1⃣ 剑宗 —— 结构派

剑宗认为：

架构 = 系统结构
他们强调：

• 分层
• 模块划分
• 组件依赖关系
• 接口定义
  代表思想包括：
• 分层架构
• MVC
• 微服务
• 六边形架构
• Clean Architecture
  他们认为：
  G o o d   S t r u c t u r e ⇒ G o o d   S y s t e m Good\ Structure \Rightarrow Good\ System Good Structure⇒Good System

示例：分层架构

// 表示一个典型三层架构的结构示意// ========================// 表现层（Presentation Layer）// ========================classUserController{public:voidlogin(){// 调用业务层 userService.login();}private: UserService userService;// 依赖业务层};// ========================// 业务层（Business Layer）// ========================classUserService{public:voidlogin(){// 执行业务逻辑 userRepository.queryUser();}private: UserRepository userRepository;// 依赖数据层};// ========================// 数据层（Data Layer）// ========================classUserRepository{public:voidqueryUser(){// 模拟数据库访问 std::cout <<"Query DB"<< std::endl;}};

这里的核心是：

• 清晰的层级结构
• 单向依赖
• 高内聚、低耦合
  这就是典型“剑宗”思想：结构即架构。

2⃣ 气宗 —— 决策派

气宗认为：

架构不是结构，而是“关键设计决策”
他们更关注：

• 技术选型
• 性能策略
• 容错机制
• 扩展方式
• 数据一致性策略
• CAP 权衡
  他们认为：
  A r c h i t e c t u r e = S e t   o f   S i g n i f i c a n t   D e s i g n   D e c i s i o n s Architecture = Set\ of\ Significant\ Design\ Decisions Architecture=Set of Significant Design Decisions
  例如：
• 是否使用微服务？
• 是否使用消息队列？
• 是否采用最终一致性？
• 是否使用缓存？
• 是否选择 CQRS？
  例如，在分布式系统中，我们面对 CAP 定理：
  C + A + P ≤ 2 C + A + P \leq 2 C+A+P≤2
  （即：一致性、可用性、分区容忍性，三者最多满足两个）
  选择 AP 还是 CP，本身就是架构决策。

示例：缓存架构决策

classUserService{public: std::string getUser(int id){// 先查缓存if(cache.count(id)){return cache[id];// 命中缓存}// 再查数据库 std::string user =queryDB(id);// 写入缓存 cache[id]= user;return user;}private: std::unordered_map<int, std::string> cache; std::string queryDB(int id){// 模拟数据库查询return"User_"+ std::to_string(id);}};

这里的关键不是代码本身，而是：

• 为什么要加缓存？
• 是否需要一致性保证？
• 是否需要失效机制？
  这才是“气宗”关注的内容。

四、两大门派的本质区别

五、现代统一观点：结构 + 决策

现代架构理论认为：
A r c h i t e c t u r e = S t r u c t u r e + B e h a v i o r + D e c i s i o n s Architecture = Structure + Behavior + Decisions Architecture=Structure+Behavior+Decisions
更精确表达为：
A = ( C o m p o n e n t s ,   C o n n e c t o r s ,   C o n s t r a i n t s ,   D e c i s i o n s ) A = (Components,\ Connectors,\ Constraints,\ Decisions) A=(Components, Connectors, Constraints, Decisions)

• Components：组件
• Connectors：连接方式
• Constraints：约束
• Decisions：关键决策
  也可以抽象成一个四元组：
  A = ⟨ S , R , C , D ⟩ A = \langle S, R, C, D \rangle A=⟨S,R,C,D⟩
  其中：
• S S S：Structure（结构）
• R R R：Runtime behavior（运行时行为）
• C C C：Constraints（约束）
• D D D：Design decisions（关键决策）

六、架构与代码的关系

代码是架构的具体实现。
可以表示为：
C o d e ⊂ I m p l e m e n t a t i o n ( A r c h i t e c t u r e ) Code \subset Implementation(Architecture) Code⊂Implementation(Architecture)
架构决定：

• 代码怎么组织
• 模块如何依赖
• 数据如何流动
  但架构 ≠ 代码。

七、一个更深层的理解

可以从“控制复杂度”的角度理解：
软件系统本质是一个状态变换系统：
S y s t e m : I n p u t → S t a t e → O u t p u t System : Input \rightarrow State \rightarrow Output System:Input→State→Output
架构的作用是：

• 约束状态变化路径
• 降低耦合
• 限制复杂度传播
  复杂度传播可以抽象为：
  C o u p l i n g ↑ ⇒ C h a n g e   C o s t ↑ Coupling \uparrow \Rightarrow Change\ Cost \uparrow Coupling↑⇒Change Cost↑
  好的架构目标是：
  d ( C h a n g e   C o s t ) d ( T i m e ) ≈ C o n s t a n t \frac{d(Change\ Cost)}{d(Time)} \approx Constant d(Time)d(Change Cost)​≈Constant
  也就是说：

随着时间增长，修改成本保持相对稳定。
这才是架构真正的价值。

八、总结一句话

软件架构不是：

• 画图
• 分层
• 用框架
  而是：

在满足需求的前提下，通过结构设计和关键决策，控制系统复杂度，使系统在长期演化中保持可控。

架构设计基础——架构设计的作用

需求 → 架构设计 → 系统开发 → 软件架构 → 软件系统
我们可以把它理解为软件从“想法”到“落地”的中间桥梁过程。

一、架构设计在整个流程中的位置

软件开发流程可以抽象为一个函数变换过程：
S o f t w a r e   S y s t e m = f ( R e q u i r e m e n t s ) Software\ System = f(Requirements) Software System=f(Requirements)
但这个函数 f f f 不是一步完成的，而是分阶段实现：
R e q u i r e m e n t s → A r c h i t e c t u r e → I m p l e m e n t a t i o n → S y s t e m Requirements \rightarrow Architecture \rightarrow Implementation \rightarrow System Requirements→Architecture→Implementation→System
也可以写成函数复合：
S y s t e m = I ( A ( R ) ) System = I(A(R)) System=I(A(R))
其中：

• R R R：需求（Requirements）
• A A A：架构设计（Architecture Design）
• I I I：实现（Implementation）
• S y s t e m System System：最终软件系统
  架构设计就是需求与实现之间的映射层。

二、架构设计的核心作用

架构设计的作用可以总结为五个核心功能：

1⃣ 把“需求”转化为“可实现结构”

需求通常是自然语言，例如：

• 支持百万用户
• 响应时间 < 100ms
• 7×24小时可用
• 支持水平扩展
  这些是“问题空间（Problem Space）”。
  架构设计把它转化为“解决空间（Solution Space）”：
• 是否使用缓存？
• 是否使用分布式？
• 是否采用微服务？
• 是否使用负载均衡？
  可以表示为映射关系：
  A r c h i t e c t u r e : P r o b l e m   S p a c e → S o l u t i o n   S p a c e Architecture : Problem\ Space \rightarrow Solution\ Space Architecture:Problem Space→Solution Space

2⃣ 控制系统复杂度

软件系统复杂度大致与规模和耦合度有关：
C o m p l e x i t y ≈ O ( N 2 ) ( 高度耦合情况下 ) Complexity \approx O(N^2) \quad (高度耦合情况下) Complexity≈O(N2)(高度耦合情况下)
如果架构合理分层、解耦：
C o m p l e x i t y ≈ O ( N ) Complexity \approx O(N) Complexity≈O(N)
架构设计的作用就是：
M i n i m i z e   C o u p l i n g Minimize\ Coupling Minimize Coupling
并提高：
M a x i m i z e   C o h e s i o n Maximize\ Cohesion Maximize Cohesion

3⃣ 决定系统的质量属性

功能需求回答：

系统做什么？
架构回答：
系统“如何”做？
架构决定：

• 性能
• 可扩展性
• 可维护性
• 安全性
• 可用性
  例如：
  如果需求是：

支持 10 万 QPS
架构决策可能包括：

• 使用缓存
• 使用读写分离
• 使用消息队列削峰
• 使用分布式部署

4⃣ 降低未来变更成本

系统演化成本可以抽象为：
C h a n g e   C o s t = f ( C o u p l i n g , S i z e , E n t r o p y ) Change\ Cost = f(Coupling, Size, Entropy) Change Cost=f(Coupling,Size,Entropy)
好的架构目标是：
d ( C h a n g e   C o s t ) d ( T i m e ) ≈ C o n s t a n t \frac{d(Change\ Cost)}{d(Time)} \approx Constant d(Time)d(Change Cost)​≈Constant
即：随着时间增长，修改成本保持稳定，而不是指数级增长。

5⃣ 作为团队协作的“蓝图”

架构是一种“共识”。
没有架构：

• 每个人写自己的代码风格
• 模块边界混乱
• 依赖关系失控
  架构定义：
• 模块边界
• 接口规范
• 数据流方向
• 分层规则
  它是团队协作的“约束系统”。

三、需求 → 架构 → 系统 的具体理解

我们通过一个实际例子说明。

场景：设计一个用户登录系统

1⃣ 需求

• 用户可以登录
• 支持 1 万并发
• 响应时间 < 200ms
• 数据必须持久化

2⃣ 架构设计决策

架构师会思考：

• 是否分层？
• 是否使用缓存？
• 是否使用数据库连接池？
• 是否使用负载均衡？
  假设我们设计为三层架构：
• 表现层
• 业务层
• 数据层

3⃣ 代码实现示例（带详细注释）

#include<iostream>#include<unordered_map>#include<string>// ===============================// 模拟数据库层（Data Layer）// ===============================classUserRepository{public:// 查询数据库（模拟） std::string findUser(const std::string& username){// 实际项目中这里会连接数据库return"password123";}};// ===============================// 业务层（Business Layer）// ===============================classUserService{public:UserService(UserRepository& repo):repository(repo){}// 登录逻辑boollogin(const std::string& username,const std::string& password){// 1. 查询数据库 std::string realPassword = repository.findUser(username);// 2. 验证密码return realPassword == password;}private: UserRepository& repository;// 依赖数据层};// ===============================// 表现层（Presentation Layer）// ===============================classUserController{public:UserController(UserService& service):userService(service){}voidhandleLogin(){ std::string username ="admin"; std::string password ="password123";if(userService.login(username, password)){ std::cout <<"Login Success\n";}else{ std::cout <<"Login Failed\n";}}private: UserService& userService;// 依赖业务层};

四、没有架构设计会发生什么？

如果没有架构，代码可能会变成：

// 典型的“上帝函数”写法（无架构）voidlogin(){// 直接写数据库逻辑 std::string realPassword ="password123";// 直接写业务逻辑if(realPassword =="password123"){ std::cout <<"Login Success\n";}}

问题：

• 逻辑耦合
• 无法扩展
• 无法测试
• 无法替换数据库
• 无法增加缓存
  复杂度增长会变成：
  C o u p l i n g ↑ ⇒ M a i n t e n a n c e   C o s t ↑ Coupling \uparrow \Rightarrow Maintenance\ Cost \uparrow Coupling↑⇒Maintenance Cost↑

五、架构的真正作用总结

我们可以把架构设计作用总结为四句话：

1⃣ 架构是需求与实现之间的桥梁

A r c h i t e c t u r e = M a p p i n g ( R e q u i r e m e n t s → S t r u c t u r e ) Architecture = Mapping(Requirements \rightarrow Structure) Architecture=Mapping(Requirements→Structure)

2⃣ 架构是复杂度控制器

G o o d   A r c h i t e c t u r e ⇒ C o n t r o l l e d   C o m p l e x i t y Good\ Architecture \Rightarrow Controlled\ Complexity Good Architecture⇒Controlled Complexity

3⃣ 架构决定系统质量上限

系统性能的上限往往由架构决定，而不是代码优化。

4⃣ 架构是长期演化的保障

软件系统本质是一个长期演化系统：
S y s t e m ( t + 1 ) = S y s t e m ( t ) + C h a n g e System(t+1) = System(t) + Change System(t+1)=System(t)+Change
架构决定：
C o s t ( C h a n g e ) ≈ S t a b l e Cost(Change) \approx Stable Cost(Change)≈Stable

六、一句话总结

需求告诉我们“做什么”，
架构决定“怎么做”，
开发实现“具体做法”，
最终形成“软件系统”。
架构设计的本质作用：
在满足需求的前提下，通过结构设计与关键决策，控制复杂度，保障系统长期可演化。

架构设计基础——常见架构分类（一）

I、分层架构（Layered Architecture）

分层架构是最经典、最基础、最普遍的一种软件架构模式。
它的核心思想：

将系统按职责划分为不同层次，每一层只负责自己的职责，并通过“自上而下”的方式进行调用。

一、分层架构的本质

可以抽象成数学结构：
S y s t e m = L 1 + L 2 + L 3 + ⋯ + L n System = L_1 + L_2 + L_3 + \cdots + L_n System=L1​+L2​+L3​+⋯+Ln​
其中：

• L 1 L_1 L1​：呈现层（Presentation）
• L 2 L_2 L2​：业务逻辑层（Business）
• L 3 L_3 L3​：数据持久层（Persistence）
• L 4 L_4 L4​：数据存储层（Storage）
  层之间满足：
  L i → L i + 1 L_i \rightarrow L_{i+1} Li​→Li+1​
  即：上层依赖下层，下层不依赖上层。
  如果违反这个规则，耦合度就会上升：
  C o u p l i n g ↑ ⇒ C o m p l e x i t y ↑ Coupling \uparrow \Rightarrow Complexity \uparrow Coupling↑⇒Complexity↑

二、典型四层结构

你列出的结构可以整理为：

呈现层（Presentation Layer） ↓ 业务逻辑层（Business Layer） ↓ 数据持久层（Persistence Layer） ↓ 数据存储层（Storage Layer） 

我们逐层解释。

1⃣ 呈现层（Presentation Layer）

负责：

• 用户交互
• UI展示
• 接收输入
• 调用业务逻辑
  特点：
• 不写核心业务逻辑
• 不直接访问数据库

2⃣ 业务逻辑层（Business Layer）

负责：

• 核心业务规则
• 数据校验
• 业务流程控制
• 事务控制
  这是系统的“灵魂层”。

3⃣ 数据持久层（Persistence Layer）

负责：

• 数据库操作
• CRUD
• ORM映射
  它不关心业务，只负责数据读写。

4⃣ 数据存储层（Storage Layer）

包括：

• MySQL
• Redis
• 文件系统
• 区块链存储
• NoSQL

三、代码示例（C++分层结构示例）

下面是一个简化示例（带详细注释）。

1⃣ 数据存储层（模拟数据库）

#include<iostream>#include<unordered_map>#include<string>// ============================// 数据存储层（Storage Layer）// ============================// 这里模拟数据库classDatabase{public:voidsave(const std::string& key,const std::string& value){ storage[key]= value;} std::string get(const std::string& key){return storage[key];}private: std::unordered_map<std::string, std::string> storage;};

2⃣ 数据持久层

// ============================// 数据持久层（Persistence Layer）// ============================classUserRepository{public:UserRepository(Database& db):database(db){}voidsaveUser(const std::string& username,const std::string& password){// 只负责存储，不管业务逻辑 database.save(username, password);} std::string findUser(const std::string& username){return database.get(username);}private: Database& database;};

3⃣ 业务逻辑层

// ============================// 业务逻辑层（Business Layer）// ============================classUserService{public:UserService(UserRepository& repo):repository(repo){}boollogin(const std::string& username,const std::string& password){// 查询数据库 std::string realPassword = repository.findUser(username);// 业务逻辑判断return realPassword == password;}private: UserRepository& repository;};

4⃣ 呈现层

// ============================// 呈现层（Presentation Layer）// ============================classUserController{public:UserController(UserService& service):userService(service){}voidhandleLogin(){ std::string username ="admin"; std::string password ="123";if(userService.login(username, password)){ std::cout <<"Login Success\n";}else{ std::cout <<"Login Failed\n";}}private: UserService& userService;};

四、MVC、MVVM、MVP 的本质区别

它们都是“分层架构”的变种，主要用于前端或UI系统。

1⃣ MVC（Model-View-Controller）

结构：

View → Controller → Model ↑ ↓ ←--------- 

• Model：数据模型
• View：界面
• Controller：控制逻辑
  数学抽象：
  V i e w = f ( M o d e l ) View = f(Model) View=f(Model)
  C o n t r o l l e r = g ( I n p u t ) Controller = g(Input) Controller=g(Input)
  优点：
• 逻辑分离
• 易于维护
  缺点：
• Controller 容易变成“上帝类”

2⃣ MVP（Model-View-Presenter）

改进 MVC：

• View 只负责显示
• Presenter 负责逻辑
  关系：
  V i e w ↔ P r e s e n t e r ↔ M o d e l View \leftrightarrow Presenter \leftrightarrow Model View↔Presenter↔Model
  View 变成“被动视图”。

3⃣ MVVM（Model-View-ViewModel）

核心思想：数据绑定。
V i e w ↔ V i e w M o d e l ↔ M o d e l View \leftrightarrow ViewModel \leftrightarrow Model View↔ViewModel↔Model
自动同步：
U I = f ( S t a t e ) UI = f(State) UI=f(State)
当状态改变时：
Δ S t a t e ⇒ Δ U I \Delta State \Rightarrow \Delta UI ΔState⇒ΔUI
优点：

• 自动数据绑定
• 更适合现代前端框架

五、SSH 架构

SSH =

• Struts
• Spring
• Hibernate
  这是 Java 时代经典三层架构整合方案：
• Struts → 表现层
• Spring → 业务层
• Hibernate → 持久层
  本质仍然是分层架构。

六、Blockchain 为什么也算一种架构？

区块链是一种分布式架构模式。
它的核心特点：

• 去中心化
• 数据不可篡改
• 共识机制
  数据结构是链式结构：
  B l o c k n = H a s h ( B l o c k n − 1 ) + D a t a n Block_n = Hash(Block_{n-1}) + Data_n Blockn​=Hash(Blockn−1​)+Datan​
  整个链：
  C h a i n = ∑ i = 1 n B l o c k i Chain = \sum_{i=1}^{n} Block_i Chain=i=1∑n​Blocki​
  它改变的是：
• 数据存储方式
• 信任模型
• 一致性机制
  这是一种“去中心化分层架构”。

七、分层架构的优缺点

优点

• 清晰
• 易维护
• 易扩展
• 易测试

缺点

• 性能损耗（多层调用）
• 可能过度设计
• 容易出现“层间穿透”

八、分层架构的本质作用

可以用一句公式总结：
D i v i d e   C o m p l e x i t y   i n t o   M a n a g e a b l e   L a y e r s Divide\ Complexity\ into\ Manageable\ Layers Divide Complexity into Manageable Layers
或者：
C o m p l e x i t y = ∑ i = 1 n C o m p l e x i t y ( L i ) Complexity = \sum_{i=1}^{n} Complexity(L_i) Complexity=i=1∑n​Complexity(Li​)
通过分层，把整体复杂度拆分为局部复杂度。

九、总结一句话

分层架构的本质是：

通过职责分离和层次划分，降低耦合，提高可维护性，使系统复杂度可控。

架构设计基础——常见架构分类

事件事件队列事件协调者事件队列事件队列事件队列事件处理器处理模块处理模块处理模块处理模块

II、事件驱动架构（Event-Driven Architecture, EDA）

事件驱动架构（EDA）是一种以“事件”为核心的架构风格。
代表技术包括：

• Node.js
• Apache Flink

一、什么是“事件”？

在计算机系统中：

事件 = 某种状态变化的通知
可以抽象表示为：
E v e n t = ( S o u r c e , T i m e s t a m p , P a y l o a d ) Event = (Source, Timestamp, Payload) Event=(Source,Timestamp,Payload)
其中：

• S o u r c e Source Source：事件来源
• T i m e s t a m p Timestamp Timestamp：发生时间
• P a y l o a d Payload Payload：数据内容
  例如：
• 用户点击按钮
• 订单创建成功
• 传感器温度变化
• 消息到达

二、事件驱动架构的核心思想

传统架构（同步调用）：

A → 调用 → B → 返回 → A 

事件驱动架构：

A → 发布事件 → 事件队列 → 消费者处理 

抽象模型：
P r o d u c e r → E v e n t Q u e u e → C o n s u m e r Producer \rightarrow EventQueue \rightarrow Consumer Producer→EventQueue→Consumer
核心特性：

• 解耦
• 异步
• 可扩展
• 高并发

三、你给出的结构图解析

你提供的 SVG 图，本质结构如下：

 事件 ↓ 事件队列 ↓ 事件协调者 ↓ ↓ ↓ 事件队列 事件队列 事件队列 ↓ ↓ ↓ ↓ ↓ 处理器 处理器 处理器 处理器 处理器 

可以形式化表示为：
E v e n t → D i s p a t c h e r → Q u e u e i i = 1 n Event \rightarrow Dispatcher \rightarrow {Queue_i}_{i=1}^n Event→Dispatcher→Queuei​i=1n​
Q u e u e i → P r o c e s s o r i j j = 1 m i Queue_i \rightarrow {Processor_{ij}}_{j=1}^{m_i} Queuei​→Processorij​j=1mi​​
这意味着：

• 一个事件可以被分发到多个队列
• 每个队列可以并行处理
• 每个队列内部可以有多个处理模块

四、事件驱动架构的运行机制

整个系统可以抽象为一个状态变换系统：
S t a t e t + 1 = S t a t e t + ∑ i = 1 n E v e n t i State_{t+1} = State_t + \sum_{i=1}^{n} Event_i Statet+1​=Statet​+i=1∑n​Eventi​
即：
系统状态是所有事件累积的结果。
如果事件是独立的，理论吞吐量：
T h r o u g h p u t ≈ N × P r o c e s s i n g R a t e Throughput \approx N \times ProcessingRate Throughput≈N×ProcessingRate
其中：

• N N N：并行消费者数量
• P r o c e s s i n g R a t e ProcessingRate ProcessingRate：单处理器速率

五、代码示例：简单事件驱动模型（C++）

1⃣ 定义事件结构

#include<iostream>#include<queue>#include<functional>#include<unordered_map>// =============================// 事件结构// =============================structEvent{ std::string type;// 事件类型 std::string data;// 事件数据};

2⃣ 事件总线（Event Bus）

// =============================// 事件总线（负责注册和分发）// =============================classEventBus{public:// 注册事件处理器voidsubscribe(const std::string& type, std::function<void(const Event&)> handler){ handlers[type].push_back(handler);}// 发布事件voidpublish(const Event& event){// 找到对应的处理器for(auto& handler : handlers[event.type]){handler(event);// 异步系统中这里通常会放入队列}}private: std::unordered_map< std::string, std::vector<std::function<void(const Event&)>>> handlers;};

3⃣ 使用示例

intmain(){ EventBus bus;// 注册订单处理模块 bus.subscribe("OrderCreated",[](const Event& e){ std::cout <<"库存系统处理订单: "<< e.data << std::endl;});// 注册通知模块 bus.subscribe("OrderCreated",[](const Event& e){ std::cout <<"发送通知: "<< e.data << std::endl;});// 发布事件 bus.publish({"OrderCreated","订单ID=1001"});return0;}

运行结果：

库存系统处理订单: 订单ID=1001 发送通知: 订单ID=1001 

特点：

• 发布者不知道谁会处理
• 消费者之间互不依赖
• 完全解耦

#include<iostream>#include<string>#include<unordered_map>#include<vector>#include<functional>#include<queue>#include<thread>#include<mutex>#include<condition_variable>#include<atomic>// ===============================// 1⃣ 事件结构// ===============================structEvent{ std::string type;// 事件类型 std::string data;// 事件数据};// ===============================// 2⃣ 线程安全队列// ===============================classThreadSafeQueue{public:// 向队列中添加事件voidpush(const Event& event){{ std::lock_guard<std::mutex>lock(mutex_); queue_.push(event);} cond_.notify_one();// 通知消费者线程}// 从队列中取出事件（阻塞）boolpop(Event& event){ std::unique_lock<std::mutex>lock(mutex_);// 等待直到有数据或停止标志 cond_.wait(lock,[this](){return!queue_.empty()|| stopped_;});if(stopped_ && queue_.empty())returnfalse; event = queue_.front(); queue_.pop();returntrue;}// 停止队列voidstop(){{ std::lock_guard<std::mutex>lock(mutex_); stopped_ =true;} cond_.notify_all();}private: std::queue<Event> queue_; std::mutex mutex_; std::condition_variable cond_;bool stopped_ =false;};// ===============================// 3⃣ 事件总线// ===============================classEventBus{public:EventBus():running_(true){// 启动工作线程 worker_ = std::thread([this](){this->process();});}~EventBus(){stop();}// 注册事件处理器voidsubscribe(const std::string& type, std::function<void(const Event&)> handler){ handlers_[type].push_back(handler);}// 发布事件（生产者调用）voidpublish(const Event& event){ queue_.push(event);}// 停止系统voidstop(){if(running_){ running_ =false; queue_.stop();if(worker_.joinable()) worker_.join();}}private:// 后台处理线程voidprocess(){while(running_){ Event event;if(!queue_.pop(event))break;// 分发事件给订阅者auto it = handlers_.find(event.type);if(it != handlers_.end()){for(auto& handler : it->second){handler(event);}}}}private: ThreadSafeQueue queue_; std::unordered_map< std::string, std::vector<std::function<void(const Event&)>>> handlers_; std::thread worker_; std::atomic<bool> running_;};// ===============================// 4⃣ 示例主函数// ===============================intmain(){ EventBus bus;// 订阅订单创建事件 bus.subscribe("OrderCreated",[](const Event& e){ std::cout <<"[库存系统] 处理订单: "<< e.data << std::endl;}); bus.subscribe("OrderCreated",[](const Event& e){ std::cout <<"[通知系统] 发送通知: "<< e.data << std::endl;}); bus.subscribe("PaymentCompleted",[](const Event& e){ std::cout <<"[账务系统] 处理支付: "<< e.data << std::endl;});// 发布事件 bus.publish({"OrderCreated","订单ID=1001"}); bus.publish({"PaymentCompleted","支付ID=9001"}); bus.publish({"OrderCreated","订单ID=1002"});// 等待一会让线程处理完 std::this_thread::sleep_for(std::chrono::seconds(1)); bus.stop();return0;}

https://godbolt.org/z/G9ada8573

worker threadThreadSafeQueueEventBusmain()worker threadThreadSafeQueueEventBusmain()初始化阶段订阅阶段（同步）发布事件（异步投递）关闭阶段EventBus() 构造启动线程 [this->>process()]构造完成subscribe("OrderCreated", 库存处理器)handlers_["OrderCreated"].push_back(...)subscribe("OrderCreated", 通知处理器)subscribe("PaymentCompleted", 账务处理器)publish({"OrderCreated", "订单ID=1001"})push(Event)加锁 → queue_.push → 解锁cond_.notify_one()pop() → 阻塞等待返回 Event "OrderCreated 订单ID=1001"查找 handlers_["OrderCreated"]执行 库存处理器执行 通知处理器publish({"PaymentCompleted", "支付ID=9001"})push(Event)notify_onepop() → 返回 "PaymentCompleted"执行 账务处理器publish({"OrderCreated", "订单ID=1002"})push → notifypop → "OrderCreated 订单ID=1002"执行 库存 + 通知 处理器bus.stop()running_ = falsequeue_.stop() → stopped_=true + notify_allpop() 返回 false（队列空且stopped）while(running_) 退出循环worker_.join()线程结束stop() 返回

六、事件驱动 vs 分层架构

七、Node.js 为什么是事件驱动？

Node.js 采用：

• 单线程
• 事件循环（Event Loop）
• 非阻塞 I/O
  其模型：
  R e q u e s t → E v e n t L o o p → C a l l b a c k Request \rightarrow EventLoop \rightarrow Callback Request→EventLoop→Callback
  核心思想：
• 不阻塞线程
• 通过回调处理事件

八、Flink 为什么是事件驱动？

Apache Flink 是流处理框架。
它的模型是：
S t r e a m = E v e n t 1 , E v e n t 2 , E v e n t 3 , . . . Stream = {Event_1, Event_2, Event_3, ...} Stream=Event1​,Event2​,Event3​,...
每个事件都会触发：
f ( E v e n t i ) → N e w S t a t e f(Event_i) \rightarrow NewState f(Eventi​)→NewState
这是典型的“流式事件驱动架构”。

九、事件驱动的优势

1⃣ 高扩展性

如果新增一个处理逻辑：
只需：
A d d   C o n s u m e r Add\ Consumer Add Consumer
无需修改原有系统。

2⃣ 高并发能力

如果有 N N N 个消费者：
T h r o u g h p u t ∝ N Throughput \propto N Throughput∝N

3⃣ 解耦

发布者不依赖消费者：
P r o d u c e r ↮ C o n s u m e r Producer \not\leftrightarrow Consumer Producer↔Consumer

十、事件驱动的缺点

✗ 调试困难

事件链条复杂：
E 1 → E 2 → E 3 E_1 \rightarrow E_2 \rightarrow E_3 E1​→E2​→E3​
排查问题困难。

✗ 一致性复杂

由于异步：
C o n s i s t e n c y ↓ Consistency \downarrow Consistency↓
必须使用：

• 最终一致性
• 消息确认机制
• 重试机制

十一、本质总结

事件驱动架构可以抽象为：
S y s t e m = ∑ i = 1 n f ( E v e n t i ) System = \sum_{i=1}^{n} f(Event_i) System=i=1∑n​f(Eventi​)
系统的演化由事件驱动，而不是函数调用驱动。

十二、一句话总结

分层架构是“按职责拆分结构”，
事件驱动架构是“按事件流组织系统”。
它更适合：

• 高并发系统
• 分布式系统
• 实时流处理系统
• 微服务系统

架构设计基础——常见架构分类

III、微内核架构（Microkernel Architecture）

插件组件插件组件插件组件插件组件微内核

代表系统：

• Eclipse
• Vim

一、什么是微内核架构？

微内核架构是一种：

核心系统保持最小功能，其他功能通过插件扩展的架构模式。
结构可以抽象为：
S y s t e m = C o r e + ∑ i = 1 n P l u g i n i System = Core + \sum_{i=1}^{n} Plugin_i System=Core+i=1∑n​Plugini​
其中：

• C o r e Core Core：微内核（核心）
• P l u g i n i Plugin_i Plugini​：插件组件

二、结合你给出的图理解

图中结构：

插件 插件 插件 插件 ↓ ↓ ↓ ↓ 微内核 

数学表达：
P l u g i n i → C o r e Plugin_i \rightarrow Core Plugini​→Core
核心思想：

• 所有插件依赖内核
• 插件之间互不依赖
• 核心只提供基础能力

三、微内核的本质思想

可以理解为：
C o r e = M i n i m a l   S t a b l e   A P I Core = Minimal\ Stable\ API Core=Minimal Stable API
核心提供：

• 插件注册机制
• 生命周期管理
• 扩展点（Extension Point）
• 事件分发机制
  插件负责：
• 具体功能实现
• 业务逻辑扩展

四、和分层架构的区别

五、Eclipse 为什么是微内核架构？

Eclipse 的结构：

• 内核（Runtime + Plugin Framework）
• Java插件
• C++插件
• Git插件
• Maven插件
  抽象模型：
  E c l i p s e = R u n t i m e + ∑ P l u g i n Eclipse = Runtime + \sum Plugin Eclipse=Runtime+∑Plugin
  如果没有插件，Eclipse 几乎什么都做不了。
  这就是典型微内核。

六、Vim 为什么也是？

Vim：

• 核心编辑功能
• 语法高亮插件
• LSP插件
• Git插件
• 主题插件
  结构：
  V i m = C o r e E d i t o r + P l u g i n s Vim = CoreEditor + Plugins Vim=CoreEditor+Plugins

七、微内核架构的运行机制

假设系统有 n n n 个插件：
F u n c t i o n a l i t y = ∑ i = 1 n C a p a b i l i t y i Functionality = \sum_{i=1}^{n} Capability_i Functionality=i=1∑n​Capabilityi​
核心只负责调度：
C o r e : R e q u e s t → P l u g i n Core : Request \rightarrow Plugin Core:Request→Plugin

八、代码示例（C++模拟微内核）

1⃣ 定义插件接口

#include<iostream>#include<vector>#include<memory>// ===========================// 插件接口（抽象类）// ===========================classPlugin{public:virtualvoidexecute()=0;// 插件必须实现的方法virtual~Plugin()=default;};

2⃣ 实现具体插件

// ===========================// 插件A// ===========================classPluginA:publicPlugin{public:voidexecute()override{ std::cout <<"PluginA 执行\n";}};// ===========================// 插件B// ===========================classPluginB:publicPlugin{public:voidexecute()override{ std::cout <<"PluginB 执行\n";}};

3⃣ 微内核核心

// ===========================// 微内核核心// ===========================classMicroKernel{public:// 注册插件voidregisterPlugin(std::shared_ptr<Plugin> plugin){ plugins.push_back(plugin);}// 执行所有插件voidrun(){for(auto& plugin : plugins){ plugin->execute();// 调用插件能力}}private: std::vector<std::shared_ptr<Plugin>> plugins;};

4⃣ 使用示例

intmain(){ MicroKernel kernel;// 注册插件 kernel.registerPlugin(std::make_shared<PluginA>()); kernel.registerPlugin(std::make_shared<PluginB>());// 执行 kernel.run();return0;}

输出：

PluginA 执行 PluginB 执行 

核心没有业务逻辑，全部功能来自插件。

九、微内核架构的优势

1⃣ 高扩展性

新增功能：
A d d   P l u g i n Add\ Plugin Add Plugin
无需修改核心代码。

2⃣ 核心稳定

C o r e ≈ C o n s t a n t Core \approx Constant Core≈Constant
核心代码变动极少，稳定性高。

3⃣ 易于定制

不同组合：
S y s t e m i = C o r e + P l u g i n   S e t i System_i = Core + {Plugin\ Set_i} Systemi​=Core+Plugin Seti​
可构建不同产品版本。

十、微内核架构的缺点

✗ 插件依赖管理复杂

插件数量增加：
D e p e n d e n c y   C o m p l e x i t y ↑ Dependency\ Complexity \uparrow Dependency Complexity↑

✗ 性能开销

插件加载、反射、动态绑定可能带来性能损耗。

十一、微内核 vs 微服务

微内核是“单体内部扩展”。
微服务是“系统级分布扩展”。

#include<iostream>#include<vector>#include<memory>#include<unordered_map>#include<string>// ===============================// 1⃣ 插件接口（抽象基类）// ===============================classPlugin{public:virtual std::string name()const=0;// 插件名称virtualvoidinitialize()=0;// 初始化virtualvoidexecute()=0;// 执行功能virtualvoidshutdown()=0;// 关闭virtual~Plugin()=default;};// ===============================// 2⃣ 微内核核心// ===============================classMicroKernel{public:// 注册插件voidregisterPlugin(std::shared_ptr<Plugin> plugin){ plugins_[plugin->name()]= plugin;}// 初始化所有插件voidinitialize(){ std::cout <<"=== MicroKernel 初始化 ===\n";for(auto&[name, plugin]: plugins_){ std::cout <<"初始化插件: "<< name <<"\n"; plugin->initialize();}}// 执行所有插件voidrun(){ std::cout <<"=== MicroKernel 执行 ===\n";for(auto&[name, plugin]: plugins_){ std::cout <<"执行插件: "<< name <<"\n"; plugin->execute();}}// 关闭所有插件voidshutdown(){ std::cout <<"=== MicroKernel 关闭 ===\n";for(auto&[name, plugin]: plugins_){ std::cout <<"关闭插件: "<< name <<"\n"; plugin->shutdown();}}private: std::unordered_map<std::string, std::shared_ptr<Plugin>> plugins_;};// ===============================// 3⃣ 示例插件A// ===============================classLoggerPlugin:publicPlugin{public: std::string name()constoverride{return"LoggerPlugin";}voidinitialize()override{ std::cout <<"[Logger] 初始化日志系统\n";}voidexecute()override{ std::cout <<"[Logger] 记录日志...\n";}voidshutdown()override{ std::cout <<"[Logger] 关闭日志系统\n";}};// ===============================// 4⃣ 示例插件B// ===============================classAuthPlugin:publicPlugin{public: std::string name()constoverride{return"AuthPlugin";}voidinitialize()override{ std::cout <<"[Auth] 初始化认证模块\n";}voidexecute()override{ std::cout <<"[Auth] 执行身份验证\n";}voidshutdown()override{ std::cout <<"[Auth] 关闭认证模块\n";}};// ===============================// 5⃣ 示例插件C// ===============================classPaymentPlugin:publicPlugin{public: std::string name()constoverride{return"PaymentPlugin";}voidinitialize()override{ std::cout <<"[Payment] 初始化支付模块\n";}voidexecute()override{ std::cout <<"[Payment] 处理支付逻辑\n";}voidshutdown()override{ std::cout <<"[Payment] 关闭支付模块\n";}};// ===============================// 6⃣ 主函数// ===============================intmain(){ MicroKernel kernel;// 注册插件 kernel.registerPlugin(std::make_shared<LoggerPlugin>()); kernel.registerPlugin(std::make_shared<AuthPlugin>()); kernel.registerPlugin(std::make_shared<PaymentPlugin>());// 生命周期管理 kernel.initialize(); kernel.run(); kernel.shutdown();return0;}

https://godbolt.org/z/ahqPTzd7x

十二、本质总结

微内核架构可以抽象为：
S y s t e m = S t a b l e   C o r e + D y n a m i c   E x t e n s i o n s System = Stable\ Core + Dynamic\ Extensions System=Stable Core+Dynamic Extensions
它的目标是：
M a x i m i z e   E x t e n s i b i l i t y w h i l e M i n i m i z e   C o r e Maximize\ Extensibility \quad while \quad Minimize\ Core Maximize ExtensibilitywhileMinimize Core

十三、一句话总结

微内核架构的核心思想是：
把系统拆成一个极小的稳定核心 + 可插拔的功能模块，通过插件机制实现无限扩展。

架构设计基础——常见架构分类

IV、微服务架构（Microservices Architecture）

客户端请求客户端请求客户端请求用户功能接口层业务服务服务模块服务模块服务模块服务模块业务服务服务模块服务模块服务模块服务模块业务服务服务模块服务模块服务模块服务模块

微服务架构是一种以业务功能为单位拆分系统、每个服务独立部署和运行的架构风格。

一、微服务架构概念

核心思想：

将单体应用拆分为一组小型、自治的服务，每个服务围绕单一业务功能构建、独立部署、独立扩展。
抽象数学表示：
S y s t e m = ∑ i = 1 n M i c r o s e r v i c e i System = \sum_{i=1}^{n} Microservice_i System=i=1∑n​Microservicei​
其中：

• M i c r o s e r v i c e i Microservice_i Microservicei​：独立的业务服务
• 服务之间通过API/消息通信，而非直接调用内部函数

二、你提供的架构图解析

图中结构：

客户端请求 → 用户功能接口层 → 业务服务 → 服务模块 

可以抽象为：
C l i e n t → A P I   G a t e w a y → S e r v i c e i i = 1 n → M o d u l e s Client \rightarrow API\ Gateway \rightarrow {Service_i}_{i=1}^{n} \rightarrow Modules Client→API Gateway→Servicei​i=1n​→Modules
图中主要层次：

1. 客户端请求：前端或外部系统发起 HTTP/gRPC/消息请求
2. 用户功能接口层（API Gateway）：统一入口，路由请求到具体服务
3. 业务服务（Microservice）：每个微服务独立部署，内部可包含多个模块
4. 服务模块：业务逻辑具体实现单元

三、微服务架构特性

1. 单一职责：每个微服务对应一个业务能力
2. 独立部署：微服务之间解耦，可以独立升级、扩展
3. 多语言/技术栈：不同微服务可采用不同技术栈
4. 自治：拥有自己的数据库、缓存、状态
5. 通信机制：主要依赖 API、消息队列、事件驱动
   数学抽象：
   F u n c t i o n a l i t y = ∑ i = 1 n f i ( S e r v i c e i ) Functionality = \sum_{i=1}^{n} f_i(Service_i) Functionality=i=1∑n​fi​(Servicei​)

四、微服务通信方式

常用通信方式：

1. 同步调用（HTTP/gRPC）
   C l i e n t → R e q u e s t S e r v i c e i → R e s p o n s e C l i e n t Client \xrightarrow{Request} Service_i \xrightarrow{Response} Client ClientRequest​Servicei​Response​Client
2. 异步消息/事件
   S e r v i c e i → E v e n t M e s s a g e Q u e u e → S u b s c r i b e S e r v i c e j Service_i \xrightarrow{Event} MessageQueue \xrightarrow{Subscribe} Service_j Servicei​Event​MessageQueueSubscribe​Servicej​
   结合事件驱动：
   S y s t e m   S t a t e t + 1 = S y s t e m   S t a t e t + ∑ E v e n t i System\ State_{t+1} = System\ State_t + \sum Event_i System Statet+1​=System Statet​+∑Eventi​

五、微服务与单体架构对比

六、微服务示例（C++简化版）

下面是一个模拟微服务系统的简单示例，使用独立服务类和消息总线：

#include<iostream>#include<string>#include<vector>#include<functional>#include<unordered_map>// =============================// 微服务接口// =============================classMicroservice{public:virtual std::string name()const=0;virtualvoidhandleRequest(const std::string& request)=0;virtual~Microservice()=default;};// =============================// 用户服务// =============================classUserService:publicMicroservice{public: std::string name()constoverride{return"UserService";}voidhandleRequest(const std::string& request)override{ std::cout <<"[UserService] 处理请求: "<< request <<"\n";}};// =============================// 订单服务// =============================classOrderService:publicMicroservice{public: std::string name()constoverride{return"OrderService";}voidhandleRequest(const std::string& request)override{ std::cout <<"[OrderService] 处理请求: "<< request <<"\n";}};// =============================// API Gateway 模拟// =============================classAPIGateway{public:voidregisterService(Microservice* service){ services_[service->name()]= service;}voidrouteRequest(const std::string& serviceName,const std::string& request){if(services_.count(serviceName)){ services_[serviceName]->handleRequest(request);}else{ std::cout <<"[API Gateway] 无此服务: "<< serviceName <<"\n";}}private: std::unordered_map<std::string, Microservice*> services_;};// =============================// 主函数// =============================intmain(){ APIGateway gateway; UserService userService; OrderService orderService; gateway.registerService(&userService); gateway.registerService(&orderService);// 模拟客户端请求 gateway.routeRequest("UserService","创建用户ID=1001"); gateway.routeRequest("OrderService","创建订单ID=5001"); gateway.routeRequest("PaymentService","支付订单ID=5001");// 不存在服务return0;}

输出示例：

[UserService] 处理请求: 创建用户ID=1001 [OrderService] 处理请求: 创建订单ID=5001 [API Gateway] 无此服务: PaymentService 

七、微服务架构总结

1. 可扩展性强：每个微服务可以独立扩展
2. 容错性高：单服务失败不影响整体
3. 技术独立：每个微服务可以使用不同技术栈
4. 复杂性高：需要处理分布式通信、数据一致性、运维和监控
   核心公式：
   S y s t e m = ∑ i = 1 n M i c r o s e r v i c e i , M i c r o s e r v i c e i = f i ( M o d u l e s ) System = \sum_{i=1}^{n} Microservice_i \quad , \quad Microservice_i = f_i(Modules) System=i=1∑n​Microservicei​,Microservicei​=fi​(Modules)

微服务架构将系统拆成自治服务，每个服务可以独立开发、部署和扩展，是分布式系统的典型实践。

• 多个微服务（UserService、OrderService、PaymentService）
• API Gateway 统一入口
• 异步消息总线（事件驱动）
• 线程安全队列处理事件
• 支持多客户端请求模拟

一、项目结构

microservice_demo/ ├── CMakeLists.txt └── main.cpp 

二、完整 main.cpp

#include<iostream>#include<string>#include<vector>#include<unordered_map>#include<queue>#include<thread>#include<mutex>#include<condition_variable>#include<functional>#include<memory>#include<atomic>#include<chrono>// ===============================// 1⃣ 事件结构// ===============================structEvent{ std::string type;// 事件类型 std::string data;// 事件数据};// ===============================// 2⃣ 线程安全队列// ===============================classThreadSafeQueue{public:voidpush(const Event& event){{ std::lock_guard<std::mutex>lock(mutex_); queue_.push(event);} cond_.notify_one();}boolpop(Event& event){ std::unique_lock<std::mutex>lock(mutex_); cond_.wait(lock,[this](){return!queue_.empty()|| stopped_;});if(stopped_ && queue_.empty())returnfalse; event = queue_.front(); queue_.pop();returntrue;}voidstop(){{ std::lock_guard<std::mutex>lock(mutex_); stopped_ =true;} cond_.notify_all();}private: std::queue<Event> queue_; std::mutex mutex_; std::condition_variable cond_;bool stopped_ =false;};// ===============================// 3⃣ 消息总线// ===============================classEventBus{public:EventBus():running_(true){ worker_ = std::thread([this](){this->process();});}~EventBus(){stop();}voidsubscribe(const std::string& type, std::function<void(const Event&)> handler){ handlers_[type].push_back(handler);}voidpublish(const Event& event){ queue_.push(event);}voidstop(){if(running_){ running_ =false; queue_.stop();if(worker_.joinable()) worker_.join();}}private:voidprocess(){while(running_){ Event event;if(!queue_.pop(event))break;auto it = handlers_.find(event.type);if(it != handlers_.end()){for(auto& handler : it->second){handler(event);}}}}private: ThreadSafeQueue queue_; std::unordered_map<std::string, std::vector<std::function<void(const Event&)>>> handlers_; std::thread worker_; std::atomic<bool> running_;};// ===============================// 4⃣ 微服务接口// ===============================classMicroservice{public:virtual std::string name()const=0;virtualvoidhandleRequest(const std::string& request)=0;virtual~Microservice()=default;};// ===============================// 5⃣ 用户服务// ===============================classUserService:publicMicroservice{public:UserService(EventBus& bus):bus_(bus){} std::string name()constoverride{return"UserService";}voidhandleRequest(const std::string& request)override{ std::cout <<"[UserService] 处理请求: "<< request <<"\n";// 发布事件 bus_.publish({"UserCreated", request});}private: EventBus& bus_;};// ===============================// 6⃣ 订单服务// ===============================classOrderService:publicMicroservice{public:OrderService(EventBus& bus):bus_(bus){// 订阅用户创建事件，自动生成订单 bus_.subscribe("UserCreated",[this](const Event& e){ std::cout <<"[OrderService] 自动生成订单 for "<< e.data <<"\n";});} std::string name()constoverride{return"OrderService";}voidhandleRequest(const std::string& request)override{ std::cout <<"[OrderService] 创建订单: "<< request <<"\n"; bus_.publish({"OrderCreated", request});}private: EventBus& bus_;};// ===============================// 7⃣ 支付服务// ===============================classPaymentService:publicMicroservice{public:PaymentService(EventBus& bus):bus_(bus){// 订阅订单创建事件，自动处理支付 bus_.subscribe("OrderCreated",[this](const Event& e){ std::cout <<"[PaymentService] 自动处理支付 for "<< e.data <<"\n";});} std::string name()constoverride{return"PaymentService";}voidhandleRequest(const std::string& request)override{ std::cout <<"[PaymentService] 手动支付: "<< request <<"\n"; bus_.publish({"PaymentCompleted", request});}private: EventBus& bus_;};// ===============================// 8⃣ API Gateway// ===============================classAPIGateway{public:voidregisterService(Microservice* service){ services_[service->name()]= service;}voidrouteRequest(const std::string& serviceName,const std::string& request){if(services_.count(serviceName)) services_[serviceName]->handleRequest(request);else std::cout <<"[API Gateway] 无此服务: "<< serviceName <<"\n";}private: std::unordered_map<std::string, Microservice*> services_;};// ===============================// 9⃣ 主函数// ===============================intmain(){ EventBus bus; UserService userService(bus); OrderService orderService(bus); PaymentService paymentService(bus); APIGateway gateway; gateway.registerService(&userService); gateway.registerService(&orderService); gateway.registerService(&paymentService);// 模拟客户端请求 gateway.routeRequest("UserService","创建用户ID=1001"); gateway.routeRequest("OrderService","创建订单ID=5001"); gateway.routeRequest("PaymentService","支付订单ID=5001"); gateway.routeRequest("UserService","创建用户ID=1002"); gateway.routeRequest("OrderService","创建订单ID=5002");// 等待异步事件处理 std::this_thread::sleep_for(std::chrono::seconds(1)); bus.stop();return0;}

三、CMakeLists.txt

cmake_minimum_required(VERSION 3.10) project(MicroserviceDemo) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) add_executable(microservice_demo main.cpp) find_package(Threads REQUIRED) target_link_libraries(microservice_demo PRIVATE Threads::Threads) 

四、编译运行

mkdir build cd build cmake ..make ./microservice_demo 

五、输出示例

[UserService] 处理请求: 创建用户ID=1001 [OrderService] 自动生成订单 for 创建用户ID=1001 [OrderService] 创建订单: 创建订单ID=5001 [PaymentService] 自动处理支付 for 创建订单ID=5001 [PaymentService] 手动支付: 支付订单ID=5001 [UserService] 处理请求: 创建用户ID=1002 [OrderService] 自动生成订单 for 创建用户ID=1002 [OrderService] 创建订单: 创建订单ID=5002 [PaymentService] 自动处理支付 for 创建订单ID=5002 

六、架构分析

1. 异步事件驱动：UserService 创建用户 → OrderService 自动生成订单 → PaymentService 自动处理支付
2. API Gateway 路由：客户端请求通过网关分发到指定微服务
3. 多微服务协作：服务之间通过事件总线通信，不直接依赖彼此
4. 可扩展性：添加新服务，只需注册并订阅事件，无需修改核心逻辑
   数学抽象：
   S y s t e m = ∑ i = 1 n M i c r o s e r v i c e i System = \sum_{i=1}^{n} Microservice_i System=i=1∑n​Microservicei​
   M i c r o s e r v i c e i = f i ( E v e n t s ) Microservice_i = f_i(Events) Microservicei​=fi​(Events)
   E v e n t B u s : E v e n t → S u b s c r i b e r s EventBus: Event \rightarrow Subscribers EventBus:Event→Subscribers

EventBus (Worker Thread)PaymentServiceOrderServiceUserServiceAPIGateway客户端 (Main)EventBus (Worker Thread)PaymentServiceOrderServiceUserServiceAPIGateway客户端 (Main)--- 系统初始化与订阅注册 ------ 请求流与异步事件流 ---异步工作线程开始处理队列subscribe("UserCreated")subscribe("OrderCreated")routeRequest("UserService", "ID=1001")handleRequest("ID=1001")publish("UserCreated", "ID=1001")routeRequest("OrderService", "ID=5001")handleRequest("ID=5001")publish("OrderCreated", "ID=5001")routeRequest("PaymentService", "ID=5001")handleRequest("ID=5001")publish("PaymentCompleted", "ID=5001")routeRequest("UserService", "ID=1002")handleRequest("ID=1002")publish("UserCreated", "ID=1002")routeRequest("OrderService", "ID=5002")handleRequest("ID=5002")publish("OrderCreated", "ID=5002")[异步] 触发 UserCreated (ID=1001)打印: 自动生成订单[异步] 触发 OrderCreated (ID=5001)打印: 自动处理支付[异步] 触发 UserCreated (ID=1002)打印: 自动生成订单[异步] 触发 OrderCreated (ID=5002)打印: 自动处理支付

架构设计基础——常见架构分类

业务处理单元业务模块业务模块业务模块业务模块业务处理单元业务模块业务模块业务模块业务模块业务处理单元业务模块业务模块业务模块业务模块虚拟中间件消息中间件数据中间件处理中间件部署中间件

V、云架构（Cloud Architecture）

云架构是一种基于虚拟化、分布式计算和中间件抽象层构建的大规模系统架构模式。
它强调：

• 资源池化
• 弹性伸缩
• 中间件解耦
• 多业务单元协同

一、整体结构理解

根据你给出的架构图，可以抽象为三层结构：

业务处理单元层（横向可扩展） ↓ 虚拟中间件层（资源与能力抽象） ↓ 底层云资源（计算/存储/网络） 

数学抽象表达：
C l o u d S y s t e m = ∑ i = 1 n B u s i n e s s U n i t i + M i d d l e w a r e L a y e r CloudSystem = \sum_{i=1}^{n} BusinessUnit_i + MiddlewareLayer CloudSystem=i=1∑n​BusinessUniti​+MiddlewareLayer

二、架构图分层解析

1⃣ 业务处理单元层

图中有 3 个“业务处理单元”，结构完全一致。
每个单元包含：

• 多个业务模块
• 本地数据或缓存
• 业务逻辑处理
  抽象表示：
  B u s i n e s s U n i t i = ∑ j = 1 m B u s i n e s s M o d u l e i j BusinessUnit_i = \sum_{j=1}^{m} BusinessModule_{ij} BusinessUniti​=j=1∑m​BusinessModuleij​
  特点：
• 横向扩展
• 可动态增加节点
• 负载均衡分发请求
  扩容公式：
  C a p a c i t y t o t a l = n × C a p a c i t y s i n g l e Capacity_{total} = n \times Capacity_{single} Capacitytotal​=n×Capacitysingle​

2⃣ 虚拟中间件层

该层是云架构的核心，图中包含：

• 消息中间件
• 数据中间件
• 处理中间件
• 部署中间件
  它们是能力抽象层。
  可以表示为：
  M i d d l e w a r e = M e s s a g e , D a t a , P r o c e s s i n g , D e p l o y m e n t Middleware = {Message, Data, Processing, Deployment} Middleware=Message,Data,Processing,Deployment
  作用：

1. 屏蔽底层基础设施差异
2. 提供统一能力接口
3. 实现分布式解耦

三、云架构核心思想

1⃣ 资源虚拟化

资源池化公式：
R e s o u r c e P o o l = ∑ i = 1 k P h y s i c a l R e s o u r c e i ResourcePool = \sum_{i=1}^{k} PhysicalResource_i ResourcePool=i=1∑k​PhysicalResourcei​
虚拟化后对上层呈现：
V i r t u a l R e s o u r c e = f ( R e s o u r c e P o o l ) VirtualResource = f(ResourcePool) VirtualResource=f(ResourcePool)
例如：

• 虚拟机
• 容器
• 虚拟网络
  典型平台包括：
• Amazon Web Services
• Microsoft Azure
• Google Cloud Platform

2⃣ 弹性伸缩

假设系统请求速率为 λ \lambda λ，单节点处理能力为 μ \mu μ。
稳定条件：
λ < n μ \lambda < n\mu λ<nμ
当：
λ ≥ n μ \lambda \ge n\mu λ≥nμ
系统自动扩容：
n = ⌈ λ μ ⌉ n = \left\lceil \frac{\lambda}{\mu} \right\rceil n=⌈μλ​⌉
这就是云架构的自动扩展模型。

3⃣ 分布式解耦

业务单元之间不直接调用，而通过中间件：
S e r v i c e A → M i d d l e w a r e → S e r v i c e B Service_A \rightarrow Middleware \rightarrow Service_B ServiceA​→Middleware→ServiceB​
避免强耦合：
C o u p l i n g ↓ ⇒ A v a i l a b i l i t y ↑ Coupling \downarrow \Rightarrow Availability \uparrow Coupling↓⇒Availability↑

四、典型云架构模式

1⃣ IaaS（基础设施即服务）

• 提供虚拟机、网络、存储
• 用户自己管理操作系统和应用

2⃣ PaaS（平台即服务）

• 提供运行环境
• 自动部署与扩展

3⃣ SaaS（软件即服务）

• 提供完整应用
• 用户无需管理基础设施
  数学抽象：
  C l o u d S t a c k = I a a S + P a a S + S a a S CloudStack = IaaS + PaaS + SaaS CloudStack=IaaS+PaaS+SaaS

五、简化云架构模拟（C++示例）

下面给出一个云架构抽象模拟代码，包含：

• 多业务节点
• 消息中间件
• 自动扩容模拟

1⃣ 云节点类

#include<iostream>#include<vector>#include<thread>#include<atomic>#include<chrono>// 模拟一个业务处理单元classBusinessUnit{public:BusinessUnit(int id):id_(id){}voidprocessRequest(int requestId){ std::cout <<"[BusinessUnit "<< id_ <<"] 处理请求: "<< requestId <<"\n"; std::this_thread::sleep_for(std::chrono::milliseconds(100));}private:int id_;};

2⃣ 云调度器（模拟弹性扩容）

classCloudScheduler{public:voidscale(int n){ units_.clear();for(int i =0; i < n;++i){ units_.emplace_back(i +1);} std::cout <<"扩容到 "<< n <<" 个业务处理单元\n";}voiddispatch(int requestId){if(units_.empty())return;staticint idx =0; units_[idx % units_.size()].processRequest(requestId); idx++;}private: std::vector<BusinessUnit> units_;};

3⃣ 主函数

intmain(){ CloudScheduler scheduler;int lambda =20;// 请求速率int mu =5;// 单节点能力int n =(lambda + mu -1)/ mu;// n = ceil(lambda / mu) scheduler.scale(n);for(int i =1; i <=10;++i){ scheduler.dispatch(i);}return0;}

六、云架构优缺点

优点

1. 弹性扩展
2. 高可用
3. 资源利用率高
4. 易于运维自动化

缺点

1. 系统复杂度高
2. 分布式一致性问题
   一致性模型：

• 强一致性
• 最终一致性
  CAP 定理：
  C o n s i s t e n c y + A v a i l a b i l i t y + P a r t i t i o n T o l e r a n c e Consistency + Availability + PartitionTolerance Consistency+Availability+PartitionTolerance
  在分布式系统中：
  只能同时满足其中两个 只能同时满足其中两个 只能同时满足其中两个

七、云架构与微服务的关系

• 微服务 = 业务拆分方式
• 云架构 = 运行基础环境
  关系公式：
  C l o u d A r c h i t e c t u r e = I n f r a s t r u c t u r e + M i c r o s e r v i c e s CloudArchitecture = Infrastructure + Microservices CloudArchitecture=Infrastructure+Microservices

八、总结

云架构核心是：

• 虚拟化
• 中间件抽象
• 分布式调度
• 自动扩展
  完整抽象：
  $$
  CloudSystem =
  \sum_{i=1}^{n} BusinessUnit_i

Middleware
+
VirtualResourcePool
$$

/** * ============================================================ * 云原生微服务架构模拟 —— C++ 完整实现 * ============================================================ * ✓ Pub/Sub 事件总线（多主题、多订阅者） * ✓ 简化 Raft 分布式一致性（Leader选举 + 多数派提交） * ✓ Token Bucket 限流 * ✓ Circuit Breaker 熔断器 * ✓ 指数退避重试 * ✓ Kubernetes 资源打分调度 * ✓ Service Mesh + Sidecar 模型 * ✓ HPA 自动扩缩容 * ✓ Saga 分布式事务 * ============================================================ */#include<algorithm>#include<atomic>#include<chrono>#include<condition_variable>#include<deque>#include<functional>#include<future>#include<iomanip>#include<iostream>#include<map>#include<memory>#include<mutex>#include<optional>#include<queue>#include<random>#include<sstream>#include<string>#include<thread>#include<unordered_map>#include<vector>// ──────────────────────────────────────────────// 工具：彩色日志// ──────────────────────────────────────────────namespace Color {constchar* RESET ="\033[0m";constchar* RED ="\033[31m";constchar* GREEN ="\033[32m";constchar* YELLOW ="\033[33m";constchar* BLUE ="\033[34m";constchar* MAGENTA ="\033[35m";constchar* CYAN ="\033[36m";constchar* WHITE ="\033[37m";constchar* BOLD ="\033[1m";}static std::mutex g_log_mutex;voidlog(const std::string& tag,const std::string& msg,constchar* color = Color::WHITE){auto now = std::chrono::system_clock::now();auto ms = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch())%1000; std::time_t t = std::chrono::system_clock::to_time_t(now); std::lock_guard<std::mutex>lk(g_log_mutex); std::cout << color <<"["<< std::put_time(std::localtime(&t),"%H:%M:%S")<<"."<< std::setw(3)<< std::setfill('0')<< ms.count()<<"] "<< Color::BOLD <<"["<< tag <<"] "<< Color::RESET << color << msg << Color::RESET <<"\n";}// ──────────────────────────────────────────────// 1. 线程安全队列// ──────────────────────────────────────────────template<typenameT>classTSQueue{public:voidpush(T item){{ std::lock_guard<std::mutex>lk(mu_); q_.push(std::move(item));} cv_.notify_one();}boolpop(T& out,int timeout_ms =200){ std::unique_lock<std::mutex>lk(mu_);if(!cv_.wait_for(lk, std::chrono::milliseconds(timeout_ms),[this]{return!q_.empty()|| stop_;}))returnfalse;if(stop_ && q_.empty())returnfalse; out = std::move(q_.front()); q_.pop();returntrue;}voidstop(){{ std::lock_guard<std::mutex>lk(mu_); stop_ =true;} cv_.notify_all();} size_t size(){ std::lock_guard<std::mutex>lk(mu_);return q_.size();}private: std::queue<T> q_; std::mutex mu_; std::condition_variable cv_;bool stop_{false};};// ══════════════════════════════════════════════// 2. Pub/Sub 事件总线// ══════════════════════════════════════════════structEvent{ std::string topic; std::string payload; std::string source;};classEventBus{public:using Handler = std::function<void(const Event&)>;EventBus(){ worker_ = std::thread([this]{run();});}~EventBus(){stop();}// 订阅主题（支持通配符 "*"）voidsubscribe(const std::string& topic, Handler h){ std::lock_guard<std::mutex>lk(mu_); subs_[topic].push_back(h);}// 发布事件（异步）voidpublish(Event ev){ queue_.push(std::move(ev));}voidstop(){if(running_.exchange(false)){ queue_.stop();if(worker_.joinable()) worker_.join();}} size_t queueSize(){return queue_.size();}private:voidrun(){while(running_){ Event ev;if(!queue_.pop(ev))break;dispatch(ev);}}voiddispatch(const Event& ev){ std::lock_guard<std::mutex>lk(mu_);// 精确匹配auto it = subs_.find(ev.topic);if(it != subs_.end())for(auto& h : it->second)h(ev);// 通配符auto wc = subs_.find("*");if(wc != subs_.end())for(auto& h : wc->second)h(ev);} TSQueue<Event> queue_; std::unordered_map<std::string, std::vector<Handler>> subs_; std::mutex mu_; std::thread worker_; std::atomic<bool> running_{true};};// ══════════════════════════════════════════════// 3. Token Bucket 限流器// ══════════════════════════════════════════════classTokenBucket{public:TokenBucket(double rate,double capacity):rate_(rate),cap_(capacity),tokens_(capacity),last_(std::chrono::steady_clock::now()){}boolacquire(double n =1.0){ std::lock_guard<std::mutex>lk(mu_);refill();if(tokens_ < n)returnfalse; tokens_ -= n;returntrue;}doubletokens(){ std::lock_guard<std::mutex>lk(mu_);refill();return tokens_;}private:voidrefill(){auto now = std::chrono::steady_clock::now();double dt = std::chrono::duration<double>(now - last_).count(); tokens_ = std::min(cap_, tokens_ + rate_ * dt); last_ = now;}double rate_, cap_, tokens_; std::chrono::steady_clock::time_point last_; std::mutex mu_;};// ══════════════════════════════════════════════// 4. Circuit Breaker 熔断器// ══════════════════════════════════════════════classCircuitBreaker{public:enumclassState{ CLOSED, OPEN, HALF_OPEN };CircuitBreaker(int threshold =3,int timeout_s =5):threshold_(threshold),timeout_s_(timeout_s){}// 执行调用，返回 true 表示成功boolcall(std::function<bool()> fn){{ std::lock_guard<std::mutex>lk(mu_);if(state_ == State::OPEN){auto elapsed = std::chrono::steady_clock::now()- opened_at_;if(elapsed < std::chrono::seconds(timeout_s_)){log("CircuitBreaker","🔴 OPEN — 请求被拒绝", Color::RED);returnfalse;} state_ = State::HALF_OPEN;log("CircuitBreaker","🟡 → HALF_OPEN 试探", Color::YELLOW);}}bool ok =fn(); std::lock_guard<std::mutex>lk(mu_);if(ok){ failures_ =0; state_ = State::CLOSED;log("CircuitBreaker","🟢 CLOSED — 调用成功", Color::GREEN);}else{++failures_;if(failures_ >= threshold_){ state_ = State::OPEN; opened_at_ = std::chrono::steady_clock::now();log("CircuitBreaker","🔴 → OPEN (failures="+ std::to_string(failures_)+")", Color::RED);}}return ok;} State state()const{return state_;} std::string stateStr()const{switch(state_){case State::CLOSED:return"CLOSED";case State::OPEN:return"OPEN";case State::HALF_OPEN:return"HALF_OPEN";}return"?";}private: State state_{State::CLOSED};int failures_{0};int threshold_, timeout_s_; std::chrono::steady_clock::time_point opened_at_;mutable std::mutex mu_;};// ══════════════════════════════════════════════// 5. 指数退避重试// ══════════════════════════════════════════════structRetryPolicy{int max_attempts =3;int base_ms =100;double multiplier =2.0;int max_ms =2000;};boolwithRetry(const std::string& name, std::function<bool()> fn, RetryPolicy policy ={}){int delay = policy.base_ms;for(int i =1; i <= policy.max_attempts;++i){if(fn())returntrue;if(i < policy.max_attempts){log("Retry", name +" 第"+ std::to_string(i)+"次失败，"+ std::to_string(delay)+"ms 后重试", Color::YELLOW); std::this_thread::sleep_for(std::chrono::milliseconds(delay)); delay = std::min((int)(delay * policy.multiplier), policy.max_ms);}}log("Retry", name +" 全部重试失败", Color::RED);returnfalse;}// ══════════════════════════════════════════════// 6. 简化 Raft 共识（Leader 选举 + 多数派提交）// ══════════════════════════════════════════════structLogEntry{int term; std::string cmd;};classRaftNode{public:enumclassRole{ FOLLOWER, CANDIDATE, LEADER };explicitRaftNode(int id,int total):id_(id),total_(total){}// 触发选举（简化：直接获得随机票数）boolstartElection(std::vector<RaftNode*>& peers){ role_ = Role::CANDIDATE; term_++;int votes =1;// 投票给自己log("Raft["+ std::to_string(id_)+"]","发起选举 term="+ std::to_string(term_), Color::CYAN);for(auto* p : peers){if(p->id_ == id_)continue;if(p->requestVote(term_, id_)) votes++;}int majority = total_ /2+1;if(votes >= majority){ role_ = Role::LEADER;log("Raft["+ std::to_string(id_)+"]","✓ 当选 Leader (votes="+ std::to_string(votes)+"/"+ std::to_string(total_)+")", Color::GREEN);returntrue;} role_ = Role::FOLLOWER;log("Raft["+ std::to_string(id_)+"]","✗ 选举失败 (votes="+ std::to_string(votes)+")", Color::RED);returnfalse;}boolrequestVote(int term,int candidateId){if(term > term_ && role_ != Role::LEADER){ term_ = term; votedFor_ = candidateId;log("Raft["+ std::to_string(id_)+"]","投票给 Node"+ std::to_string(candidateId), Color::CYAN);returntrue;}returnfalse;}// Leader 追加日志，超半数确认后提交boolappendLog(const std::string& cmd, std::vector<RaftNode*>& peers){if(role_ != Role::LEADER)returnfalse; LogEntry entry{term_, cmd}; log_.push_back(entry);int acks =1;for(auto* p : peers){if(p->id_ == id_)continue;if(p->acceptEntry(entry)) acks++;}int majority = total_ /2+1;if(acks >= majority){ commitIndex_ =(int)log_.size()-1;log("Raft["+ std::to_string(id_)+"]"," 提交 \""+ cmd +"\" (acks="+ std::to_string(acks)+")", Color::GREEN);for(auto* p : peers){if(p->id_ == id_)continue; p->commitIndex_ = commitIndex_;}returntrue;}log("Raft["+ std::to_string(id_)+"]"," 提交失败 acks不足", Color::RED);returnfalse;}boolacceptEntry(const LogEntry& e){ log_.push_back(e);returntrue;// 简化：总是接受} std::string roleStr()const{switch(role_){case Role::LEADER:return"LEADER";case Role::CANDIDATE:return"CANDIDATE";default:return"FOLLOWER";}}intid()const{return id_;}boolisLeader()const{return role_ == Role::LEADER;}private:int id_, total_; Role role_{Role::FOLLOWER};int term_{0}, votedFor_{-1}, commitIndex_{-1}; std::vector<LogEntry> log_;};// ══════════════════════════════════════════════// 7. Kubernetes 调度器（资源打分）// ══════════════════════════════════════════════structNode{ std::string name;int cpu_total, cpu_used;int mem_total, mem_used;double score{0};};structPod{ std::string name;int cpu_req, mem_req;};classK8sScheduler{public:voidaddNode(Node n){ std::lock_guard<std::mutex>lk(mu_); nodes_.push_back(n);} std::optional<std::string>schedule(const Pod& pod){ std::lock_guard<std::mutex>lk(mu_); std::string best;double bestScore =-1;for(auto& n : nodes_){if(n.cpu_total - n.cpu_used < pod.cpu_req)continue;if(n.mem_total - n.mem_used < pod.mem_req)continue;// 打分：空闲资源比例越大越好（LeastAllocated）double cpuFree =100.0*(n.cpu_total-n.cpu_used)/n.cpu_total;double memFree =100.0*(n.mem_total-n.mem_used)/n.mem_total; n.score =(cpuFree + memFree)/2.0;if(n.score > bestScore){ bestScore = n.score; best = n.name;}}if(best.empty())return std::nullopt;// 分配资源for(auto& n : nodes_){if(n.name == best){ n.cpu_used += pod.cpu_req; n.mem_used += pod.mem_req;}}log("K8s-Scheduler","✓ Pod ["+ pod.name +"] → "+ best +" (score="+ std::to_string((int)bestScore)+")", Color::MAGENTA);return best;}voidprintNodes(){ std::lock_guard<std::mutex>lk(mu_);log("K8s-Nodes","─────────────────────────────────", Color::MAGENTA);for(auto& n : nodes_){ std::string s = n.name +" CPU:"+ std::to_string(n.cpu_used)+"/"+ std::to_string(n.cpu_total)+" MEM:"+ std::to_string(n.mem_used)+"/"+ std::to_string(n.mem_total);log("K8s-Nodes", s, Color::MAGENTA);}}private: std::vector<Node> nodes_; std::mutex mu_;};// ══════════════════════════════════════════════// 8. Sidecar / Service Mesh// ══════════════════════════════════════════════// Sidecar Proxy：拦截请求，注入限流+熔断+重试classSidecarProxy{public:SidecarProxy(const std::string& svc,double rps =5.0):service_(svc),bucket_(rps, rps*2),breaker_(){}boolintercept(const std::string& req, std::function<bool()> handler){// 1) 限流if(!bucket_.acquire()){log("Sidecar["+ service_ +"]"," 限流拒绝: "+ req, Color::RED);returnfalse;}// 2) 熔断 + 重试bool ok =false;withRetry(service_ +"::"+ req,[&]()->bool{return breaker_.call(handler);});return ok;}// 简化版：直接执行（记录链路）boolcall(const std::string& req, std::function<bool()> fn){if(!bucket_.acquire()){log("Sidecar["+ service_ +"]"," 限流: token="+ std::to_string((int)bucket_.tokens()), Color::RED);returnfalse;}log("Sidecar["+ service_ +"]","→ 转发请求: "+ req, Color::CYAN);bool ok = breaker_.call(fn);log("Sidecar["+ service_ +"]", ok ?"← 响应成功":"← 响应失败", ok ? Color::GREEN : Color::RED);return ok;}const std::string&service()const{return service_;} std::string cbState()const{return breaker_.stateStr();}private: std::string service_; TokenBucket bucket_; CircuitBreaker breaker_;};// Service Mesh 控制平面（管理 Sidecar 注册与服务发现）classServiceMesh{public:voidregisterSidecar(std::shared_ptr<SidecarProxy> proxy){ std::lock_guard<std::mutex>lk(mu_); proxies_[proxy->service()]= proxy;} std::shared_ptr<SidecarProxy>find(const std::string& svc){ std::lock_guard<std::mutex>lk(mu_);auto it = proxies_.find(svc);return(it != proxies_.end())? it->second :nullptr;}voidprintStatus(){ std::lock_guard<std::mutex>lk(mu_);log("ServiceMesh","── Sidecar 状态 ──", Color::BLUE);for(auto&[name, p]: proxies_)log("ServiceMesh", name +" CB="+ p->cbState(), Color::BLUE);}private: std::unordered_map<std::string, std::shared_ptr<SidecarProxy>> proxies_; std::mutex mu_;};// ══════════════════════════════════════════════// 9. HPA 自动扩缩容// ══════════════════════════════════════════════classHPAController{public:HPAController(const std::string& deployment,int minR,int maxR,double targetCPU):name_(deployment),minReplicas_(minR),maxReplicas_(maxR),targetCPU_(targetCPU),replicas_(minR){}// 模拟当前 CPU 使用率，触发扩缩容voidreconcile(double currentCPU){int desired =(int)std::ceil(replicas_ * currentCPU / targetCPU_); desired = std::clamp(desired, minReplicas_, maxReplicas_);if(desired != replicas_){log("HPA["+ name_ +"]",(desired > replicas_ ?" 扩容 ":"⬇ 缩容 ")+ std::to_string(replicas_)+" → "+ std::to_string(desired)+" (CPU="+ std::to_string((int)currentCPU)+"%)", desired > replicas_ ? Color::YELLOW : Color::CYAN); replicas_ = desired;}else{log("HPA["+ name_ +"]","= 维持 "+ std::to_string(replicas_)+" 副本 (CPU="+ std::to_string((int)currentCPU)+"%)", Color::WHITE);}}intreplicas()const{return replicas_;}private: std::string name_;int minReplicas_, maxReplicas_;double targetCPU_;int replicas_;};// ══════════════════════════════════════════════// 10. Saga 分布式事务（补偿事务模型）// ══════════════════════════════════════════════structSagaStep{ std::string name; std::function<bool()> action; std::function<void()> compensate;// 补偿（回滚）动作};classSagaOrchestrator{public:voidaddStep(SagaStep step){ steps_.push_back(std::move(step));}boolexecute(){ std::vector<int> done;log("Saga","=== 开始 Saga 事务 ===", Color::MAGENTA);for(int i =0; i <(int)steps_.size();++i){log("Saga","▶ 执行步骤["+ std::to_string(i+1)+"]: "+ steps_[i].name, Color::MAGENTA);if(!steps_[i].action()){log("Saga","✗ 步骤["+ std::to_string(i+1)+"] 失败，开始补偿", Color::RED);// 逆序补偿已完成的步骤for(int j =(int)done.size()-1; j >=0;--j){log("Saga","↩ 补偿步骤["+ std::to_string(done[j]+1)+"]: "+ steps_[done[j]].name, Color::YELLOW); steps_[done[j]].compensate();}log("Saga","=== Saga 事务回滚完成 ===", Color::RED);returnfalse;} done.push_back(i);}log("Saga","=== Saga 事务全部成功提交 ===", Color::GREEN);returntrue;}private: std::vector<SagaStep> steps_;};// ══════════════════════════════════════════════// 11. 微服务实现（User / Order / Inventory / Payment）// ══════════════════════════════════════════════classUserService{public:UserService(EventBus& bus, SidecarProxy& proxy):bus_(bus),proxy_(proxy){ bus_.subscribe("UserQuery",[this](const Event& e){log("UserService","收到查询事件: "+ e.payload, Color::GREEN);});}boolcreateUser(const std::string& userId){return proxy_.call("createUser:"+ userId,[&]()->bool{log("UserService","创建用户 "+ userId, Color::GREEN); bus_.publish({"UserCreated", userId,"UserService"});returntrue;});}private: EventBus& bus_; SidecarProxy& proxy_;};classInventoryService{public:InventoryService(EventBus& bus, SidecarProxy& proxy):bus_(bus),proxy_(proxy){ bus_.subscribe("OrderCreated",[this](const Event& e){log("InventoryService","订单创建，预扣库存: "+ e.payload, Color::CYAN);});}boolreserve(const std::string& itemId,int qty,bool failSim =false){return proxy_.call("reserve:"+ itemId,[&]()->bool{if(failSim){log("InventoryService","✗ 库存不足: "+ itemId, Color::RED);returnfalse;}log("InventoryService","预扣库存 "+ itemId +" x"+ std::to_string(qty), Color::CYAN);returntrue;});}voidcancelReserve(const std::string& itemId){log("InventoryService","↩ 释放库存: "+ itemId, Color::YELLOW);}private: EventBus& bus_; SidecarProxy& proxy_;};classOrderService{public:OrderService(EventBus& bus, SidecarProxy& proxy):bus_(bus),proxy_(proxy){ bus_.subscribe("UserCreated",[this](const Event& e){log("OrderService","用户 "+ e.payload +" 创建，初始化订单历史", Color::BLUE);});}boolcreateOrder(const std::string& orderId,const std::string& userId){return proxy_.call("createOrder:"+ orderId,[&]()->bool{log("OrderService","创建订单 "+ orderId +" for "+ userId, Color::BLUE); bus_.publish({"OrderCreated", orderId,"OrderService"});returntrue;});}voidcancelOrder(const std::string& orderId){log("OrderService","↩ 取消订单: "+ orderId, Color::YELLOW);}private: EventBus& bus_; SidecarProxy& proxy_;};classPaymentService{public:PaymentService(EventBus& bus, SidecarProxy& proxy):bus_(bus),proxy_(proxy){ bus_.subscribe("OrderCreated",[this](const Event& e){log("PaymentService","收到订单 "+ e.payload +" 等待支付", Color::MAGENTA);});}boolcharge(const std::string& orderId,double amount,bool failSim =false){return proxy_.call("charge:"+ orderId,[&]()->bool{if(failSim){log("PaymentService","✗ 扣款失败: "+ orderId, Color::RED);returnfalse;}log("PaymentService","💳 扣款成功 订单="+ orderId +" ¥"+ std::to_string((int)amount), Color::MAGENTA); bus_.publish({"PaymentDone", orderId,"PaymentService"});returntrue;});}voidrefund(const std::string& orderId){log("PaymentService","↩ 退款: "+ orderId, Color::YELLOW);}private: EventBus& bus_; SidecarProxy& proxy_;};// ══════════════════════════════════════════════// MAIN// ══════════════════════════════════════════════intmain(){ std::cout << Color::BOLD << Color::BLUE <<"\n╔══════════════════════════════════════════════════════╗\n"<<"║ 云原生微服务架构模拟 —— C++ Complete Demo ║\n"<<"╚══════════════════════════════════════════════════════╝\n"<< Color::RESET <<"\n";// ── A. 事件总线 ──────────────────────────────log("Main","━━━ A. 启动 Pub/Sub 事件总线 ━━━", Color::BOLD); EventBus bus;// ── B. Service Mesh + Sidecar ────────────────log("Main","━━━ B. 构建 Service Mesh + Sidecar ━━━", Color::BOLD); ServiceMesh mesh;auto spUser = std::make_shared<SidecarProxy>("UserService",10.0);auto spOrder = std::make_shared<SidecarProxy>("OrderService",8.0);auto spInv = std::make_shared<SidecarProxy>("InventoryService",6.0);auto spPay = std::make_shared<SidecarProxy>("PaymentService",5.0); mesh.registerSidecar(spUser); mesh.registerSidecar(spOrder); mesh.registerSidecar(spInv); mesh.registerSidecar(spPay);// ── C. 微服务实例 ──────────────────────────── UserService userSvc(bus,*spUser); OrderService orderSvc(bus,*spOrder); InventoryService invSvc(bus,*spInv); PaymentService paySvc(bus,*spPay);// ── D. Kubernetes 调度器 ─────────────────────log("Main","━━━ D. Kubernetes 调度器初始化 ━━━", Color::BOLD); K8sScheduler scheduler; scheduler.addNode({"node-1",8,2,16384,4096}); scheduler.addNode({"node-2",4,1,8192,1024}); scheduler.addNode({"node-3",16,5,32768,8192});// 调度几个 Pod scheduler.schedule({"user-svc-pod-1",1,512}); scheduler.schedule({"order-svc-pod-1",2,1024}); scheduler.schedule({"pay-svc-pod-1",1,768}); scheduler.schedule({"inv-svc-pod-1",2,1024}); scheduler.printNodes();// ── E. Raft 分布式共识 ───────────────────────log("Main","\n━━━ E. Raft 分布式共识模拟 ━━━", Color::BOLD); std::vector<std::unique_ptr<RaftNode>> nodes;for(int i =0; i <5;++i) nodes.push_back(std::make_unique<RaftNode>(i,5)); std::vector<RaftNode*> peers;for(auto& n : nodes) peers.push_back(n.get());// Node 0 发起选举 nodes[0]->startElection(peers);if(nodes[0]->isLeader()){ nodes[0]->appendLog("SET key=user1001 val=Alice", peers); nodes[0]->appendLog("SET key=order5001 val=PENDING", peers);}// ── F. HPA 自动扩缩容 ────────────────────────log("Main","\n━━━ F. HPA 自动扩缩容模拟 ━━━", Color::BOLD); HPAController hpa("order-service",2,10,60.0); std::vector<double> cpuSamples ={30,55,72,90,95,70,50,35};for(double cpu : cpuSamples){ hpa.reconcile(cpu); std::this_thread::sleep_for(std::chrono::milliseconds(100));}// ── G. 正常 Saga 事务 ────────────────────────log("Main","\n━━━ G. Saga 正常流程 ━━━", Color::BOLD);{ SagaOrchestrator saga; saga.addStep({"创建用户",[&]{return userSvc.createUser("USR-1001");},[&]{log("Saga-Comp","删除用户 USR-1001", Color::YELLOW);}}); saga.addStep({"预扣库存",[&]{return invSvc.reserve("ITEM-SKU-888",2);},[&]{ invSvc.cancelReserve("ITEM-SKU-888");}}); saga.addStep({"创建订单",[&]{return orderSvc.createOrder("ORD-5001","USR-1001");},[&]{ orderSvc.cancelOrder("ORD-5001");}}); saga.addStep({"支付扣款",[&]{return paySvc.charge("ORD-5001",299.0);},[&]{ paySvc.refund("ORD-5001");}}); saga.execute();}// ── H. Saga 回滚（支付失败场景）────────────────log("Main","\n━━━ H. Saga 回滚（支付失败）━━━", Color::BOLD);{ SagaOrchestrator saga; saga.addStep({"创建用户",[&]{return userSvc.createUser("USR-1002");},[&]{log("Saga-Comp","删除用户 USR-1002", Color::YELLOW);}}); saga.addStep({"预扣库存",[&]{return invSvc.reserve("ITEM-SKU-999",1);},[&]{ invSvc.cancelReserve("ITEM-SKU-999");}}); saga.addStep({"创建订单",[&]{return orderSvc.createOrder("ORD-5002","USR-1002");},[&]{ orderSvc.cancelOrder("ORD-5002");}}); saga.addStep({"支付扣款（模拟失败）",[&]{return paySvc.charge("ORD-5002",599.0,true/*fail*/);},[&]{ paySvc.refund("ORD-5002");}}); saga.execute();}// ── I. 限流压测 ──────────────────────────────log("Main","\n━━━ I. Token Bucket 限流压测 ━━━", Color::BOLD);{ TokenBucket tb(3.0,5.0);// 3 rps, burst=5int ok =0, fail =0;for(int i =0; i <12;++i){if(tb.acquire()) ok++;else fail++;}log("TokenBucket","发送12个请求: 通过="+ std::to_string(ok)+" 拒绝="+ std::to_string(fail), Color::CYAN);}// ── J. 熔断器演示 ────────────────────────────log("Main","\n━━━ J. Circuit Breaker 演示 ━━━", Color::BOLD);{ CircuitBreaker cb(3,2);int failCount =0;auto badFn =[&]()->bool{return++failCount >5;// 前5次失败};for(int i =0; i <8;++i){ cb.call(badFn); std::this_thread::sleep_for(std::chrono::milliseconds(50));}// 等待 OPEN 超时后恢复log("CircuitBreaker","等待熔断器恢复（2s）...", Color::YELLOW); std::this_thread::sleep_for(std::chrono::seconds(2));bool recovered = cb.call([]{returntrue;});log("CircuitBreaker", recovered ?"✓ 熔断器恢复 CLOSED":"仍然 OPEN", recovered ? Color::GREEN : Color::RED);}// ── K. Service Mesh 状态 ─────────────────────log("Main","\n━━━ K. Service Mesh 状态报告 ━━━", Color::BOLD); mesh.printStatus();// ── 等待异步事件处理完毕 ────────────────────── std::this_thread::sleep_for(std::chrono::milliseconds(500)); bus.stop(); std::cout << Color::BOLD << Color::GREEN <<"\n✓ 所有演示完成！\n"<< Color::RESET;return0;}

╔══════════════════════════════════════════════════════╗ ║ 云原生微服务架构模拟 —— C++ Complete Demo ║ ╚══════════════════════════════════════════════════════╝ [01:12:26.807][Main] ━━━ A. 启动 Pub/Sub 事件总线 ━━━ [01:12:26.807][Main] ━━━ B. 构建 Service Mesh + Sidecar ━━━ [01:12:26.807][Main] ━━━ D. Kubernetes 调度器初始化 ━━━ [01:12:26.807][K8s-Scheduler] ✓ Pod [user-svc-pod-1] → node-2 (score=81)[01:12:26.807][K8s-Scheduler] ✓ Pod [order-svc-pod-1] → node-1 (score=75)[01:12:26.807][K8s-Scheduler] ✓ Pod [pay-svc-pod-1] → node-3 (score=71)[01:12:26.807][K8s-Scheduler] ✓ Pod [inv-svc-pod-1] → node-3 (score=67)[01:12:26.807][K8s-Nodes] ───────────────────────────────── [01:12:26.807][K8s-Nodes] node-1 CPU:4/8 MEM:5120/16384 [01:12:26.807][K8s-Nodes] node-2 CPU:2/4 MEM:1536/8192 [01:12:26.807][K8s-Nodes] node-3 CPU:8/16 MEM:9984/32768 [01:12:26.807][Main] ━━━ E. Raft 分布式共识模拟 ━━━ [01:12:26.807][Raft[0]] 发起选举 term=1[01:12:26.807][Raft[1]] 投票给 Node0 [01:12:26.807][Raft[2]] 投票给 Node0 [01:12:26.807][Raft[3]] 投票给 Node0 [01:12:26.807][Raft[4]] 投票给 Node0 [01:12:26.807][Raft[0]] ✓ 当选 Leader (votes=5/5)[01:12:26.807][Raft[0]] 提交 "SET key=user1001 val=Alice"(acks=5)[01:12:26.807][Raft[0]] 提交 "SET key=order5001 val=PENDING"(acks=5)[01:12:26.807][Main] ━━━ F. HPA 自动扩缩容模拟 ━━━ [01:12:26.807][HPA[order-service]]= 维持 2 副本 (CPU=30%)[01:12:26.907][HPA[order-service]]= 维持 2 副本 (CPU=55%)[01:12:27.008][HPA[order-service]] 扩容 2 → 3(CPU=72%)[01:12:27.108][HPA[order-service]] 扩容 3 → 5(CPU=90%)[01:12:27.208][HPA[order-service]] 扩容 5 → 8(CPU=95%)[01:12:27.308][HPA[order-service]] 扩容 8 → 10(CPU=70%)[01:12:27.408][HPA[order-service]] ⬇ 缩容 10 → 9(CPU=50%)[01:12:27.508][HPA[order-service]] ⬇ 缩容 9 → 6(CPU=35%)[01:12:27.608][Main] ━━━ G. Saga 正常流程 ━━━ [01:12:27.608][Saga]=== 开始 Saga 事务 ===[01:12:27.608][Saga] ▶ 执行步骤[1]: 创建用户 [01:12:27.608][Sidecar[UserService]] → 转发请求: createUser:USR-1001 [01:12:27.608][UserService] 创建用户 USR-1001 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[UserService]] ← 响应成功 [01:12:27.608][Saga] ▶ 执行步骤[2]: 预扣库存 [01:12:27.608][Sidecar[InventoryService]] → 转发请求: reserve:ITEM-SKU-888 [01:12:27.608][InventoryService] 预扣库存 ITEM-SKU-888 x2 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[InventoryService]] ← 响应成功 [01:12:27.608][Saga] ▶ 执行步骤[3]: 创建订单 [01:12:27.608][Sidecar[OrderService]] → 转发请求: createOrder:ORD-5001 [01:12:27.608][OrderService] 创建订单 ORD-5001 for USR-1001 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[OrderService]] ← 响应成功 [01:12:27.608][Saga] ▶ 执行步骤[4]: 支付扣款 [01:12:27.608][Sidecar[PaymentService]] → 转发请求: charge:ORD-5001 [01:12:27.608][PaymentService] 💳 扣款成功 订单=ORD-5001 ¥299 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[PaymentService]] ← 响应成功 [01:12:27.608][Saga]=== Saga 事务全部成功提交 ===[01:12:27.608][Main] ━━━ H. Saga 回滚（支付失败）━━━ [01:12:27.608][Saga]=== 开始 Saga 事务 ===[01:12:27.608][Saga] ▶ 执行步骤[1]: 创建用户 [01:12:27.608][Sidecar[UserService]] → 转发请求: createUser:USR-1002 [01:12:27.608][UserService] 创建用户 USR-1002 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[UserService]] ← 响应成功 [01:12:27.608][Saga] ▶ 执行步骤[2]: 预扣库存 [01:12:27.608][Sidecar[InventoryService]] → 转发请求: reserve:ITEM-SKU-999 [01:12:27.608][InventoryService] 预扣库存 ITEM-SKU-999 x1 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[InventoryService]] ← 响应成功 [01:12:27.608][Saga] ▶ 执行步骤[3]: 创建订单 [01:12:27.608][Sidecar[OrderService]] → 转发请求: createOrder:ORD-5002 [01:12:27.608][OrderService] 创建订单 ORD-5002 for USR-1002 [01:12:27.608][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:27.608][Sidecar[OrderService]] ← 响应成功 [01:12:27.608][Saga] ▶ 执行步骤[4]: 支付扣款（模拟失败） [01:12:27.608][Sidecar[PaymentService]] → 转发请求: charge:ORD-5002 [01:12:27.608][PaymentService] ✗ 扣款失败: ORD-5002 [01:12:27.608][Sidecar[PaymentService]] ← 响应失败 [01:12:27.608][Saga] ✗ 步骤[4] 失败，开始补偿 [01:12:27.608][Saga] ↩ 补偿步骤[3]: 创建订单 [01:12:27.608][OrderService] ↩ 取消订单: ORD-5002 [01:12:27.608][Saga] ↩ 补偿步骤[2]: 预扣库存 [01:12:27.608][InventoryService] ↩ 释放库存: ITEM-SKU-999 [01:12:27.608][Saga] ↩ 补偿步骤[1]: 创建用户 [01:12:27.608][Saga-Comp] 删除用户 USR-1002 [01:12:27.608][Saga]=== Saga 事务回滚完成 ===[01:12:27.608][Main] ━━━ I. Token Bucket 限流压测 ━━━ [01:12:27.608][TokenBucket] 发送12个请求: 通过=5 拒绝=7[01:12:27.608][Main] ━━━ J. Circuit Breaker 演示 ━━━ [01:12:27.708][CircuitBreaker] 🔴 → OPEN (failures=3)[01:12:27.759][CircuitBreaker] 🔴 OPEN — 请求被拒绝 [01:12:27.809][CircuitBreaker] 🔴 OPEN — 请求被拒绝 [01:12:27.859][CircuitBreaker] 🔴 OPEN — 请求被拒绝 [01:12:27.909][CircuitBreaker] 🔴 OPEN — 请求被拒绝 [01:12:27.959][CircuitBreaker] 🔴 OPEN — 请求被拒绝 [01:12:28.009][CircuitBreaker] 等待熔断器恢复（2s）... [01:12:30.009][CircuitBreaker] 🟡 → HALF_OPEN 试探 [01:12:30.009][CircuitBreaker] 🟢 CLOSED — 调用成功 [01:12:30.009][CircuitBreaker] ✓ 熔断器恢复 CLOSED [01:12:30.009][Main] ━━━ K. Service Mesh 状态报告 ━━━ [01:12:30.009][ServiceMesh] ── Sidecar 状态 ── [01:12:30.009][ServiceMesh] InventoryService CB=CLOSED [01:12:30.009][ServiceMesh] PaymentService CB=CLOSED [01:12:30.009][ServiceMesh] OrderService CB=CLOSED [01:12:30.009][ServiceMesh] UserService CB=CLOSED ✓ 所有演示完成！ 

架构模块说明

https://godbolt.org/z/3xWfMnqzj