Posted in

Go语言中文网红包模块源码深度剖析，手把手复现其限流、幂等、回滚机制

by 性能优化专家||0

第一章：Go语言中文网微信红包模块架构概览

Go语言中文网微信红包模块采用典型的微服务分层架构，以高并发、强一致性与可追溯性为核心设计目标。整体由接入层、业务逻辑层、数据访问层和基础设施层构成，各层通过标准HTTP/gRPC接口通信，并依托Go原生协程与channel实现轻量级并发调度。

核心组件职责划分

  • 红包发放服务：接收用户发包请求，校验金额、人数、风控规则，生成唯一红包ID并写入Redis预热缓存；
  • 红包领取服务：处理抢红包请求，基于Redis Lua脚本执行原子扣减（保障超发防护），成功后触发异步落库与消息通知；
  • 资金结算服务：对接银行/支付通道，按T+1规则批量处理红包到账与手续费分账；
  • 审计追踪服务：全链路埋点日志统一接入ELK，关键操作（如发包、拆包、退款）均生成不可篡改的区块链哈希存证。

关键技术选型与约束

组件 技术栈 约束说明
缓存 Redis Cluster + Lua 所有红包状态变更必须通过Lua原子脚本执行
持久化 PostgreSQL 14（分库分表） 红包主表按red_packet_id % 64分片，余额变更强制走行级锁
消息队列 Kafka 3.0 异步事件（如到账通知）启用Exactly-Once语义

发放红包核心逻辑示例

以下为红包创建时的Go代码片段，体现幂等性与事务边界控制：

// 创建红包前先检查幂等Key（防止重复提交）
idempotentKey := fmt.Sprintf("idempotent:%s", req.ClientTraceID)
if ok, _ := redisClient.SetNX(ctx, idempotentKey, "1", 10*time.Minute).Result(); !ok {
    return errors.New("duplicate request detected")
}

// 使用Redis Pipeline预占总金额（避免超发）
pipe := redisClient.Pipeline()
pipe.HSet(ctx, "red_packet:"+packetID, "total_amount", req.TotalAmount)
pipe.HSet(ctx, "red_packet:"+packetID, "remain_count", req.Count)
pipe.Expire(ctx, "red_packet:"+packetID, 24*time.Hour)
_, err := pipe.Exec(ctx)
if err != nil {
    // 回滚幂等Key
    redisClient.Del(ctx, idempotentKey)
    return err
}

该模块已稳定支撑单日峰值58万次发包、230万次抢包，平均响应延迟低于42ms。

第二章：限流机制源码深度剖析与手把手复现

2.1 令牌桶算法原理与Go标准库time.Ticker实现对比

令牌桶（Token Bucket）是一种经典限流算法：以恒定速率向桶中添加令牌，请求需消耗令牌才能通过；桶有容量上限，满则丢弃新令牌。其核心参数为速率（rps）和容量（burst），支持突发流量。

核心差异本质

  • 令牌桶：请求驱动，检查+消费原子操作，允许短时突发；
  • time.Ticker：时间驱动，仅提供周期性通知，无状态、无容量概念，需额外逻辑模拟限流。

对比表格

维度 令牌桶 time.Ticker
状态保持 ✅ 桶中剩余令牌数 ❌ 无状态
突发处理 ✅ 支持 burst ❌ 均匀间隔，无累积能力
实现复杂度 中（需原子计数） 极低（仅通道接收） 
// 使用 time.Ticker 模拟简单速率限制（无burst）
ticker := time.NewTicker(100 * time.Millisecond) // ≈10 QPS
for range ticker.C {
    handleRequest() // 严格按周期执行
}

此代码仅实现“固定间隔执行”，无法应对初始空闲期的突发请求；缺少令牌计数与条件消费逻辑，不具备真正令牌桶语义。

graph TD
    A[请求到达] --> B{桶中有令牌？}
    B -->|是| C[消耗令牌，放行]
    B -->|否| D[拒绝或等待]
    E[定时器] -->|每T秒| F[向桶添加min(可用空间, 1)令牌]

2.2 并发安全的RateLimiter结构体设计与原子操作实践

核心字段与内存布局

