罗罗编程学习记录
本页内容 展开查看

05.7 阶段 6 数据层、缓存与消息

所属:全栈开发面试题库 / 学习路径 / 05 Go 全栈

本页目录

一、阶段定位

阶段 5(05.6)把服务暴露到网络上,本阶段解决"服务背后的数据怎么存、怎么读、怎么异步"。HTTP handler 后面通常接三层:关系库(MySQL/PostgreSQL)存业务数据、Redis 做热点缓存与分布式锁、Kafka 做异步解耦。这三层的工程做法有大量坑:连接池参数怎么配、事务里能不能调远程、缓存穿透怎么防、消息重复消费怎么办。

与前后阶段的衔接:

  • 往上接阶段 4 的 pprof:数据库连接池打满、Redis 连接泄漏,要靠 pprof heap 与 goroutine profile 定位。
  • 往上接阶段 3 的 context:所有 DB/Redis/Kafka 调用都必须接收 ctx,否则超时取消不生效。
  • 往下接阶段 7(05.8):连接池指标、缓存命中率、消费延迟要做成 Prometheus 指标。
  • 再往下接阶段 8(05.9):高并发下连接池与 goroutine 并发度的关系是核心调优点。

原提纲里的"卡点"展开成可判断的现象依据:

  • 事务里混入网络调用:一个事务里调了 Redis 或下游 HTTP,事务持锁时间从毫秒变成秒,连接池被占满。
  • 缓存空值与过期策略缺失:热点 key 过期瞬间,大量请求同时回源数据库(缓存击穿)。
  • 消费失败后跳过消息:用 consumer.Commit() 先提交再处理,处理失败时消息已丢,无法重投。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能配置 database/sql 连接池参数(MaxOpenConns/MaxIdleConns/ConnMaxLifetime) 写出参数说明,并解释为什么 MaxOpenConns 要小于 DB 端 max_connections
能用 pgx 或 sqlc 写查询,避免 N+1 对"查 100 个用户 + 各自订单"写出一条 JOIN 而非 100 次查询
能正确使用事务与隔离级别,事务里不做远程调用 代码评审时能指出"事务里调 Redis"是反模式
能实现缓存穿透/击穿/雪崩三类防护 用空值缓存 + 互斥重建 + 随机过期组合实现
能写一个带幂等键的 Kafka 消费者,重复投递不产生副作用 同一消息投递两次,数据库只有一条记录
能解释连接池上限与 goroutine 并发度的关系 说出"为什么 1000 并发请求不能配 1000 个 DB 连接"

建议学时:

  • 全职:2 周,约 60–70 小时。database/sql 与连接池 15 小时、事务与 N+1 15 小时、Redis 与缓存 15 小时、Kafka 与幂等 15 小时、实战 10 小时。
  • 在职:5–6 周,约 70 小时。Redis 与 Kafka 各占一周。

学时分配建议:database/sql 与连接池 20%、事务与 SQL 优化 20%、Redis 与缓存 25%、分布式锁 10%、Kafka 与幂等 25%。

三、先修自检

先修项 合格标准 不合格时回到
context 超时 能用 ctx 让下游函数退出 05.4 的 5.3 节
错误包装 能用 %w 保留错误链 05.3 的 5.3 节
HTTP handler 能写分层 handler + service 05.6 的 5.3 节
pprof 能抓 heap 与 goroutine profile 05.5 的 5.5 节
SQL 基础 能写 SELECT/JOIN/WHERE/GROUP BY 05.1 关系型通用能力

经验判断:有 Java 经验的人容易过度依赖 JPA/Hibernate 式 ORM,忽略 SQL 本身;有 Python 经验的人容易用裸 pymysql 不管理连接池。Go 生态里 sqlc 与 pgx 是主流,不要一上来就 GORM。

四、知识地图

