系统架构设计的多语言实现与核心机制

系统架构设计可以比作建筑蓝图，它定义了软件系统的整体结构和行为。下面我将结合UML和五种编程语言（C++、C#、Python、Java）来详细说明系统架构设计的核心机制和原理。

一、UML（统一建模语言）

UML是用于可视化、描述、构建和记录软件系统制品的标准语言。在架构设计中，UML提供多种图表来从不同视角描述系统。

核心机制：

1. 抽象：通过类、接口、组件等元素隐藏细节，展示关键特征。

2. 多视图建模：提供静态结构图（如类图、组件图）和动态行为图（如序列图、活动图）。

3. 标准化图元：使用标准的图形符号，便于跨团队沟通。

举例：

• 类图：展示系统中类的静态结构，包括类的属性、方法和类之间的关系（继承、关联、依赖等）。

• 序列图：展示对象之间动态的交互关系，强调消息的时间顺序。

原理：
UML基于面向对象的思想，通过模型来描述系统，这些模型可以被转换为代码。例如，类图中的类可以直接映射为C++、Java等面向对象语言中的类。

二、C++

C++是一种静态类型、编译式、通用的、支持面向对象和泛型编程的程序设计语言。

在架构设计中的角色：
C++常用于性能要求高、底层资源管理严格的系统，如游戏引擎、高频交易系统、嵌入式系统等。

核心机制：

1. 面向对象编程：通过类、继承、多态等组织代码结构。

2. 模板元编程：提供编译时多态，用于编写通用、高效的代码（如STL）。

3. 手动内存管理：通过指针、引用、new/delete等直接控制内存，提高性能但增加复杂度。

4. RAII（资源获取即初始化）：利用对象生命周期管理资源，确保异常安全。

举例：
假设设计一个游戏引擎的架构，我们可能使用C++定义核心类：

// 使用UML类图设计的几个关键类
class GameObject {
public:
    virtual void Update(float deltaTime) = 0;
    virtual void Render() = 0;
    // ...
};

class Scene {
private:
    std::vector<GameObject*> objects;
public:
    void AddObject(GameObject* obj);
    void RemoveObject(GameObject* obj);
    void UpdateAll(float deltaTime);
    void RenderAll();
    // ...
};

架构原理：
C++允许开发者直接操作硬件资源，因此架构设计时需特别注意资源管理、性能优化和异常安全。常见的设计模式如工厂模式、观察者模式等在C++中广泛应用。

三、C#

C#是一种面向对象的、运行于.NET Framework和.NET Core（现在称为.NET）之上的高级程序设计语言。

在架构设计中的角色：
C#常用于企业级应用、Web应用（ASP.NET）、游戏开发（Unity）等。

核心机制：

1. 面向对象：支持类、接口、继承、多态等。

2. 属性与事件：提供属性（get/set）和事件（event）机制，用于封装和数据绑定。

3. 委托与Lambda表达式：支持函数式编程风格。

4. 自动内存管理：通过垃圾回收器（GC）自动管理内存，减少内存泄漏风险。

5. 反射：允许在运行时检查类型信息，实现动态编程。

举例：
设计一个MVC（模型-视图-控制器）架构的Web应用：

// 模型
public class Product {
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

// 控制器
public class ProductController : Controller {
    private readonly IProductRepository _repository;
    public ProductController(IProductRepository repository) {
        _repository = repository; // 依赖注入
    }
    public IActionResult Index() {
        var products = _repository.GetAll();
        return View(products);
    }
}

// 视图（Razor）
@model IEnumerable<Product>
@foreach (var p in Model) {
    <tr><td>@p.Name</td><td>@p.Price</td></tr>
}

架构原理：
C#与.NET框架结合，支持依赖注入、AOP（面向切面编程）等架构模式，便于构建松耦合、可测试的系统。在架构设计中，常采用分层架构（表现层、业务层、数据层）或微服务架构。

四、Python

Python是一种解释型、高级、通用的编程语言，以简洁的语法和强大的库支持而闻名。

在架构设计中的角色：
Python常用于Web开发（Django、Flask）、数据科学、人工智能、脚本编写等。

核心机制：

1. 动态类型：变量无需声明类型，运行时确定。

2. 鸭子类型：“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子。”不关注对象类型，只关注行为。

3. 装饰器：在不修改原函数代码的情况下增加功能，常用于AOP。

4. 生成器与迭代器：支持惰性计算，处理大规模数据流。

5. 模块与包：通过模块化组织代码，便于重用。

举例：
设计一个微服务架构，使用Flask构建RESTful API：

# service.py
from flask import Flask, jsonify, request

app = Flask(__name__)

# 模拟数据存储
products = [
    {'id': 1, 'name': 'Laptop', 'price': 999.99},
    {'id': 2, 'name': 'Mouse', 'price': 19.99}
]

@app.route('/products', methods=['GET'])
def get_products():
    return jsonify(products)

@app.route('/products/<int:product_id>', methods=['GET'])
def get_product(product_id):
    product = next((p for p in products if p['id'] == product_id), None)
    if product is None:
        return jsonify({'error': 'Product not found'}), 404
    return jsonify(product)

if __name__ == '__main__':
    app.run(debug=True)

架构原理：
Python的架构设计强调简洁和可读性，常用设计模式如工厂模式、策略模式等。在分布式系统中，Python常用于快速构建微服务，通过消息队列（如RabbitMQ）或RPC（如gRPC）进行通信。

五、Java

Java是一种面向对象的、跨平台的编程语言，运行于Java虚拟机（JVM）上。

在架构设计中的角色：
Java广泛应用于企业级应用、Android应用、大数据处理（Hadoop）等。

核心机制：

1. 平台无关性：一次编写，到处运行，得益于JVM。

2. 面向对象：类、接口、继承、多态等。

3. 自动内存管理：通过垃圾回收器管理内存。

4. 异常处理：强制检查异常，提高代码健壮性。

5. 多线程：内置线程支持，便于并发编程。

举例：
设计一个基于Spring Boot的微服务架构：

// 实体类
@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private BigDecimal price;
    // getters and setters
}

// 仓库接口（Spring Data JPA）
public interface ProductRepository extends JpaRepository<Product, Long> {
}

// 服务层
@Service
public class ProductService {
    @Autowired
    private ProductRepository repository;
    
    public List<Product> findAll() {
        return repository.findAll();
    }
    
    public Product findById(Long id) {
        return repository.findById(id).orElseThrow(() -> 
            new ResourceNotFoundException("Product not found"));
    }
}

// 控制器层
@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService service;
    
    @GetMapping
    public ResponseEntity<List<Product>> getAllProducts() {
        return ResponseEntity.ok(service.findAll());
    }
}

架构原理：
Java生态系统庞大，框架（如Spring）提供了全面的解决方案，包括依赖注入、AOP、事务管理等。在架构设计中，Java常采用分层架构、微服务架构，并利用设计模式（如单例、工厂、代理等）提高代码质量。

概述总结

系统架构设计是软件工程的基石，它通过一系列重大决策来塑造系统的结构和行为。UML作为可视化工具，帮助架构师表达设计思想。不同的编程语言因其特性在不同领域发挥优势：C++注重性能和资源控制，C#和Java适合企业级应用，Python则擅长快速开发和数据处理。在架构设计时，需要根据系统需求、团队技能和业务目标选择合适的技术栈，并运用设计原则（如SOLID）和模式构建可维护、可扩展的系统。