RateLimiter 采用无锁设计，关键状态集中于两个 atomic.Int64 字段：

  • tokens：当前可用令牌数（带符号，负值表示欠额）
  • lastUpdate：上一次填充时间戳（纳秒级，用于滑动窗口计算）

原子操作实践

// 尝试获取 token，返回是否成功及新剩余量
func (r *RateLimiter) tryAcquire(now int64, burst int64) (bool, int64) {
    for {
        oldTokens := r.tokens.Load()
        oldLast := r.lastUpdate.Load()
        // 计算应补充的令牌：基于时间差与速率
        delta := (now - oldLast) * r.rateNanos / 1e9 // rateNanos = 1e9 / QPS
        newTokens := min(burst, oldTokens+delta)
        // CAS 更新：仅当状态未被其他 goroutine 修改时生效
        if r.tokens.CompareAndSwap(oldTokens, newTokens) &&
           r.lastUpdate.CompareAndSwap(oldLast, now) {
            return newTokens > 0, newTokens - 1
        }
    }
}

逻辑分析：循环 CAS 避免 ABA 问题；rateNanos 表示每纳秒生成的令牌份额（如 QPS=100 → rateNanos=1e7），burst 限制最大桶容量。时间差乘以速率即为理论新增令牌数，min 确保不超限。

关键约束对比

操作 是否阻塞 是否重试 线程安全机制
tryAcquire 否 是（CAS循环） CompareAndSwap
Wait 是 否 结合 time.Sleep

数据同步机制

使用 atomic.Load/Store 保证 lastUpdate 与 tokens 的读写可见性，避免缓存不一致；所有修改路径均通过单一 CAS 原子块完成，消除竞态窗口。

2.3 基于Redis分布式限流的Lua脚本嵌入与本地缓存降级策略

当Redis集群出现网络延迟或短暂不可用时，纯远程限流将导致请求阻塞或误放行。此时需在应用层嵌入具备原子性与容错能力的Lua限流脚本，并联动本地缓存实现平滑降级。

Lua限流脚本（令牌桶）

-- KEYS[1]: 限流key（如 "rate:uid:123"）
-- ARGV[1]: 桶容量；ARGV[2]: 每秒补充令牌数；ARGV[3]: 当前时间戳（毫秒）
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local bucket = redis.call("HMGET", KEYS[1], "tokens", "updated_at")
local tokens = tonumber(bucket[1]) or capacity
local updated_at = tonumber(bucket[2]) or now

-- 计算应补充的令牌数（基于时间差）
local delta = math.max(0, math.min(capacity, (now - updated_at) / 1000 * rate))
tokens = math.min(capacity, tokens + delta)

-- 判断是否可通行
local allowed = tokens >= 1 and 1 or 0
if allowed == 1 then
    tokens = tokens - 1
    redis.call("HMSET", KEYS[1], "tokens", tokens, "updated_at", now)
    redis.call("EXPIRE", KEYS[1], 60) -- 自动过期保障内存安全
end
return {allowed, tokens}

该脚本以原子方式完成“读-算-写”，避免竞态；HMGET/HMSET减少内存占用；EXPIRE防止冷key长期驻留；ARGV[3]由客户端传入，规避Redis时钟漂移风险。

降级策略协同机制

触发条件 行为 生效范围
Redis连接超时（>200ms） 切换至Caffeine本地令牌桶 单JVM进程内
连续3次Lua执行失败 启用固定窗口计数器（无状态） 全局降级开关

数据同步机制

graph TD
    A[请求到达] --> B{Redis可用？}
    B -->|是| C[执行Lua限流]
    B -->|否| D[查本地Caffeine缓存]
    D --> E{本地桶有余量？}
    E -->|是| F[扣减并返回允许]
    E -->|否| G[返回429]
    C --> H[结果写回本地缓存]

2.4 压测验证：wrk+pprof定位QPS瓶颈与goroutine泄漏点

在高并发服务上线前，需通过真实流量模拟识别隐性性能缺陷。我们采用 wrk 进行多线程 HTTP 压测，并结合 Go 内置 pprof 实时分析运行时状态。

快速启动压测与采样

# 启动 wrk 模拟 100 并发、持续 30 秒，启用连接复用
wrk -t4 -c100 -d30s --latency http://localhost:8080/api/items