模块 知识点 掌握程度 对应题库章节
database/sql 连接池参数、Stmt、上下文超时、事务 能讲清原理 05.1 关系型通用能力
驱动与 ORM pgx、GORM、Ent、sqlc 取舍 会用 05.2 MySQL
事务与隔离 隔离级别、脏读/不可重复读/幻读、锁 能讲清原理 05.3 PostgreSQL
SQL 优化 N+1、批量写入、预加载、索引配合 会用 05.1 关系型通用能力
Redis 客户端 go-redis、连接池、pipeline、Lua 会用 09.3 缓存体系
缓存策略 穿透/击穿/雪崩、布隆、随机过期 能讲清原理 09.3 缓存体系
分布式锁 Redis SET NX、过期、释放归属 会用 09.3 缓存体系
Kafka 生产、消费、消费者组、offset、幂等、顺序 会用 09.4 消息队列

进度管理建议:连接池与事务是面试高频,必须到"能讲清原理";缓存三问题与幂等要求"能讲清原理"。

五、分模块精讲

5.1 database/sql 与连接池参数

为什么需要它:Go 标准库 database/sql 提供连接池,但默认参数(MaxOpenConns=0 即无限)会让服务在并发上去后把数据库连接打满。连接池参数是生产环境必配的。

核心机制:

  • sql.Open 只是创建连接池对象,不真正连接;第一次 Ping 或查询才建连。
  • SetMaxOpenConns(n):最大打开连接数;0 表示无限。必须设,否则 DB 端 max_connections(默认 151)会被打满。
  • SetMaxIdleConns(n):最大空闲连接数;应 ≤ MaxOpenConns。
  • SetConnMaxLifetime(d):连接最大存活时间;应小于 DB 端 wait_timeout(MySQL 默认 8 小时),避免用被服务端断开的连接。
  • SetConnMaxIdleTime(d):空闲连接最大存活时间。
  • 所有查询必须传 ctx,超时后数据库连接会被取消并归还。

最小可运行示例:

package main

import (
	"context"
	"database/sql"
	"log"
	"time"

	_ "github.com/jackc/pgx/v5/stdlib" // PostgreSQL 驱动
)

func main() {
	db, err := sql.Open("pgx", "postgres://user:pass@127.0.0.1:5432/app")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// 关键:连接池参数
	db.SetMaxOpenConns(20)          // 小于 DB 端 max_connections
	db.SetMaxIdleConns(10)          // 空闲 10
	db.SetConnMaxLifetime(5 * time.Minute)  // 小于 DB wait_timeout
	db.SetConnMaxIdleTime(2 * time.Minute)

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	var name string
	err = db.QueryRowContext(ctx, "SELECT name FROM users WHERE id = $1", 1).Scan(&name)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(name)
}

常见坑:

现象 原因 修法
pq: sorry, too many clients already MaxOpenConns 无限,超过 DB max_connections 设 SetMaxOpenConns(20)
context deadline exceeded 后连接泄漏 没传 ctx,慢查询占着连接 所有查询用 QueryRowContext
偶发 EOF / bad connection 连接被 DB 端断开但池里还在用 设 SetConnMaxLifetime 小于 wait_timeout
连接池里一直是旧连接 SetMaxIdleConns 太大,空闲连接不回收 设 SetConnMaxIdleTime

面试考法:"database/sql 连接池参数怎么设""为什么 MaxOpenConns 不能无限""为什么要传 ctx"。要点:MaxOpenConns 限制并发连接;Lifetime 小于 DB 超时;ctx 超时取消查询。

5.2 pgx、GORM、sqlc 取舍

为什么需要它:Go 生态有三种主流数据访问方式:裸 database/sql + pgx 驱动、全自动 ORM(GORM)、代码生成(sqlc)。选错了项目会很痛苦。

核心机制:

  • pgx:PostgreSQL 原生驱动,性能最好,支持原生类型;比 database/sql 快但绑定 PG。
  • GORM:全自动 ORM,链式 API,开发快;但 SQL 不可控、N+1 容易犯、复杂查询难写。
  • sqlc:从 SQL 生成类型安全的 Go 代码;写原生 SQL 但有类型检查;是 Go 社区推荐的"SQL 优先"方案。
  • Ent:Facebook 开源的图模型 ORM,适合复杂关联查询。
  • 选择:小项目快速原型用 GORM;中大型项目用 sqlc + pgx;跨数据库用 database/sql 接口。

最小可运行示例:

-- query.sql:sqlc 输入
-- name: GetUser :one
SELECT id, name, email FROM users WHERE id = $1;