系统架构设计的多语言实现与核心机制

一、架构设计的建筑蓝图比喻详解

1.1 建筑蓝图与软件架构对应关系

graph LR
    A[建筑蓝图] --> B[软件架构]
    
    subgraph A[建筑领域]
        A1[结构设计] --> A2[承重墙]
        A3[管线布局] --> A4[水电暖]
        A5[房间功能] --> A6[客厅/卧室]
        A7[施工规范] --> A8[建筑标准]
    end
    
    subgraph B[软件领域]
        B1[组件设计] --> B2[微服务/模块]
        B3[通信协议] --> B4[HTTP/gRPC]
        B5[数据流] --> B6[消息队列]
        B7[部署环境] --> B8[K8s/云]
    end
    
    A2 --> B2
    A4 --> B4
    A6 --> B6
    A8 --> B8

二、UML：架构设计的可视化语言

2.1 UML在架构设计中的核心作用

// Java示例：UML类图到代码的映射
// ==============================================
// UML类图元素定义
// ==============================================

// 1. 类定义（Class）
@UML(description = "表示一个类的UML元素")
public abstract class UmlClass {
    private String name;
    private Visibility visibility;
    private List<UmlAttribute> attributes;
    private List<UmlOperation> operations;
    
    // 2. 可见性（Visibility）
    public enum Visibility {
        PUBLIC("+"),      // 公共
        PRIVATE("-"),     // 私有
        PROTECTED("#"),   // 保护
        PACKAGE("~")      // 包内可见
    }
    
    // 3. 关联关系（Association）
    public static class Association {
        private UmlClass from;
        private UmlClass to;
        private Cardinality fromCardinality; // 多重性
        private Cardinality toCardinality;
        private String roleName; // 角色名
        
        // UML多重性表示
        public enum Cardinality {
            ZERO_OR_ONE("0..1"),
            ONE("1"),
            ZERO_OR_MORE("*"),
            ONE_OR_MORE("1..*"),
            SPECIFIC("n");
        }
    }
    
    // 4. 继承关系（Generalization）
    public interface Animal {}          // 抽象类/接口
    public class Mammal implements Animal {} // 实现关系
    public class Dog extends Mammal {}       // 继承关系
}

// ==============================================
// 架构设计模式示例：观察者模式
// ==============================================

// UML类图对应的Java实现
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

interface Observer {
    void update(String event);
}

// 具体主题
class TemperatureSensor implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private float temperature;
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update("温度变化: " + temperature);
        }
    }
    
    public void setTemperature(float temp) {
        this.temperature = temp;
        notifyObservers(); // 状态改变时通知观察者
    }
}

// 具体观察者
class TemperatureDisplay implements Observer {
    @Override
    public void update(String event) {
        System.out.println("显示器: " + event);
    }
}

class AlarmSystem implements Observer {
    @Override
    public void update(String event) {
        System.out.println("报警系统: 检查" + event);
    }
}

// ==============================================
// UML序列图对应的代码时序
// ==============================================
public class UmlSequenceDiagram {
    /**
     * UML序列图表示的对象交互时序：
     * 1. 用户 -> Sensor: setTemperature(25.5)
     * 2. Sensor -> TemperatureDisplay: update()
     * 3. Sensor -> AlarmSystem: update()
     */
    public void demonstrateSequence() {
        // 创建主题
        TemperatureSensor sensor = new TemperatureSensor();
        
        // 创建观察者
        Observer display = new TemperatureDisplay();
        Observer alarm = new AlarmSystem();
        
        // 注册观察者
        sensor.attach(display);
        sensor.attach(alarm);
        
        // 触发状态变化（模拟UML序列图）
        sensor.setTemperature(25.5f); // 这里触发整个观察者链
    }
}

2.2 UML架构视图示例

# Python: UML多视图架构实现
# ==============================================
# 1. 逻辑视图（类图）
# ==============================================
from abc import ABC, abstractmethod
from typing import List, Dict, Optional
from dataclasses import dataclass
from enum import Enum

class UmlRelationshipType(Enum):
    """UML关系类型"""
    ASSOCIATION = "association"      # 关联
    AGGREGATION = "aggregation"     # 聚合
    COMPOSITION = "composition"     # 组合
    INHERITANCE = "inheritance"     # 继承
    DEPENDENCY = "dependency"       # 依赖
    REALIZATION = "realization"     # 实现

@dataclass
class UmlClass:
    """UML类表示"""
    name: str
    attributes: List[str]
    methods: List[str]
    visibility: Dict[str, str]  # 属性:可见性
    
    def generate_plantuml(self) -> str:
        """生成PlantUML代码（文本化UML）"""
        plantuml = f"class {self.name} {{\n"
        
        # 添加属性
        for attr in self.attributes:
            plantuml += f"  {attr}\n"
        
        # 添加方法
        for method in self.methods:
            plantuml += f"  {method}()\n"
        
        plantuml += "}"
        return plantuml

@dataclass
class UmlRelationship:
    """UML关系"""
    source: str
    target: str
    relationship_type: UmlRelationshipType
    label: Optional[str] = None
    multiplicity: Optional[str] = None
    
    def generate_plantuml(self) -> str:
        """生成关系PlantUML代码"""
        arrows = {
            UmlRelationshipType.ASSOCIATION: "-->",
            UmlRelationshipType.AGGREGATION: "o--",
            UmlRelationshipType.COMPOSITION: "*--",
            UmlRelationshipType.INHERITANCE: "--|>",
            UmlRelationshipType.DEPENDENCY: "..>",
            UmlRelationshipType.REALIZATION: "..|>"
        }
        
        arrow = arrows.get(self.relationship_type, "-->")
        label = f" : {self.label}" if self.label else ""
        multiplicity = f' "{self.multiplicity}"' if self.multiplicity else ""
        
        return f"{self.source} {arrow}{multiplicity} {self.target}{label}"

# ==============================================
# 2. 部署视图（部署图）
# ==============================================
class DeploymentNode:
    """部署节点"""
    
    def __init__(self, name: str, node_type: str):
        self.name = name
        self.node_type = node_type  # 如: server, database, load_balancer
        self.artifacts: List[str] = []
        self.connections: List[DeploymentConnection] = []
    
    def add_artifact(self, artifact: str):
        self.artifacts.append(artifact)
    
    def connect_to(self, target: 'DeploymentNode', protocol: str = "HTTP"):
        connection = DeploymentConnection(self, target, protocol)
        self.connections.append(connection)
        return connection
    
    def generate_deployment_diagram(self) -> str:
        """生成部署图PlantUML"""
        diagram = f'node "{self.name}" as {self.name.replace(" ", "_")} {{\n'
        
        for artifact in self.artifacts:
            diagram += f'  artifact "{artifact}"\n'
        
        diagram += "}"
        return diagram

@dataclass
class DeploymentConnection:
    """部署连接"""
    source: DeploymentNode
    target: DeploymentNode
    protocol: str
    
    def generate_connection(self) -> str:
        src = self.source.name.replace(" ", "_")
        tgt = self.target.name.replace(" ", "_")
        return f'{src} --> {tgt} : {self.protocol}'

