秒杀系统架构深度解析：从零构建高并发电商秒杀平台-优快云博客

秒杀系统架构深度解析：从零构建高并发电商秒杀平台

本文深入探讨了秒杀系统的核心业务场景与技术挑战，包括商品展示与预热、秒杀下单流程、订单处理等关键环节。详细分析了高并发流量冲击、数据一致性保障、系统性能优化、防刷安全机制等核心技术挑战，并提供了架构设计原则、模块划分策略、数据库优化方案以及完整的环境搭建与部署指南，为构建高可用、高性能的秒杀系统提供全面解决方案。

秒杀系统核心业务场景与技术挑战分析

秒杀系统作为电商平台中最具挑战性的业务场景之一，其核心在于如何在极短时间内处理海量用户请求，同时保证系统的稳定性、数据的一致性和用户体验的流畅性。本文将从业务场景和技术挑战两个维度深入分析秒杀系统的核心特性。

核心业务场景分析

1. 商品展示与预热阶段

在秒杀活动开始前，系统需要处理大量用户对商品详情页的访问请求。这个阶段的主要业务场景包括：

mermaid

关键业务指标：

页面响应时间：< 100ms
并发用户数：10万+
缓存命中率：> 99%

2. 秒杀下单核心流程

秒杀开始时的核心业务流程涉及库存扣减、订单创建等多个关键操作：

mermaid

3. 订单处理与状态通知

秒杀成功后，系统需要及时处理订单状态并通知用户：

处理阶段	业务逻辑	技术实现
订单创建	生成唯一订单号，记录用户和商品信息	分布式ID生成，数据库事务
支付处理	对接支付网关，处理支付回调	异步消息，幂等性处理
状态通知	通过多种渠道通知用户秒杀结果	消息队列，推送服务

技术挑战深度解析

1. 高并发流量冲击

秒杀系统面临的最大挑战是瞬时高并发流量，通常具有以下特征：

mermaid

具体挑战：

流量峰值：瞬时QPS可达10万级别
资源竞争：库存资源的激烈竞争
连接瓶颈：数据库连接池、Redis连接数限制

2. 数据一致性保障

在分布式环境下，保证库存数据的一致性是最核心的技术难题：

mermaid

一致性解决方案对比：

方案类型	实现方式	优点	缺点
悲观锁	数据库行锁	强一致性	性能低下，容易死锁
乐观锁	版本号控制	并发性能好	冲突率高时效率下降
Redis原子操作	decr命令	高性能	需要与数据库同步
分布式锁	Redis/Zookeeper	强一致性	实现复杂，性能开销

3. 系统性能优化

面对海量请求，系统需要在各个层面进行性能优化：

前端层面优化：

静态资源CDN加速
页面缓存和片段缓存
请求合并和减少

后端层面优化：

// 示例：Redis预减库存核心代码
public boolean preReduceStock(Long goodsId) {
    String key = "miaosha:stock:" + goodsId;
    Long stock = redisTemplate.opsForValue().decrement(key);
    if (stock != null && stock >= 0) {
        return true;
    } else {
        // 库存不足，恢复预减
        redisTemplate.opsForValue().increment(key);
        return false;
    }
}

数据库层面优化：

读写分离架构
分库分表策略
SQL语句优化和索引设计

4. 防刷和安全性挑战

秒杀系统需要应对各种恶意请求和安全威胁：

常见安全威胁：

脚本抢购和机器人攻击
重复提交和并发攻击
数据篡改和中间人攻击

防护措施： mermaid

5. 容错和降级机制

在极端情况下，系统需要具备良好的容错能力：

降级策略：

页面静态化降级
服务功能降级
限流和熔断保护

容错方案：

集群部署和负载均衡
故障自动转移
数据备份和恢复

典型业务场景技术实现

场景一：库存超卖防护