-- name: ListUsers :many
SELECT id, name FROM users ORDER BY id LIMIT $1;
# sqlc 生成类型安全的 Go 代码
sqlc generate
# 产出 db.go、models.go、query.sql.go
# GetUser(ctx, 1) 返回 (*User, error),类型安全

常见坑:

现象 原因 修法
GORM 查 N+1:循环里 db.First(&user) 没预加载 用 Preload("Orders") 或 JOIN
sqlc 生成代码报错 SQL 语法不对 在 PG 里先手动跑通 SQL
用 GORM 写复杂查询性能差 ORM 生成的 SQL 低效 改用 db.Raw 写原生 SQL

面试考法:"GORM 与 sqlc 区别""为什么 Go 社区推荐 sqlc"。要点:GORM 自动但 SQL 不可控;sqlc 写 SQL 但类型安全;原生 SQL 性能可控。

5.3 事务与隔离级别

为什么需要它:事务保证多个操作要么全成功要么全回滚。但事务里做远程调用会持锁过久,是线上事故的高发原因。

核心机制:

  • 隔离级别:读未提交、读已提交、可重复读、串行化。MySQL 默认 RR,PostgreSQL 默认 RC。
  • 问题:脏读(读到未提交)、不可重复读(同事务两次读不同)、幻读(同条件两次范围查询行数不同)。
  • 事务用法:db.BeginTx(ctx, opts) → 执行 SQL → Commit() 或 Rollback()。
  • 铁律:事务里不做远程调用(HTTP、Redis、Kafka),因为网络延迟不可控,锁持有时长从毫秒变秒。
  • 长事务排查:pg_stat_activity 看 state = 'idle in transaction'。

最小可运行示例:

func transfer(ctx context.Context, db *sql.DB, from, to int, amount float64) error {
	tx, err := db.BeginTx(ctx, nil) // 默认隔离级别
	if err != nil {
		return err
	}
	defer tx.Rollback() // Commit 后 Rollback 返回 ErrTxDone,无害

	if _, err := tx.ExecContext(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, from); err != nil {
		return err
	}
	if _, err := tx.ExecContext(ctx, "UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, to); err != nil {
		return err
	}
	// 注意:这里不要调 Redis 或 HTTP!
	return tx.Commit()
}

常见坑:

现象 原因 修法
数据库连接池被打满 事务里调远程,长事务占连接 把远程调用移到事务外
ERROR: current transaction is aborted, commands ignored until end of transaction block PG 里一条 SQL 失败后没 Rollback 出错后立刻 Rollback,不要继续执行
并发扣减出现负余额 RR 下没加行锁 用 SELECT ... FOR UPDATE 或乐观锁版本号

面试考法:"隔离级别有哪些""事务里为什么不能做远程调用""怎么防超卖"。要点:四级隔离;远程调用持锁;FOR UPDATE 或乐观锁。

5.4 N+1 与批量写入

为什么需要它:N+1 是 ORM 项目最常见性能问题——查 100 个用户再循环查订单,变成 101 次查询。批量写入则是另一个极端:一次插一行,10 万行变成 10 万次往返。

核心机制:

  • N+1:先查 N 个主对象,再循环查每个的关联对象;应该改成一条 JOIN 或 IN 查询。
  • 批量写入:用 INSERT INTO t (a,b) VALUES (?,?),(?,?),(?,?) 一次多行;或 COPY(PG)/ LOAD DATA(MySQL)。
  • 批量大小:通常 100–1000 行一批,太大单条 SQL 超时,太小网络开销大。
  • 预加载:GORM 的 Preload、sqlc 的手写 JOIN。

最小可运行示例:

// 反例:N+1
rows, _ := db.QueryContext(ctx, "SELECT id FROM users LIMIT 100")
for rows.Next() {
	var id int
	rows.Scan(&id)
	db.QueryRowContext(ctx, "SELECT COUNT(*) FROM orders WHERE user_id = $1", id) // 100 次额外查询
}

// 正例:一条 JOIN
db.QueryRowContext(ctx, `
	SELECT u.id, COUNT(o.id) AS order_count
	FROM users u LEFT JOIN orders o ON o.user_id = u.id
	GROUP BY u.id LIMIT 100
`)