# ==============================================
# 3. 组件视图（组件图）
# ==============================================
class SoftwareComponent:
    """软件组件"""
    
    def __init__(self, name: str, component_type: str):
        self.name = name
        self.component_type = component_type  # 如: service, library, module
        self.required_interfaces: List[str] = []
        self.provided_interfaces: List[str] = []
        self.dependencies: List['SoftwareComponent'] = []
    
    def add_interface(self, interface_name: str, provided: bool = True):
        if provided:
            self.provided_interfaces.append(interface_name)
        else:
            self.required_interfaces.append(interface_name)
    
    def add_dependency(self, component: 'SoftwareComponent'):
        self.dependencies.append(component)
    
    def generate_component_diagram(self) -> str:
        """生成组件图PlantUML"""
        diagram = f'component "{self.name}" as {self.name.replace(" ", "_")} {{\n'
        
        # 提供的接口
        for interface in self.provided_interfaces:
            diagram += f'  [{interface}]\n'
        
        # 需要的接口
        for interface in self.required_interfaces:
            diagram += f'  {{{interface}}}\n'
        
        diagram += "}"
        return diagram

# ==============================================
# 4. 用例视图（用例图）
# ==============================================
class UseCase:
    """用例"""
    
    def __init__(self, name: str, description: str):
        self.name = name
        self.description = description
        self.actors: List['Actor'] = []
        self.extensions: List['UseCase'] = []
    
    def add_actor(self, actor: 'Actor'):
        self.actors.append(actor)
    
    def extend(self, use_case: 'UseCase'):
        self.extensions.append(use_case)
    
    def generate_use_case_diagram(self) -> str:
        """生成用例图PlantUML"""
        diagram = f'usecase "{self.name}" as UC_{self.name.replace(" ", "_")}\n'
        
        for actor in self.actors:
            diagram += f'actor "{actor.name}" as {actor.name.replace(" ", "_")}\n'
            diagram += f'{actor.name.replace(" ", "_")} --> UC_{self.name.replace(" ", "_")}\n'
        
        for ext in self.extensions:
            diagram += f'UC_{self.name.replace(" ", "_")} <.. UC_{ext.name.replace(" ", "_")} : extends\n'
        
        return diagram

class Actor:
    """参与者"""
    def __init__(self, name: str, actor_type: str = "primary"):
        self.name = name
        self.actor_type = actor_type

# ==============================================
# 完整架构示例：智能家居系统
# ==============================================
class SmartHomeArchitecture:
    """智能家居系统架构"""
    
    def __init__(self):
        self.components = self._create_components()
        self.deployment_nodes = self._create_deployment_nodes()
        self.use_cases = self._create_use_cases()
    
    def _create_components(self) -> Dict[str, SoftwareComponent]:
        """创建系统组件"""
        components = {}
        
        # 核心组件
        components['gateway'] = SoftwareComponent("网关服务", "service")
        components['gateway'].add_interface("设备管理API", provided=True)
        components['gateway'].add_interface("数据上报API", provided=True)
        
        components['rule_engine'] = SoftwareComponent("规则引擎", "service")
        components['rule_engine'].add_interface("规则管理API", provided=True)
        components['rule_engine'].add_interface("事件处理API", provided=True)
        components['rule_engine'].add_dependency(components['gateway'])
        
        components['alert_service'] = SoftwareComponent("报警服务", "service")
        components['alert_service'].add_interface("报警触发API", provided=True)
        components['alert_service'].add_interface("通知发送API", provided=True)
        components['alert_service'].add_dependency(components['rule_engine'])
        
        return components
    
    def _create_deployment_nodes(self) -> Dict[str, DeploymentNode]:
        """创建部署节点"""
        nodes = {}
        
        # 云服务器
        nodes['cloud_server'] = DeploymentNode("云服务器", "virtual_machine")
        nodes['cloud_server'].add_artifact("网关服务")
        nodes['cloud_server'].add_artifact("规则引擎")
        nodes['cloud_server'].add_artifact("报警服务")
        
        # 边缘网关
        nodes['edge_gateway'] = DeploymentNode("边缘网关", "embedded_device")
        nodes['edge_gateway'].add_artifact("本地控制服务")
        nodes['edge_gateway'].add_artifact("设备协议适配器")
        
        # 物联网设备
        nodes['iot_device'] = DeploymentNode("智能设备", "iot_device")
        nodes['iot_device'].add_artifact("传感器固件")
        nodes['iot_device'].add_artifact("通信模块")
        
        # 建立连接
        nodes['iot_device'].connect_to(nodes['edge_gateway'], "Zigbee/MQTT")
        nodes['edge_gateway'].connect_to(nodes['cloud_server'], "HTTPS")
        
        return nodes
    
    def _create_use_cases(self) -> Dict[str, UseCase]:
        """创建用例"""
        use_cases = {}
        
        # 主要参与者
        resident = Actor("住户", "primary")
        admin = Actor("管理员", "secondary")
        
        # 主要用例
        use_cases['remote_control'] = UseCase("远程控制", "通过手机APP远程控制设备")
        use_cases['remote_control'].add_actor(resident)
        
        use_cases['auto_scene'] = UseCase("自动场景", "根据条件自动执行场景")
        use_cases['auto_scene'].add_actor(resident)
        
        use_cases['alert_notification'] = UseCase("报警通知", "异常情况报警通知")
        use_cases['alert_notification'].add_actor(resident)
        use_cases['alert_notification'].extend(use_cases['auto_scene'])
        
        use_cases['device_management'] = UseCase("设备管理", "管理物联网设备")
        use_cases['device_management'].add_actor(admin)
        
        return use_cases
    
    def generate_architecture_documentation(self) -> str:
        """生成完整的架构文档（包含所有UML图）"""
        documentation = "# 智能家居系统架构设计\n\n"
        
        # 1. 用例图
        documentation += "## 1. 用例图\n```plantuml\n@startuml\n"
        for use_case in self.use_cases.values():
            documentation += use_case.generate_use_case_diagram()
        documentation += "@enduml\n```\n\n"
        
        # 2. 组件图
        documentation += "## 2. 组件图\n```plantuml\n@startuml\n"
        for component in self.components.values():
            documentation += component.generate_component_diagram() + "\n"
        
        # 添加组件间依赖关系
        documentation += "网关服务 --> 规则引擎 : 使用\n"
        documentation += "规则引擎 --> 报警服务 : 触发\n"
        documentation += "@enduml\n```\n\n"
        
        # 3. 部署图
        documentation += "## 3. 部署图\n```plantuml\n@startuml\n"
        for node in self.deployment_nodes.values():
            documentation += node.generate_deployment_diagram() + "\n"
        
        # 添加节点间连接
        for node in self.deployment_nodes.values():
            for conn in node.connections:
                documentation += conn.generate_connection() + "\n"
        
        documentation += "@enduml\n```\n\n"
        
        return documentation

# 使用示例
if __name__ == "__main__":
    architecture = SmartHomeArchitecture()
    print(architecture.generate_architecture_documentation())

三、C++：系统级架构实现

3.1 C++架构设计的核心机制

// C++: 系统级架构设计与实现
// ==============================================
// 1. 内存管理架构
// ==============================================
#include <iostream>
#include <memory>
#include <vector>
#include <functional>