// 数据库层面防止超卖
@Transactional
public boolean reduceStockWithPessimisticLock(Long goodsId, Integer quantity) {
    MiaoshaGoods goods = goodsMapper.selectForUpdate(goodsId);
    if (goods.getStockCount() >= quantity) {
        goods.setStockCount(goods.getStockCount() - quantity);
        goodsMapper.updateStock(goods);
        return true;
    }
    return false;
}

// Redis原子操作防止超卖
public boolean reduceStockWithRedis(Long goodsId) {
    String stockKey = "miaosha:stock:" + goodsId;
    Long currentStock = redisTemplate.opsForValue().decrement(stockKey);
    return currentStock != null && currentStock >= 0;
}

场景二：秒杀路径验证

// 生成秒杀路径
public String generateMiaoshaPath(Long userId, Long goodsId) {
    String path = MD5Utils.md5(userId + goodsId + System.currentTimeMillis() + salt);
    redisTemplate.opsForValue().set("miaosha:path:" + userId + ":" + goodsId, path, 5, TimeUnit.MINUTES);
    return path;
}

// 验证秒杀路径
public boolean verifyMiaoshaPath(Long userId, Long goodsId, String path) {
    String storedPath = redisTemplate.opsForValue().get("miaosha:path:" + userId + ":" + goodsId);
    return path != null && path.equals(storedPath);
}

性能指标与监控体系

建立完善的监控体系对秒杀系统至关重要：

关键性能指标： | 指标类别 | 监控项 | 预警阈值 | |---------|--------|----------| | 系统性能 | QPS/TPS | > 80% 最大容量 | | 响应时间 | API平均响应时间 | > 200ms | | 资源使用 | CPU/内存使用率 | > 85% | | 数据库 | 连接数/慢查询 | > 最大连接数80% |

监控体系架构： mermaid

通过以上分析可以看出，秒杀系统的技术挑战主要集中在高并发处理、数据一致性、系统性能和安全性四个方面。成功的秒杀系统需要在架构设计、技术选型和细节实现上做到精益求精，才能在极端业务场景下保持稳定可靠的服务能力。

整体架构设计与模块划分策略

秒杀系统作为高并发场景下的典型应用，其架构设计需要充分考虑性能、可扩展性、稳定性和安全性。本项目采用分层架构和微服务思想，通过合理的模块划分实现了业务解耦和技术栈的统一管理。

架构设计原则

在秒杀系统的架构设计中，我们遵循以下核心原则：

分层解耦原则：将系统划分为表现层、业务层、数据访问层，各层职责清晰
微服务化原则：按业务功能划分服务模块，实现服务自治和独立部署
高可用原则：通过集群部署、负载均衡、故障转移等机制确保系统稳定性
性能优化原则：采用缓存、异步处理、批量操作等技术提升系统吞吐量

系统模块划分

根据业务功能和技术栈特点，系统被划分为以下核心模块：

1. 用户管理模块 (miaosha-admin)

mermaid

用户管理模块负责系统的用户认证、权限控制和会话管理，采用标准的MVC架构：

层级	组件	职责描述
表现层	miaosha-admin-web	用户界面渲染、请求转发
业务层	miaosha-admin-service	用户认证、权限校验、会话管理
接口层	miaosha-admin-api	接口定义、DTO传输

2. 订单处理模块 (miaosha-order)

mermaid

订单模块采用CQRS模式，将读写操作分离：

// 订单服务接口定义
public interface OrderService {
    // 命令操作
    Order createOrder(MiaoshaUser user, GoodsVo goods);
    boolean payOrder(Long orderId);
    
    // 查询操作  
    Order getOrderById(Long orderId);
    List<Order> getUserOrders(Long userId);
    MiaoshaOrder getMiaoshaOrderByUserIdGoodsId(Long userId, Long goodsId);
}

3. RPC服务模块 (miaosha-rpc)

mermaid

RPC模块基于Dubbo框架实现分布式服务调用，包含三个子模块：