// 批量插入
_, err := db.ExecContext(ctx, `
	INSERT INTO users (name, age) VALUES
		($1, $2), ($3, $4), ($5, $6)
`, "a", 20, "b", 30, "c", 40)

常见坑:

现象 原因 修法
查询慢,日志里有 100 条相似 SQL N+1 改 JOIN 或 IN
批量插入太慢 一次一行 改多值 INSERT,每批 500 行
批量插入大事务锁表 一批太大 控制每批 100–500 行

面试考法:"N+1 怎么发现""怎么批量插入""预加载的代价"。要点:日志里相似 SQL;多值 INSERT;JOIN 代价是返回大结果集。

5.5 Redis 客户端与缓存三问题

为什么需要它:Redis 是热点缓存默认方案,但缓存穿透、击穿、雪崩三类问题会让缓存形同虚设,甚至把数据库打挂。

核心机制:

  • 客户端:go-redis/v9,连接池参数 PoolSize(默认 10 * CPU 核数)。
  • 缓存穿透:查不存在的 key,每次都打到 DB。防护:缓存空值(短 TTL)或布隆过滤器。
  • 缓存击穿:热点 key 过期瞬间,大量请求同时回源。防护:互斥重建(用 SET NX 锁让一个请求回源,其他等待)或逻辑不过期。
  • 缓存雪崩:大量 key 同时过期。防护:TTL 加随机抖动(如 5 分钟 ± 30 秒)。
  • 一致性:先更新 DB 再删缓存(不是更新缓存);删除失败重试。

最小可运行示例:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/redis/go-redis/v9"
)

func getUser(ctx context.Context, rdb *redis.Client, db *sql.DB, id string) (*User, error) {
	cacheKey := "user:" + id

	// 1. 读缓存
	if val, err := rdb.Get(ctx, cacheKey).Result(); err == nil {
		return decodeUser(val)
	}

	// 2. 互斥重建:只让一个请求回源
	lockKey := "lock:" + cacheKey
	ok, err := rdb.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
	if err != nil {
		return nil, err
	}
	if !ok {
		// 其他请求等 50ms 后重读缓存
		time.Sleep(50 * time.Millisecond)
		return getUser(ctx, rdb, db, id)
	}
	defer rdb.Del(ctx, lockKey)

	// 3. 回源 DB
	u, err := queryDB(ctx, db, id)
	if err != nil {
		// 穿透:缓存空值 60 秒
		rdb.Set(ctx, cacheKey, "", 60*time.Second)
		return nil, err
	}

	// 4. 写缓存,TTL 加随机抖动防雪崩
	ttl := 5*time.Minute + time.Duration(time.Now().UnixNano()%60)*time.Second
	rdb.Set(ctx, cacheKey, encodeUser(u), ttl)
	return u, nil
}

常见坑:

现象 原因 修法
DB QPS 突然飙高 缓存击穿:热点 key 过期 互斥重建或逻辑不过期
大量不存在 key 打到 DB 缓存穿透 空值缓存或布隆过滤器
缓存重启后 DB 瞬间打挂 大量 key 同时过期(雪崩) TTL 加随机抖动
缓存与 DB 不一致 更新 DB 后没删缓存 先更新 DB 再删缓存;失败重试

面试考法:"缓存穿透/击穿/雪崩区别""怎么防""缓存与 DB 一致性"。要点:穿透=不存在;击穿=热点过期;雪崩=大面积过期;先更新 DB 再删缓存。

5.6 分布式锁

为什么需要它:多实例部署时,定时任务、库存扣减需要互斥。单机 sync.Mutex 不够,要用 Redis 分布式锁。

核心机制:

  • SET key value NX EX seconds:只在 key 不存在时设置,带过期。
  • value 必须是唯一标识(如 UUID),释放时用 Lua 脚本验证 value 再删,防止误删别人的锁。
  • 锁过期时间要覆盖业务最长执行时间;业务超长时用续期(如 Redisson 的 watchdog)。
  • 强一致场景用 Redis RedLock(多节点),但生产多数用单节点 + 业务幂等。

最小可运行示例:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/redis/go-redis/v9"
)