// RAII (Resource Acquisition Is Initialization)
// C++核心架构模式：资源获取即初始化
template<typename T>
class SmartPointer {
private:
    T* ptr;
    
public:
    // 构造函数获取资源
    explicit SmartPointer(T* p = nullptr) : ptr(p) {
        std::cout << "资源获取: 构造SmartPointer" << std::endl;
    }
    
    // 析构函数释放资源
    ~SmartPointer() {
        delete ptr;
        std::cout << "资源释放: 析构SmartPointer" << std::endl;
    }
    
    // 禁用拷贝（避免双重释放）
    SmartPointer(const SmartPointer&) = delete;
    SmartPointer& operator=(const SmartPointer&) = delete;
    
    // 移动语义（C++11引入的架构级特性）
    SmartPointer(SmartPointer&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
        std::cout << "移动构造: 转移资源所有权" << std::endl;
    }
    
    SmartPointer& operator=(SmartPointer&& other) noexcept {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
            std::cout << "移动赋值: 转移资源所有权" << std::endl;
        }
        return *this;
    }
    
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
};

// ==============================================
// 2. 模板元编程（编译时架构）
// ==============================================
template<typename T>
struct TypeInfo {
    static const char* name() { return "unknown"; }
};

// 特化模板（编译时多态）
template<>
struct TypeInfo<int> {
    static const char* name() { return "int"; }
};

template<>
struct TypeInfo<double> {
    static const char* name() { return "double"; }
};

template<>
struct TypeInfo<std::string> {
    static const char* name() { return "string"; }
};

// 编译时策略选择
template<typename T, typename Policy>
class Container {
    Policy policy;
    T value;
    
public:
    Container(T val) : value(val) {}
    
    void process() {
        policy.apply(value);
    }
};

// 策略模式实现
struct PrintPolicy {
    template<typename T>
    void apply(T& val) {
        std::cout << "打印: " << val << std::endl;
    }
};

struct LogPolicy {
    template<typename T>
    void apply(T& val) {
        std::cout << "日志: 处理值 " << val << std::endl;
    }
};

// ==============================================
// 3. 系统级接口设计
// ==============================================
class SystemInterface {
public:
    virtual ~SystemInterface() = default;
    
    // 纯虚函数定义接口
    virtual void initialize() = 0;
    virtual void shutdown() = 0;
    virtual void process() = 0;
    
    // 非虚接口模式 (NVI Pattern)
    void execute() {
        initialize();
        process();
        shutdown();
    }
};

// ==============================================
// 4. 插件系统架构（微内核模式）
// ==============================================
class Plugin {
public:
    virtual ~Plugin() = default;
    virtual std::string name() const = 0;
    virtual void execute() = 0;
};

class PluginManager {
private:
    std::vector<std::unique_ptr<Plugin>> plugins;
    
public:
    // 插件注册（运行时扩展）
    void registerPlugin(std::unique_ptr<Plugin> plugin) {
        plugins.push_back(std::move(plugin));
        std::cout << "注册插件: " << plugins.back()->name() << std::endl;
    }
    
    // 执行所有插件
    void executeAll() {
        for (const auto& plugin : plugins) {
            std::cout << "执行插件: " << plugin->name() << std::endl;
            plugin->execute();
        }
    }
    
    // 查找插件
    Plugin* findPlugin(const std::string& name) {
        for (const auto& plugin : plugins) {
            if (plugin->name() == name) {
                return plugin.get();
            }
        }
        return nullptr;
    }
};

// 具体插件实现
class TemperaturePlugin : public Plugin {
public:
    std::string name() const override {
        return "TemperatureSensor";
    }
    
    void execute() override {
        std::cout << "温度传感器: 读取温度数据" << std::endl;
    }
};

class LightPlugin : public Plugin {
public:
    std::string name() const override {
        return "LightController";
    }
    
    void execute() override {
        std::cout << "灯光控制器: 调节灯光亮度" << std::endl;
    }
};

// ==============================================
// 5. 高性能通信架构
// ==============================================
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <atomic>

template<typename T>
class ThreadSafeQueue {
private:
    std::queue<T> queue;
    mutable std::mutex mutex;
    std::condition_variable condition;
    
public:
    void push(T value) {
        std::lock_guard<std::mutex> lock(mutex);
        queue.push(std::move(value));
        condition.notify_one();
    }
    
    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mutex);
        if (queue.empty()) {
            return false;
        }
        value = std::move(queue.front());
        queue.pop();
        return true;
    }
    
    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lock(mutex);
        condition.wait(lock, [this] { return !queue.empty(); });
        value = std::move(queue.front());
        queue.pop();
    }
    
    bool empty() const {
        std::lock_guard<std::mutex> lock(mutex);
        return queue.empty();
    }
};

// ==============================================
// 6. 反应器模式（Reactor Pattern）
// ==============================================
class EventHandler {
public:
    virtual ~EventHandler() = default;
    virtual void handle_event(int event_type) = 0;
};

class Reactor {
private:
    std::unordered_map<int, std::vector<EventHandler*>> event_handlers;
    
public:
    void register_handler(int event_type, EventHandler* handler) {
        event_handlers[event_type].push_back(handler);
    }
    
    void remove_handler(int event_type, EventHandler* handler) {
        auto& handlers = event_handlers[event_type];
        handlers.erase(std::remove(handlers.begin(), handlers.end(), handler), 
                      handlers.end());
    }
    
    void handle_events(int event_type) {
        auto it = event_handlers.find(event_type);
        if (it != event_handlers.end()) {
            for (auto handler : it->second) {
                handler->handle_event(event_type);
            }
        }
    }
};

// ==============================================
// 主函数：演示C++架构特性
// ==============================================
int main() {
    std::cout << "=== C++系统架构示例 ===\n" << std::endl;
    
    // 1. 演示RAII和移动语义
    std::cout << "1. RAII和移动语义:" << std::endl;
    {
        SmartPointer<int> p1(new int(42));
        SmartPointer<int> p2 = std::move(p1); // 移动构造
        std::cout << "值: " << *p2 << std::endl;
    } // 自动释放资源
    
    // 2. 演示模板元编程
    std::cout << "\n2. 模板元编程:" << std::endl;
    std::cout << "类型: " << TypeInfo<int>::name() << std::endl;
    std::cout << "类型: " << TypeInfo<double>::name() << std::endl;
    
    Container<int, PrintPolicy> container1(100);
    container1.process();
    
    Container<std::string, LogPolicy> container2("测试数据");
    container2.process();
    
    // 3. 演示插件系统
    std::cout << "\n3. 插件系统架构:" << std::endl;
    PluginManager pluginManager;
    
    pluginManager.registerPlugin(std::make_unique<TemperaturePlugin>());
    pluginManager.registerPlugin(std::make_unique<LightPlugin>());
    
    pluginManager.executeAll();
    
    // 4. 演示线程安全队列
    std::cout << "\n4. 线程安全通信架构:" << std::endl;
    ThreadSafeQueue<int> tsQueue;
    
    // 生产者线程
    std::thread producer([&tsQueue]() {
        for (int i = 0; i < 5; ++i) {
            tsQueue.push(i);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    });
    
    // 消费者线程
    std::thread consumer([&tsQueue]() {
        for (int i = 0; i < 5; ++i) {
            int value;
            tsQueue.wait_and_pop(value);
            std::cout << "消费: " << value << std::endl;
        }
    });
    
    producer.join();
    consumer.join();
    
    std::cout << "\n=== 架构演示完成 ===" << std::endl;
    
    return 0;
}

3.2 C++架构编译与运行

# Makefile for C++ Architecture Example
CXX = g++
CXXFLAGS = -std=c++17 -Wall -O2 -pthread

TARGET = architecture_demo
SRCS = main.cpp
OBJS = $(SRCS:.cpp=.o)

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CXX) $(CXXFLAGS) -o $@ $^

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) $(TARGET)