dubbo-api: 服务接口定义和DTO对象
dubbo-provider: 服务提供者实现
dubbo-consumer: 服务消费者调用

4. 核心业务模块 (miaosha-v2)

mermaid

核心业务模块采用经典的分层架构：

层级	包结构	主要组件
Web层	com.geekq.miaosha.controller	MVC控制器
Service层	com.geekq.miaosha.service	业务服务实现
DAO层	com.geekq.miaosha.dao	数据访问对象
实体层	com.geekq.miaosha.domain	领域模型

数据模型设计

系统采用关系型数据库存储核心业务数据，主要表结构包括：

-- 商品表
CREATE TABLE goods (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    goods_name VARCHAR(16),
    goods_title VARCHAR(64),
    goods_img VARCHAR(64),
    goods_detail LONGTEXT,
    goods_price DECIMAL(10,2),
    goods_stock INT
);

-- 秒杀商品表
CREATE TABLE miaosha_goods (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    goods_id BIGINT,
    miaosha_price DECIMAL(10,2),
    stock_count INT,
    start_date DATETIME,
    end_date DATETIME
);

-- 订单表
CREATE TABLE order_info (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT,
    goods_id BIGINT,
    goods_name VARCHAR(16),
    goods_count INT,
    goods_price DECIMAL(10,2),
    status TINYINT,
    create_date DATETIME
);

服务通信机制

模块间采用多种通信方式确保系统的高效协作：

同步HTTP调用: Web层内部服务调用
Dubbo RPC调用: 跨模块服务调用
RabbitMQ异步消息: 秒杀订单异步处理
Redis缓存共享: 分布式缓存数据同步

配置管理策略

系统采用Maven模块化配置，实现环境隔离和依赖管理：

<!-- 父POM统一管理依赖版本 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.3.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 环境配置文件隔离 -->
spring:
  profiles:
    active: @activatedProperties@

这种模块划分策略使得系统具备良好的可扩展性和可维护性，每个模块都可以独立开发、测试和部署，同时通过统一的接口规范确保模块间的协同工作。

数据库表结构设计与优化方案

秒杀系统作为高并发场景的典型应用，其数据库设计直接决定了系统的性能和稳定性。本文将从表结构设计、索引优化、分库分表策略等多个维度，深入分析秒杀系统的数据库架构方案。

核心表结构设计

秒杀系统的数据库设计围绕以下几个核心表展开：

1. 商品表 (goods)

商品表存储所有商品的基本信息，是秒杀系统的基础数据表：

CREATE TABLE `goods` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '商品ID',
  `goods_name` varchar(16) DEFAULT NULL COMMENT '商品名称',
  `goods_title` varchar(64) DEFAULT NULL COMMENT '商品标题',
  `goods_img` varchar(64) DEFAULT NULL COMMENT '商品的图片',
  `goods_detail` longtext COMMENT '商品的详情介绍',
  `goods_price` decimal(10,2) DEFAULT '0.00' COMMENT '商品单价',
  `goods_stock` int(11) DEFAULT '0' COMMENT '商品库存，-1表示没有限制',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

设计要点：

使用bigint类型作为主键，支持海量数据
goods_stock字段设计为-1表示无限库存，便于普通商品和秒杀商品统一管理
使用utf8mb4字符集，支持emoji等特殊字符

2. 秒杀商品表 (miaosha_goods)

秒杀商品表是核心业务表，存储秒杀活动的特定信息：

CREATE TABLE `miaosha_goods` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '秒杀的商品表',
  `goods_id` bigint(20) DEFAULT NULL COMMENT '商品Id',
  `miaosha_price` decimal(10,2) DEFAULT '0.00' COMMENT '秒杀价',
  `stock_count` int(11) DEFAULT NULL COMMENT '库存数量',
  `start_date` datetime DEFAULT NULL COMMENT '秒杀开始时间',
  `end_date` datetime DEFAULT NULL COMMENT '秒杀结束时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

