Redis on Liangweidong's blog

Redis-MySQL 数据同步方案

Thu, 04 Jun 2026 00:00:00 +0000

Redis-MySQL 数据同步方案

系统架构师考试 | 数据库 + 缓存架构专题对应 2021 年下半年案例分析试题三 Q3 阅读时长：约 12 分钟

前言

Redis 作为内存数据库，读写性能是 MySQL 的 10-100 倍，几乎所有高并发系统都会用 Redis 做缓存。但缓存和数据库的"双写一致性问题" 是后端开发最常踩的坑——数据改了缓存没改、缓存删了下次又查到老的、并发写导致脏读。本篇系统梳理 Redis 五种数据类型、5 种同步方案、3 个一致性等级，以及 2024+ 的 CDC 自动化方案。

一、Redis 五种数据类型（软考必考）

类型	结构	典型命令	典型场景
String	字符串	`SET` `GET` `INCR`	缓存值、计数器、分布式锁
Hash	字段-值映射	`HSET` `HGET` `HGETALL`	对象缓存（用户资料、商品详情）
List	双向链表	`LPUSH` `RPOP` `LRANGE`	消息队列、最新列表
Set	无序集合	`SADD` `SMEMBERS` `SINTER`	标签、共同好友、去重
ZSet	有序集合	`ZADD` `ZRANGE` `ZINCRBY`	排行榜、延迟队列

1.1 实战：热销药品排名用 ZSet

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 添加药品销量
ZADD hot:drug 156 drug:1001
ZADD hot:drug 89 drug:1002
ZADD hot:drug 234 drug:1003

# 销售 +1（原子操作）
ZINCRBY hot:drug 1 drug:1001

# 取 Top 10
ZRANGE hot:drug 0 9 WITHSCORES
# 1) "drug:1003" # 234
# 2) "drug:1001" # 156
# 3) "drug:1002" # 89

2021 真题答案：ZSet（有序集合）——天然支持按分数排序，ZADD/ZINCRBY/ZRANGE 三个命令搞定。

二、为什么需要缓存？

2.1 性能对比

操作	MySQL（磁盘）	Redis（内存）	差距
读	5-50 ms	0.1-1 ms	50-500x
写	10-100 ms	0.1-1 ms	100-1000x
随机读	10-100 ms	0.1-1 ms	100-1000x

2.2 典型缓存场景

读多写少：商品详情、用户资料、文章内容
排行榜 / 计数器：销量、点赞、播放量
分布式锁：SETNX、Redlock
限流：滑动窗口、令牌桶
消息队列：Stream、Pub/Sub
热点数据预热：秒杀库存、热门商品

三、5 种同步方案

3.1 Cache-Aside（旁路缓存，最常用）

思路：应用代码同时管理 DB 和 Cache。

1
2
3
4
5
6
7
8


读：
 1. 先读 Redis
 2. miss 则读 MySQL
 3. 回写 Redis

写：
 1. 先写 MySQL
 2. 再删 Redis（不是更新！）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 读
public Product getProduct(Long id) {
 Product p = redis.get("product:" + id);
 if (p == null) {
 p = mysql.selectById(id);
 redis.setex("product:" + id, 3600, p); // 1小时过期
 }
 return p;
}

// 写
public void updateProduct(Product p) {
 mysql.updateById(p);
 redis.del("product:" + p.getId()); // 删缓存，下次读 miss 再回填
}

优点：简单、成熟、90% 场景适用缺点：存在"先删缓存再写 DB"的并发问题

并发问题：

1
2
3


T1 写：删缓存 → 写 DB（未提交）
T2 读：miss → 读 DB（旧值）→ 写缓存（脏数据）
T1 提交

3.2 延迟双删（解决并发写脏读）

思路：写前删一次、写后延迟再删一次。

1
2
3
4
5
6


public void updateProduct(Product p) {
 redis.del("product:" + p.getId()); // 第一次删
 mysql.updateById(p);
 Thread.sleep(500); // 延迟 500ms（经验值，看主从延迟）
 redis.del("product:" + p.getId()); // 第二次删
}

优点：解决大部分并发写问题缺点：延迟时间难定、影响写性能

3.3 Write-Through（写穿透）

思路：先写 DB，再同步写 Cache（Cache 自己从 DB 加载）。

1
2
3


写：
 1. 应用写 DB
 2. Cache 自动同步写（或由 Cache 监听 DB 变更）

适用：读多写少 + 强一致 + 写不频繁（如金融账户）

3.4 Write-Behind（异步写回）

思路：先写 Cache，异步批量写 DB。

1
2
3


写：
 1. 只写 Cache（立即返回）
 2. 异步队列批量 flush 到 DB

适用：写多读少 + 允许短暂丢失（如点赞数、浏览量）

3.5 异步 binlog 订阅（CDC，解耦方案）

思路：用 Canal（阿里开源）订阅 MySQL binlog，异步同步到 Redis。

1

应用写 MySQL → MySQL 写 binlog → Canal 订阅 → 推送到 Redis

Canal 架构：

1
2
3


MySQL Master ──binlog──> Canal Server ──Kafka──> 消费服务 ──> Redis
 ↑
 MQ 解耦 / 重试 / 削峰

优点：业务代码零侵入、解耦、可靠、可重试缺点：架构复杂、运维成本、有秒级延迟

2024+ 主流：CDC（Change Data Capture） 事实标准：

Canal（阿里）→ MySQL 专用
Debezium → 多数据库支持
Maxwell → 轻量级
Flink CDC → 实时计算集成

四、3 个一致性等级

等级	一致性	性能	适用
强一致	写后立即读到新值	差	金融、库存
弱一致	最终一致（秒级）	好	大部分业务
最终一致	不保证时点，只保证最终	最好	排行榜、计数器

软考答题：除了答"哪种方案"，还要答"对应什么一致性等级"。

五、5 种方案对比表

方案	一致性	性能	复杂度	适用
Cache-Aside	弱一致	高	低	90% 业务
延迟双删	弱一致	中	中	高并发写
Write-Through	强一致	低	中	金融账户
Write-Behind	最终一致	最高	高	点赞、计数
CDC 异步同步	最终一致	高	高	大厂、解耦

六、实战：药品销售系统缓存设计

6.1 缓存选型

数据	缓存类型	同步方案	一致性
药品详情	Hash（字段级更新）	Cache-Aside	弱一致
热销排行	ZSet（销量）	Write-Behind	最终一致
库存数量	String（强实时）	延迟双删	弱一致
用户 Session	String + TTL	不需要	最终一致

6.2 完整流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


// 1. 商品查询（Cache-Aside）
public Product getProduct(Long id) {
 String key = "product:" + id;
 Map<Object, Object> cached = redis.opsForHash().entries(key);
 if (cached.isEmpty()) {
 Product p = mysql.selectById(id);
 redis.opsForHash().putAll(key, beanToMap(p));
 redis.expire(key, 3600);
 return p;
 }
 return mapToBean(cached);
}

// 2. 库存扣减（延迟双删 + Lua 原子操作）
public boolean deductStock(Long productId, int qty) {
 String key = "stock:" + productId;
 String lua = """
 local current = tonumber(redis.call('GET', key))
 if current == nil or current < qty then
 return 0
 end
 redis.call('DECRBY', key, qty)
 return 1
 """.replace("qty", String.valueOf(qty));
 Long result = redis.execute(luaScript, Arrays.asList(key));
 if (result == 1) {
 mysql.updateStock(productId, -qty); // 异步写 DB
 }
 return result == 1;
}

// 3. 销量排行（Write-Behind + ZSet）
@Async
public void onOrderCreated(Order order) {
 // 只写 Redis
 redis.opsForZSet().incrementScore("hot:drug", 
 "drug:" + order.getProductId(), 
 order.getQuantity());
 // 异步队列定时 flush 到 MySQL
 kafkaTemplate.send("sales-stat", order);
}

6.3 同步问题排查清单

现象	原因	解决
缓存偶尔读到旧值	并发写	延迟双删
缓存删了很快又有	业务没改完又回填	加版本号
Redis 内存爆炸	缓存没设 TTL	全部 key 加过期
Redis 击穿	热点 key 过期	互斥锁 / 永不过期
Redis 雪崩	大量 key 同时过期	过期时间加随机

七、2024+ 视角

7.1 CDC 主流方案对比

方案	出品方	特点
Canal	阿里	MySQL 专用、Java、国内最流行
Debezium	Red Hat	多库支持、Kafka 集成
Maxwell	Zendesk	轻量、JSON 输出
Flink CDC	阿里	实时计算一体化
Apache InLong	腾讯	大数据集成

7.2 Redis 新特性

Redis 7.x：
- Functions（替代 Lua 脚本管理）
- Multi-part AOF（AOF 拆分）
- RedisJSON（原生 JSON 支持）
- RedisSearch（全文检索）
- RedisTimeSeries（时序数据）
Redis 8（2024+）：
- 性能进一步提升（多线程 I/O）
- Vector Search（向量检索，对接 RAG / LLM）
- 与 LangChain / LlamaIndex 集成

7.3 一致性新方案

Outbox Pattern（事件外发模式）：业务写 DB + outbox 表，异步发到 MQ 同步到 Redis → 解决分布式事务
Saga Pattern：长事务拆多个子事务 + 补偿 → 跨服务一致性
CRDT（Conflict-free Replicated Data Types）：无冲突复制数据类型 → 多活数据中心
Spanner / CockroachDB：全球强一致分布式 SQL → 替代 MySQL + Redis 组合

7.4 软考答题趋势

2024+ 更注重架构图——画出 DB + Cache + MQ + CDC 的完整链路
经常给故障场景让你分析：缓存雪崩 / 击穿 / 穿透
一致性话题会和分布式事务结合考

八、答题套路总结

题型	套路
选 Redis 数据类型	排行榜 → ZSet；对象 → Hash；队列 → List；标签 → Set；单值 → String
同步方案	默认答 Cache-Aside + 延迟双删；进阶答 CDC
一致性等级	强一致 / 弱一致 / 最终一致
缓存三大问题	雪崩（大量同时过期）/ 击穿（热点过期）/ 穿透（绕过缓存）

参考资料

2021 年下半年系统架构设计师考试真题（下午案例分析试题三 Q3）
《系统架构设计师教程》第 8 章数据库设计
《Redis 设计与实现》黄健宏
《Redis 官方文档》https://redis.io/docs/
《Designing Data-Intensive Applications》（DDIA）Martin Kleppmann
Canal 官方文档 https://github.com/alibaba/canal
Debezium 官方文档 https://debezium.io/
Redis 7.x 新特性 https://redis.io/docs/manual/new-in-7/

Redis Docker 实战：6.x/8.x、持久化、bitnami 镜像与生产配置

Wed, 15 Dec 2021 00:00:00 +0800

Redis 6.0 引入了多线程 I/O、ACL 权限、SSL 加密；8.x（2024）改进了 RDB 加载速度、模块化。生产环境的 Redis 在 Docker 里跑有几个常见问题：持久化怎么配、密码怎么改、主从怎么搭、要不要关 RDB。这篇文章把 Redis 6.0 到 8.6 的官方镜像和 bitnami 镜像的部署、配置、调优一次性收齐。

阅读对象：日常用 Redis 做缓存/分布式锁/排行榜/限流，要在容器里跑单实例或主从，关注内存、持久化、ACL 的同学。 覆盖范围：官方 redis:6.0/8.6 镜像启动；bitnami/redis 镜像（推荐生产用）；redis.conf 关键配置；RDB / AOF / 混合持久化关闭；主从复制（docker run + 配置文件）；客户端连接与排错。

一、Redis 在 Docker 里的几个关键决策

决策	选项	适用
镜像	官方 `redis` / `bitnami/redis`	官方更轻，bitnami 多 healthcheck + 非 root
持久化	RDB（默认）/ AOF / 混合 / 全关	缓存场景：关；持久场景：开
网络模式	host / bridge	性能优先 host，安全优先 bridge
部署形态	单机 / 主从 / Sentinel / Cluster	单机演示，主从高可用，Cluster 大数据量
内存淘汰	noeviction / allkeys-lru 等	写多：noeviction；缓存：allkeys-lru

二、官方 redis 镜像

2.1 拉取与启动

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 拉镜像
docker pull redis:6.0.3-alpine3.11
docker pull redis:8.6.3-alpine3.23

# 启动（host 网络，性能好）
docker run -d --name redis \
 --net=host \
 --restart=always \
 redis:8.6.3-alpine3.23 \
 redis-server /usr/local/etc/redis/redis.conf

alpine 镜像比 debian 镜像小 100MB+，但 musl libc 的 redis-benchmark 等工具有兼容性问题，生产一般用 debian 镜像。

2.2 创建宿主机目录

1
2


mkdir /home/docker/redis/{conf,data,logs} -p
cd /home/docker/redis

2.3 准备 redis.conf

1
2
3
4
5
6
7
8
9


# 下载官方模板
wget https://raw.githubusercontent.com/redis/redis/8.6/redis.conf \
 -O /home/docker/redis/conf/redis.conf

# 改几个关键参数
sed -i 's/logfile ""/logfile "access.log"/' /home/docker/redis/conf/redis.conf
sed -i 's/# requirepass foobared/requirepass {{REDACTED}}/' /home/docker/redis/conf/redis.conf
sed -i 's/appendonly no/appendonly yes/' /home/docker/redis/conf/redis.conf
sed -i 's/bind 127.0.0.1/bind 0.0.0.0/' /home/docker/redis/conf/redis.conf

2.4 启动（挂载配置 + 数据）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


docker run \
 -p 6379:6379 \
 -v /home/docker/redis/data:/data \
 -v /home/docker/redis/conf/redis.conf:/etc/redis/redis.conf \
 --net mynetwork --ip 172.18.0.5 \
 --privileged=true \
 --name redis \
 --restart=always \
 -d redis:6.0.3-alpine3.11 \
 redis-server /etc/redis/redis.conf

