RabbitMQ: 高并发外卖系统的微服务架构设计与工程实现

Wang's Blog2025-12-14 19:49

需求分析与架构设计目标

  1. 核心需求
  • 用户在线下单外卖，实时查询订单进度。
  • 系统需承受短时间内的高并发请求（如用餐高峰期的流量激增）
  • 订单状态实时追踪：用户可实时查询订单进度
  • 保证业务数据持久化与结构化查询能力
  • 高并发承载能力：系统需承受用餐高峰期的突发流量
    • （典型峰值时段：中午11:00-13:00及晚上17:00-20:00）
  1. 架构设计原则
    • 微服务解耦：各服务独立开发部署，避免单点故障
    • 消息中间件：使用 RabbitMQ 异步解耦业务逻辑，削峰填谷
    • 数据库持久化：业务数据必须持久化到数据库（非消息队列），支持事务与复杂查询

架构设计三大支柱

1 ) 微服务解耦

将应用程序拆分为松耦合、可独立部署的服务单元：

  • 每个服务是单一功能的独立组件（如订单服务、骑手服务）

  • 服务间通过API接口通信，封装内部实现细节

  • 示例交互：

    javascript 复制代码 
    // 订单服务调用骑手服务API 
POST /api/delivery/assign 
{
  "orderId": "ORD12345",
  "userLocation": "39.9042,116.4074"
}

2 ) 消息中间件解耦

使用RabbitMQ实现业务逻辑异步化解耦：

  • 解决服务间强依赖问题
  • 增强系统弹性与可扩展性
  • 消息传输保障（生产者确认/消费者ACK机制）

3 ) 数据持久化策略

双持久化设计：

  • RabbitMQ：消息临时存储（需显式启用持久化）

  • MySQL：业务数据结构化持久存储

  • 关键差异：

    存储类型 查询能力 事务支持 数据丢失风险
    RabbitMQ 无 无 需配置持久化
    MySQL 强 支持 低

微服务拆分策略

拆分方法对比与选择：

方法 核心逻辑 适用性
系统操作拆分 按操作类型归类（如订单创建、查询） 重构类项目
业务能力拆分 按功能边界划分（订单、商家等独立服务） 推荐：高内聚低耦合
子域拆分（DDD） 按领域模型归类 复杂业务系统

业务能力拆分实践：

  1. 订单微服务（Order Service）：订单创建、状态管理、进度查询
  2. 商家微服务（Restaurant Service）：商品信息校验、库存管理
  3. 骑手微服务（Delivery Service）：骑手调度、位置追踪
  4. 结算微服务（Settlement Service）：支付网关对接（微信/支付宝）
  5. 积分微服务（Reward Service）：用户积分计算与奖励发放

案例实现
订单服务 骑手服务 商家服务 结算服务 积分服务

关键点：微服务间通过 API 或消息通信，封装实现细节（如订单服务内部逻辑对骑手服务透明）

业务流程与异步通信设计

订单处理流程（RabbitMQ 驱动）：

  1. 发送消息 2. 校验商品 3. 分配骑手 4. 更新状态 5. 发起结算 6. 支付结果 7. 发放积分 用户下单 订单微服务 商家微服务 订单微服务 骑手微服务 结算微服务 积分微服务

  2. 订单服务创建订单 → 异步通知商家服务校验商品

  3. 校验成功 → 订单服务更新状态 → 调用骑手服务分配骑手

  4. 骑手分配完成 → 触发结算服务支付 → 支付成功后调用积分服务

  5. 所有状态变更通过 RabbitMQ 异步回传，保证最终一致性

架构拓扑图

ss 复制代码 
用户 → [订单微服务] → (RabbitMQ) → [商家微服务]  
                     → (RabbitMQ) → [骑手微服务]  
                     → (RabbitMQ) → [结算微服务]  
                     → (RabbitMQ) → [积分微服务]  
                ↳ MySQL 数据库集群

或看下面的核心组件拓扑
用户端 订单服务 RabbitMQ 商家服务 骑手服务 结算服务 积分服务 MySQL