-t4 指定 4 个协程（避免 OS 线程调度开销），-c100 维持 100 个长连接，--latency 输出详细延迟分布，便于识别尾部延迟突增。

实时诊断 goroutine 泄漏

访问 http://localhost:8080/debug/pprof/goroutine?debug=2 可获取带栈追踪的完整 goroutine 列表。重点关注重复出现、阻塞在 select{} 或 chan receive 的长期存活协程。

性能热点对比（采样 30s CPU profile）

模块 占比 典型表现
JSON 序列化 38% encoding/json.(*encodeState).marshal
DB 查询 29% database/sql.(*Rows).Next 阻塞等待
JWT 验证 15% crypto/rsa.(*PrivateKey).Sign

graph TD A[wrk 发起 HTTP 请求] –> B[服务接收并分发 Handler] B –> C{是否启用 pprof?} C –>|是| D[采集 goroutine / heap / cpu profile] C –>|否| E[仅返回业务响应] D –> F[分析阻塞点与内存增长趋势]

2.5 自定义限流中间件集成gin框架并支持动态配置热更新

核心设计思路

基于令牌桶算法实现轻量级限流器，通过原子操作保障高并发安全，并解耦配置源（如 etcd / Redis / 文件监听）。

配置热更新机制

// 监听配置变更，触发限流规则重载
func (l *Limiter) WatchConfig(ctx context.Context, key string) {
    for range l.watcher.Watch(ctx, key) {
        cfg, _ := l.configStore.Get(key)
        l.mu.Lock()
        l.rules = parseRules(cfg) // 解析 JSON 规则：path、qps、burst
        l.mu.Unlock()
    }
}

parseRules 将 {"/api/user": {"qps": 100, "burst": 200}} 转为内存映射；l.mu 确保规则切换时读写安全。

Gin 中间件注册

func RateLimitMiddleware(limiter *Limiter) gin.HandlerFunc {
    return func(c *gin.Context) {
        if !limiter.Allow(c.Request.URL.Path) {
            c.AbortWithStatusJSON(429, gin.H{"error": "too many requests"})
            return
        }
        c.Next()
    }
}

Allow() 内部按路径查规则、执行令牌桶判断，失败即中断请求链。

支持的配置源对比

源类型 实时性 一致性 适用场景
文件监听 秒级 弱 开发/测试环境
etcd 毫秒级 强 生产集群统一管控
Redis 毫秒级 最终一致 高吞吐临时降级

graph TD A[HTTP Request] –> B{Gin Middleware} B –> C[Extract Path] C –> D[Load Rule via RW Lock] D –> E[TokenBucket Allow?] E –>|Yes| F[Proceed] E –>|No| G[Return 429]

第三章：幂等性保障机制解析与工程化落地

3.1 幂等Key生成策略：业务ID+请求指纹+时间窗口哈希实践

在高并发分布式场景下，仅依赖业务ID易导致跨窗口重复提交失效。需融合业务唯一性、请求内容确定性与时间局部性约束三要素。

核心组成要素

  • 业务ID：如 order_123456，标识操作归属主体
  • 请求指纹：对 payload 字段（排除非幂等字段如 timestamp）做 SHA-256 摘要
  • 时间窗口哈希：取 floor(currentTime / 300000)（5分钟滑动窗口），避免长期存储膨胀

示例实现（Java）

public String generateIdempotentKey(String bizId, Map<String, Object> payload) {
    String fingerprint = DigestUtils.sha256Hex(JSON.toJSONString(
        payload.entrySet().stream()
               .filter(e -> !e.getKey().equals("reqId")) // 排除非幂等字段
               .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
    ));
    long window = System.currentTimeMillis() / 300_000;
    return String.format("%s:%s:%d", bizId, fingerprint.substring(0, 16), window);
}

逻辑说明：fingerprint 截取前16位降低存储开销；window 使用整除实现5分钟对齐；bizId 确保跨业务隔离。该组合使同一窗口内相同业务+相同语义请求必然映射到唯一 key。

策略对比表

维度 单纯业务ID 业务ID+指纹 本方案（+时间窗口）
存储成本 极低 高 中（窗口复用）
时序容错能力 无 弱（永久冲突） 强（窗口内去重） 
graph TD
    A[原始请求] --> B[清洗payload]
    B --> C[计算SHA-256指纹]
    C --> D[取5分钟时间窗]
    D --> E[拼接bizId:fingerprint:window]
    E --> F[Redis SETNX校验]