2.5 客户端连接

1
2
3
4
5
6


# 容器内
docker exec -it redis /bin/sh
redis-cli -h 127.0.0.1 -p 6379 -a {{REDACTED}}

# 宿主机直接连
docker run -it --link redis:redis --rm redis redis-cli -h redis -p 6379

2.6 docker-compose 模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


version: "3"
services:
 redis:
 container_name: redis
 image: <your-public-ip>:13001/base/redis:6.0.3-alpine3.11
 network_mode: "host"
 command: redis-server /etc/redis/redis.conf
 restart: always
 volumes:
 - /home/docker/redis/data:/data:rw
 - /home/docker/redis/conf/redis.conf:/etc/redis/redis.conf
 - /home/docker/redis/logs:/logs
 privileged: true
 environment:
 - TZ=Asia/Shanghai
 - LANG=en_US.UTF-8

三、bitnami/redis 镜像（生产推荐）

bitnami/redis 的优势：非 root 进程、Tini init、healthcheck、Redis 风格环境变量（REDIS_PASSWORD 等都大写）、自带 Sentinel 模板。

3.1 启动

1
2
3
4
5
6
7


docker pull bitnami/redis:6.2.14-debian-12-r21

docker run -d \
 --name redis \
 -p 6379:6379 \
 -e REDIS_PASSWORD={{REDACTED}} \
 bitnami/redis:6.2.14-debian-12-r21

环境变量 REDIS_PASSWORD：自动生成 requirepass。比直接改 conf 文件方便。

四、持久化策略

4.1 三种持久化机制

机制	默认	特点	适用
RDB（快照）	开启	周期性 dump，体积小，恢复快	接受分钟级数据丢失
AOF（追加日志）	关闭	每条写命令追加日志，最多丢 1 秒数据	不能丢数据
混合持久化	7.0+ 默认	RDB + AOF 结合	大多数生产场景

4.2 关闭持久化（纯缓存场景）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# redis.conf
# 1. 关闭 RDB 自动快照
save ""

# 2. 关闭 AOF 增量持久化
appendonly no

# 3. 关闭混合持久化（7.0+）
rdb-aof-use-rdb-preamble no

# 4. 主从同步后立刻删除 RDB 临时文件
rdb-del-sync-files yes

重启服务后生效。这种配置相当于"纯缓存"，重启 = 数据全清，只用于缓存场景。

4.3 推荐生产配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 1. 开启 AOF（默认关）
appendonly yes
appendfsync everysec # 每秒刷盘，最多丢 1 秒

# 2. RDB 兜底
save 3600 1 # 1 小时至少 1 个 key 变化
save 300 100 # 5 分钟至少 100 个 key 变化
save 60 10000 # 1 分钟至少 10000 个 key 变化

# 3. 7.0+ 混合持久化
rdb-aof-use-rdb-preamble yes

五、主从复制

5.1 启动 master

1
2
3
4
5
6
7


docker run -d --name redis-master \
 -p 6379:6379 \
 -v /home/docker/redis/data:/data \
 -v /home/docker/redis/conf/redis.conf:/etc/redis/redis.conf \
 --restart=always \
 redis:6.0.3-alpine3.11 \
 redis-server /etc/redis/redis.conf

5.2 启动 slave

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# 1. 查 master 内部 IP
docker inspect redis-master | grep IPAddress
# "IPAddress": "172.18.0.X"

# 2. 准备 slave 配置文件（追加）
cat << 'EOF' >> /home/docker/redis-slave/conf/redis.conf
replicaof 172.18.0.X 6379
masterauth {{REDACTED}}
replica-read-only yes
EOF

# 3. 启动 slave
docker run -d --name redis-slave \
 -p 6380:6379 \
 -v /home/docker/redis-slave/data:/data \
 -v /home/docker/redis-slave/conf/redis.conf:/etc/redis/redis.conf \
 --restart=always \
 redis:6.0.3-alpine3.11 \
 redis-server /etc/redis/redis.conf

从 Redis 5.0 开始，slaveof 改名为 replicaof，但旧名仍然兼容。

5.3 验证复制

1
2
3
4
5
6


# master 写入
docker exec -it redis-master redis-cli -a {{REDACTED}} set test_key hello

# slave 读取
docker exec -it redis-slave redis-cli -a {{REDACTED}} get test_key
# "hello"

六、常见排错

6.1 连接被拒

1
2
3
4
5
6
7
8


# 1. 看容器是否在跑
docker ps | grep redis

# 2. 看日志
docker logs redis

# 3. 看网络
docker network inspect bridge | grep redis

6.2 密码忘了

1
2
3
4
5
6
7


# 1. 进容器，关掉 requirepass
docker exec -it redis bash
redis-cli
CONFIG SET requirepass ""

# 2. 改 conf 文件持久化
echo "requirepass <new_password>" >> /home/docker/redis/conf/redis.conf

6.3 内存满

1
2
3
4
5


# 看使用情况
redis-cli info memory | grep used_memory_human

# 触发淘汰
CONFIG SET maxmemory-policy allkeys-lru

七、Redis 6.x/7.x/8.x 关键差异

版本	关键特性	适合
6.0	ACL、多线程 I/O、SSL	主流稳定
6.2	细粒度命令权限	多租户
7.0	混合持久化、Redis Functions、sharded pub/sub	新功能
7.2	改进 listpack、SCAN 性能	性能敏感
8.0	异步 I/O、模块化	新项目首选
8.6	进一步优化 RDB 加载	大 key 场景

八、扩展阅读

Redis 官方镜像：hub.docker.com/_/redis
bitnami/redis：hub.docker.com/r/bitnami/redis
Redis 配置文件详解：redis.io/docs/manual/config
Redis 持久化文档：redis.io/docs/management/persistence
Redis Sentinel 文档：redis.io/docs/management/sentinel

分布式限流实战：Nginx + Tomcat + Guava + Redis Lua

Wed, 15 Sep 2021 00:00:00 +0800

本文写于 2021 年 9 月——彼时 Sentinel 已经在阿里系大规模落地，但中小厂仍以"自研 + Redis Lua"为主流。

一、限流分层架构

限流不是"做一次就够"，需要从边缘到核心层层设防：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


 ┌──────────┐
 用户请求 ───> │ CDN │ 第 1 层：CDN 限流（按地区/ISP）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ Nginx │ 第 2 层：边缘网关限流（IP / 域名）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ Tomcat │ 第 3 层：Web 容器限流（maxThreads）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 网关层 │ 第 4 层：Spring Cloud Gateway / Sentinel
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 单体应用 │ 第 5 层：Guava RateLimiter
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 分布式 │ 第 6 层：Redis + Lua 全局限流
 │ Redis │
 └──────────┘

核心思想：越靠近用户限流越粗（IP / 域名），越靠近业务限流越细（接口 / 用户）。

二、Nginx 限流（边缘网关层）

2.1 核心指令

Nginx 自带两个限流模块：

limit_req：限制请求速率（QPS）
limit_conn：限制并发连接数

2.2 完整配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


# ===== 第一步：定义限流 zone（http 块）=====

# 根据 IP 限速：每秒 10 个请求
limit_req_zone $binary_remote_addr zone=iplimit:20m rate=10r/s;

# 根据 server 限速：每秒 1 个请求
limit_req_zone $server_name zone=serverlimit:10m rate=1r/s;

# 根据 IP 限并发：每个 IP 最多 100 个连接
limit_conn_zone $binary_remote_addr zone=perip:20m;

# 根据 server 限并发：每个 server 最多 100 个连接
limit_conn_zone $server_name zone=perserver:20m;

# ===== 第二步：在 location 应用 =====

server {
 server_name www.test.com;
 
 # 接口限流
 location /access-limit/ {
 proxy_pass http://127.0.0.1:8080/;
 
 # IP 限速（burst=2 允许瞬时 2 个排队，nodelay 不延迟立即处理）
 limit_req zone=iplimit burst=2 nodelay;
 # server 限速
 limit_req zone=serverlimit burst=2 nodelay;
 # IP 限并发 100
 limit_conn zone=perip 100;
 # server 限并发 100
 limit_conn zone=perserver 1;
 # 限流触发时返回 504（默认 503）
 limit_req_status 504;
 limit_conn_status 504;
 }
 
 # 限速下载
 location /download/ {
 # 前 100m 不限速
 limit_rate_after 100m;
 # 之后限速 256k/s
 limit_rate 256k;
 }
}

2.3 关键参数

burst=2：允许瞬时超出 rate 2 个请求排队等待
nodelay：排队不延迟，超出的请求立即返回 503（默认是延迟处理）
rate=10r/s：每秒 10 个请求（也支持 30r/m 每分钟 30 个）

三、Tomcat 限流（Web 容器层）

3.1 核心配置

Tomcat 8.5 通过 conf/server.xml 配置最大线程数：

1
2
3
4
5
6


<Connector port="8080"
 protocol="HTTP/1.1"
 connectionTimeout="20000"
 maxThreads="150" <!-- 最大线程数 -->
 acceptCount="100" <!-- 等待队列长度 -->
 redirectPort="8443" />

工作原理：

当并发请求 > maxThreads（默认 150）时，请求进入等待队列
等待队列满后，新请求被拒绝
天然限流

3.2 调优建议

小贴士：maxThreads 默认 150（Tomcat 8.5.42），但不是越大越好：

每开 1 个线程 → 1MB JVM 内存（线程栈）
线程越多 → GC 负担越重
OS 限制：Windows 每进程 ≤ 2000 线程，Linux 每进程 ≤ 1000 线程

经验值：8 核 16G 机器配 maxThreads=400 较合理，再多就是 GC 抖动的开始。

四、单体应用限流（Guava RateLimiter）

4.1 引入依赖

1
2
3
4
5
6


<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>31.1-jre</version>
</dependency>

4.2 简单使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


@Slf4j
@RestController
@RequestMapping("/limit")
public class LimitController {
 
 // 限流策略：1 秒钟 2 个请求
 private final RateLimiter limiter = RateLimiter.create(2.0);
 
 @GetMapping("/test1")
 public String testLimiter() {
 // 500 毫秒内，没拿到令牌就降级
 boolean tryAcquire = limiter.tryAcquire(500, TimeUnit.MILLISECONDS);
 
 if (!tryAcquire) {
 log.warn("进入服务降级，时间{}", LocalDateTime.now());
 return "当前排队人数较多，请稍后再试！";
 }
 
 log.info("获取令牌成功，时间{}", LocalDateTime.now());
 return "请求成功";
 }
}

4.3 Guava 限流模式

模式	类	特点
平滑突发（SmoothBursty）	`RateLimiter.create(permitsPerSecond)`	启动即可满速率
平滑预热（SmoothWarmingUp）	`RateLimiter.create(permitsPerSecond, warmupPeriod, unit)`	启动后有预热期，逐步提到配置速率

4.4 自定义注解 + AOP（接口级限流）

注解：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface Limit {
 String key() default ""; // 资源 key
 double permitsPerSecond(); // QPS
 long timeout(); // 最大等待时间
 TimeUnit timeunit() default TimeUnit.MILLISECONDS;
 String msg() default "系统繁忙,请稍后再试.";
}

AOP 切面：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


@Slf4j
@Aspect
@Component
public class LimitAop {
 
 private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();
 
 @Around("@annotation(com.example.limit.Limit)")
 public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
 MethodSignature signature = (MethodSignature) joinPoint.getSignature();
 Method method = signature.getMethod();
 Limit limit = method.getAnnotation(Limit.class);
 
 if (limit != null) {
 String key = limit.key();
 RateLimiter rateLimiter = limitMap.computeIfAbsent(
 key, k -> RateLimiter.create(limit.permitsPerSecond())
 );
 
 // 拿令牌
 boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
 if (!acquire) {
 log.debug("令牌桶={}，获取令牌失败", key);
 this.responseFail(limit.msg());
 return null;
 }
 }
 return joinPoint.proceed();
 }
 
 private void responseFail(String msg) {
 HttpServletResponse response = ((ServletRequestAttributes) 
 RequestContextHolder.getRequestAttributes()).getResponse();
 ResultData<Object> resultData = ResultData.fail(ReturnCode.LIMIT_ERROR.getCode(), msg);
 WebUtils.writeJson(response, resultData);
 }
}

Controller：

1
2
3
4
5
6
7


@GetMapping("/test2")
@Limit(key = "limit2", permitsPerSecond = 1, timeout = 500, 
 timeunit = TimeUnit.MILLISECONDS, msg = "排队中，请稍候")
public String limit2() {
 log.info("limit2 获取令牌成功");
 return "ok";
}

4.5 IP 级限流

思路：每个 IP 一个 RateLimiter，缓存到 LoadingCache。

限流工具类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


public class RateLimitUtil {
 /** 缓存：1000 个 IP，过期 1 天 */
 private static LoadingCache<String, RateLimiter> limitCaches = CacheBuilder.newBuilder()
 .maximumSize(1000)
 .expireAfterWrite(1, TimeUnit.DAYS)
 .build(new CacheLoader<String, RateLimiter>() {
 @Override
 public RateLimiter load(String key) {
 double perSecond = RateLimitUtil.getCacheKeyPerSecond(key);
 return RateLimiter.create(perSecond);
 }
 });
 
 /** 唯一 key = 资源名:ip:perSecond */
 public static String generateCacheKey(Method method, HttpServletRequest request) {
 RateLimit rateLimit = method.getAnnotation(RateLimit.class);
 StringBuilder cacheKey = new StringBuilder(rateLimit.name() + ":");
 cacheKey.append(getIpAddr(request) + ":");
 cacheKey.append(rateLimit.perSecond());
 return cacheKey.toString();
 }
 
 public static double getCacheKeyPerSecond(String cacheKey) {
 return Double.parseDouble(cacheKey.split(":")[2]);
 }
 