核心流程

  1. 用户提交订单 → 订单微服务 创建订单，状态置为"处理中"。
  2. 订单微服务 通过 RabbitMQ 通知 商家微服务 校验商品 → 校验成功 → 更新订单状态。
  3. 订单微服务 通过 RabbitMQ 通知 骑手微服务 分配骑手 → 返回骑手信息 → 更新订单状态。
  4. 订单微服务 通过 RabbitMQ 通知 结算微服务 完成支付 → 返回结算结果 → 更新订单状态。
  5. 订单微服务 通过 RabbitMQ 通知 积分微服务 增加用户积分 → 返回积分结果 → 订单状态更新为"完成"。

服务职责划分

微服务 核心能力 数据实体
订单服务 订单创建/状态更新/查询 OrderDetail
商家服务 商品校验/库存管理 Restaurant, Product
骑手服务 骑手分配/位置追踪 Deliveryman
结算服务 支付处理/交易对账 Settlement
积分服务 积分计算/权益发放 Reward

订单生命周期工作流

  1. 下单阶段

    • 用户发起订单 → 订单服务创建订单记录（状态：处理中）
    • 异步通知商家服务（RabbitMQ消息）

  2. 商品校验阶段

    • 商家服务校验商品可用性
    • 回传校验结果（消息队列）
    • 订单服务更新状态 → 待分配骑手

  3. 骑手分配阶段

    • 订单服务推送分配请求
    • 骑手服务匹配最优骑手
    • 更新订单状态 → 骑手已接单

  4. 结算阶段

    • 订单服务触发结算指令
    • 结算服务对接支付网关（微信/支付宝）
    • 更新状态 → 支付完成

  5. 积分处理阶段

    • 结算成功触发积分计算
    • 积分服务发放用户积分
    • 最终状态 → 订单完成

数据库设计原则与表结构

1 ）核心原则：

  • 禁止共享数据库：每个微服务独占数据库/表（如 order_db 仅订单服务访问）
    • 每个微服务使用独立数据库/表空间
    • 禁止服务间直接共享数据库
    • 数据交互仅通过接口/消息进行
  • 避免外键约束：跨服务数据关联通过业务逻辑实现（如订单表存储商家ID，非外键）
  • 索引优化：高频查询字段加索引（如订单状态），数据量小的表（<1000行）仅保留主键索引

2 ）表结构设计（部分示例）：

  1. 订单表 (order_detail)

    sql 复制代码 
    CREATE TABLE order_detail (
  id INT NOT NULL AUTO_INCREMENT COMMENT '订单ID',
  status VARCHAR(20) NOT NULL COMMENT '订单状态',
  address VARCHAR(255) NOT NULL COMMENT '配送地址',
  user_id INT NOT NULL COMMENT '用户ID',
  product_id INT NOT NULL COMMENT '商品ID',
  deliveryman_id INT COMMENT '骑手ID',
  settlement_id INT COMMENT '结算ID',
  reward_id INT COMMENT '积分ID',
  price DECIMAL(10,2) COMMENT '订单金额',
  created_at DATETIME COMMENT '创建时间',
  PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

  2. 骑手表 (deliveryman)

    sql 复制代码 
    CREATE TABLE deliveryman (
  id INT NOT NULL AUTO_INCREMENT COMMENT '骑手ID',
  name VARCHAR(36) NOT NULL COMMENT '骑手名称',
  status VARCHAR(20) DEFAULT 'active' COMMENT '状态：active/inactive',
  updated_at DATETIME COMMENT '更新时间',
  PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

3 ）表设计禁忌

  • 禁止使用外键约束
  • 小型表（<1000行）慎用索引
  • 表名避开SQL关键字（如order→order_detail）

接口设计规范

  1. 创建订单接口
    • 方法：POST /orders
    • 参数：用户ID、商品列表、配送地址。
    • 响应：订单ID、初始状态（processing）。
  2. 查询订单接口
    • 方法：GET /orders/{orderId}
    • 响应：订单状态、骑手位置、支付结果（重点字段加粗）。
  3. 风格要求：严格遵循 RESTful 规范，JSON 格式交互。

关键优化策略

  1. 消息可靠性

    • 持久化：交换机（durable:true）、队列（durable:true）、消息（deliveryMode:2）
    • ACK机制：手动ACK确保消息不丢失，结合重试策略

  2. 消息积压处理

    • 动态扩展消费者实例

    • 设置消息TTL(Time-To-Live)

      bash 复制代码 
      # RabbitMQ策略配置 
rabbitmqctl set_policy TTL ".*" '{"message-ttl":60000}' --apply-to queues

  3. 高并发应对

    • 限流：通过 prefetchCount 控制消费者并发数。
    • 异步解耦：耗时操作（如支付、骑手调度）通过消息队列异步化

  4. 分布式事务一致性

    • 采用Saga事务模式：

      sequenceDiagram 订单服务->>+商家服务： 创建订单(Tx1) 商家服务-->>-订单服务： 确认库存 订单服务->>+支付服务： 扣款(Tx2) 支付服务-->>-订单服务： 扣款成功 订单服务->>+积分服务： 加积分(Tx3) 积分服务-->>-订单服务： 操作成功

  5. 缓存策略

    • 高频查询数据使用Redis缓存
    • 订单状态变更时双写更新

  6. 容错设计

    • 死信队列：捕获处理失败的消息，避免阻塞主流程。
    • 服务降级：核心服务（如订单创建）与非核心服务（如积分计算）分离

工程示例：1

1 ) RabbitMQ 基础配置

安装依赖：

bash 复制代码 
npm install amqplib amqp-connection-manager @nestjs/microservices

连接配置 (rabbitmq.config.ts)：

typescript 复制代码 
import { connect } from 'amqplib';
 
export const RABBITMQ_CONFIG = {
  url: 'amqp://user:password@localhost:5672',
  exchange: 'order_exchange',
  queue: {
    order: 'order_queue',
    payment: 'payment_queue'
  }
};
 
export async function createRabbitMQConnection() {
  return connect(RABBITMQ_CONFIG.url);
}

2 ) 订单服务生产者示例