3.2 基于Redis SETNX+EXPIRE的原子幂等锁实现与超时续期方案

核心挑战：SETNX与EXPIRE非原子性

直接分步调用 SETNX key value + EXPIRE key ttl 存在竞态风险：若SETNX成功但EXPIRE失败，将导致永久死锁。

原子化解决方案：SET命令替代

SET lock:order:123 "client-abc" NX EX 30
  • NX：仅当key不存在时设置（等价于SETNX）
  • EX 30：同时设置30秒过期时间（原子执行）
  • 返回 OK 表示加锁成功，nil 表示锁已被占用

超时续期机制（Watchdog）

  • 客户端启动独立协程，每10秒检查锁归属并执行 PEXPIRE lock:order:123 30000
  • 续期前需校验value是否为本客户端ID（防误删）

锁释放安全流程

步骤 操作 说明
1 Lua脚本比对value if redis.call("GET", KEYS[1]) == ARGV[1] then ...
2 成功则DEL 避免其他客户端释放锁
3 否则返回0 表示无权操作 
graph TD
    A[尝试加锁] --> B{SET key val NX EX ttl}
    B -->|OK| C[执行业务逻辑]
    B -->|nil| D[重试或拒绝]
    C --> E[启动续期协程]
    E --> F[定时PEXPIRE+value校验]

3.3 数据库唯一约束兜底与幂等日志表的异步清理机制

核心设计思想

在高并发写入场景中，仅靠应用层校验无法完全避免重复数据。因此采用「双保险」策略：数据库唯一索引强制拦截 + 幂等日志表记录操作指纹。

幂等日志表结构

字段名 类型 说明
id BIGINT PK 自增主键
biz_key VARCHAR(128) 业务唯一标识（如 order_id:uid）
created_at DATETIME 插入时间，用于TTL清理

异步清理流程

-- 每日凌晨清理7天前的日志（避免长事务阻塞）
DELETE FROM idempotent_log 
WHERE created_at < DATE_SUB(NOW(), INTERVAL 7 DAY) 
LIMIT 10000; -- 分批删除防锁表

逻辑分析：LIMIT 10000 防止单次删除耗时过长；DATE_SUB 确保时间计算精准；该语句由定时任务（如Airflow或Cron Job）驱动，解耦核心链路。

清理调度策略

  • ✅ 每日02:00触发，错峰避开业务高峰
  • ✅ 失败自动重试3次，超时阈值设为15分钟
  • ✅ 清理进度写入监控埋点（cleaned_rows, duration_ms）
graph TD
    A[定时任务触发] --> B{是否满足清理条件？}
    B -->|是| C[执行分批DELETE]
    B -->|否| D[跳过]
    C --> E[上报监控指标]
    E --> F[记录清理日志]

第四章：事务回滚与补偿机制全链路实现

4.1 红包发放场景下的Saga模式拆解：预占、扣减、发券、通知四阶段

在高并发红包发放中，Saga 模式将长事务拆解为四个幂等、可补偿的本地事务阶段：

四阶段职责划分

  • 预占：冻结用户账户额度（如 red_packet_quota: 100），防止超发
  • 扣减：原子扣减红包库存（DB 行锁 + version 控制）
  • 发券：向用户券表插入记录，并异步写入 Redis 缓存
  • 通知：触发消息队列（如 RocketMQ），驱动 APP 推送与日志归档

核心补偿逻辑示例（伪代码）

// 扣减库存（带乐观锁）
int updated = jdbcTemplate.update(
    "UPDATE t_red_packet_stock SET stock = stock - 1, version = version + 1 " +
    "WHERE id = ? AND stock > 0 AND version = ?", 
    packetId, expectedVersion); // expectedVersion 来自预占阶段读取

该 SQL 保证库存不超卖且避免 ABA 问题；updated == 0 时触发预占回滚。

Saga 各阶段状态流转