run: $(TARGET)
	./$(TARGET)

.PHONY: all clean run

四、C#：企业级架构实现

4.1 C#架构设计的核心机制

// C#: 企业级架构设计与实现
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace ArchitectureDesign
{
    // ==============================================
    // 1. 依赖注入架构
    // ==============================================
    
    // 服务接口定义
    public interface IService
    {
        Task ExecuteAsync();
    }
    
    public interface IRepository<T>
    {
        Task<T> GetByIdAsync(int id);
        Task<IEnumerable<T>> GetAllAsync();
        Task AddAsync(T entity);
        Task UpdateAsync(T entity);
        Task DeleteAsync(int id);
    }
    
    // 具体服务实现
    public class DataService : IService
    {
        private readonly IRepository<User> _userRepository;
        
        // 构造函数注入
        public DataService(IRepository<User> userRepository)
        {
            _userRepository = userRepository;
        }
        
        public async Task ExecuteAsync()
        {
            var users = await _userRepository.GetAllAsync();
            Console.WriteLine($"获取到 {users.Count()} 个用户");
        }
    }
    
    // 泛型仓储实现
    public class GenericRepository<T> : IRepository<T> where T : class, IEntity
    {
        private readonly List<T> _data = new();
        
        public Task<T> GetByIdAsync(int id)
        {
            var entity = _data.FirstOrDefault(e => e.Id == id);
            return Task.FromResult(entity);
        }
        
        public Task<IEnumerable<T>> GetAllAsync()
        {
            return Task.FromResult(_data.AsEnumerable());
        }
        
        public Task AddAsync(T entity)
        {
            _data.Add(entity);
            return Task.CompletedTask;
        }
        
        public Task UpdateAsync(T entity)
        {
            var existing = _data.FirstOrDefault(e => e.Id == entity.Id);
            if (existing != null)
            {
                _data.Remove(existing);
                _data.Add(entity);
            }
            return Task.CompletedTask;
        }
        
        public Task DeleteAsync(int id)
        {
            var entity = _data.FirstOrDefault(e => e.Id == id);
            if (entity != null)
            {
                _data.Remove(entity);
            }
            return Task.CompletedTask;
        }
    }
    
    public interface IEntity
    {
        int Id { get; set; }
    }
    
    public class User : IEntity
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }
    
    // ==============================================
    // 2. 中间件管道架构
    // ==============================================
    
    public interface IMiddleware
    {
        Task InvokeAsync(HttpContext context, Func<Task> next);
    }
    
    public class HttpContext
    {
        public Dictionary<string, string> Headers { get; } = new();
        public string Body { get; set; }
        public int StatusCode { get; set; }
    }
    
    // 日志中间件
    public class LoggingMiddleware : IMiddleware
    {
        public async Task InvokeAsync(HttpContext context, Func<Task> next)
        {
            Console.WriteLine($"请求开始: {DateTime.UtcNow}");
            
            await next();
            
            Console.WriteLine($"请求结束: {DateTime.UtcNow}, 状态码: {context.StatusCode}");
        }
    }
    
    // 认证中间件
    public class AuthenticationMiddleware : IMiddleware
    {
        public async Task InvokeAsync(HttpContext context, Func<Task> next)
        {
            if (!context.Headers.ContainsKey("Authorization"))
            {
                context.StatusCode = 401;
                return;
            }
            
            await next();
        }
    }
    
    // 中间件管道构建器
    public class MiddlewarePipeline
    {
        private readonly List<IMiddleware> _middlewares = new();
        
        public MiddlewarePipeline Use(IMiddleware middleware)
        {
            _middlewares.Add(middleware);
            return this;
        }
        
        public async Task RunAsync(HttpContext context)
        {
            Func<Task> pipeline = () => Task.CompletedTask;
            
            // 反向构建中间件链
            for (int i = _middlewares.Count - 1; i >= 0; i--)
            {
                var currentMiddleware = _middlewares[i];
                var next = pipeline;
                pipeline = () => currentMiddleware.InvokeAsync(context, next);
            }
            
            await pipeline();
        }
    }
    
    // ==============================================
    // 3. 事件驱动架构
    // ==============================================
    
    // 领域事件基类
    public abstract class DomainEvent
    {
        public DateTime OccurredOn { get; } = DateTime.UtcNow;
        public Guid EventId { get; } = Guid.NewGuid();
    }
    
    // 订单创建事件
    public class OrderCreatedEvent : DomainEvent
    {
        public int OrderId { get; }
        public string CustomerName { get; }
        public decimal Amount { get; }
        
        public OrderCreatedEvent(int orderId, string customerName, decimal amount)
        {
            OrderId = orderId;
            CustomerName = customerName;
            Amount = amount;
        }
    }
    
    // 事件处理器接口
    public interface IEventHandler<TEvent> where TEvent : DomainEvent
    {
        Task HandleAsync(TEvent @event);
    }
    
    // 邮件通知处理器
    public class EmailNotificationHandler : IEventHandler<OrderCreatedEvent>
    {
        public async Task HandleAsync(OrderCreatedEvent @event)
        {
            Console.WriteLine($"发送邮件给 {@event.CustomerName}, 订单 {@event.OrderId} 创建成功");
            await Task.Delay(100); // 模拟发送邮件
        }
    }
    
    // 库存更新处理器
    public class InventoryUpdateHandler : IEventHandler<OrderCreatedEvent>
    {
        public async Task HandleAsync(OrderCreatedEvent @event)
        {
            Console.WriteLine($"更新库存，订单 {@event.OrderId}");
            await Task.Delay(150);
        }
    }
    
    // 事件总线
    public class EventBus
    {
        private readonly Dictionary<Type, List<object>> _handlers = new();
        
        public void Subscribe<TEvent>(IEventHandler<TEvent> handler) where TEvent : DomainEvent
        {
            var eventType = typeof(TEvent);
            if (!_handlers.ContainsKey(eventType))
            {
                _handlers[eventType] = new List<object>();
            }
            
            _handlers[eventType].Add(handler);
        }
        
        public async Task PublishAsync<TEvent>(TEvent @event) where TEvent : DomainEvent
        {
            var eventType = typeof(TEvent);
            if (_handlers.TryGetValue(eventType, out var handlers))
            {
                foreach (var handler in handlers.OfType<IEventHandler<TEvent>>())
                {
                    await handler.HandleAsync(@event);
                }
            }
        }
    }
    
    // ==============================================
    // 4. CQRS架构模式
    // ==============================================
    
    // 命令
    public interface ICommand
    {
    }
    
    public class CreateOrderCommand : ICommand
    {
        public string CustomerName { get; set; }
        public List<OrderItem> Items { get; set; } = new();
    }
    
    public class OrderItem
    {
        public string ProductName { get; set; }
        public int Quantity { get; set; }
        public decimal Price { get; set; }
    }
    
    // 命令处理器
    public interface ICommandHandler<TCommand> where TCommand : ICommand
    {
        Task HandleAsync(TCommand command);
    }
    
    public class CreateOrderCommandHandler : ICommandHandler<CreateOrderCommand>
    {
        private readonly EventBus _eventBus;
        
        public CreateOrderCommandHandler(EventBus eventBus)
        {
            _eventBus = eventBus;
        }
        
        public async Task HandleAsync(CreateOrderCommand command)
        {
            // 1. 验证命令
            if (string.IsNullOrEmpty(command.CustomerName))
            {
                throw new ArgumentException("客户名称不能为空");
            }
            
            // 2. 执行业务逻辑（创建订单）
            var orderId = GenerateOrderId();
            var totalAmount = command.Items.Sum(i => i.Quantity * i.Price);
            
            Console.WriteLine($"创建订单: ID={orderId}, 客户={command.CustomerName}, 总金额={totalAmount}");
            
            // 3. 发布领域事件
            var orderCreatedEvent = new OrderCreatedEvent(orderId, command.CustomerName, totalAmount);
            await _eventBus.PublishAsync(orderCreatedEvent);
        }
        
        private int GenerateOrderId()
        {
            return new Random().Next(1000, 9999);
        }
    }
    
    // 查询
    public interface IQuery<TResult>
    {
    }
    
    public class GetOrderQuery : IQuery<OrderViewModel>
    {
        public int OrderId { get; set; }
    }
    
    public class OrderViewModel
    {
        public int OrderId { get; set; }
        public string CustomerName { get; set; }
        public decimal TotalAmount { get; set; }
        public DateTime CreatedDate { get; set; }
    }
    
    // 查询处理器
    public interface IQueryHandler<TQuery, TResult> where TQuery : IQuery<TResult>
    {
        Task<TResult> HandleAsync(TQuery query);
    }
    
    public class GetOrderQueryHandler : IQueryHandler<GetOrderQuery, OrderViewModel>
    {
        public Task<OrderViewModel> HandleAsync(GetOrderQuery query)
        {
            // 从读模型（如数据库视图）获取数据
            var viewModel = new OrderViewModel
            {
                OrderId = query.OrderId,
                CustomerName = "张三",
                TotalAmount = 999.99m,
                CreatedDate = DateTime.UtcNow.AddDays(-1)
            };
            
            return Task.FromResult(viewModel);
        }
    }
    
    // ==============================================
    // 5. 工作单元模式
    // ==============================================
    
    public interface IUnitOfWork : IDisposable
    {
        Task<int> SaveChangesAsync();
        Task BeginTransactionAsync();
        Task CommitTransactionAsync();
        Task RollbackTransactionAsync();
    }
    
    public class UnitOfWork : IUnitOfWork
    {
        private bool _disposed = false;
        
        public Task<int> SaveChangesAsync()
        {
            Console.WriteLine("保存所有更改");
            return Task.FromResult(1);
        }
        
        public Task BeginTransactionAsync()
        {
            Console.WriteLine("开始事务");
            return Task.CompletedTask;
        }
        
        public Task CommitTransactionAsync()
        {
            Console.WriteLine("提交事务");
            return Task.CompletedTask;
        }
        
        public Task RollbackTransactionAsync()
        {
            Console.WriteLine("回滚事务");
            return Task.CompletedTask;
        }
        
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // 释放托管资源
                    Console.WriteLine("释放工作单元资源");
                }
                
                _disposed = true;
            }
        }
        
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }
    
    // ==============================================
    // 主程序
    // ==============================================
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("=== C#企业级架构示例 ===\n");
            
            // 1. 演示依赖注入
            Console.WriteLine("1. 依赖注入架构:");
            IRepository<User> userRepository = new GenericRepository<User>();
            IService dataService = new DataService(userRepository);
            await dataService.ExecuteAsync();
            
            // 2. 演示中间件管道
            Console.WriteLine("\n2. 中间件管道架构:");
            var pipeline = new MiddlewarePipeline();
            pipeline.Use(new LoggingMiddleware());
            pipeline.Use(new AuthenticationMiddleware());
            
            var httpContext = new HttpContext();
            httpContext.Headers["Authorization"] = "Bearer token123";
            
            await pipeline.RunAsync(httpContext);
            
            // 3. 演示事件驱动架构
            Console.WriteLine("\n3. 事件驱动架构:");
            var eventBus = new EventBus();
            eventBus.Subscribe(new EmailNotificationHandler());
            eventBus.Subscribe(new InventoryUpdateHandler());
            
            var orderEvent = new OrderCreatedEvent(1001, "李四", 299.99m);
            await eventBus.PublishAsync(orderEvent);
            
            // 4. 演示CQRS架构
            Console.WriteLine("\n4. CQRS架构:");
            var createOrderCommand = new CreateOrderCommand
            {
                CustomerName = "王五",
                Items = new List<OrderItem>
                {
                    new OrderItem { ProductName = "笔记本电脑", Quantity = 1, Price = 5999.99m },
                    new OrderItem { ProductName = "鼠标", Quantity = 2, Price = 89.50m }
                }
            };
            
            var commandHandler = new CreateOrderCommandHandler(eventBus);
            await commandHandler.HandleAsync(createOrderCommand);
            
            // 5. 演示工作单元模式
            Console.WriteLine("\n5. 工作单元模式:");
            using (var unitOfWork = new UnitOfWork())
            {
                await unitOfWork.BeginTransactionAsync();
                try
                {
                    await unitOfWork.SaveChangesAsync();
                    await unitOfWork.CommitTransactionAsync();
                }
                catch
                {
                    await unitOfWork.RollbackTransactionAsync();
                    throw;
                }
            }
            
            Console.WriteLine("\n=== 架构演示完成 ===");
        }
    }
}