typescript 复制代码 
// src/order/order.producer.ts 
import { Injectable } from '@nestjs/common';
import * as amqp from 'amqplib';
import { RABBITMQ_CONFIG } from '../config/rabbitmq.config';
 
@Injectable()
export class OrderProducer {
  async sendOrderEvent(orderData: any) {
    const conn = await amqp.connect(RABBITMQ_CONFIG.url);
    const channel = await conn.createChannel();
    
    await channel.assertExchange(RABBITMQ_CONFIG.exchange, 'topic', { durable: true });
    await channel.assertQueue(RABBITMQ_CONFIG.queue.order, { durable: true });
    await channel.bindQueue(
      RABBITMQ_CONFIG.queue.order,
      RABBITMQ_CONFIG.exchange,
      'order.created'
    );
 
    // 发送消息（持久化）
    channel.publish(
      RABBITMQ_CONFIG.exchange,
      'order.created',
      Buffer.from(JSON.stringify(orderData)),
      { persistent: true } // 保证重启后消息不丢失 
    );
  }
}

3 ) 商家服务消费者示例

typescript 复制代码 
// src/merchant/merchant.consumer.ts 
import { Injectable, OnModuleInit } from '@nestjs/common';
import * as amqp from 'amqplib';
import { RABBITMQ_CONFIG } from '../config/rabbitmq.config';
import { MerchantService } from './merchant.service';
 
@Injectable()
export class MerchantConsumer implements OnModuleInit {
  constructor(private readonly merchantService: MerchantService) {}
 
  async onModuleInit() {
    await this.listenForOrderEvents();
  }
 
  private async listenForOrderEvents() {
    const conn = await amqp.connect(RABBITMQ_CONFIG.url);
    const channel = await conn.createChannel();
 
    await channel.assertExchange(RABBITMQ_CONFIG.exchange, 'topic', { durable: true });
    await channel.assertQueue(RABBITMQ_CONFIG.queue.order, { durable: true });
    await channel.bindQueue(
      RABBITMQ_CONFIG.queue.order,
      RABBITMQ_CONFIG.exchange,
      'order.created'
    );
 
    channel.consume(RABBITMQ_CONFIG.queue.order, async (msg) => {
      if (msg) {
        const order = JSON.parse(msg.content.toString());
        try {
          // 校验商品信息
          await this.merchantService.validateProducts(order.productIds);
          channel.ack(msg); // 手动ACK确认
          
          // 回传校验结果（通过另一队列）
          channel.publish(
            RABBITMQ_CONFIG.exchange,
            'order.validated',
            Buffer.from(JSON.stringify({ orderId: order.id, isValid: true }))
          );
        } catch (error) {
          channel.nack(msg); // 校验失败，重试或进入死信队列
        }
      }
    });
  }
}