设计要点：

与商品表分离设计，避免频繁的秒杀活动影响正常商品数据
包含秒杀特有的时间范围和价格信息
库存数量独立管理，便于库存预热和扣减操作

3. 订单表 (order_info)

订单表记录完整的订单信息：

CREATE TABLE `order_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户ID',
  `goods_id` bigint(20) DEFAULT NULL COMMENT '商品ID',
  `delivery_addr_id` bigint(20) DEFAULT NULL COMMENT '收获地址ID',
  `goods_name` varchar(16) DEFAULT NULL COMMENT '冗余过来的商品名称',
  `goods_count` int(11) DEFAULT '0' COMMENT '商品数量',
  `goods_price` decimal(10,2) DEFAULT '0.00' COMMENT '商品单价',
  `order_channel` tinyint(4) DEFAULT '0' COMMENT '1pc，2android，3ios',
  `status` tinyint(4) DEFAULT '0' COMMENT '订单状态',
  `create_date` datetime DEFAULT NULL COMMENT '订单的创建时间',
  `pay_date` datetime DEFAULT NULL COMMENT '支付时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

设计要点：

包含订单状态机（0新建未支付，1已支付，2已发货，3已收货，4已退款，5已完成）
冗余存储商品名称和价格，避免关联查询
记录订单渠道，便于统计分析

4. 秒杀订单表 (miaosha_order)

秒杀订单表专门记录秒杀成功的订单关系：

CREATE TABLE `miaosha_order` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户ID',
  `order_id` bigint(20) DEFAULT NULL COMMENT '订单ID',
  `goods_id` bigint(20) DEFAULT NULL COMMENT '商品ID',
  PRIMARY KEY (`id`),
  UNIQUE KEY `u_uid_gid` (`user_id`,`goods_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

关键优化：

建立唯一索引u_uid_gid，防止同一用户重复秒杀同一商品
与主订单表分离，减轻主订单表的写入压力

5. 用户表 (miaosha_user)

用户表存储用户基本信息：