阶段 成功动作 失败补偿动作
预占 写入 t_prelock 表 删除预占记录
扣减 更新库存并返回新 version 恢复原 version
发券 插入 t_coupon 逻辑删除（is_deleted=1）
通知 发送 MQ SUCCESS 消息 补偿发送 NOTICE_FAIL 
graph TD
    A[预占] -->|success| B[扣减]
    B -->|success| C[发券]
    C -->|success| D[通知]
    D -->|fail| C_Comp[发券补偿]
    C_Comp --> B_Comp[扣减补偿]
    B_Comp --> A_Comp[预占释放]

4.2 基于context.Context传递回滚上下文与可逆操作函数注册机制

在分布式事务或复合操作中，需确保失败时能精准回退。核心思路是将回滚能力“注入”到 context.Context 中，实现跨调用链的上下文感知。

回滚函数注册与携带

type RollbackCtxKey struct{}

func WithRollback(ctx context.Context, fn func() error) context.Context {
    return context.WithValue(ctx, RollbackCtxKey{}, fn)
}

func ExecuteWithRollback(ctx context.Context, op func() error) error {
    if op == nil {
        return nil
    }
    if err := op(); err != nil {
        // 触发注册的回滚函数（若存在）
        if rb, ok := ctx.Value(RollbackCtxKey{}).(func() error); ok {
            rb() // 忽略回滚错误，或应记录日志
        }
        return err
    }
    return nil
}

逻辑分析：WithRollback 将可逆操作函数作为值绑定至 context；ExecuteWithRollback 在主操作失败后自动触发该函数。参数 ctx 携带回滚能力，fn 是无参、返回 error 的纯回滚逻辑（如数据库反向更新、文件删除等）。

回滚注册策略对比

策略 适用场景 可组合性 生命周期管理
单次注册（覆盖） 简单线性流程 低 手动
栈式追加（slice） 多层嵌套操作（推荐） 高 自动（defer）
Map键名注册 按语义分类回滚（如“cache”、“db”） 中 需显式清理

回滚执行流程（mermaid）

graph TD
    A[开始操作] --> B{执行主逻辑}
    B -->|成功| C[返回结果]
    B -->|失败| D[从ctx提取回滚函数]
    D --> E[顺序执行已注册回滚函数]
    E --> F[返回原始错误]

4.3 分布式事务异常捕获：panic恢复、error分类（网络/DB/业务）及分级重试策略

panic 恢复机制

在事务协调器中，需用 recover() 捕获协程级崩溃，避免整个服务中断：

func runWithRecover(fn func()) {
    defer func() {
        if r := recover(); r != nil {
            log.Error("panic recovered in TX coordinator", "panic", r)
            metrics.PanicCounter.Inc()
        }
    }()
    fn()
}

逻辑分析：defer+recover 必须在同 goroutine 内执行；metrics.PanicCounter 用于监控异常频次；log.Error 记录原始 panic 值，便于根因定位。

error 分类与响应策略

类型 示例 可重试性 建议动作
网络 i/o timeout, connection refused ✅ 高 指数退避重试
DB deadlock detected, duplicate key ⚠️ 中 限次重试 + 补偿回滚
业务 insufficient_balance ❌ 低 直接终止，触发补偿流程

分级重试策略

graph TD
    A[初始请求] --> B{error 类型}
    B -->|网络错误| C[指数退避: 100ms→200ms→400ms]
    B -->|DB 错误| D[固定3次, 间隔500ms]
    B -->|业务错误| E[跳过重试, 调用 Compensate()]

4.4 补偿任务调度器设计：基于TTL+定时扫描+幂等执行的后台Worker实现

核心设计思想

为应对分布式事务中异步操作失败场景，补偿任务需满足自动触发、防重复、可收敛三大特性。采用 TTL（Time-To-Live）标记任务过期时间，结合低频定时扫描（如每30秒）发现待执行任务，并通过唯一业务键 + 数据库 INSERT ... ON CONFLICT DO NOTHING 实现天然幂等。

关键组件协同流程

graph TD
    A[任务写入] -->|设置ttl字段| B[Redis/DB]
    C[定时Worker] -->|SCAN WHERE ttl < NOW()| B
    C -->|获取任务列表| D[按business_key去重]
    D -->|并发执行| E[幂等更新状态]

幂等执行保障示例（PostgreSQL）