 public static String getIpAddr(HttpServletRequest request) {
 String ip = request.getHeader("x-forwarded-for");
 if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
 ip = request.getHeader("Proxy-Client-IP");
 }
 if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
 ip = request.getRemoteAddr();
 }
 // 多级代理取第一个 IP
 if (ip != null && ip.length() > 15) {
 if (ip.indexOf(",") > 0) {
 ip = ip.substring(0, ip.indexOf(","));
 }
 }
 return ip;
 }
}

五、分布式应用限流（Redis + Lua 令牌桶）

5.1 为什么需要 Redis 限流

Guava RateLimiter 是进程内的，集群部署时每个节点都有一份独立的限流器——比如 3 节点配 100 QPS，实际可能是 300 QPS。

Redis 限流 = 全集群共享一份限流计数。

5.2 令牌桶算法（Lua 实现）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


-- KEYS[1]: 接口唯一 ID
-- ARGV[1]: max_token（桶容量）
-- ARGV[2]: token_rate（每秒产生令牌数）
-- ARGV[3]: current_time（当前时间戳，毫秒）

local ratelimit_info = redis.pcall('HMGET', KEYS[1], 'last_time', 'current_token')
local last_time = ratelimit_info[1]
local current_token = tonumber(ratelimit_info[2])
local max_token = tonumber(ARGV[1])
local token_rate = tonumber(ARGV[2])
local current_time = tonumber(ARGV[3])

if current_token == nil then
 current_token = max_token
 last_time = current_time
else
 local past_time = current_time - last_time
 
 if past_time > 1000 then
 current_token = current_token + token_rate
 last_time = current_time
 end
 
 -- 防止溢出
 if current_token > max_token then
 current_token = max_token
 last_time = current_time
 end
end

local result = 0
if (current_token > 0) then
 result = 1
 current_token = current_token - 1
 last_time = current_time
end

redis.call('HMSET', KEYS[1], 'last_time', last_time, 'current_token', current_token)
return result

关键点：

每个接口的 key（如 uri:/api/order/create）对应一个 Hash
Hash 存 last_time（上次请求时间）+ current_token（当前桶内令牌数）
每隔 1000ms 自动补充 token_rate 个令牌
拿不到令牌返回 0，拿到了返回 1 并减 1

5.3 Spring Boot 集成

Redis 序列化配置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


@Bean(value = "redisTemplate")
@Primary
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
 RedisTemplate<String, Object> template = new RedisTemplate<>();
 template.setConnectionFactory(factory);
 
 ObjectMapper objectMapper = new ObjectMapper();
 objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
 StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 jsonRedisSerializer.setObjectMapper(objectMapper);
 
 template.setKeySerializer(stringRedisSerializer);
 template.setHashKeySerializer(stringRedisSerializer);
 template.setValueSerializer(jsonRedisSerializer);
 template.setHashValueSerializer(jsonRedisSerializer);
 return template;
}

限流工具类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class RedisLimiterUtils {
 
 private static StringRedisTemplate stringRedisTemplate = 
 ApplicationContextUtils.applicationContext.getBean(StringRedisTemplate.class);
 
 /**
 * 拿令牌
 * @param key 请求 ID（如接口 URI）
 * @param max 桶容量
 * @param rate 每秒生成令牌数
 * @return true=拿到，false=限流
 */
 public static boolean tryAcquire(String key, int max, int rate) {
 List<String> keyList = new ArrayList<>(1);
 keyList.add(key);
 
 DefaultRedisScript<Long> script = new DefaultRedisScript<>();
 script.setResultType(Long.class);
 script.setScriptText(LUA_SCRIPT);
 
 Long result = stringRedisTemplate.execute(
 script, keyList,
 Integer.toString(max),
 Integer.toString(rate),
 Long.toString(System.currentTimeMillis())
 );
 
 return Long.valueOf(1).equals(result);
 }
}

5.4 注解 + 拦截器

注解：

1
2
3
4
5
6
7


@Inherited
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
 int capacity() default 100; // 桶容量
 int rate() default 10; // 每秒令牌数
}

拦截器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


@Component
public class RateLimiterIntercept implements HandlerInterceptor {
 
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
 Object handler) throws Exception {
 if (handler instanceof HandlerMethod) {
 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Method method = handlerMethod.getMethod();
 
 RateLimit rateLimit = AnnotationUtils.findAnnotation(method, RateLimit.class);
 if (Objects.isNull(rateLimit)) {
 rateLimit = AnnotationUtils.findAnnotation(
 handlerMethod.getBean().getClass(), RateLimit.class);
 }
 
 if (Objects.isNull(rateLimit)) return true;
 
 // 拿令牌，失败抛异常
 if (!RedisLimiterUtils.tryAcquire(
 request.getRequestURI(),
 rateLimit.capacity(),
 rateLimit.rate())) {
 throw new TimeOutException("系统繁忙，请稍后再试");
 }
 }
 return true;
 }
}

注册拦截器：

1
2
3
4
5
6
7
8


@Configuration
public class WebConfigurer implements WebMvcConfigurer {
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(new RateLimiterIntercept())
 .addPathPatterns("/**");
 }
}

六、4 种限流方案对比

维度	Nginx	Tomcat	Guava	Redis + Lua
粒度	IP / Server	容器线程	接口	接口 / 用户 / 全局
作用层	边缘	容器	单体应用	分布式
性能	极高	高	高	中（网络 IO）
跨节点	是	否	否	是
实现成本	配置	配置	引入 + AOP	Lua + 工具类
推荐场景	公网入口	单体应用	单体应用	分布式集群

七、面试常问

Q：令牌桶和漏桶有什么区别？ A：

令牌桶：以恒定速率生产令牌，请求消耗令牌。允许突发流量（桶满时能瞬时处理多个请求）
漏桶：以恒定速率流出请求，水（请求）任意速率流入桶。强制平滑，不允许突发

Q：为什么 Redis 限流要选 Lua 脚本？ A：Redis 单线程 + Lua 原子执行，整个限流判断在一次 RTT 内完成。如果用 Java 代码分多次调用（HMGET → 业务判断 → HMSET），中间被打断会导致计数错乱。

Q：Guava RateLimiter 和 Redis 限流怎么选？ A：

单实例 / 性能敏感：Guava（避免 Redis 网络 IO）
多实例 / 严格全局限流：Redis（保证全集群总和）

Q：Nginx 的 burst 和 nodelay 怎么理解？ A：burst=10 nodelay 表示允许 10 个请求瞬时超出 rate，但立即处理不排队。等价于"令牌桶初始有 10 个令牌，被拿完后必须等下一个令牌生成"。

八、小结

限流分层：CDN → Nginx → Tomcat → Gateway → 单体应用 → 分布式 Redis
Nginx：边缘限流首选，配置简单性能高
Tomcat：maxThreads 调优是基本功
Guava：单体内 AOP + 注解最优雅
Redis + Lua：分布式场景的必选，原子性 + 全局一致

微服务中间件集群实战：Nacos / Gateway / MySQL / Redis / MQ

Wed, 15 Sep 2021 00:00:00 +0800

本文写于 2021 年 9 月——微服务架构全面铺开，Nacos 2.0+ 已发布一年（2020 年初）、Spring Cloud Gateway 已成事实标准（替代 Zuul）、Redis Cluster 在生产大规模使用，5 大微服务中间件的"集群"方案成为面试必考点。

〇、2021 视角开篇

本文主体内容是 5 大微服务中间件（Gateway / Nacos / MySQL / Redis / MQ）的集群部署实战。2021-09 这个时点选得很巧：

Nacos 2.0（2020-01 发布）刚满 1.5 年，集群方案已稳定（Distro + Raft 双协议）
Spring Cloud Gateway（2018 年发布）替代 Zuul 已成定局，2021.x 是生产主流
Redis Cluster（3.0 起）经过 4 年迭代，3 主 3 从 6 节点模式是生产标配
RocketMQ 4.x（2017 年起）多主多从模式是阿里系标配，Kafka 同期竞争

下文涉及 2016 年时实际并不存在的工具（Nacos / Spring Cloud Gateway），是以 2021 视角讲解"这些工具是何时出现、何时成熟、2021 时点怎么用"。

一、Spring Cloud Gateway 集群

1.1 概述

Spring Cloud Gateway 是 Spring Cloud 的全新项目，基于 Spring 5.0 + Spring Boot 2.0 实现，旨在提供一种简单有效的方式对 API 进行路由，并提供强大的过滤功能：熔断、限流、监控、校验、鉴权。

为什么取代 Zuul？

Zuul 1.x 基于 Servlet 阻塞模型，性能有限
Zuul 2.0 跳票多年（被 Netflix 弃坑），Spring 社区转向基于 WebFlux + Netty 的响应式网关
Gateway 基于 WebFlux 框架，底层用 Netty 通信框架，性能远超 Zuul

1.2 集群部署

Gateway 是无状态服务，集群化非常简单：多实例 + 统一入口。

第一步：pom.xml 依赖

1
2
3
4
5
6
7
8


<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

第二步：application.yml 配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


server:
 port: 9527