4 ) 关键配置与优化

  • 消息持久化：

    typescript 复制代码 
    { persistent: true } // 生产者端 
{ durable: true }    // 队列声明

  • 死信队列（DLX）：处理失败消息。

  • 连接池管理：使用 amqp-connection-manager 自动重连。

  • 微服务间通信协议：

    typescript 复制代码 
    // main.ts 中集成 
import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // 绑定 RabbitMQ 微服务
  app.connectMicroservice<MicroserviceOptions>({
    transport: Transport.RMQ,
    options: {
      urls: ['amqp://localhost:5672'],
      queue: 'order_queue',
      queueOptions: { durable: true },
    },
  });
  
  await app.startAllMicroservices();
  await app.listen(3000);
}
bootstrap();

工程示例：2

RabbitMQ基础配置

1 ) 连接工厂配置

typescript 复制代码 
// src/mq/mq.module.ts
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
 
@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'ORDER_SERVICE',
        transport: Transport.RMQ,
        options: {
          urls: ['amqp://user:password@rabbitmq-host:5672'],
          queue: 'order_queue',
          queueOptions: {
            durable: true, // 队列持久化 
          },
          noAck: false, // 手动确认消息 
        },
      },
    ]),
  ],
  exports: [ClientsModule],
})
export class MQModule {}

2 ) 消息生产者实现

typescript 复制代码 
// src/order/order.service.ts
import { Inject, Injectable } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
 
@Injectable()
export class OrderService {
  constructor(
    @Inject('ORDER_SERVICE') private readonly client: ClientProxy
  ) {}
 
  async createOrder(orderData: CreateOrderDto) {
    // 1. 保存订单到数据库 
    const order = await this.orderRepo.save(orderData);
    
    // 2. 发送订单创建事件（异步解耦）
    this.client.emit('order_created', {
      orderId: order.id,
      userId: order.account_id,
      products: order.products
    });
    
    return { id: order.id, status: 'PROCESSING' };
  }
}

3 ) 消息消费者实现

typescript 复制代码 
// src/restaurant/restaurant.controller.ts
import { Controller } from '@nestjs/common';
import { EventPattern, Payload } from '@nestjs/microservices';
 
@Controller()
export class RestaurantController {
  @EventPattern('order_created')
  async handleOrderCreated(@Payload() data: OrderCreatedEvent) {
    // 1. 校验商品库存 
    const isValid = await this.productService.validateProducts(
      data.products
    );
    
    // 2. 回传校验结果
    this.client.emit('product_validated', {
      orderId: data.orderId,
      isValid,
      timestamp: new Date()
    });
  }
}

三种消息可靠性方案

1 ) 方案1：生产者确认模式

typescript 复制代码 
// 生产者确认配置 
channel.publish(
  'exchange',
  'routingKey',
  Buffer.from(JSON.stringify(message)),
  { persistent: true }, // 消息持久化 
  (err) => {
    if (err) {
      // 消息发布失败处理 
      console.error('Message publish failed:', err);
    }
  }
);

2 ）方案2：消费者手动ACK

typescript 复制代码 
@EventPattern('order_created')
async handleEvent(
  @Payload() data: any,
  @Ctx() context: RmqContext 
) {
  const channel = context.getChannelRef();
  const originalMsg = context.getMessage();
  
  try {
    // 业务处理 
    await this.processOrder(data);
    
    // 手动确认
    channel.ack(originalMsg);
  } catch (err) {
    // 消息重试或进入死信队列
    channel.nack(originalMsg, false, false);
  }
}

3 ）方案3：死信队列(DLX)配置

typescript 复制代码 
// 声明死信交换器
await channel.assertExchange('dlx_exchange', 'direct', { durable: true });
 
// 创建带死信队列参数的订单队列 
await channel.assertQueue('order_queue', {
  durable: true,
  deadLetterExchange: 'dlx_exchange',
  deadLetterRoutingKey: 'dead_letters'
});
 
// 绑定死信队列 
await channel.bindQueue('dead_letter_queue', 'dlx_exchange', 'dead_letters');

工程示例：3

1 ) 方案1：基础消息生产与消费

typescript 复制代码 
// order.service.ts (订单微服务)  
import { Injectable } from '@nestjs/common';  
import { RabbitMQService } from '@nestjs-plus/rabbitmq';  
 
@Injectable()  
export class OrderService {  
  constructor(private readonly rabbitMQService: RabbitMQService) {}  
 