var releaseLock = redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end
`)

func withLock(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration, fn func() error) error {
	token := fmt.Sprintf("%d", time.Now().UnixNano())
	ok, err := rdb.SetNX(ctx, key, token, ttl).Result()
	if err != nil {
		return err
	}
	if !ok {
		return fmt.Errorf("lock busy: %s", key)
	}
	defer releaseLock.Run(ctx, rdb, []string{key}, token)
	return fn()
}

常见坑:

现象 原因 修法
业务执行慢,锁过期了别人拿到锁 TTL 太短 设 TTL 大于业务最长耗时;或用续期
释放锁删了别人的锁 直接 DEL 不验证 value 用 Lua 脚本验证 value
锁没释放 进程崩溃,TTL 兜底 必须设过期时间

面试考法:"Redis 分布式锁怎么实现""为什么要用 Lua 释放""RedLock 是什么"。要点:SET NX EX + 唯一 token;Lua 验证后删;RedLock 多节点多数派。

5.7 Kafka 生产消费与幂等

为什么需要它:异步解耦用消息队列,但消息至少一次投递意味着重复消费是常态,消费者必须幂等。

核心机制:

  • 生产:Produce 发送消息到 topic;key 决定分区(相同 key 进同分区,保证顺序)。
  • 消费:消费者组(consumer group)下,分区在组内分摊;一个分区同一时间只能被组内一个消费者消费。
  • offset:消费位点提交时机有三种——自动提交、手动提交(处理完再提交)、同步提交。
  • 幂等:每条消息带唯一 ID(如业务主键 + 操作类型),消费者先查"是否处理过",处理过就跳过。
  • 顺序:要全局顺序只能用单分区;分区内顺序由 key 保证。

最小可运行示例:

package main

import (
	"context"
	"database/sql"
	"encoding/json"
	"log"

	"github.com/segmentio/kafka-go"
)

type OrderEvent struct {
	OrderID string `json:"order_id"`
	Action  string `json:"action"`
}

func consume(ctx context.Context, r *kafka.Reader, db *sql.DB) error {
	for {
		m, err := r.ReadMessage(ctx)
		if err != nil {
			return err
		}

		var evt OrderEvent
		if err := json.Unmarshal(m.Value, &evt); err != nil {
			// 坏消息:提交 offset 跳过,不重试
			_ = r.CommitMessages(ctx, m)
			continue
		}

		// 幂等:用 order_id + action 作为唯一键
		var exists bool
		err = db.QueryRowContext(ctx,
			"SELECT EXISTS(SELECT 1 FROM processed_events WHERE order_id = $1 AND action = $2)",
			evt.OrderID, evt.Action).Scan(&exists)
		if err != nil {
			return err
		}
		if exists {
			_ = r.CommitMessages(ctx, m) // 已处理,跳过
			continue
		}

		// 业务处理
		if err := handleOrder(ctx, db, evt); err != nil {
			return err // 不提交,下次重投
		}

		// 记录处理位点
		if _, err := db.ExecContext(ctx,
			"INSERT INTO processed_events (order_id, action) VALUES ($1, $2)",
			evt.OrderID, evt.Action); err != nil {
			return err
		}
		_ = r.CommitMessages(ctx, m)
		log.Printf("processed %s %s", evt.OrderID, evt.Action)
	}
}

常见坑:

现象 原因 修法
消息重复消费导致副作用 没做幂等 用唯一键 + processed_events 表
处理失败后消息丢失 先 Commit 再处理 处理成功后再 Commit
顺序错乱 不同 key 的消息进不同分区 需要顺序用同 key;全局顺序单分区
消费者 rebalance 频繁 处理时间长超过 session.timeout 调大 session.timeout;异步处理

面试考法:"Kafka 怎么保证不丢消息""怎么保证幂等""怎么保证顺序"。要点:手动提交;唯一键去重;同 key 同分区。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
配置连接池 用 pgx 连本地 PG,设 MaxOpenConns=20 SHOW max_connections 与池参数对照 1 小时
事务转账 写一个 transfer 函数,两个账户扣款加款 故意让第二步失败,验证回滚 1 小时
缓存空值 查不存在的用户,缓存空值 60 秒 连续两次查询,第二次命中缓存 1 小时
分布式锁 用 SET NX EX 实现锁,Lua 释放 两个进程同时抢锁,只有一个拿到 1 小时
Kafka 幂等消费 写一个消费者,用 processed_events 表去重 同一条消息发两次,DB 只一条记录 2 小时

6.2 改造型

练习 要求 验收标准 预计耗时
消除 N+1 给定循环查询代码,改成 JOIN 日志里 SQL 从 101 条变 1 条 2 小时
批量写入 把循环 INSERT 改成多值 INSERT,每批 500 10 万行插入时间下降 10 倍 2 小时
互斥重建 给热点 key 加 SET NX 锁 并发 100 请求,DB 只收到 1 次回源 1 小时
TTL 抖动 给所有缓存 key TTL 加 ±30 秒随机 同批 key 不在同一秒过期 0.5 小时
修复先提交后处理 给定先 Commit 后处理的代码,改成处理成功再 Commit 故意让处理失败,消息重投 1 小时

6.3 设计型

练习 要求 验收标准 预计耗时
用户资料缓存层 实现 GetUser:读缓存→互斥回源→写缓存,穿透/击穿/雪崩都防护 压测下 DB QPS 平稳 6 小时
订单事件消费者 消费 Kafka 订单事件,幂等处理,失败重投 重复投递无副作用;失败重投 6 小时
库存扣减 用 Redis 预扣 + DB 最终扣,分布式锁防超卖 并发 1000 下不超卖 5 小时

七、排障表

现象 可能原因 排查步骤 解决办法
pq: sorry, too many clients already MaxOpenConns 无限 pg_stat_activity 看连接数 设 SetMaxOpenConns(20)
偶发 EOF / bad connection 连接被 DB 端断开 看 DB wait_timeout;对比 ConnMaxLifetime 设 Lifetime 小于 wait_timeout
DB QPS 突然飙高 缓存击穿/雪崩 看 Redis 命中率日志 互斥重建;TTL 抖动
缓存与 DB 不一致 更新 DB 后没删缓存 看业务代码顺序 先更新 DB 再删缓存;失败重试
消息重复消费产生副作用 没做幂等 看 processed_events 表 用唯一键去重
消息处理失败后丢失 先 Commit 后处理 看消费代码顺序 处理成功再 Commit
连接池占满 事务里调远程,长事务 pg_stat_activity 看 idle in transaction 远程调用移到事务外
分布式锁误删 直接 DEL 不验证 token 看释放代码 用 Lua 验证 token

八、出口条件

全部勾选后再进入 05.8 阶段 7 可观测性与云原生部署。

  • [ ] 能配置 database/sql 连接池参数并解释每个参数
  • [ ] 能用 pgx 或 sqlc 写查询,消除 N+1
  • [ ] 能正确使用事务,事务里不做远程调用
  • [ ] 能实现缓存穿透/击穿/雪崩三类防护
  • [ ] 能用 Redis SET NX + Lua 释放实现分布式锁
  • [ ] 能写带幂等键的 Kafka 消费者,重复投递无副作用
  • [ ] 能解释连接池上限与 goroutine 并发度的关系

自测题:

  1. SetMaxOpenConns 为什么不能设为 0(无限)?
    • 要点:会超过 DB 端 max_connections(默认 151),导致 too many clients;应设为小于 DB 上限。
  2. 事务里为什么不能调 HTTP 或 Redis?
    • 要点:网络延迟不可控,持锁时间从毫秒变秒,连接池占满、锁冲突。
  3. 缓存穿透、击穿、雪崩的区别?
    • 要点:穿透=查不存在的 key;击穿=热点 key 过期瞬间;雪崩=大量 key 同时过期。
  4. 分布式锁为什么要用 Lua 脚本释放?
    • 要点:防止误删别人的锁——先 GET 验证 token 再 DEL,Lua 保证原子性。
  5. Kafka 消费者怎么保证幂等?
    • 要点:每条消息带唯一键,先查 processed_events,处理过就跳过。
  6. 为什么要"先更新 DB 再删缓存"而不是"更新缓存"?
    • 要点:更新缓存可能写入旧值;删除缓存让下次读时重建,避免并发覆盖。