4.2 C#项目架构文件

<!-- ArchitectureDesign.csproj -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
  </ItemGroup>

</Project>

/* launchSettings.json */
{
  "profiles": {
    "ArchitectureDesign": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "environmentVariables": {
        "DOTNET_ENVIRONMENT": "Development"
      }
    }
  }
}

五、Python：敏捷架构实现

5.1 Python架构设计的核心机制

# Python: 敏捷架构设计与实现
# ==============================================
# 1. 装饰器模式与依赖注入
# ==============================================
import functools
import time
from abc import ABC, abstractmethod
from typing import Dict, List, Callable, Any, Optional
from dataclasses import dataclass
from contextlib import contextmanager

# 装饰器：性能监控
def timing_decorator(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间: {end_time - start_time:.4f}秒")
        return result
    return wrapper

# 装饰器：缓存
def cache_decorator(max_size: int = 128):
    def decorator(func: Callable) -> Callable:
        cache = {}
        
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 生成缓存键
            key = (args, frozenset(kwargs.items()))
            
            if key in cache:
                print(f"缓存命中: {func.__name__}")
                return cache[key]
            
            result = func(*args, **kwargs)
            
            # 维护缓存大小
            if len(cache) >= max_size:
                # 移除最旧的项
                oldest_key = next(iter(cache))
                cache.pop(oldest_key)
            
            cache[key] = result
            return result
        
        return wrapper
    return decorator

# 装饰器：认证检查
def require_auth(role: str = "user"):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 这里应该检查用户认证
            user_role = kwargs.get('user_role', 'guest')
            
            if role == "admin" and user_role != "admin":
                raise PermissionError("需要管理员权限")
            elif role == "user" and user_role not in ["user", "admin"]:
                raise PermissionError("需要用户权限")
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

# ==============================================
# 2. 依赖注入容器
# ==============================================
class DIContainer:
    """依赖注入容器"""
    
    def __init__(self):
        self._services = {}
        self._instances = {}
    
    def register(self, interface, implementation):
        """注册服务"""
        self._services[interface] = implementation
    
    def get(self, interface):
        """获取服务实例"""
        if interface in self._instances:
            return self._instances[interface]
        
        if interface in self._services:
            implementation = self._services[interface]
            instance = implementation()
            self._instances[interface] = instance
            return instance
        
        raise KeyError(f"服务未注册: {interface}")
    
    def inject(self, func):
        """依赖注入装饰器"""
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 分析函数参数，自动注入依赖
            import inspect
            sig = inspect.signature(func)
            
            for param_name, param in sig.parameters.items():
                if param.annotation != inspect.Parameter.empty:
                    if param_name not in kwargs:
                        try:
                            kwargs[param_name] = self.get(param.annotation)
                        except KeyError:
                            pass
            
            return func(*args, **kwargs)
        return wrapper

# ==============================================
# 3. 上下文管理器架构
# ==============================================
@contextmanager
def database_connection(connection_string: str):
    """数据库连接上下文管理器"""
    print(f"连接到数据库: {connection_string}")
    connection = {"connection": "mock_db_connection", "open": True}
    
    try:
        yield connection
    except Exception as e:
        print(f"数据库错误: {e}")
        raise
    finally:
        connection["open"] = False
        print("数据库连接已关闭")

@contextmanager
def transaction_manager(connection):
    """事务管理器"""
    print("开始事务")
    
    try:
        yield
        print("提交事务")
    except Exception as e:
        print(f"回滚事务: {e}")
        raise

# ==============================================
# 4. 异步架构（asyncio）
# ==============================================
import asyncio
import aiohttp
from concurrent.futures import ThreadPoolExecutor

class AsyncService:
    """异步服务架构"""
    
    def __init__(self):
        self.session = None
    
    async def __aenter__(self):
        self.session = aiohttp.ClientSession()
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.session.close()
    
    @timing_decorator
    async def fetch_data(self, urls: List[str]) -> List[Dict]:
        """并发获取数据"""
        tasks = [self._fetch_single(url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return [r for r in results if not isinstance(r, Exception)]
    
    async def _fetch_single(self, url: str) -> Dict:
        """获取单个URL"""
        async with self.session.get(url) as response:
            return {"url": url, "status": response.status, "data": await response.text()}
    
    async def process_with_semaphore(self, tasks: List, concurrency: int = 5):
        """使用信号量控制并发度"""
        semaphore = asyncio.Semaphore(concurrency)
        
        async def process_with_limit(task):
            async with semaphore:
                return await task
        
        return await asyncio.gather(*[process_with_limit(task) for task in tasks])

# ==============================================
# 5. 微服务架构模式
# ==============================================
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
import uvicorn
from typing import List

# 数据模型
class Product(BaseModel):
    id: int
    name: str
    price: float
    category: str

class Order(BaseModel):
    id: int
    customer_id: int
    products: List[Product]
    total_amount: float

# 仓储模式
class Repository:
    def __init__(self):
        self._data = {}
    
    def add(self, key, value):
        self._data[key] = value
    
    def get(self, key):
        return self._data.get(key)
    
    def get_all(self):
        return list(self._data.values())
    
    def delete(self, key):
        if key in self._data:
            del self._data[key]

# 服务层
class ProductService:
    def __init__(self, repository: Repository):
        self.repository = repository
    
    def create_product(self, product: Product) -> Product:
        self.repository.add(product.id, product)
        return product
    
    def get_product(self, product_id: int) -> Optional[Product]:
        return self.repository.get(product_id)
    
    def list_products(self, category: Optional[str] = None) -> List[Product]:
        all_products = self.repository.get_all()
        if category:
            return [p for p in all_products if p.category == category]
        return all_products

# 依赖注入
def get_product_service():
    repository = Repository()
    # 初始化一些示例数据
    repository.add(1, Product(id=1, name="Laptop", price=999.99, category="Electronics"))
    repository.add(2, Product(id=2, name="Mouse", price=25.99, category="Electronics"))
    repository.add(3, Product(id=3, name="Desk", price=199.99, category="Furniture"))
    return ProductService(repository)

# FastAPI应用
app = FastAPI(title="微服务架构示例")

@app.get("/")
async def root():
    return {"message": "微服务架构示例"}

@app.get("/products", response_model=List[Product])
async def get_products(
    category: Optional[str] = None,
    service: ProductService = Depends(get_product_service)
):
    return service.list_products(category)

@app.get("/products/{product_id}", response_model=Product)
async def get_product(
    product_id: int,
    service: ProductService = Depends(get_product_service)
):
    product = service.get_product(product_id)
    if not product:
        raise HTTPException(status_code=404, detail="产品未找到")
    return product

@app.post("/products", response_model=Product)
async def create_product(
    product: Product,
    service: ProductService = Depends(get_product_service)
):
    return service.create_product(product)

# ==============================================
# 6. 消息队列架构
# ==============================================
import queue
import threading
import json

class MessageQueue:
    """简单的消息队列实现"""
    
    def __init__(self):
        self.queue = queue.Queue()
        self.consumers = []
        self.running = False
    
    def publish(self, topic: str, message: Dict):
        """发布消息"""
        envelope = {
            "topic": topic,
            "message": message,
            "timestamp": time.time()
        }
        self.queue.put(envelope)
        print(f"发布消息到主题 '{topic}': {message}")
    
    def subscribe(self, topic: str, callback: Callable):
        """订阅主题"""
        self.consumers.append((topic, callback))
    
    def start(self):
        """启动消费者"""
        self.running = True
        
        def worker():
            while self.running:
                try:
                    envelope = self.queue.get(timeout=1)
                    topic, message = envelope["topic"], envelope["message"]
                    
                    # 通知相关订阅者
                    for sub_topic, callback in self.consumers:
                        if sub_topic == topic:
                            try:
                                callback(message)
                            except Exception as e:
                                print(f"消费者处理消息失败: {e}")
                    
                    self.queue.task_done()
                except queue.Empty:
                    continue
        
        # 启动消费者线程
        self.consumer_thread = threading.Thread(target=worker, daemon=True)
        self.consumer_thread.start()
    
    def stop(self):
        """停止队列"""
        self.running = False
        self.consumer_thread.join()

# ==============================================
# 7. 配置管理架构
# ==============================================
import os
from pathlib import Path
from enum import Enum

class Environment(Enum):
    DEVELOPMENT = "development"
    STAGING = "staging"
    PRODUCTION = "production"

class Config:
    """配置管理类"""
    
    def __init__(self, env: Environment = None):
        self.env = env or self._detect_environment()
        self._config = self._load_config()
    
    def _detect_environment(self) -> Environment:
        env_str = os.getenv("ENVIRONMENT", "development").lower()
        
        if env_str == "production":
            return Environment.PRODUCTION
        elif env_str == "staging":
            return Environment.STAGING
        else:
            return Environment.DEVELOPMENT
    
    def _load_config(self) -> Dict:
        """加载配置"""
        config = {
            "app": {
                "name": "ArchitectureDemo",
                "version": "1.0.0"
            },
            "database": {
                "development": {
                    "host": "localhost",
                    "port": 5432,
                    "database": "dev_db"
                },
                "production": {
                    "host": "db.production.com",
                    "port": 5432,
                    "database": "prod_db"
                }
            },
            "cache": {
                "redis_host": os.getenv("REDIS_HOST", "localhost"),
                "redis_port": int(os.getenv("REDIS_PORT", 6379))
            }
        }
        
        # 根据环境覆盖配置
        if self.env == Environment.PRODUCTION:
            config["debug"] = False
            config["log_level"] = "ERROR"
        else:
            config["debug"] = True
            config["log_level"] = "DEBUG"
        
        return config
    
    def get(self, key: str, default=None):
        """获取配置项"""
        keys = key.split(".")
        value = self._config
        
        for k in keys:
            if isinstance(value, dict) and k in value:
                value = value[k]
            else:
                return default
        
        return value

# ==============================================
# 主程序
# ==============================================
def main():
    print("=== Python敏捷架构示例 ===\n")
    
    # 1. 演示装饰器
    print("1. 装饰器模式:")
    
    @timing_decorator
    @cache_decorator(max_size=2)
    def expensive_operation(n: int) -> int:
        time.sleep(0.1)
        return n * n
    
    print(f"结果1: {expensive_operation(5)}")
    print(f"结果2: {expensive_operation(5)}")  # 缓存命中
    print(f"结果3: {expensive_operation(6)}")
    print(f"结果4: {expensive_operation(7)}")
    
    # 2. 演示依赖注入
    print("\n2. 依赖注入容器:")
    
    class Database:
        def query(self):
            return "查询结果"
    
    class Service:
        def __init__(self, db: Database):
            self.db = db
        
        def execute(self):
            return self.db.query()
    
    container = DIContainer()
    container.register(Database, Database)
    
    @container.inject
    def business_logic(db: Database):
        return db.query()
    
    print(f"依赖注入结果: {business_logic()}")
    
    # 3. 演示上下文管理器
    print("\n3. 上下文管理器:")
    
    with database_connection("postgresql://localhost/db") as conn:
        print(f"连接状态: {conn}")
        
        with transaction_manager(conn):
            print("执行数据库操作")
    
    # 4. 演示异步架构
    print("\n4. 异步架构:")
    
    async def demo_async():
        async with AsyncService() as service:
            urls = [
                "https://httpbin.org/delay/1",
                "https://httpbin.org/delay/2",
                "https://httpbin.org/delay/1"
            ]
            results = await service.fetch_data(urls)
            print(f"获取到 {len(results)} 个结果")
    
    asyncio.run(demo_async())
    
    # 5. 演示消息队列
    print("\n5. 消息队列架构:")
    
    mq = MessageQueue()
    
    def handle_email(message):
        print(f"处理邮件: {message}")
    
    def handle_sms(message):
        print(f"处理短信: {message}")
    
    mq.subscribe("email", handle_email)
    mq.subscribe("sms", handle_sms)
    
    mq.start()
    
    mq.publish("email", {"to": "user@example.com", "subject": "Hello"})
    mq.publish("sms", {"to": "+123456789", "message": "Test SMS"})
    
    time.sleep(1)  # 给消费者时间处理
    mq.stop()
    
    # 6. 演示配置管理
    print("\n6. 配置管理架构:")
    config = Config(Environment.DEVELOPMENT)
    print(f"环境: {config.env}")
    print(f"数据库主机: {config.get('database.development.host')}")
    print(f"调试模式: {config.get('debug')}")
    
    print("\n=== 架构演示完成 ===")

if __name__ == "__main__":
    # 运行FastAPI微服务（需要单独运行）
    # uvicorn.run(app, host="0.0.0.0", port=8000)
    
    # 运行主程序
    main()

5.2 Python项目架构文件

# requirements.txt
fastapi==0.95.1
uvicorn[standard]==0.21.1
pydantic==1.10.7
aiohttp==3.8.4

# project_structure.txt
python-architecture/
├── README.md
├── requirements.txt
├── pyproject.toml
├── src/
│   ├── __init__.py
│   ├── main.py
│   ├── decorators.py
│   ├── di_container.py
│   ├── async_service.py
│   ├── models.py
│   ├── repositories.py
│   ├── services.py
│   └── config.py
├── tests/
│   ├── __init__.py
│   ├── test_decorators.py
│   ├── test_services.py
│   └── test_async.py
├── docker/
│   ├── Dockerfile
│   └── docker-compose.yml
└── docs/
    ├── architecture.md
    └── api.md

六、架构设计原则总结

6.1 架构决策对比表

语言	核心架构机制	适用场景	架构模式
UML	多视图建模、标准化符号	架构可视化、设计沟通	4+1视图、架构描述语言
C++	RAII、模板元编程、手动内存	系统软件、游戏引擎、嵌入式	微内核、反应器、插件
C#	依赖注入、中间件、事件驱动	企业应用、Web服务、桌面应用	分层、CQRS、工作单元
Python	装饰器、上下文管理器、异步	快速原型、数据科学、微服务	微服务、消息队列、配置管理

6.2 架构设计检查清单

## 架构设计质量检查清单

### 1. 功能需求满足度
- [ ] 是否覆盖所有业务功能？
- [ ] 是否有清晰的接口定义？
- [ ] 是否支持预期的用户规模？

### 2. 质量属性
- [ ] 性能指标是否明确？
- [ ] 可靠性设计（容错、恢复）？
- [ ] 安全性考虑（认证、授权）？
- [ ] 可维护性（代码结构、文档）？
- [ ] 可扩展性（水平/垂直扩展）？

### 3. 技术决策
- [ ] 技术栈选择是否合理？
- [ ] 第三方依赖是否可控？
- [ ] 团队技术能力匹配？
- [ ] 部署和运维成本？

### 4. 演化能力
- [ ] 是否支持渐进式升级？
- [ ] 数据迁移路径是否清晰？
- [ ] 向后兼容性考虑？
- [ ] 技术债务管理策略？

6.3 架构设计产出物

架构设计文档应包含：
1. 架构愿景与目标
2. 约束条件和假设
3. 架构决策记录（ADR）
4. 架构视图（4+1视图）
5. 接口定义
6. 数据模型
7. 部署架构
8. 演进路线图

总结

系统架构设计是软件工程的战略决策过程，它定义了系统的骨架结构和演化方向。通过UML进行可视化表达，结合不同编程语言的特性实现具体架构：

• UML是架构师的通用语言，用于跨团队沟通
• **C++**提供底层控制和极致性能的架构能力
• **C#**提供企业级应用的完整架构解决方案
• Python支持快速迭代和灵活的架构模式
• Java（前文已详述）提供稳定的企业级架构生态

优秀的架构设计应该在约束条件下找到最优平衡点，既要满足当前需求，又要为未来演化预留空间。架构师需要在技术深度、业务理解、系统思维和沟通能力之间找到平衡，构建可持续演进的软件系统。