  async createOrder(orderData: any) {  
    // 保存订单到数据库  
    const order = await this.saveOrderToDB(orderData);  
 
    // 发送消息到商家微服务队列  
    this.rabbitMQService.publish('restaurant_exchange', 'product.verify', {  
      orderId: order.id,  
      productId: orderData.productId  
    });  
  }  
}  
 
// restaurant.service.ts (商家微服务)  
@Injectable()  
export class RestaurantService {  
  constructor(private readonly rabbitMQService: RabbitMQService) {}  
 
  @RabbitSubscribe({  
    exchange: 'restaurant_exchange',  
    routingKey: 'product.verify',  
    queue: 'product_verify_queue'  
  })  
  async handleProductVerification(msg: { orderId: number; productId: number }) {  
    const isValid = await this.checkProductAvailability(msg.productId);  
    this.rabbitMQService.publish('order_exchange', 'product.verified', {  
      orderId: msg.orderId,  
      isValid  
    });  
  }  
}

2 ) 方案2：消息持久化与ACK机制

typescript 复制代码 
// RabbitMQ 配置 (app.module.ts)  
import { RabbitMQModule } from '@nestjs-plus/rabbitmq';  
 
@Module({  
  imports: [  
    RabbitMQModule.forRoot({  
      exchanges: [  
        { name: 'order_exchange', type: 'direct', durable: true }, // 持久化交换机  
      ],  
      uri: 'amqp://user:password@localhost:5672',  
      prefetchCount: 10, // 控制并发量  
    }),  
  ],  
})  
export class AppModule {}  
 
// 消费者示例（自动ACK确认）  
@RabbitSubscribe({  
  exchange: 'order_exchange',  
  routingKey: 'product.verified',  
  queue: 'order_update_queue',  
  queueOptions: { durable: true }, // 持久化队列  
})  
async handleOrderUpdate(msg: { orderId: number; isValid: boolean }) {  
  if (msg.isValid) {  
    await this.updateOrderStatus(msg.orderId, 'VERIFIED');  
  } else {  
    await this.cancelOrder(msg.orderId);  
  }  
  // 消息处理成功后自动ACK  
}

3 ) 方案3：死信队列（DLX）处理失败消息

typescript 复制代码 
// 定义死信交换机和队列  
@Module({  
  imports: [  
    RabbitMQModule.forRoot({  
      exchanges: [  
        { name: 'dlx_exchange', type: 'direct' },  
      ],  
      queues: [  
        {  
          name: 'dead_letter_queue',  
          options: { durable: true },  
          exchange: 'dlx_exchange',  
          routingKey: 'dead_letter',  
        },  
      ],  
    }),  
  ],  
})  
export class AppModule {}  
 
// 业务队列绑定死信交换机  
@RabbitSubscribe({  
  exchange: 'order_exchange',  
  routingKey: 'payment.process',  
  queue: 'payment_queue',  
  queueOptions: {  
    durable: true,  
    deadLetterExchange: 'dlx_exchange', // 指向死信交换机  
    deadLetterRoutingKey: 'dead_letter',  
  },  
})  
async handlePayment(msg: { orderId: number; amount: number }) {  
  try {  
    await this.processPayment(msg.orderId, msg.amount);  
  } catch (error) {  
    // 处理失败，消息自动进入死信队列  
    throw new Error('Payment failed');  
  }  
}

三种高并发优化方案

方案 适用场景 核心逻辑
RabbitMQ 削峰 瞬时流量爆发（秒杀场景） 请求入队 → 服务按消费能力处理 → 避免服务雪崩
数据库分库分表 订单量 > 千万级 按用户ID哈希分库 (user_id % 4) → 分散写入压力
读写分离 + 缓存 高频查询（订单状态） 写主库 → 读从库 → 热点数据存入 Redis（设置 TTL 防穿透）

关键知识点补充

  1. RabbitMQ 核心概念

    • Exchange：路由消息（类型：direct/topic/fanout）。
    • Queue：消息存储单元（需绑定 Exchange 和 Routing Key）。
    • ACK 机制：手动确认（channel.ack()）防止消息丢失。

  2. 微服务通信模式

    • 同步：REST API（适用实时性要求高场景）。
    • 异步：消息队列（推荐业务解耦）。

  3. NestJS 最佳实践

    • 使用 @nestjs/microservices 封装消息通信
    • 依赖注入（DI）管理 RabbitMQ 生产者/消费者

关键优化策略