-- 插入补偿任务（带TTL与业务唯一键）
INSERT INTO comp_tasks (
  id, business_key, payload, status, ttl
) VALUES (
  gen_random_uuid(),
  'order_123456', 
  '{"action":"refund"}',
  'pending',
  NOW() + INTERVAL '5 minutes'
)
ON CONFLICT (business_key) WHERE status = 'pending' 
DO NOTHING; -- 防止重复插入未完成任务

逻辑说明：ON CONFLICT (business_key) 利用唯一索引；WHERE status = 'pending' 确保仅未处理任务可被跳过，已成功或失败的任务仍可重试（需配合后续状态机）。ttl 字段用于扫描过滤，避免全表扫描。

扫描策略对比

策略 QPS压力 延迟上限 实现复杂度
全表轮询 高 30s 低
TTL索引扫描 低 30s 中（需ttl索引）
消息队列TTL 极低 秒级 高（依赖MQ能力）

推荐采用 TTL索引扫描：在 comp_tasks(ttl) 上建立 B-tree 索引，SELECT * FROM comp_tasks WHERE ttl <= NOW() LIMIT 100 可高效分页执行。

第五章：总结与高并发红包系统的演进思考

红包系统从单体到分层解耦的关键跃迁

某头部社交平台在2021年春节活动期间，单日红包发放峰值达 830万次/秒，原基于MySQL+Redis缓存的单体架构频繁触发连接池耗尽与主从延迟超2s。团队紧急实施分层改造：将「发红包」、「抢红包」、「拆红包」、「资金结算」四核心流程解耦为独立服务，通过RocketMQ实现最终一致性，并引入本地消息表保障事务可靠性。改造后，系统在2023年除夕夜承载峰值 1260万次/秒 请求，平均响应时间稳定在 47ms（P99

幂等与库存双控机制的工程落地细节

为规避超发，系统采用「预占库存 + 状态机校验」双重防护：

  • 预占阶段：使用 Redis Lua 脚本原子扣减 red_packet_pool:{id} 剩余数量；
  • 拆包阶段：先校验 red_packet_record:{id}:{uid} 是否已存在（SETNX），再更新 user_balance 并写入 Kafka 日志。
    实测数据显示，该机制使重复领取率从 0.017% 降至 0.000023%，且 Lua 脚本执行耗时均值仅 0.8ms。

流量洪峰下的动态降级策略组合

面对突发流量，系统启用三级熔断： 等级 触发条件 动作 恢复方式
L1 QPS > 800万 关闭「随机金额生成」 自动检测5分钟内QPS
L2 Redis集群CPU > 92% 切换至本地Caffeine缓存 运维手动确认后生效
L3 Kafka积压 > 500万条 启用内存队列暂存并限速10万/s 积压低于10万条自动退出

分布式ID与分库分表的实际适配

红包订单ID采用 Snowflake + 业务标识前缀（如 RP_1234567890123456789），其中机器ID段映射至数据库物理节点编号。分库策略按红包活动ID哈希取模16，分表按用户ID末两位路由，共16库×100表。上线后单表数据量控制在 820万行以内（远低于MySQL推荐的2000万阈值），慢查询数量下降 94%。

flowchart TD
    A[用户点击“开”] --> B{是否已领取？}
    B -->|是| C[返回历史结果]
    B -->|否| D[Lua预占库存]
    D --> E{库存>0?}
    E -->|否| F[返回“手慢了”]
    E -->|是| G[插入领取记录]
    G --> H[异步通知财务系统]
    H --> I[更新用户余额]

监控告警体系的闭环验证机制

部署 Prometheus + Grafana 实时追踪 red_packet_take_success_rate、redis_stock_decr_latency、kafka_lag_per_partition 三大黄金指标。当 take_success_rate 连续3分钟低于99.95%，自动触发Jenkins流水线回滚至上一稳定版本，并向值班工程师推送含堆栈快照的飞书告警。2023年全年因该机制避免3次潜在资损事故。

架构演进中的技术债偿还路径

初期为保上线采用强依赖DB事务，后续通过「Saga模式」重构资金链路：发红包生成正向事务，拆红包触发补偿事务（如余额不足则回调退款）。补偿逻辑经混沌工程注入网络分区故障验证，重试3次后成功率仍达100%。当前补偿任务平均完成耗时 1.2s，较原事务模型降低 68% 锁等待时间。

专治系统慢、卡、耗资源，让服务飞起来。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注