CREATE TABLE `miaosha_user` (
  `id` bigint(20) NOT NULL COMMENT '用户ID，手机号码',
  `nickname` varchar(255) NOT NULL,
  `password` varchar(32) DEFAULT NULL,
  `salt` varchar(10) DEFAULT NULL,
  `head` varchar(128) DEFAULT NULL COMMENT '头像',
  `register_date` datetime DEFAULT NULL COMMENT '注册时间',
  `last_login_date` datetime DEFAULT NULL COMMENT '上次登录时间',
  `login_count` int(11) DEFAULT '0' COMMENT '登录次数',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

数据库优化策略

1. 索引优化

mermaid

2. 分表分库策略

面对高并发秒杀场景，必须采用分表分库策略：

垂直分表：

热点数据分离：将库存字段从商品表中分离
读写分离：订单表和秒杀订单表分离

水平分库分表： mermaid

3. 字段类型优化

字段类型	使用场景	优化建议
`bigint`	ID主键	使用无符号bigint，范围更大
`decimal(10,2)`	金额字段	精确计算，避免浮点误差
`datetime`	时间字段	存储时间戳，节省空间
`varchar`	变长字符串	根据实际长度设置，避免浪费

4. 事务与锁优化

-- 使用乐观锁控制库存扣减
UPDATE miaosha_goods 
SET stock_count = stock_count - 1 
WHERE goods_id = #{goodsId} AND stock_count > 0;

-- 使用悲观锁防止超卖
SELECT * FROM miaosha_goods WHERE id = #{id} FOR UPDATE;

性能监控与调优

建立完善的数据库监控体系：

慢查询监控：设置long_query_time=0.1s，实时捕获慢SQL
连接数监控：监控最大连接数和活跃连接数
锁等待监控：检测行锁等待和死锁情况
缓冲池监控：优化InnoDB缓冲池大小

总结

秒杀系统的数据库设计需要在高并发、高可用、一致性之间找到平衡点。通过合理的表结构设计、索引优化、分库分表策略，以及精细化的锁控制，可以构建出支撑百万级并发的高性能数据库架构。关键在于前期设计要充分考虑业务场景，后期要通过监控持续优化。

项目环境搭建与部署指南

秒杀系统作为高并发场景的典型应用，其环境搭建和部署需要精心规划。本文将详细介绍如何从零开始搭建miaosha秒杀系统的完整运行环境，包括开发环境、测试环境和生产环境的配置部署。

环境要求与前置准备

在开始部署之前，需要确保系统满足以下基本要求：

组件	版本要求	说明
JDK	1.8+	推荐使用OpenJDK 8或Oracle JDK 8
Maven	3.6+	项目构建工具
MySQL	5.7+	关系型数据库
Redis	5.0+	缓存数据库
RabbitMQ	3.8+	消息队列
Zookeeper	3.4+	服务注册与发现

数据库环境搭建

首先需要创建秒杀系统所需的数据库和表结构：

-- 创建数据库
CREATE DATABASE miaosha CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- 使用数据库
USE miaosha;

-- 执行项目提供的SQL脚本
SOURCE /path/to/miaosha.sql;

关键数据表结构说明：

mermaid

中间件安装与配置

Redis安装配置

# 安装Redis
wget http://download.redis.io/releases/redis-6.2.6.tar.gz
tar xzf redis-6.2.6.tar.gz
cd redis-6.2.6
make

# 修改配置文件
vim redis.conf
# 设置密码：requirepass youxin11
# 绑定IP：bind 0.0.0.0
# 保护模式：protected-mode no

# 启动Redis
./src/redis-server redis.conf

RabbitMQ安装配置

# 安装Erlang
wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
sudo dpkg -i erlang-solutions_2.0_all.deb
sudo apt-get update
sudo apt-get install erlang

# 安装RabbitMQ
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.13/rabbitmq-server_3.9.13-1_all.deb
sudo dpkg -i rabbitmq-server_3.9.13-1_all.deb

# 启用管理插件
sudo rabbitmq-plugins enable rabbitmq_management

# 创建用户
sudo rabbitmqctl add_user mqadmin mqadmin
sudo rabbitmqctl set_user_tags mqadmin administrator
sudo rabbitmqctl set_permissions -p / mqadmin ".*" ".*" ".*"

Zookeeper安装配置

# 下载Zookeeper
wget https://archive.apache.org/dist/zookeeper/zookeeper-3.4.14/zookeeper-3.4.14.tar.gz
tar -xzf zookeeper-3.4.14.tar.gz
cd zookeeper-3.4.14

# 配置Zookeeper
cp conf/zoo_sample.cfg conf/zoo.cfg
vim conf/zoo.cfg
# 修改数据目录：dataDir=/var/lib/zookeeper
# 客户端端口：clientPort=2181

# 启动Zookeeper
bin/zkServer.sh start

项目编译与打包

项目采用Maven多模块架构，需要按照特定顺序进行编译：

# 克隆项目
git clone https://gitcode.com/gh_mirrors/mi/miaosha.git
cd miaosha

# 清理并编译整个项目
mvn clean compile -DskipTests

# 打包各个模块
mvn package -DskipTests -pl miaosha-v2/miaosha-web
mvn package -DskipTests -pl miaosha-order/miaosha-order-provider
mvn package -DskipTests -pl miaosha-rpc/dubbo-provider

项目模块依赖关系如下：

mermaid

配置文件详解

根据不同的环境，需要配置相应的application.properties文件：

开发环境配置 (application-dev.properties)

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/miaosha?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=your_password

# Redis配置
redis.host=localhost
redis.port=6379
redis.password=youxin11

# RabbitMQ配置  
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=mqadmin
spring.rabbitmq.password=mqadmin

# Dubbo配置
dubbo.registry.address=zookeeper://localhost:2181
dubbo.protocol.port=20880

生产环境配置 (application-prod.properties)

# 数据库集群配置
spring.datasource.url=jdbc:mysql://db-cluster:3306/miaosha?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=prod_user
spring.datasource.password=strong_password

# Redis哨兵模式
redis.sentinel.master=mymaster
redis.sentinel.nodes=redis1:26379,redis2:26379,redis3:26379

# RabbitMQ集群
spring.rabbitmq.addresses=rabbit1:5672,rabbit2:5672,rabbit3:5672

# Dubbo注册中心集群
dubbo.registry.address=zookeeper://zk1:2181?backup=zk2:2181,zk3:2181

服务启动与部署

单机部署流程

# 启动Zookeeper
cd zookeeper-3.4.14
bin/zkServer.sh start

# 启动Redis
redis-server /path/to/redis.conf

# 启动RabbitMQ
sudo systemctl start rabbitmq-server

# 启动Dubbo服务提供者
java -jar miaosha-order-provider-1.0.0.jar --spring.profiles.active=dev

# 启动Web应用
java -jar miaosha-web-1.0.0.jar --spring.profiles.active=dev --server.port=9091

容器化部署

建议使用Docker Compose进行容器化部署：

version: '3.8'
services:
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: miaosha
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql

  redis:
    image: redis:6.2-alpine
    command: redis-server --requirepass youxin11
    ports:
      - "6379:6379"

  rabbitmq:
    image: rabbitmq:3.9-management-alpine
    environment:
      RABBITMQ_DEFAULT_USER: mqadmin
      RABBITMQ_DEFAULT_PASS: mqadmin
    ports:
      - "5672:5672"
      - "15672:15672"

  zookeeper:
    image: zookeeper:3.4
    ports:
      - "2181:2181"

  miaosha-web:
    build: .
    image: miaosha-web:1.0.0
    ports:
      - "9091:9091"
    depends_on:
      - mysql
      - redis
      - rabbitmq
      - zookeeper
    environment:
      SPRING_PROFILES_ACTIVE: prod

volumes:
  mysql_data:

环境验证与测试

部署完成后，需要进行系统验证：

服务健康检查

# 检查Web服务
curl http://localhost:9091/health

# 检查数据库连接
mysql -h localhost -u root -p -e "SELECT COUNT(*) FROM goods;"

# 检查Redis连接
redis-cli -h localhost -p 6379 -a youxin11 ping

# 检查RabbitMQ
curl -u mqadmin:mqadmin http://localhost:15672/api/overview

性能压力测试 使用JMeter进行秒杀场景压力测试，模拟高并发请求：

<!-- JMeter测试计划示例 -->
<ThreadGroup guiclass="ThreadGroupGui" testclass="ThreadGroup" testname="秒杀压力测试">
    <intProp name="ThreadGroup.num_threads">1000</intProp>
    <intProp name="ThreadGroup.ramp_time">60</intProp>
    <longProp name="ThreadGroup.duration">300</longProp>
</ThreadGroup>

监控配置 建议配置以下监控指标：

应用性能监控（APM）
数据库连接池监控
Redis缓存命中率
RabbitMQ消息堆积情况
JVM内存使用情况

通过以上完整的环境搭建和部署指南，您可以成功部署miaosha秒杀系统，并为后续的性能调优和高可用架构扩展奠定坚实基础。

总结

秒杀系统作为高并发场景的典型应用，其成功实施需要在架构设计、技术选型和细节实现上做到精益求精。通过合理的分层架构、微服务划分、数据库优化、缓存策略、异步处理等多重技术手段，才能在极端业务场景下保持稳定可靠的服务能力。本文提供的完整环境搭建指南和部署方案，为实际项目落地提供了可靠的技术支撑，帮助开发者构建出能够支撑百万级并发的高性能秒杀平台。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考