1 ) 消息积压处理

  • 动态扩展消费者实例

  • 设置消息TTL(Time-To-Live)

    bash 复制代码 
    # RabbitMQ策略配置 
rabbitmqctl set_policy TTL ".*" '{"message-ttl":60000}' --apply-to queues

2 ) 分布式事务一致性

  • 采用Saga事务模式：

订单服务 商家服务 支付服务 积分服务 创建订单(Tx1) 确认库存 扣款(Tx2) 扣款成功 加积分(Tx3) 操作成功 订单服务 商家服务 支付服务 积分服务

3 ) 缓存策略

  • 高频查询数据使用Redis缓存
  • 订单状态变更时双写更新

生产环境注意事项

1 ) RabbitMQ集群部署

bash 复制代码 
# 节点加入集群命令 
rabbitmqctl join_cluster rabbit@node1

表示当前节点（新节点）将主动加入 rabbit@node1 所在的集群

2 ) 消息监控指标

  • 关键监控项：
    • 消息积压量（queue_depth）
    • 消息投递速率（publish_rate）
    • 消费者处理延迟（consumer_latency）

3 ) 连接池配置

yaml 复制代码 
# application.yaml 
spring:
  rabbitmq:
    connection-timeout: 5000 
    cache:
      connection:
        mode: CONNECTION
        size: 5
    listener:
      simple:
        concurrency: 10 
        max-concurrency: 50 
        prefetch: 100
  • 本架构通过微服务拆分和消息队列解耦，实现了外卖系统的高可用与高并发需求
  • 建议开发者重点把握服务边界划分、消息可靠性保障及数据一致性方案，这些是构建分布式系统的核心挑战

RabbitMQ 运维命令参考

bash 复制代码 
# 创建交换机  
rabbitmqadmin declare exchange name=order_exchange type=direct durable=true  
 
# 创建持久化队列  
rabbitmqadmin declare queue name=payment_queue durable=true arguments='{"x-dead-letter-exchange":"dlx_exchange"}'  
 
# 绑定队列到交换机  
rabbitmqadmin declare binding source=order_exchange destination_type=queue destination=payment_queue routing_key=payment.process  
 
# 监控消息积压  
rabbitmqctl list_queues name messages_ready messages_unacknowledged

总结

本文重构并优化了原始文案的核心技术内容，重点包括：

  1. 通过 业务能力拆分微服务 实现高内聚低耦合
  2. RabbitMQ 异步通信 保障系统高可用与解耦
  3. 数据库设计的 三禁止原则（禁共享、禁外键、慎用索引）
  4. 提供 完整的 NestJS + RabbitMQ 工程示例，涵盖生产/消费/配置全流程
  5. 三种高并发优化方案灵活应对不同流量场景
相关推荐
墨香幽梦客12 小时前
合规视角的数据安全与隐私：HIPAA等法规的架构内生化实践
java·分布式·微服务
znhy605812 小时前
分布计算系统
网络·分布式
csdn_aspnet12 小时前
微服务架构
微服务·架构
狮恒12 小时前
OpenHarmony Flutter 分布式设备发现与连接：无感组网与设备协同管理方案
分布式·flutter·wpf·openharmony
毕设源码-朱学姐12 小时前
【开题答辩全过程】以 基于微服务架构的会计云学堂的设计与实现为例，包含答辩的问题和答案
微服务·云原生·架构
喵个咪13 小时前
开箱即用的 GoWind Admin｜风行，企业级前后端一体中后台框架：极速搭建微服务应用
后端·微服务·go
Wang's Blog14 小时前
RabbitMQ: 消息交换机制的核心原理与实践指南之基于 AMQP 协议的系统设计与工程实现
分布式·rabbitmq
狮恒14 小时前
OpenHarmony Flutter 分布式音视频：跨设备流传输与实时协同交互方案
分布式·flutter·wpf·openharmony
狮恒15 小时前
OpenHarmony Flutter 分布式安全与隐私保护：跨设备可信交互与数据防泄漏方案
分布式·flutter·wpf·openharmony
热门推荐
01GitHub 镜像站点02【AutoGLM部署】本地私有化部署AI手机Agent03UV安装并设置国内源04【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）05Open-AutoGLM Windows 安装部署教程06Linux下V2Ray安装配置指南07BongoCat - 跨平台键盘猫动画工具08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09Windows 11 官方系统安装与重装完整教程（2025年最新版）10Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser