🏗️

常见架构模式：单体/分层/MVC/微内核

📂 architecture ⏱ 3 min 422 words

架构模式设计模式

常见架构模式：单体/分层/MVC/微内核

架构模式概述

架构模式是解决特定架构问题的通用解决方案模板。选择正确的架构模式对于系统的成功至关重要，它会影响系统的可维护性、可扩展性和开发效率。

单体架构

单体架构是将所有功能模块打包在一个单一的部署单元中。这是最简单和传统的架构模式。

优点

开发简单，易于测试
部署方便，只需部署一个应用
调试简单，所有代码在一个项目中

缺点

随着系统增长，代码库变得庞大难以维护
技术栈锁定，难以引入新技术
扩展性差，无法针对特定模块独立扩展

// 单体架构示例结构
@SpringBootApplication
public class MonolithicApplication {
    public static void main(String[] args) {
        SpringApplication.run(MonolithicApplication.class, args);
    }
}

// 所有模块在一个项目中
@Controller
@RequestMapping("/api/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    
    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
        return ResponseEntity.ok(orderService.createOrder(request));
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private InventoryService inventoryService;
    
    public Order createOrder(OrderRequest request) {
        // 业务逻辑
        Order order = new Order(request);
        paymentService.processPayment(order);
        inventoryService.updateStock(order);
        return orderRepository.save(order);
    }
}

分层架构

分层架构将系统划分为多个水平层，每层只与相邻层交互。这是最常见的架构模式之一。

典型分层

表示层：处理用户界面和用户交互
业务逻辑层：实现业务规则和流程
数据访问层：处理数据持久化
数据库层：存储数据

# 分层架构示例
# 表示层 (Controllers)
class OrderController:
    def __init__(self, order_service):
        self.order_service = order_service
    
    def create_order(self, request):
        return self.order_service.create_order(request)

# 业务逻辑层 (Services)
class OrderService:
    def __init__(self, order_repository, payment_service):
        self.order_repository = order_repository
        self.payment_service = payment_service
    
    def create_order(self, order_data):
        order = Order(order_data)
        self.payment_service.process_payment(order)
        return self.order_repository.save(order)

# 数据访问层 (Repositories)
class OrderRepository:
    def __init__(self, db_connection):
        self.db = db_connection
    
    def save(self, order):
        return self.db.insert('orders', order.to_dict())

MVC模式

MVC（Model-View-Controller）是一种设计模式，将应用程序分为三个核心组件：模型、视图和控制器。

组件职责

模型（Model）：管理数据和业务逻辑
视图（View）：负责用户界面显示
控制器（Controller）：处理用户输入，协调模型和视图

// MVC模式示例 (Node.js/Express)
// 模型 (Model)
const Order = require('./models/Order');

// 控制器 (Controller)
const orderController = {
    async createOrder(req, res) {
        try {
            const order = new Order(req.body);
            await order.save();
            res.status(201).json(order);
        } catch (error) {
            res.status(400).json({ error: error.message });
        }
    },
    
    async getOrder(req, res) {
        const order = await Order.findById(req.params.id);
        if (!order) {
            return res.status(404).json({ error: 'Order not found' });
        }
        res.json(order);
    }
};

// 路由 (Router)
app.post('/orders', orderController.createOrder);
app.get('/orders/:id', orderController.getOrder);

// 视图 (View) - 通常是前端模板或前端框架
// views/order.ejs
/*
<h1>Order Details</h1>
<p>Order ID: <%= order.id %></p>
<p>Status: <%= order.status %></p>
*/

微内核架构

微内核架构（也称为插件架构）将核心功能与可扩展功能分离。核心系统提供最小功能集，插件通过定义良好的接口扩展功能。

优点

高度可扩展，可以通过添加插件扩展功能
核心系统保持简洁和稳定
支持第三方开发者扩展系统

// 微内核架构示例
// 核心系统
interface Plugin {
    name: string;
    version: string;
    initialize(): void;
    execute(context: any): any;
    destroy(): void;
}

class CoreSystem {
    private plugins: Map<string, Plugin> = new Map();
    
    registerPlugin(plugin: Plugin): void {
        this.plugins.set(plugin.name, plugin);
        plugin.initialize();
        console.log(`Plugin ${plugin.name} registered`);
    }
    
    unregisterPlugin(name: string): void {
        const plugin = this.plugins.get(name);
        if (plugin) {
            plugin.destroy();
            this.plugins.delete(name);
            console.log(`Plugin ${name} unregistered`);
        }
    }
    
    executePlugin(name: string, context: any): any {
        const plugin = this.plugins.get(name);
        if (!plugin) {
            throw new Error(`Plugin ${name} not found`);
        }
        return plugin.execute(context);
    }
}

// 插件示例
class AnalyticsPlugin implements Plugin {
    name = 'analytics';
    version = '1.0.0';
    
    initialize(): void {
        console.log('Analytics plugin initialized');
    }
    
    execute(context: any): any {
        console.log('Tracking event:', context.event);
        return { tracked: true };
    }
    
    destroy(): void {
        console.log('Analytics plugin destroyed');
    }
}

// 使用
const core = new CoreSystem();
const analytics = new AnalyticsPlugin();
core.registerPlugin(analytics);
core.executePlugin('analytics', { event: 'page_view' });

模式选择指南

模式	适用场景	优点	缺点
单体架构	小型项目、原型开发	简单、快速开发	扩展性差、维护困难
分层架构	企业应用、传统Web应用	结构清晰、易于理解	性能开销、层间通信
MVC模式	Web应用、移动应用	职责分离、易于测试	增加复杂性
微内核架构	IDE、浏览器、可扩展系统	高度可扩展、插件化	核心复杂、插件管理