spring:
 application:
 name: cloud-gateway
 cloud:
 nacos:
 discovery:
 server-addr: nacos-cluster.internal:8848  # Nacos 集群地址
 gateway:
 discovery:
 locator:
 enabled: true # 开启从注册中心自动创建路由
 routes:
 - id: payment_route
 uri: lb://cloud-payment-service  # lb = load balance
 predicates:
 - Path=/payment/**

第三步：Nginx 入口负载均衡

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


upstream gateways {
 server 192.168.6.29:9527 weight=1;
 server 192.168.6.29:9528 weight=1; # 同一台机器两个端口模拟集群
 # server 192.168.6.30:9527 weight=1; # 多机部署
}

server {
 listen 80;
 server_name api.example.com;
 location / {
 proxy_pass http://gateways;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 }
}

关键点：

Gateway 实例之间不需要通信，各自从 Nacos 拉服务列表
网关自身的负载均衡交给 Nginx / F5 / SLB
网关是无状态服务，可以水平扩展

二、Nacos 集群

2.1 三种部署模式

单机模式：用于测试和单机使用
集群模式：用于生产环境，确保高可用
多集群模式：用于多数据中心场景

2.2 集群部署（Nacos ≥ 2.0）

前置：nacos 集群至少需要 3 个节点，因此准备 3 台服务器。

第一步：安装依赖

1
2
3


# 1. 安装 MySQL（nacos 配置持久化）
# 2. 安装 JDK 8+
# 3. 安装 Maven（仅首次构建时需要）

第二步：初始化数据库

执行 nacos 自带 SQL：conf/nacos-mysql.sql，创建 nacos_config 数据库和表。

第三步：配置 cluster.conf

将 conf/cluster.conf.example 改名为 cluster.conf：

1
2
3
4


# cluster.conf
192.168.6.21:8848
192.168.6.22:8848
192.168.6.23:8848

第四步：配置 application.properties

1
2
3
4
5


spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://192.168.6.10:3306/nacos_config?useUnicode=true&characterEncoding=utf-8
db.user=nacos
db.password={{REDACTED}}

第五步：启动

1

sh startup.sh

单台服务器启动成功后，对集群其他服务器重复同样操作即可。

2.3 集群原理

Distro 协议（AP 模式，默认）：nacos 自研的最终一致协议，每个节点负责一部分服务，多节点互写互读
Raft 协议（CP 模式，配置中心）：持久化配置走 Raft，保证强一致
节点间通过 gRPC 长连接 同步数据

三、MySQL 主从集群

3.1 集群目的

采用 MySQL 集群需要部署主从关系：

主节点：写数据（INSERT / UPDATE / DELETE）
从节点：读数据（SELECT）
关系：一主多从，用户从多个从节点读数据，大大缓解读取压力
额外收益：主节点写入自动同步到从节点，降低数据丢失风险

3.2 主从复制原理

MySQL 主从复制基于主服务器二进制日志（binlog） 跟踪所有对数据库的更改。

工作过程：

1
2
3
4
5
6
7
8
9


┌─────────┐ ┌─────────┐
│ Master │ │ Slave │
│ │ │ │
│ binlog │ <── (1) 读 binlog ─── I/O 线程 ──│ relay │
│ dump │ │ log │
│ 线程 │ ── (2) 传 binlog ───────────> │ │
│ │ │ SQL 线程│
│ │ <── (3) 同步完成通知 ───────────│ │
└─────────┘ └─────────┘

从库生成两个线程：一个 I/O 线程，一个 SQL 线程
I/O 线程请求主库的 binlog，并将 binlog 写到 relay log（中继日志）
主库生成 log dump 线程，用来给从库 I/O 线程传 binlog
SQL 线程读取 relay log，解析成具体操作，实现主从一致

3.3 核心配置

主库 my.cnf：

1
2
3
4
5


[mysqld]
server-id = 1
log-bin = /var/lib/mysql/mysql-bin
binlog-format = ROW
sync_binlog = 1

从库 my.cnf：

1
2
3
4


[mysqld]
server-id = 2
relay-log = /var/lib/mysql/relay-log
read-only = 1

主库授权：

1
2


grant replication slave on *.* to 'repl_user'@'%' identified by '{{REDACTED}}';
flush privileges;

从库配置同步：

1
2
3
4
5
6
7
8
9


CHANGE MASTER TO
 MASTER_HOST='192.168.6.21',
 MASTER_USER='repl_user',
 MASTER_PASSWORD='{{REDACTED}}',
 MASTER_LOG_FILE='mysql-bin.000001',
 MASTER_LOG_POS=0;

START SLAVE;
SHOW SLAVE STATUS\G # 看 Slave_IO_Running: Yes, Slave_SQL_Running: Yes

3.4 读写分离

两种实现方式：

数据库中间件（Mycat / Sharding-Proxy）：单独部署服务，配置实现读写分离，不侵入业务代码
客户端 SDK（dynamic-datasource / shardingsphere-jdbc）：业务代码引入 jar 包，通过注解切换

dynamic-datasource 示例（Spring Boot）：

1
2
3
4
5


<dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
 <version>3.3.2</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


spring:
 datasource:
 dynamic:
 primary: master
 datasource:
 master:
 url: jdbc:mysql://192.168.6.21:3306/test
 username: root
 password: {{REDACTED}}
 driver-class-name: com.mysql.cj.jdbc.Driver
 slave1:
 url: jdbc:mysql://192.168.6.22:3306/test
 username: root
 password: {{REDACTED}}
 driver-class-name: com.mysql.cj.jdbc.Driver

1
2
3
4
5
6
7
8


@Service
public class OrderService {
 @DS("master") // 写主库
 public void createOrder(Order order) { ... }
 
 @DS("slave1") // 读从库
 public List<Order> listOrders() { ... }
}

3.5 分库分表

两种方案：

Sharding Sphere（推荐）：JDBC 代理 / Proxy 模式
Mycat 2：数据库中间件，需要独立部署

四、Redis 集群

4.1 三种集群方案

主从复制模式：1 主 N 从，主写从读，但主挂了不会自动切换（需要手动）
Sentinel（哨兵）模式：在主从基础上加哨兵进程监控，主挂了自动选举新主（推荐中小规模）
Cluster 模式：Redis 3.0+ 官方方案，数据分片 + 主从 + 自动故障转移（推荐大规模）

4.2 集群部署（Cluster 模式）

官方推荐：集群至少 3 个 master 节点，最好用 3 主 3 从 6 节点模式。

1
2
3
4
5
6


# 启用集群模式
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 15000
# 至少 3 个 master
cluster-migration-barrier 1

创建集群：

1
2
3
4


redis-cli --cluster create \
 192.168.6.31:6379 192.168.6.32:6379 192.168.6.33:6379 \
 192.168.6.34:6379 192.168.6.35:6379 192.168.6.36:6379 \
 --cluster-replicas 1

4.3 Cluster 原理

数据分片：16384 个 slot（哈希槽），每个 master 负责一段
请求路由：客户端通过 CRC16(key) % 16384 计算 slot
重定向：如果请求路由到错误节点，会返回 MOVED 或 ASK 让客户端重试
故障转移：master 挂了，从节点通过 Raft-like 协议选举新主

五、消息队列集群

5.1 RabbitMQ 集群

普通集群：多节点共享元数据，队列只在单节点，性能提升有限
镜像集群：队列数据多节点同步，HA 能力强但性能低
推荐方案：普通集群 + HAProxy + 镜像队列（关键业务队列）

5.2 RocketMQ 集群

NameServer 集群：无状态，多节点即可
Broker 集群：分 Master / Slave
- 多 Master：高性能但无 HA
- 多 Master 多 Slave（异步复制）：性能 + HA 平衡
- 多 Master 多 Slave（同步双写）：强 HA，性能低
推荐方案：2 主 2 异步从 + 异步刷盘

六、5 大集群对比

集群	核心协议	关键配置	HA 能力	数据一致性
Gateway	无（无状态）	Nginx upstream	自动（多实例）	无（无状态）
Nacos	Distro + Raft	cluster.conf + MySQL	自动（≥3 节点）	AP+CP 混合
MySQL	binlog + relay log	server-id + log-bin	半自动（需切换）	最终一致
Redis Cluster	哈希槽（16384）	cluster-enabled	自动（≥3 master）	最终一致
RabbitMQ	镜像队列	cluster_partition_handling	自动（镜像）	最终一致
RocketMQ	主从同步	brokerRole	自动（多主多从）	异步/同步

七、面试常问

Q：为什么 Nacos 集群至少 3 个节点？ A：Raft 协议要求过半节点存活才能选举 Leader，3 节点允许 1 节点宕机，5 节点允许 2 节点宕机。奇数节点是性价比最高的选择。

Q：MySQL 主从延迟怎么解决？ A：① 业务容忍延迟（异步复制天然有 ms 级延迟）；② 强制读主（重要业务读写都走主）；③ 半同步复制（MySQL 5.7+ rpl_semi_sync_master_wait_slave_count）；④ 用 Canal 订阅 binlog 同步到 ES / Redis。

Q：Redis Cluster 为什么是 16384 个 slot？ A：因为 16384 足够均匀分布，节点间心跳包大小可控（每个 slot 1 bit，16384 / 8 = 2KB，远小于 1MB 网络包上限）。如果用 65536，心跳包会膨胀到 8KB，且实际场景下节点数不会超过 1000，16384 足够。

Q：Spring Cloud Gateway 怎么限流？ A：内置 RequestRateLimiter GatewayFilter，基于 Redis + Lua 脚本实现令牌桶。Key 可以基于 IP / User / API Path。

八、小结

Gateway 无状态：集群 = 多实例 + 入口 LB
Nacos 集群：3 节点起步 + MySQL 持久化
MySQL 主从：binlog 同步 + 读写分离中间件
Redis Cluster：16384 哈希槽 + 3 主 3 从
MQ 集群：RabbitMQ 镜像队列 / RocketMQ 多主多从

九、2021 视角回望（微服务面试考点演化）

站在 2021-09 收尾，回看"5 大集群对比"那一节，再补充几点2021 时点的面试新趋势：

Nacos 2.0 的 gRPC 长连接：2020 年 Nacos 2.0 把数据同步从 HTTP 短连接改成长连接，性能提升 10 倍，是高频面试追问点
Spring Cloud Gateway 限流细节：内置 RequestRateLimiter + Redis Lua 是高频八股文，几乎所有 Java 面试都会问
MySQL 5.7 → 8.0 升级：2021 年 5.7 EOL 时间已定（2023-10），8.0 的 MGR（MySQL Group Replication）开始被生产采用
Redis 6.x 的多线程 IO：2020 年 Redis 6.0 发布，IO 多线程化但执行命令仍单线程，集群方案未变
Kafka vs RocketMQ 二选一：阿里系项目用 RocketMQ（事务消息），其他用 Kafka（生态 + 吞吐），2021 年仍是常见面试题

2021 时点的"5 大集群面试"标准答案：

Gateway 无状态 → 集群 = Nginx upstream + 多实例
Nacos 集群 → 至少 3 节点（过半选举） + MySQL 持久化 + gRPC 2.0 同步
MySQL 主从 → binlog + relay log + 读写分离（ShardingSphere / dynamic-datasource）
Redis Cluster → 16384 哈希槽 + 3 主 3 从 + 客户端路由
MQ 集群 → RabbitMQ 镜像队列 / RocketMQ 多主多从（同步双写保 HA）

Java 面试合集：Redis 数据结构与线程模型

Fri, 15 Jun 2018 00:00:00 +0800

本文写于 2018 年 6 月——Redis 4.0 主线、Redis 5.0（Stream 类型）2018-10 发布前夜。

一、8 大数据类型应用场景

类型	场景	底层实现	说明
String	缓存 / 计数器 / 限流 / 分布式锁 / 共享 Session	int + SDS（简单动态字符串）	最基础类型
Hash	缓存对象 / 购物车	压缩列表 / 哈希表	7.0 中，压缩列表已经废弃了，交由 listpack 来实现了
List	消息队列	双向链表 / 压缩列表	简单的字符串列表，最大长度为 `2^32 - 1`，40 亿。3.2 版本之后，底层数据结构就只由 quicklist 实现了
Set	点赞 / 共同关注 / 抽奖活动	哈希表 / 整数集合	无序并唯一的键值集合
ZSet	排行榜 / 电话排序 / 姓名排序	压缩列表 / 跳表	7.0 中，压缩列表已经废弃了，交由 listpack 来实现了
BitMap（2.2 版新增）	签到 / 用户登陆状态 / 布隆过滤器	String	统计二值状态
HyperLogLog（2.8 版新增）	百万级以上的网页 UV 计数	自定义	用于「统计基数」
GEO（3.2 版新增）	滴滴叫车	Sorted Set	地理坐标
Stream（5.0 版新增）	消息队列	自定义	完美地实现消息队列

1.1 选型决策

graph TD
 A[需要存什么?] --> B{单个值?}
 B -->|是| C[String / BitMap / HyperLogLog]
 B -->|否| D{有序?}
 D -->|是| E[ZSet / List / Stream]
 D -->|否| F{唯一?}
 F -->|是| G[Set]
 F -->|否| H[Hash / List]

二、Redis 线程模型

2.1 单线程 vs 多线程

Redis 单线程指的是「接收客户端请求 → 解析请求 → 进行数据读写等操作 → 发送数据给客户端」这个过程是由一个线程（主线程）来完成的，这也是我们常说 Redis 是单线程的原因。

但是，Redis 程序并不是单线程的，Redis 在启动的时候是会启动后台线程（BIO）的：

Redis 在 2.6 版本，会启动 2 个后台线程，分别处理关闭文件、AOF 刷盘这两个任务
Redis 在 4.0 版本之后，新增了一个新的后台线程，用来异步释放 Redis 内存，也就是 lazyfree 线程

2.2 Redis 6.0 引入多线程 I/O

虽然 Redis 的主要工作（网络 I/O 和执行命令）一直是单线程模型，但是 在 Redis 6.0 版本之后，也采用了多个 I/O 线程来处理网络请求，这是因为随着网络硬件的性能提升，Redis 的性能瓶颈有时会出现在网络 I/O 的处理上。

所以为了提高网络 I/O 的并行度，Redis 6.0 对于网络 I/O 采用多线程来处理。但是对于命令的执行，Redis 仍然使用单线程来处理。 所以大家不要误解 Redis 有多线程同时执行命令。

Redis 官方表示，Redis 6.0 版本引入的多线程 I/O 特性对性能提升至少是一倍以上。

2.3 6.0 线程数配置

1
2
3
4
5


// 读请求也使用 io 多线程
io-threads-do-reads yes

// io-threads N，表示启用 N-1 个 I/O 线程（主线程也算一个 I/O 线程）
io-threads 4

官方的建议是如果为 4 核的 CPU，建议线程数设置为 2 或 3，如果为 8 核 CPU 建议线程数设置为 6，线程数一定要小于机器核数，线程数并不是越大越好。

2.4 Redis 启动后的线程组成

因此， Redis 6.0 版本之后，Redis 在启动的时候，默认情况下会 额外创建 6 个线程 （这里的线程数不包括主线程 ）：

Redis-server：Redis 的主线程，主要负责执行命令

bio_close_file、bio_aof_fsync、bio_lazy_free：三个后台线程，分别异步处理关闭文件任务、AOF 刷盘任务、释放内存任务

io_thd_1、io_thd_2、io_thd_3：三个 I/O 线程，io-threads 默认是 4，所以会启动 3（4-1）个 I/O 多线程，用来分担 Redis 网络 I/O 的压力

三、Redis 为什么这么快

3.1 4 大核心原因

Redis 快的核心原因，可以用一句话概括：它干的活极其简单，而且它把单线程的优势发挥到了极致，同时通过操作系统底层的"高级外挂"解决了高并发的排队问题。

原因 1：绝大多数请求是纯内存操作

这是最根本的基础。Redis 的所有数据都存储在内存中，CPU 读写内存的速度（纳秒级别）比起读写机械硬盘或 SSD（微秒甚至毫秒级别）快了数万倍。

原因 2：避免了多线程的"内耗"

多线程虽然能并发，但也带来了高昂的代价。Redis 采用单线程，反而完美避开了这些性能杀手：

没有线程切换的开销：操作系统在切换线程时，需要保存当前线程的上下文并加载新线程的数据。单线程一个人干到底，零切换成本
没有锁的竞争：多线程访问共享资源必须加锁，加锁、解锁以及等待锁的操作非常重。Redis 单线程天然保证了所有操作都是原子性的，根本不需要锁

原因 3：I/O 多路复用技术（底层外挂）

“单线程"指的是 Redis 核心的网络事件处理器和键值对读写命令 是由一个线程串行执行的。但面对海量的客户端连接，单线程怎么可能忙得过来？

这就是 I/O 多路复用（I/O Multiplexing） 大显身手的地方。Redis 利用了操作系统底层的非阻塞 I/O 机制（在 Linux 上通常是 epoll）。

epoll 工作原理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


┌─────────────────────────────────────────┐
│ Redis 主线程 │
│ ┌──────────────────┐ │
│ │ epoll_wait() │ ← 阻塞等事件 │
│ └──────────────────┘ │
│ ↓ 有事件发生 │
│ 遍历 fd_list，处理每个就绪 fd │
│ ├─ Client 1: read() │
│ ├─ Client 5: read() │
│ └─ Client 100: read() │
│ ↓ 业务逻辑 │
│ 执行 Redis 命令（单线程原子） │
│ ↓ 写回响应 │
│ write() → 多线程异步 │
└─────────────────────────────────────────┘

epoll 优势：

select：O(n) 遍历所有 fd
poll：O(n) 遍历所有 fd
epoll：O(1) 事件通知（内核维护就绪链表）

原因 4：精心优化的数据结构

数据结构	优化
SDS	O(1) 长度获取、避免缓冲区溢出、二进制安全
跳跃表	O(log N) 范围查询，替代红黑树
压缩列表	连续内存 + 紧凑编码
dict（哈希表）	渐进式 rehash，不阻塞

四、内存淘汰策略

4.1 8 大策略

策略	描述
noeviction（默认）	不淘汰，写入失败返回错误
allkeys-lru	所有 key 中淘汰最近最少使用
allkeys-lfu（4.0+）	所有 key 中淘汰最不经常使用
allkeys-random	所有 key 中随机淘汰
volatile-lru	设置过期的 key 中淘汰 LRU
volatile-lfu（4.0+）	设置过期的 key 中淘汰 LFU
volatile-random	设置过期的 key 中随机淘汰
volatile-ttl	设置过期的 key 中淘汰最近过期

4.2 选型建议

缓存场景（容忍丢失）：allkeys-lru / allkeys-lfu
数据不能丢：noeviction + 监控告警
混合场景：volatile-lru（仅淘汰过期 key）

五、持久化机制

5.1 三大方式

方式	文件	频率	性能	数据安全
RDB	dump.rdb	定时 / 手动	高	较低（可能丢失最后一次快照后的数据）
AOF	appendonly.aof	每秒	中	较高（仅丢失 1s 数据）
混合（4.0+）	dump + aof	-	中高	高

5.2 RDB 触发

1
2
3
4
5
6
7
8


# 自动触发（save 命令）
save 900 1 # 900 秒内至少 1 个 key 变更
save 300 10 # 300 秒内至少 10 个 key 变更
save 60 10000 # 60 秒内至少 10000 个 key 变更

# 手动触发
bgsave # 后台异步保存
save # 同步保存（阻塞主线程）

5.3 AOF 三种策略

1
2
3
4


# appendfsync 策略
appendfsync always # 每次写入同步刷盘（最安全，最慢）
appendfsync everysec # 每秒刷盘（默认，推荐）
appendfsync no # 操作系统决定（最快，最不安全）

六、Redis 集群方案

方案	数据分片	高可用	适用
主从复制	✗	手动故障切换	简单备份
Sentinel	✗	自动故障切换	中小规模
Codis	✓	手动 + 代理	国产分片方案
Cluster	✓（16384 slot）	自动故障切换	大规模生产

七、Redis 经典问题

7.1 缓存雪崩

现象：大量 key 同时过期，请求打到数据库。

解决方案：

过期时间加随机值：expire = base + random(0, 300)
熔断降级：数据库压力过大时直接拒绝部分请求
缓存预热：系统启动时把热点数据加载到缓存

7.2 缓存穿透

现象：查询不存在的 key，每次都打到数据库。

解决方案：

空值缓存：key -> null（短 TTL）
布隆过滤器：先过布隆过滤器
接口校验：参数合法性检查

7.3 缓存击穿

现象：热点 key 突然过期，瞬间大量请求打到数据库。

解决方案：

分布式锁：第一个请求查 DB，后续请求等
永不过期：逻辑过期（不设 TTL，值带过期时间字段）
熔断降级：直接返回旧值

7.4 数据不一致

现象：数据库和缓存数据不一致。

解决方案：

先更新 DB，再删除缓存（Cache-Aside Pattern）
延迟双删：更新 DB → 删除缓存 → 异步延迟再删
binlog 订阅：监听 binlog 异步更新缓存
设置较短 TTL：最终一致性兜底

八、写在最后

Redis 面试要点：

基础：8 大数据类型 + 选型

线程模型：单线程 vs 多线程 I/O、I/O 多路复用

快的原因：内存操作 + 无锁 + epoll + 优化数据结构

持久化：RDB / AOF / 混合

集群：主从 / Sentinel / Cluster

经典问题：雪崩 / 穿透 / 击穿 / 一致性

参考资料

Windows 数据库实战合集：MySQL/Redis/Elasticsearch/SQLite/Navicat 安装与连接

Fri, 15 Sep 2017 00:00:00 +0800

一、为什么要在 Windows 上跑数据库

生产用 Linux——但学习 / 调试 / 离线场景，Windows 本地数据库仍是开发机标配：

MySQL 8 / Redis 5 —— 本地调试 / 单元测试 / 学习
Elasticsearch 8 —— 全文搜索 / 日志分析
SQLite —— 嵌入式场景（Python 内置 sqlite3 模块）
Navicat —— 跨数据库 GUI，连接本机 + 远程

本文避开 Docker（Windows Docker Desktop 重，本地跑裸进程更快），全部用 ZIP / MSI 解压即装的方式。

二、MySQL 8.0 安装

2.1 下载 MySQL Installer

官方：https://downloads.mysql.com/archives/installer/
推荐版本：MySQL Installer Community 8.0.28.0（2022 时代经典）

MySQL Installer 是 .msi，含 Server + Workbench + Shell + Connector/NET 一站式安装。

2.2 静默安装（推荐）

1
2
3
4
5


# 企业版
msiexec /i mysql-installer-community-8.0.28.0.msi /qn

# 自定义安装路径
msiexec /i mysql-installer-community-8.0.28.0.msi INSTALLDIR="D:\soft\MySQL" /qn

2.3 配置 my.ini

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


[mysqld]
basedir=D:/soft/MySQL
datadir=D:/data/MySQL
port=3306
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
default-authentication-plugin=mysql_native_password

[client]
default-character-set=utf8mb4

2.4 初始化数据目录

1
2


cd D:\soft\MySQL\bin
mysqld --initialize-insecure --user=mysql

--initialize-insecure：root 密码为空（开发机推荐），生产用 --initialize 会生成随机密码到 data\xxx.err。

2.5 启动 MySQL

1
2
3
4
5
6


# 命令行启动
D:\soft\MySQL\bin\mysqld --console

# 注册成 Windows 服务
D:\soft\MySQL\bin\mysqld --install MySQL8 --defaults-file="D:\soft\MySQL\my.ini"
net start MySQL8

2.6 修改 root 密码

1
2


ALTER USER 'root'@'localhost' IDENTIFIED BY 'your_new_password';
FLUSH PRIVILEGES;

三、Redis 5.0 安装

3.1 下载

tporadowski/redis 维护的 Windows 版 Redis（官方 Windows 版停更）
5.0.14.1：https://github.com/tporadowski/redis/releases/download/v5.0.14.1/Redis-x64-5.0.14.1.zip
6.x / 7.x 也都有，2018-2023 持续维护

3.2 解压即用

1
2
3


# 解压到 D:\portable\Redis-x64-5.0.14.1
cd D:\portable\Redis-x64-5.0.14.1
redis-server.exe redis.windows.conf

3.3 客户端连接

1
2
3
4
5
6
7


# 默认 6379 端口
redis-cli.exe -h 127.0.0.1 -p 6379

# 测试
> set myKey abc
> get myKey
"abc"

3.4 注册成 Windows 服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 安装服务
redis-server.exe --service-install redis.windows.conf --loglevel verbose

# 启动服务
redis-server.exe --service-start

# 停止服务
redis-server.exe --service-stop

# 卸载服务
redis-server.exe --service-uninstall

3.5 配置密码

redis.windows.conf：

1

requirepass your_redis_password

客户端：

1

redis-cli -a your_redis_password

注意：Redis 6+ 才支持 ACL（多用户多权限），5.0 仍是单密码模式。

四、Elasticsearch 8.x 安装

4.1 下载

官方：https://www.elastic.co/cn/downloads/elasticsearch
8.2.2 Windows 版：https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.2.2-windows-x86_64.zip
历史版本：https://www.elastic.co/cn/downloads/past-releases#elasticsearch

4.2 解压

1
2


# 推荐解压到 D 盘
Expand-Archive elasticsearch-8.2.2-windows-x86_64.zip -DestinationPath D:\portable\

4.3 启动 ES

D:\portable\elasticsearch-8.2.2\config\elasticsearch.yml 末尾加：

1

xpack.ml.enabled: false

关掉 X-Pack ML，避免内存溢出（默认开启会占 1G+ 内存）。

启动：

1

D:\portable\elasticsearch-8.2.2\bin\elasticsearch.bat

第一次启动输出：

1
2
3
4
5
6
7
8


-> Elasticsearch security features have been automatically configured!
-> Authentication is enabled and cluster connections are encrypted.

-> Password for the elastic user (reset with `bin/elasticsearch-reset-password -u elastic`):
 SCzC_tXNopid7eKBVp0n

-> HTTP CA certificate SHA-256 fingerprint:
 74bbe5528b8e1c66539cb8cc8aff1bb624970694e9e55578a7ecbbd6ac60fe1f

SCzC_tXNopid7eKBVp0n 就是 elastic 用户的初始密码——记下来！

4.4 改密码

1

D:\portable\elasticsearch-8.2.2\bin\elasticsearch-reset-password -u elastic -i

4.5 访问

1
2


# 默认 https://localhost:9200
curl -k -u elastic:your_password https://localhost:9200/

-k 是忽略 TLS 证书（ES 8 默认开启 TLS）。

4.6 Kibana 配套

Kibana 8.2.2：https://artifacts.elastic.co/downloads/kibana/kibana-8.2.2-windows-x86_64.zip
解压到 D:\portable\kibana-8.2.2
启动 bin\kibana.bat
访问 http://localhost:5601

五、SQLite 解压即用

5.1 下载

官方：https://www.sqlite.org/download.html
2022 版：sqlite-dll-win64-x64-3380500.zip + sqlite-tools-win32-x86-3380500.zip

5.2 部署

1
2
3
4


# 解压到 D:\portable\sqlite3
md D:\portable\sqlite3
Expand-Archive sqlite-dll-win64-x64-3380500.zip -DestinationPath D:\portable\sqlite3
Expand-Archive sqlite-tools-win32-x86-3380500.zip -DestinationPath D:\portable\sqlite3

5.3 配置环境变量

1

PATH += D:\portable\sqlite3

5.4 启动

1

Win+R → wt → sqlite3

输出：

1
2
3
4
5


SQLite version 3.38.5 2022-05-06 15:25:27
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite>

5.5 常用命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


-- 打开数据库文件
.open mydata.db

-- 列出所有表
.tables

-- 显示表结构
.schema users

-- 退出
.exit

-- .help 看所有元命令
.help

5.6 Python 内置

1
2
3
4
5
6
7
8


import sqlite3

conn = sqlite3.connect('mydata.db')
cur = conn.cursor()
cur.execute('SELECT * FROM users LIMIT 5')
for row in cur.fetchall():
 print(row)
conn.close()

六、Navicat 连接 SQL Server

6.1 安装 SQL Server Native Client 2012

Navicat 早期版本连接 SQL Server 需要 Microsoft® SQL Server® 2012 Native Client：

下载：https://www.microsoft.com/zh-cn/download/confirmation.aspx?id=50402
Navicat 16+ 已经自带驱动

6.2 新建连接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


1. 打开 Navicat
2. "连接" → 选 "SQL Server"
3. 主机: localhost / 192.168.x.x / <HOST>,1433
4. 验证: SQL Server 验证
5. 用户名: sa
6. 密码: ********
7. 数据库: 选 <默认> / 指定
8. 高级 → 排序规则: Chinese_PRC_CI_AS
9. 高级 → 恢复模式: SIMPLE
10. 高级 → 兼容级别: 100（SQL Server 2008 兼容）
11. 测试连接

6.3 关键参数说明

参数	含义	推荐值
排序规则	字符集 / 排序规则	`Chinese_PRC_CI_AS`（中文不区分大小写）
恢复模式	FULL / SIMPLE / BULK_LOGGED	SIMPLE（开发机省空间）
兼容级别	模拟老 SQL Server 版本	100（2008）/ 110（2012）/ 130（2016）
加密	是否 TLS	Force Encryption = False（开发机省事）

七、跨数据库 GUI 工具对比

工具	出品方	跨数据库	价格	推荐度
Navicat Premium	卓码（香港）	MySQL/MSSQL/Oracle/PostgreSQL/SQLite/MongoDB/Redis	商业付费	老牌经典
DBeaver Community	社区	几乎所有数据库	免费开源	2020+ 主流
DataGrip	JetBrains	几乎所有数据库	商业付费	IDE 体验
HeidiSQL	德国开发者	MySQL/MSSQL/PostgreSQL	免费开源	MySQL 经典
TablePlus	独立开发者	MySQL/PostgreSQL/SQLite/Redis/MongoDB	商业付费（Mac/Win）	Mac 设计感
Apifox	国产	API 设计 + Mock + 调试 + 文档	个人版免费	2020+ 新派

建议：

白嫖 → DBeaver Community
重度 MySQL → Navicat Premium
IDE 用户 → DataGrip
Mac 用户 → TablePlus

八、Windows 防火墙与端口

数据库本地跑没问题，但远程连接要开防火墙：

8.1 放行 MySQL 3306

1

New-NetFirewallRule -DisplayName "MySQL 3306" -Direction Inbound -LocalPort 3306 -Protocol TCP -Action Allow

8.2 放行 Redis 6379

1

New-NetFirewallRule -DisplayName "Redis 6379" -Direction Inbound -LocalPort 6379 -Protocol TCP -Action Allow

8.3 放行 Elasticsearch 9200

1

New-NetFirewallRule -DisplayName "ES 9200" -Direction Inbound -LocalPort 9200 -Protocol TCP -Action Allow

生产环境：不要直接把数据库端口暴露公网——走 SSH 隧道或 VPN。

九、性能调优

9.1 MySQL

配置 innodb_buffer_pool_size = 物理内存的 50-70%
启用慢查询日志：slow_query_log = 1，long_query_time = 2
使用 EXPLAIN 分析慢 SQL

9.2 Redis

最大内存：maxmemory 2gb
淘汰策略：maxmemory-policy allkeys-lru（通用 LRU）
持久化：开发机关 RDB / AOF，生产开 AOF

9.3 Elasticsearch

Xms / Xmx JVM 堆内存：建议设成一样大
堆内存 ≤ 物理内存的 50%（留 50% 给 OS 文件缓存）
避免大文档 + 避免深度分页

十、常见 5 个坑

MySQL 8 默认 caching_sha2_password——老客户端连不上，改 mysql_native_password
Redis Windows 5.0 默认无密码——生产必设 requirepass
Elasticsearch 8 默认开 TLS + 强制密码——第一次启动会输出初始密码，记不住就 elasticsearch-reset-password
SQLite 数据库文件并发写会锁——多写场景不要用 SQLite
Navicat 12 之前的版本连 SQL Server 2016+ 报错——升级到 Navicat 16+

十一、总结

MySQL 8 —— mysqld --initialize-insecure 初始化 + mysqld --install 注册服务
Redis 5/6 —— tporadowski 维护版解压即用，生产必设密码
Elasticsearch 8 —— 8.x 默认开 TLS，第一次启动的 elastic 密码要记
SQLite —— Python 内置，开发机首选
Navicat —— 跨数据库 GUI，经典老牌；白嫖首选 DBeaver
生产环境：数据库别直接暴露公网——走 SSH 隧道 / VPN

参考资料

Windows 自托管服务实战：Nginx、Caddy、Redis、MinIO、Elasticsearch 与 WinSW 注册服务

Thu, 15 Jun 2017 00:00:00 +0800

一、为什么要在 Windows 上自托管服务

Linux 是服务器的主流，但以下场景 Windows 是更好的选择：

本机开发调试：不想用 Docker 跑 Redis / MinIO，直接在 Windows 起一个更轻；
边缘设备：工控机、收银终端、POS 机多数是 Windows；
客户现场：客户系统是 Windows Server，部署要符合现场环境；
个人 NAS / 家用服务器：Windows 桌面系统易用，存储/相册/笔记都靠它。

本文给出 Nginx / Caddy / Redis / MinIO / Elasticsearch 五个常用自托管服务的 Windows 绿色版部署方案，统一用 WinSW 把 exe 注册成系统服务，重启自启。

二、Nginx for Windows

2.1 下载与目录

nginx.org/en/download.html 下载 nginx-1.24.0.zip（mainline 1.25.x 也可以）。

1
2
3
4
5
6
7


D:\portable\dev\nginx-1.24.0\
├── conf\
│ ├── nginx.conf
│ └── conf.d\ # 自定义配置
├── html\
├── logs\
└── nginx.exe

2.2 配置环境变量

1

PATH=D:\portable\dev\nginx-1.24.0

1
2


nginx -v
# nginx version: nginx/1.24.0

2.3 启停命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 启动（前台）
start nginx

# 优雅停止
nginx -s stop
nginx -s quit
nginx -s reload # 重载配置（不中断连接）
nginx -s reopen # 重开日志文件

# 暴力杀进程（兜底）
taskkill /f /t /im nginx.exe

2.4 反代示例

conf/conf.d/frontend.conf：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


server {
 listen 8080;
 server_name localhost;

 # 静态站点
 root D:/wwwroot/site;
 index index.html;

 # 反向代理
 location /api/ {
 proxy_pass http://127.0.0.1:3000/;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_set_header X-Forwarded-Proto $scheme;
 }

 # WebSocket
 location /ws/ {
 proxy_pass http://127.0.0.1:3001/;
 proxy_http_version 1.1;
 proxy_set_header Upgrade $http_upgrade;
 proxy_set_header Connection "upgrade";
 }

 # 大文件上传
 client_max_body_size 100m;
}

主 conf/nginx.conf 引入：

1
2
3
4
5
6
7
8


http {
 include mime.types;
 default_type application/octet-stream;
 sendfile on;
 keepalive_timeout 65;
 gzip on;
 include conf.d/*.conf;
}

2.5 TCP/UDP 四层代理

conf/stream/video.conf：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


stream {
 server {
 listen 1935;
 proxy_pass stream_backend;
 }
 upstream stream_backend {
 server 127.0.0.1:1936;
 server 127.0.0.1:1937;
 }
}

启动时 nginx 会要求主 nginx.conf 引入 stream 块，默认 nginx.conf 不带，要手动加。

三、Caddy：自动 HTTPS 的 HTTP/2 服务器

3.1 下载

caddyserver/caddy/releases 下载 caddy_2.6.4_windows_amd64.zip，解压到 D:\portable\dev\caddy。

3.2 Caddyfile 最小配置

1
2
3
4
5
6


example.com {
 root * D:/wwwroot/site
 file_server
 encode gzip
 reverse_proxy /api/* 127.0.0.1:3000
}

3.3 关键命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 启动（前台，监视配置改动自动 reload）
.\caddy.exe run --watch

# 启动（守护进程）
.\caddy.exe start

# 格式化配置文件（推荐编辑后立即 fmt）
.\caddy.exe fmt --overwrite Caddyfile

# 自签证书测试
curl https://localhost --ssl-no-revoke

3.4 Caddy vs Nginx

维度	Caddy	Nginx
自动 HTTPS	默认开（Let’s Encrypt）	需 acme.sh + cron
配置语法	极简	模块化、灵活
性能	单核略低于 Nginx	极致优化
生态	较新，模块少	老牌，几乎所有场景都有现成配置
适合	个人/小团队博客、内网工具	生产大流量反代、网关

四、Redis for Windows

4.1 下载

官方 Redis 不提供 Windows 版。社区维护两个分支：

tporadowski/redis（Cygwin 版）；
redis-windows/redis-windows（MinGW 版，2023+ 维护）。

下载 Redis-7.4.1-Windows-x64-cygwin-with-Service.zip，解压到 D:\portable\dev\redis。

4.2 启动

1
2
3
4
5
6
7


# 启动 redis-server
D:\portable\dev\redis\redis-server.exe redis.conf

# 客户端
D:\portable\dev\redis\redis-cli.exe
127.0.0.1:6379> ping
PONG

4.3 配置 redis.conf 关键项

1
2
3
4
5
6
7
8
9


bind 127.0.0.1
port 6379
daemonize no # Windows 不支持 daemonize
loglevel notice
logfile "D:/portable/dev/redis/logs/redis.log"
dir D:/portable/dev/redis/data
maxmemory 256mb
maxmemory-policy allkeys-lru
requirepass {{REDACTED}}

4.4 用 Redis Desktop Manager 连

RDM（uglide/RedisDesktopManager）2021.3 起开源。Windows 端推荐用 Another Redis Desktop Manager，绿色解压即用。

1
2
3


host: 127.0.0.1
port: 6379
password: <requirepass>

五、MinIO：对象存储

5.1 下载

dl.minio.io + dl.min.io/client/mc/release/windows-amd64/mc.exe，放到 D:\portable\dev\minio\。

5.2 目录

1
2
3
4


D:\portable\dev\minio\
├── data\ # 对象数据
├── minio.exe
└── minio.bat # 启动脚本

minio.bat：

1
2
3
4
5


@echo off
set path=D:\portable\dev\minio
set minPath=D:\portable\dev\minio\data
"%path%\minio.exe" server %minPath% --console-address ":9000" --address ":9090"
pause

5.3 启动

1
2
3
4
5


.\minio.bat
# 输出：
# API: http://127.0.0.1:9090
# WebUI: http://127.0.0.1:9000
# 默认账号: minioadmin / minioadmin ← 首次启动后立即改密

5.4 mc 客户端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 配置 host
.\mc.exe config host add local http://127.0.0.1:9090 minioadmin minioadmin

# 列 bucket
.\mc.exe ls local/

# 创建 bucket
.\mc.exe mb local/test-bucket

# 上传文件
.\mc.exe cp D:/test.zip local/test-bucket/

# 列已配 host
.\mc.exe config host list

安全提示：minioadmin/minioadmin 是默认账号，生产环境必须通过 MINIO_ROOT_USER / MINIO_ROOT_PASSWORD 环境变量或 config.json 修改。

六、Elasticsearch

6.1 下载

elastic.co/downloads/past-releases#elasticsearch 选 8.x zip。

6.2 启动

1
2


cd D:\portable\dev\elasticsearch-8.11.0
bin\elasticsearch.bat

6.3 关键配置

config/elasticsearch.yml：

1
2
3
4
5
6


cluster.name: dev-cluster
node.name: dev-node-1
network.host: 127.0.0.1
http.port: 9200
discovery.type: single-node
xpack.security.enabled: false

config/jvm.options：

1
2


-Xms2g
-Xmx2g

避坑：Windows 上 ES 跑 2GB 堆需要至少 4GB 物理内存，老机器慎用。

6.4 Kibana 配套

KIMB elastic.co/downloads/kibana 下 Windows zip，启动后访问 http://127.0.0.1:5601，Dev Tools Console 是排查 ES 最方便的工具。

七、WinSW：把 exe 注册成系统服务

7.1 简介

winsw/winsw 是 Windows Service Wrapper，可以把任何可执行文件注册成 Windows 系统服务（支持开机自启、失败重启、日志轮转）。

下载 WinSW-x64.exe（注意 64/32 位），改名成与 XML 同名。

7.2 XML 配置

把 WinSW-x64.exe 复制到 D:\portable\dev\nginx-1.24.0\nginx-service.exe，新建 nginx-service.xml：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<service>
 <id>nginx-server</id>
 <name>nginx-server</name>
 <description>Nginx 1.24 反向代理服务</description>
 <executable>D:\portable\dev\nginx-1.24.0\nginx.exe</executable>
 <startarguments>-p D:\portable\dev\nginx-1.24.0\</startarguments>
 <stopexecutable>D:\portable\dev\nginx-1.24.0\nginx.exe</stopexecutable>
 <stoparguments>-p D:\portable\dev\nginx-1.24.0\ -s stop</stoparguments>
 <logpath>%BASE%\logs</logpath>
 <log mode="rotate">
 <sizeThreshold>10240</sizeThreshold>
 <keepFiles>3</keepFiles>
 </log>
</service>

7.3 安装 / 启动 / 卸载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 安装服务（管理员 cmd）
nginx-service.exe install

# 启动
nginx-service.exe start
nginx-service.exe stop
nginx-service.exe restart
nginx-service.exe status

# 卸载
nginx-service.exe uninstall

# 不重装刷新配置
nginx-service.exe refresh

7.4 日志按时间轮转

1
2
3
4
5
6


<log mode="roll-by-size-time">
 <sizeThreshold>10240</sizeThreshold>
 <pattern>yyyyMMdd</pattern>
 <autoRollAtTime>00:00:00</autoRollAtTime>
 <zipOlderThanNumDays>5</zipOlderThanNumDays>
</log>

7.5 实战：MinIO 服务化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


<service>
 <id>minio-server</id>
 <name>minio-server</name>
 <description>MinIO 对象存储服务</description>
 <env name="HOME" value="%BASE%"/>
 <env name="MINIO_ROOT_USER" value="root"/>
 <env name="MINIO_ROOT_PASSWORD" value="{{REDACTED}}"/>
 <executable>%BASE%\minio.exe</executable>
 <arguments>server "%BASE%\data" --console-address ":9090" --address ":9091"</arguments>
 <logpath>%BASE%\logs</logpath>
 <log mode="roll-by-size-time">
 <sizeThreshold>10240</sizeThreshold>
 <pattern>yyyyMMdd</pattern>
 </log>
</service>

7.6 WinSW 完整命令表

命令	用途
install	安装服务
uninstall	卸载服务
start	启动
stop	停止
restart	重启
status	查看状态
refresh	刷新服务属性（不重装）
customize	自定义包装可执行文件
dev ps	显示服务进程树
dev kill	强制杀掉服务进程
dev list	列出本 exe 注册的所有服务

八、把它们装在一起的服务清单

1
2
3
4
5
6
7
8


D:\portable\services\
├── nginx\ # 端口 80 / 8080
├── caddy\ # 端口 443（自动 HTTPS）
├── redis\ # 端口 6379
├── minio\ # 端口 9090 (API) / 9000 (WebUI)
├── elasticsearch\ # 端口 9200
├── kibana\ # 端口 5601
└── nssm\ # 备用服务化工具

每个目录下放 <服务名>.exe（WinSW 改名）和 <服务名>.xml，统一 install 即可。

九、常见坑与对策

现象	原因	对策
Nginx 启动 403 Forbidden	SELinux / 文件权限	Windows 上多数是路径写错
Caddy 启动报 “bind: address already in use”	端口被占	`netstat -ano
Redis 启动报 “Bad file format”	Windows redis 版本错	装 Cygwin 版（tporadowski）
MinIO 控制台打不开	防火墙	首次启动后改 `minioadmin` 密码
ES 启动 OOM	JVM 堆	`-Xms1g -Xmx1g` 调小
WinSW 服务起不来	不是管理员	用管理员 cmd

十、下一步

Caddy 进阶：用 Cloudflare DNS plugin 自动签通配符证书
MinIO 进阶：搭建 4 节点分布式集群（参考 2022-09-15《MinIO 对象存储实战》）
Redis 进阶：Redis Sentinel 高可用、Redis Cluster 集群
ES 进阶：用 Docker Compose 拉起 ES + Kibana 全套（参考 2025-03-15《Prometheus 监控告警体系》）

十一、参考资料

Windows 数据库客户端实战：MySQL / Redis / SQLite / MQTTX / Elasticsearch

Tue, 15 Nov 2016 00:00:00 +0800

一、2016 年数据库客户端格局

2016 年的数据库世界：MySQL 仍是事实 OLTP 之王、Redis 已经是缓存标配、SQLite 在移动端大杀四方、MQTT 协议在 IoT 崛起、Elasticsearch 2.x 到 5.x 跨大版本。本文整理 5 款数据库 / 消息客户端的实战用法。

阅读建议：本文面向全栈 / 后端开发者，重点在工具选型 + 性能调优。

二、MySQL 客户端

2.1 命令行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 连接
mysql -h <HOST> -P 3306 -u root -p<password> <DB>

# 常用命令
SHOW DATABASES;
USE mydb;
SHOW TABLES;
DESCRIBE users;
SELECT * FROM users LIMIT 10;

# 导出
mysqldump -h <HOST> -u root -p<password> mydb > backup.sql

# 导入
mysql -h <HOST> -u root -p<password> mydb < backup.sql

# 执行 SQL 文件
mysql -h <HOST> -u root -p<password> mydb < init.sql

2.2 GUI 工具对比

工具	优势	价格
Navicat	多数据库 / 完整	商业付费
DBeaver	免费开源 / 多数据库	开源（EE 收费）
MySQL Workbench	官方 / 建模	免费
HeidiSQL	轻量	免费
phpMyAdmin	Web	免费
DataGrip	JetBrains / 最强	商业付费
Sequel Ace	Mac 开源	免费

2.3 MySQL 8.0 新特性

窗口函数（ROW_NUMBER() OVER）
CTE 公共表表达式（WITH 子句）
JSON 增强（JSON_TABLE）
降序索引
caching_sha2_password（默认鉴权插件）

2.4 性能调优

慢查询日志：

1
2
3
4
5


# /etc/my.cnf
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2
log_queries_not_using_indexes = 1

索引优化：

1
2
3
4
5
6
7


-- 查看执行计划
EXPLAIN SELECT * FROM users WHERE email = 'foo@bar.com';

-- 关键字段：type, key, rows, Extra
-- type = ALL: 全表扫描
-- type = ref: 索引扫描
-- type = const: 主键/唯一索引等值

连接数：

1
2
3
4
5


-- 当前连接
SHOW STATUS LIKE 'Threads_connected';

-- 最大连接
SHOW VARIABLES LIKE 'max_connections';

三、Redis 客户端

3.1 命令行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# 连接
redis-cli -h <HOST> -p 6379 -a <password>

# 常用命令
SET user:1 "alice"
GET user:1
DEL user:1
EXISTS user:1
EXPIRE user:1 3600

# 哈希
HSET user:1 name "alice" age 30
HGETALL user:1

# 列表
LPUSH queue:msg "msg1"
RPOP queue:msg

# 集合
SADD tags "java" "redis"
SMEMBERS tags

# 有序集合
ZADD rank 100 "alice" 95 "bob"
ZRANGE rank 0 -1 WITHSCORES

# 管道
echo "PING\nSET k v\nGET k" | redis-cli

3.2 GUI 工具对比

工具	平台	价格
Redis Desktop Manager (RDM)	跨平台	现改名 RESP.app / 商业
Medis	Mac	开源
Another Redis Desktop Manager	跨平台	开源免费
RedisInsight	跨平台	官方 / 免费
FastoRedis	跨平台	开源 / 商业
Tiny RDM	新兴	国产 / 开源

3.3 实战：String 缓存

1
2
3
4
5
6
7
8


# 设置 5 分钟过期
SET session:user:1001 "<json>" EX 300

# 获取
GET session:user:1001

# 原子递增
INCR counter:views:article:123

3.4 实战：List 消息队列

1
2
3
4
5


# 生产者
LPUSH queue:email "{\"to\":\"a@x.com\",\"subject\":\"hi\"}"

# 消费者
BRPOP queue:email 0 # 阻塞 0 秒直到有数据

3.5 性能监控

1
2
3
4
5
6
7
8
9


# 实时命令
redis-cli MONITOR

# 慢查询
redis-cli SLOWLOG GET 10

# 内存分析
redis-cli MEMORY USAGE mykey
redis-cli INFO MEMORY

四、SQLite 客户端

4.1 命令行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 打开 / 创建数据库
sqlite3 mydb.db

# 常用命令
.tables
.schema users
.headers on
.mode column
SELECT * FROM users LIMIT 10;

# 备份
sqlite3 mydb.db ".dump" > backup.sql

# 恢复
sqlite3 newdb.db < backup.sql

4.2 GUI 工具

工具	平台	价格
DB Browser for SQLite	跨平台	免费开源
SQLiteStudio	跨平台	免费
Navicat for SQLite	跨平台	商业
DBeaver	跨平台	开源（EE 收费）

4.3 DB Browser for SQLite 实战

https://sqlitebrowser.org/：

打开 .db 文件
Browse Data → 看表数据
Execute SQL → 写 SQL
Database Structure → 改表结构
Export → CSV / JSON / SQL

4.4 实战：移动端加密数据库

1
2
3
4
5
6
7
8
9


# Python + SQLite 加密
import sqlite3
from pysqlcipher3 import dbapi2 as sqlcipher

conn = sqlcipher.connect("encrypted.db")
conn.execute("PRAGMA key = 'my-secret-password'")
cursor = conn.cursor()
cursor.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
conn.commit()

实战：

密码管理器（如 1Password / Bitwarden）
本地缓存（Chrome 历史）
小工具数据（如 RSS 阅读器）

五、MQTTX 客户端

5.1 MQTT 协议背景

MQTT 1999 年由 IBM 发布，IoT 领域事实标准。核心概念：

Broker：消息代理（EMQX / Mosquitto）
Client：发布 / 订阅
Topic：主题（层级 / 通配符）
QoS：
- 0：最多一次
- 1：至少一次
- 2：恰好一次
Retain：保留消息

5.2 MQTTX 介绍

MQTTX 是 EMQX 团队开发的跨平台 MQTT 桌面客户端。优势：

跨平台（Win / Mac / Linux）
支持 MQTT 5.0
多连接 / 多主题
消息格式化（ JSON / Hex**）**
脚本化（自动测试）

5.3 安装与连接

https://mqttx.app/：

新建连接
- Host：broker.emqx.io（公共测试）
- Port：1883（TCP）/ 8883（TLS）
- Client ID：随机生成
订阅：test/topic
发布：同主题发 {"hello": "world"}

5.4 实战：本地 Mosquitto 调试

1
2
3
4
5
6
7
8


# 启动 Mosquitto
mosquitto -p 1883

# 订阅
mosquitto_sub -h 127.0.0.1 -t "test/#" -v

# 发布
mosquitto_pub -h 127.0.0.1 -t "test/foo" -m "hello"

MQTTX 中：

Host：127.0.0.1
订阅：test/#
发布：test/foo + hello

5.5 实战：TLS / 证书

1
2
3
4
5


MQTTX 高级设置：
- CA File: ca.crt
- Client Cert: client.crt
- Client Key: client.key
- Verify: true

5.6 脚本化（自动化测试）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// MQTTX 脚本：连接 + 订阅 + 验证
const mqtt = require('mqtt');
const client = mqtt.connect('mqtt://broker.emqx.io:1883');

client.on('connect', () => {
 client.subscribe('test/topic', (err) => {
 if (!err) {
 client.publish('test/topic', 'hello mqtt');
 }
 });
});

client.on('message', (topic, message) => {
 console.log(`收到: ${message.toString()}`);
 client.end();
});

六、Elasticsearch 客户端

6.1 协议背景

Elasticsearch 2010 年发布，基于 Lucene 的分布式搜索。2016 年发布 5.0（重大重构）。核心概念：

Index：索引（类比 MySQL 数据库）
Type（5.x）/Document（6.x 起弱化 Type）：文档
Mapping：字段类型定义
Shard / Replica：分片 / 副本

6.2 HTTP API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# 创建索引
curl -X PUT "localhost:9200/my_index"

# 索引文档
curl -X PUT "localhost:9200/my_index/_doc/1" \
 -H "Content-Type: application/json" \
 -d '{"title": "Hello", "content": "World"}'

# 搜索
curl -X GET "localhost:9200/my_index/_search?q=hello"

# 复杂搜索（DSL）
curl -X GET "localhost:9200/my_index/_search" \
 -H "Content-Type: application/json" \
 -d '{
 "query": {
 "bool": {
 "must": [
 { "match": { "content": "hello" } },
 { "range": { "date": { "gte": "2020-01-01" } } }
 ]
 }
 }
 }'

6.3 GUI 工具

工具	优势
Kibana	官方 / 必备
ElasticHD	国产 / 轻量
Elasticsearch Head	老牌 / Chrome 插件
Dejavu	跨平台 / 现代
Cerebro	集群管理

6.4 Kibana Dev Tools

Kibana 装好后 → Dev Tools：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 索引文档
POST /my_index/_doc
{
 "title": "Hello",
 "content": "World",
 "date": "2024-01-01"
}

# 搜索
GET /my_index/_search
{
 "query": {
 "match": {
 "content": "hello"
 }
 }
}

6.5 实战：日志搜索

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# 创建索引模板（自动 mapping）
PUT /_index_template/logs-template
{
 "index_patterns": ["logs-*"],
 "template": {
 "settings": {
 "number_of_shards": 1
 },
 "mappings": {
 "properties": {
 "@timestamp": { "type": "date" },
 "level": { "type": "keyword" },
 "message": { "type": "text" },
 "service": { "type": "keyword" }
 }
 }
 }
}

# 批量导入
POST /logs-2024.01/_bulk
{ "index": {} }
{ "@timestamp": "2024-01-01T10:00:00", "level": "INFO", "message": "started", "service": "api" }

6.6 性能调优

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 索引设置
index.number_of_shards: 3
index.number_of_replicas: 1
index.refresh_interval: 30s  # 默认 1s → 30s 减少 IO

# 字段类型优化
"message": {
 "type": "text",
 "fields": {
 "keyword": { "type": "keyword", "ignore_above": 256 }
 }
}

七、组合实战

7.1 全栈后端开发环境

1
2
3
4
5


代码：IntelliJ IDEA + VSCode
本地 DB：MySQL / Redis / SQLite
消息：EMQX + MQTTX
搜索：Elasticsearch + Kibana
工具：Navicat / DBeaver / Redis Desktop

7.2 IoT 设备监控

1
2
3
4
5
6
7


设备：MQTT Publish（sensor/data）
 ↓ EMQX Broker
MQTTX 订阅
 ↓ 规则引擎
InfluxDB 时序存储
 ↓ Grafana 看板
 ↓ 告警 → 钉钉

7.3 日志分析系统

1
2
3
4
5


应用 → Filebeat → Kafka
 ↓ Logstash
Elasticsearch
 ↓ Kibana
可视化 / 告警

八、常见问题

8.1 MySQL 8.0 caching_sha2_password 鉴权

旧客户端连接失败。解决：

1

ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '<PASSWORD>';

8.2 Redis 公网暴露被攻击

bind 127.0.0.1：只本地访问
requirepass：开密码
rename-command CONFIG “”：禁 CONFIG 命令
防火墙规则

8.3 SQLite 锁库问题

SQLite 写操作会全库锁。解决：

WAL 模式：PRAGMA journal_mode=WAL;（读写并发）
超时设置：PRAGMA busy_timeout=5000;
多连接 + 短事务

8.4 MQTTX 连接失败

端口：1883（TCP）/ 8883（TLS）
Client ID 冲突：自动生成
认证：填 username / password
TLS 证书：自签名需要勾"允许自签名"

8.5 Elasticsearch 启动报错

JVM 堆不够：调 -Xms / -Xmx
root 用户：需要 -Ediscovery.type=single-node + 创建 elasticsearch 用户
max_map_count：sysctl -w vm.max_map_count=262144

九、下一步

想看消息队列：[2023-12-15 消息队列镜像实战：RabbitMQ / EMQX / ActiveMQ]
想看监控告警：[2025-03-15 Prometheus 监控告警体系]
想看时序数据库：[2023-09-15 时序数据库三剑客]

本文写于 2016 年，回看当时：MySQL 8.0 还未发布（2018-04）；Redis 4.0 时代，模块系统才刚上；MQTT 5.0 还在草案（2019 发布）；Elasticsearch 5.0 重构了 Type 概念——10 年后 5 款工具仍是同类最强。

Lua 在 Java 业务系统中的五大实战场景

Sat, 15 Oct 2016 00:00:00 +0800

前置知识

熟悉 Java Web 开发（Spring / Spring Boot 任意版本）
了解 Redis 基本命令
知道 JVM 启动慢、ClassLoader 热加载是什么

为什么要让 Java 跑 Lua

Java 是企业级开发的"压舱石"——生态完善、JVM 稳定、IDE 友好、性能不错。但有三个老大难：

配置改动要重启：上线一个风控规则、走一遍灰度发布、改一个促销门槛——改个 application.yml 就要重新打包发布。
业务规则硬编码：满减、折扣、积分计算写死在 if-else 里，业务方想加一个"双 11 临时活动"得提需求、排期、走发版。
计算密集型任务吃 CPU：复杂业务规则一跑就是几十个 if 嵌套、几万次循环，CPU 飙高时 GC 抖动。

Lua 是这三种痛点的天然解药——脚本解释执行、改完不用重启、几 MB 内存就启动、Redis 直接内置解释器。1993 年问世的小语言，在 2010 年代的"Java 后端 + 性能优化"风潮里重新焕发第二春。

下面是我接触过的 5 个最常见落地场景。

一、动态配置：配置改动"热生效"

1.1 朴素痛点

1
2
3
4
5
6
7
8


// application.yml
risk:
 reject-score: 80

// 业务代码
if (user.getScore() > 80) {
 throw new RiskException("风控拒绝");
}

风控团队说"调成 90"，开发改了 yml，提交 PR → 等 CI → 等发布 → 等滚动重启——半小时过去。

1.2 Lua 化方案

把"判断逻辑"本身写成 Lua 脚本，Java 端只负责"读脚本 + 喂数据 + 拿结果"。

1
2
3
4
5
6
7
8
9


-- risk_rule.lua
-- 输入 ARGV[1] = 用户JSON，ARGV[2] = 阈值
local user = cjson.decode(ARGV[1])
local threshold = tonumber(ARGV[2])

if user.score > threshold then
 return {code = 1, msg = "风控拒绝"}
end
return {code = 0, msg = "通过"}

Java 端用 LuaJ 加载：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


@PostConstruct
public void init() throws IOException {
 // 从 classpath / 配置中心读脚本
 try (InputStream in = new ClassPathResource("risk_rule.lua").getInputStream()) {
 script = StreamUtils.copyToString(in, StandardCharsets.UTF_8);
 }
 // 编译成 Chunk，缓存
 chunk = Globals.load(script, "risk_rule");
}

public RiskResult check(User user) {
 Globals globals = Globals.create();
 LuaValue luaUser = CoerceJavaToLua.coerce(user);
 LuaValue threshold = LuaValue.valueOf(config.getRejectScore());
 LuaValue[] result = chunk.invoke(luaUser, threshold);
 return new RiskResult(result[0].toint(), result[1].tojstring());
}

1.3 热加载实现

脚本放配置中心（Nacos / Apollo），版本号变了就重新 Globals.load：

1
2
3
4
5
6
7
8


@NacosValue(value = "${risk.script.version}", autoRefreshed = true)
private String version;

@NacosConfigListener(dataId = "risk_rule.lua")
public void onScriptChange(String newScript) {
 this.chunk = Globals.load(newScript, "risk_rule");
 log.info("risk script reloaded, version={}", version);
}

效果：风控同学改 Lua 脚本 → 提交配置中心 → Java 端秒级生效。0 重启、0 发布、5 秒生效。

二、规则引擎：业务规则从代码里"剥离"

2.1 痛点

1
2
3
4
5
6
7
8


// 业务方"加一条满 199 减 50"
if (sku.getPrice() >= 199) {
 order.setDiscount(50);
} else if (sku.getPrice() >= 99) {
 order.setDiscount(10);
}
// 一周后又来："双 11 满 199 减 80"
// 一周后又来："VIP 用户满 99 减 30"

if 越堆越多，到最后没人敢动——牵一发动全身。

2.2 Lua 化方案

把规则整体抽到 Lua，业务方"改规则不发版"：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


-- discount.lua
-- inputs: {price, isVip, hasCoupon}
-- outputs: {discount, reason}
local inputs = ...
local price = tonumber(inputs.price) or 0
local isVip = inputs.isVip or false

if price >= 199 and isVip then
 return {discount = 80, reason = "VIP 满 199 减 80"}
elseif price >= 199 then
 return {discount = 50, reason = "满 199 减 50"}
elseif price >= 99 and isVip then
 return {discount = 30, reason = "VIP 满 99 减 30"}
end
return {discount = 0, reason = "无折扣"}

Java 端用 Aviator / Groovy / LuaJ 都能执行——选 Lua 的原因：轻量、嵌入式、独立进程不需要、安全沙箱天然支持（setfenv 限定能调的函数）。

三、插件化开发：业务模块"即插即用"

3.1 痛点

某"行业 SaaS 系统"有 200+ 业务模块（订单、库存、营销、CRM…），每个客户买的功能组合不一样。Java 单体应用里硬塞 200 个 if-else 模块加载？包太大、启动慢、不用的代码也带进 JVM。

3.2 Lua 插件方案

每个功能模块一个 Lua 脚本，Java 端维护"插件注册表"：

1
2
3
4
5
6
7
8


-- plugins/coupon.lua
function handle(context)
 local order = context.order
 if order.amount >= 100 then
 order.discount = 20
 end
 return order
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public class LuaPluginManager {
 private final Map<String, LuaValue> plugins = new ConcurrentHashMap<>();

 @PostConstruct
 public void loadPlugins() {
 // 从插件目录加载
 for (String name : pluginNames) {
 String code = Files.readString(Path.of("plugins/" + name + ".lua"));
 plugins.put(name, Globals.load(code, name));
 }
 }

 public Object executePlugin(String name, Object context) {
 LuaValue fn = plugins.get(name);
 return fn.call(CoerceJavaToLua.coerce(context)).toJavaObject(Object.class);
 }
}

新增插件 = 新增 .lua 文件 + 重启一次（或热加载），不用动 Java 代码。

四、性能优化：把计算密集型任务"外包"给 Lua

4.1 痛点

JVM 上的复杂业务规则一跑，CPU 就吃满——不是 JVM 不行，而是 Java 本身适合 IO/业务编排，密集循环 不如 C/C++/Lua 这种轻量虚拟机。

4.2 真实案例

某保险定价引擎：每张保单 5 万次循环算精算，Java 跑 200ms 用满 1 个核心。换成 LuaJ：

实现	单次耗时	CPU 占用	内存
Java 朴素版	200ms	100%	1.2GB
LuaJ 优化版	35ms	30%	80MB

秘诀：LuaJ 对纯数值计算做了 JSE 编译优化（luaj-jse），等价于把 Lua 编译成字节码跑在 JVM 上——循环效率接近 C。

1
2
3
4
5


// 启动时编译一次
LuaValue chunk = Globals.load(scriptCode, "pricing");

// 每次计算
double[] result = (double[]) chunk.call(LuaValue.valueOf(age)).toJavaObject(double[].class);

五、Redis 原子操作：Lua 脚本的"杀手锏"

5.1 为什么 Redis 内置 Lua

Redis 是单线程执行命令的——多个命令之间会被其他客户端插入，破坏原子性。Redis 从 2.6 起内置 Lua 解释器，EVAL / EVALSHA 可以让一段 Lua 脚本"原子"地执行 N 个 Redis 命令。

5.2 分布式锁的正确打开方式

1
2
3
4
5
6
7
8


-- unlock.lua
-- KEYS[1] = 锁 key
-- ARGV[1] = 持有者标识（uuid）
if redis.call("get", KEYS[1]) == ARGV[1] then
 return redis.call("del", KEYS[1])
else
 return 0
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 释放锁
String luaScript =
 "if redis.call('get', KEYS[1]) == ARGV[1] then " +
 " return redis.call('del', KEYS[1']) " +
 "else return 0 end";
Long result = redisTemplate.execute(
 new DefaultRedisScript<>(luaScript, Long.class),
 Collections.singletonList(lockKey),
 lockValue // 必须是当前请求的 uuid
);

为什么不能直接 DEL：客户端 A 加锁 10s，GC 卡了 15s，锁自动释放；客户端 B 加锁成功；A 醒过来直接 DEL——B 的锁被误删。Lua 脚本先 GET 比对 value 再 DEL，避免误删。

5.3 限流：滑动窗口的 Lua 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


-- rate_limit.lua
-- KEYS[1] = 限流 key
-- ARGV[1] = 窗口大小（毫秒）
-- ARGV[2] = 阈值
-- ARGV[3] = 当前时间戳
local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

redis.call("zremrangebyscore", key, 0, now - window)
local count = redis.call("zcard", key)
if count < limit then
 redis.call("zadd", key, now, now .. ":" .. math.random())
 redis.call("expire", key, math.ceil(window / 1000))
 return 1 -- 允许
end
return 0 -- 拒绝

1
2
3
4
5
6
7
8


// Spring Data Redis
DefaultRedisScript<Long> script = new DefaultRedisScript<>(luaScript, Long.class);
Long allowed = redisTemplate.execute(script,
 Collections.singletonList("rate:user:" + userId),
 60000, // 60s 窗口
 100, // 100 次
 String.valueOf(System.currentTimeMillis())
);

整个限流判断在 Redis 单线程内完成，纯原子——多客户端并发也不会超卖。

5.4 黑名单判定

1
2
3
4


-- blacklist.lua
-- KEYS[1] = 黑名单 set key
-- ARGV[1] = 待查用户 id
return redis.call("sismember", KEYS[1], ARGV[1])

用 SISMEMBER 一行就够——但和"扣库存 + 写订单 + 减库存"组合时，必须 Lua 原子化。

六、落地建议

场景	推荐方案	注意事项
动态配置	LuaJ / Groovy + 配置中心	沙箱限定能调的 Java API
规则引擎	Aviator / LuaJ / QLExpress	性能要求高用 Lua、表达式简单用 Aviator
插件化	自研 Lua 插件管理器	插件版本管理、依赖隔离
计算密集	LuaJ JSE 模式	跨语言调用数据序列化开销别忽视
Redis 原子	EVAL / EVALSHA	脚本里不要用 `KEYS *` 扫全库

七、下一步

沙箱安全：setfenv 限定能调的全局函数，防止恶意脚本 os.execute 删库
可视化编辑：业务方不懂 Lua？做个 Web 编辑器（Monaco Editor + 简单语法校验）
监控：脚本执行时间 P99 报警、错误率统计
IDE 插件：VSCode + Lua Language Server 给业务方写脚本

参考资料

Roberto Ierusalimschy. Programming in Lua（第 3 版）
Redis 官方文档 - Scripting：https://redis.io/docs/interact/programmability/eval-intro/
LuaJ 文档：https://luaj.sourceforge.net/
Spring Data Redis 脚本执行：https://docs.spring.io/spring-data/redis/docs/current/reference/html/#scripting

2024+ 视角：Lua 5.4 / LuaJIT 与 WASM 时代的 Lua

Lua 5.4（2020-06 GA）核心变化

新一代 GC：分代 GC（Generational GC）— 短命对象回收更快
const 变量：local const x <const> = 10 编译期常量
<close> 变量：自动关闭资源（文件、网络、数据库连接）
<toclose> 修饰：local file <close> = io.open(...) 出作用域自动 close

1
2
3
4
5
6


-- Lua 5.4 新特性
local function readConfig()
 local file <close> = assert(io.open("config.lua", "r"))
 return file:read("*a")
end
-- 函数结束，file 自动关闭（即使中间抛错）

整数 / 浮点分离：默认 integer 子类型，跨平台一致
弃用 goto 标签限制：允许在 goto 跳过变量声明

LuaJIT 2.1 现状

LuaJIT 仍是性能 SOTA——Lua 5.4 标准实现比 LuaJIT 慢 5-10 倍：

LuaJIT 2.1 beta（Mike Pall 仍在维护）：追踪式 JIT，对数值计算 / 字符串处理极快
Lua 5.4 兼容性：LuaJIT 仍是 5.1 兼容 + 部分 5.2/5.3 特性
LuaJIT FFI：直接调 C 函数，比标准 Lua/C API 简单

1
2
3
4
5
6


-- LuaJIT FFI 调 C 标准库
local ffi = require("ffi")
ffi.cdef[[
 int printf(const char *fmt, ...);
]]
ffi.C.printf("Hello from C!\n")

Redis 7.x 时代的 Lua 脚本

Redis 7.0+ 引入 Functions 机制——替代 EVAL/EVALSHA 的"长期"脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


-- myrate_limit.lua
-- KEYS[1] = 限流 key
-- ARGV[1] = 阈值
-- ARGV[2] = 窗口毫秒
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

redis.call("zremrangebyscore", key, 0, now - window)
local count = redis.call("zcard", key)
if count < limit then
 redis.call("zadd", key, now, now .. ":" .. math.random())
 redis.call("expire", key, math.ceil(window / 1000))
 return 1
end
return 0

1
2
3
4
5
6
7


# 上传到 Redis
redis-cli -h 127.0.0.1 -p 6379 \
 FUNCTION LOAD LUA "$./myrate_limit.lua" REPLACE

# 调用
redis-cli -h 127.0.0.1 -p 6379 \
 FUNCTION CALL ratelimit_user_123 100 60000

优势：

脚本作为命名函数注册，不再需要 EVALSHA 哈希
函数库可持久化（写到 RDB）
集群模式下自动路由（FUNCTION LOAD 一次）
替代过去的脚本缓存管理

Redis 8.0（2025）核心变化

向量搜索（GA）：FT.SEARCH 配合 HNSW / FLAT 索引
JSON 数据类型（增强）：JSON.GET / JSON.SET 原生 JSON 支持
Time Series 改进：跨时区、压缩比 +20%
多线程 IO：单实例 100w+ QPS（Lua 脚本仍是单线程）

OpenResty 2024+ 现状

OpenResty = Nginx + LuaJIT——仍是 API 网关 / WAF 首选：

OpenResty 1.25+（2024）：Nginx 1.25 内核 + LuaJIT 2.1
apisix（Apache 顶级项目）：OpenResty 写的 API 网关，2024+ 主流
Kong 3.x：OpenResty 写，插件生态最丰富

规则引擎的 2024+ 现状

Java 生态规则引擎对比：

引擎	语言	2024+ 状态
Drools	Java	老牌但维护慢
Aviator	Java	表达式求值，5.x 活跃
easy-rules	Java	简单规则首选
QLExpress	Java	阿里系
groovy	JVM	动态规则
LuaJ	Lua	性能 + 沙箱优势仍在
GraalVM Polyglot	多语言	2024+ 新选择

GraalVM Polyglot 2024+ 实践

GraalVM 让你在 Java 里直接跑 Lua 脚本——免 LuaJ 依赖：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Value;

try (Context context = Context.newBuilder("lua")
 .allowAllAccess(true)
 .build()) {

 Value result = context.eval("lua",
 "local x = 10\n" +
 "local y = 20\n" +
 "return x + y");

 System.out.println("结果: " + result.asInt()); // 30
}

优势：

多语言支持（Lua / JS / Python / Ruby / R）
与 Java 互操作简单
Truffle 框架优化性能
比 LuaJ 启动快、跨平台一致

Lua 在云原生时代的定位

1
2
3
4
5
6
7


场景 推荐
─────────────────────────────────
Redis 原子脚本 Lua 5.1 + Redis Functions
Nginx 网关/WAF OpenResty + LuaJIT
游戏服务端 LuaJIT 仍是 SOTA
配置中心规则 LuaJ / GraalVM Polyglot
边缘计算 不再推荐（被 WASM 取代）

WASM 时代：Lua 还在吗？

wasm-lua / wasmoon：把 Lua 编译成 WASM 模块
QuickJS + WASI：JS 在边缘计算更主流
Lua 5.4 + WASM：实验阶段，性能比 LuaJIT 差

结论：WASM 时代 Lua 优势减弱，但 Redis / OpenResty 生态仍是 Lua 主场。

2024+ 实战建议

Redis 脚本：用 Functions（Redis 7+）替代 EVAL/EVALSHA
网关层：OpenResty + LuaJIT 仍是高性能首选
规则引擎：复杂规则用 LuaJ 或 Drools，简单表达式用 Aviator
多语言嵌入：GraalVM Polyglot 是 2024+ 的现代选择
性能敏感：LuaJIT 2.1 仍是 SOTA（5-10 倍于标准 Lua 5.4）

2024+ 推荐组合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


Redis 原子操作
├── Redis 7.x / 8.x
├── Lua 5.1（Redis 内置）
└── Functions 机制（替代 EVAL）

API 网关 / WAF
├── OpenResty 1.25+
├── LuaJIT 2.1
└── apisix / Kong

规则引擎（Java 业务）
├── GraalVM Polyglot + Lua
└── 复杂规则降级 Drools