分布式架构、高并发、微服务

50 章完整教程 · 从零基础到架构师

零基础友好 · 每个概念都用大白话讲透 · 含大量代码示例与架构图 · 涵盖 Redis/Kafka/Nacos/Spring Cloud/Docker/K8s

第一章:开篇——为什么要学分布式与微服务?

1.1 一个真实的场景

假设你开了一家小饭馆。一开始,你一个人既是厨师、又是收银员、又是服务员。客人不多的时候,完全忙得过来。这就是单体架构——所有功能都在一个系统里,简单、直接、好管理。

但有一天,你的饭馆火了。门口排起了长队,你一个人根本忙不过来。于是你开始招人:一个专职厨师、一个收银员、两个服务员。每个人只负责一件事,但配合起来效率极高。这就是微服务架构——把一个大系统拆成多个小服务,各司其职。

再后来,你的饭馆成了连锁品牌,全城有 50 家分店。你需要一套系统来管理所有分店的库存、订单、会员。这套系统每秒钟要处理上万次请求——双十一那天更是要扛住 10 倍的流量。这就是高并发——系统要能同时处理海量请求,不能崩。

一句话总结

分布式 = 把事情分给多台机器一起干
高并发 = 同时扛住大量用户的请求
微服务 = 把一个大系统拆成多个小服务

1.2 行业现状与薪资前景

不管你是在校学生还是工作几年的开发者,掌握分布式和微服务技术都是涨薪最快的路径之一。来看看真实的数据:

技术栈初级(1-3年)中级(3-5年)高级(5年+)
单体架构8-12K12-18K18-25K
微服务架构12-18K18-30K30-50K
分布式+高并发15-20K25-40K40-70K+
为什么薪资差这么多? 因为能搞定分布式和高并发的人,解决的是系统能不能扛住、能不能扩展的核心问题。这直接决定了公司的业务能不能做大。老板愿意为这种能力付高薪。

1.3 哪些公司在用这些技术?

几乎所有互联网大厂和中大型公司都在用分布式微服务架构:

1.4 学习路线图

本教程按照以下顺序组织,建议从头到尾循序渐进:

1
基础认知(第1-5章):搞懂什么是分布式、高并发、微服务,打好计算机基础
2
理论基础(第6-10章):CAP、BASE、共识算法、分布式事务——这些是面试必考、架构设计的根基
3
核心组件(第11-18章):Redis、Kafka、分布式锁、配置中心——每个都是实际项目中天天用的
4
高并发设计(第19-26章):IO模型、负载均衡、分库分表、缓存、限流——让系统扛住流量的核心技术
5
微服务架构(第27-36章):Spring Cloud全家桶、服务治理、安全——企业级微服务落地
6
云原生(第37-42章):Docker、K8s、服务网格、CI/CD——现代部署必备
7
监控运维(第43-46章):日志、监控、压测、故障排查——线上问题不求人
8
综合实战(第47-50章):秒杀系统、Feed流、数据大屏——把所有知识串起来

第二章:一切的起点——单体架构

2.1 什么是单体架构?

单体架构(Monolithic Architecture)就是把一个应用的所有功能——用户管理、订单处理、支付、通知——全部写在一个项目里,打包成一个部署单元(比如一个 JAR 包或一个 WAR 包),部署在一台服务器上。

生活类比

单体架构就像一个全能型小店:老板一个人既当厨师、又当收银、又当服务员、又当采购。好处是成本低、管理简单;坏处是一旦老板病了,整个店就停摆了。

典型的单体项目结构
my-shop/
├── src/
│   ├── controller/        ← 所有接口都在这里
│   │   ├── UserController.java
│   │   ├── OrderController.java
│   │   ├── PayController.java
│   │   └── NotifyController.java
│   ├── service/           ← 所有业务逻辑都在这里
│   │   ├── UserService.java
│   │   ├── OrderService.java
│   │   ├── PayService.java
│   │   └── NotifyService.java
│   ├── mapper/            ← 所有数据库操作都在这里
│   └── entity/            ← 所有实体类都在这里
├── pom.xml                ← 一个项目、一个配置文件
└── application.yml

2.2 单体架构的优点

别小看单体架构,它在很多场景下是最佳选择:

什么时候单体架构就够用了? 如果你的系统日活用户在 1 万以下,团队在 5 人以下,业务逻辑不太复杂——用单体架构就够了。不要为了"高大上"而强行上微服务,那只会增加不必要的复杂度。

2.3 单体架构的问题

当业务增长到一定程度,单体架构的问题就会暴露出来:

问题具体表现后果
代码耦合改一个功能可能影响其他功能开发效率越来越低,改一个 bug 冒出三个
部署风险改一行代码就要重新部署整个系统每次上线都心惊胆战
无法水平扩展订单模块压力大,但只能整体扩容浪费服务器资源,成本飙升
技术栈绑定整个项目只能用一种语言和框架无法根据场景选择最合适的技术
团队协作困难20 个人改同一个代码仓库代码冲突不断,合并痛苦
类比:单体架构的崩溃时刻

想象一个自助餐厅:一开始只有 10 个菜品,一个厨师就能搞定。后来菜品增加到 100 个,一个厨房根本放不下那么多锅碗瓢盆。更要命的是,做菜的油烟会飘到甜品区,做甜品的面粉会飘到炒菜区——互相干扰。你需要把它们拆成独立的厨房。

2.4 什么时候该拆分?

当你的系统出现以下信号时,就该考虑从单体转向微服务了:

1
部署频率越来越高:每次改一行代码都要重新部署整个系统,上线变成一件"大事"
2
团队规模增长:超过 10 个开发同时改一个项目,代码冲突频繁
3
性能瓶颈:某个模块(如订单)压力特别大,但只能整体扩容
4
故障扩散:一个模块的 bug 导致整个系统崩溃
5
技术债务:代码越来越难维护,新功能开发速度明显变慢

第三章:核心概念扫盲——分布式、高并发、微服务

3.1 什么是分布式系统?

分布式系统(Distributed System)的定义很简单:一组通过网络互相通信、协同工作的计算机,对外表现为一个整体。

生活类比

分布式系统就像一个快递公司:全国有成千上万个网点(节点),每个网点只负责自己区域的收发(分工),但它们通过统一的系统协同工作——你在新疆下单,北京的仓库发货,中间经过多个中转站,最终送到你手上。你不需要知道包裹经过了哪些站,你只知道"下单→收货"。

分布式系统的核心特征:

分布式 ≠ 集群 很多人搞混这两个概念。集群是多台机器做同一件事(比如 3 台服务器都部署了同一个应用)。分布式是多台机器做不同的事,合起来完成一个大任务。集群是"多人做同一件事",分布式是"多人做不同的事"。

3.2 什么是高并发?

高并发(High Concurrency)是指系统在同一时间内需要处理大量并发请求的能力。注意两个关键词:同一时间和大量请求。

指标含义小系统中型系统大型系统
QPS每秒查询数<1001,000-10,000100,000+
TPS每秒事务数<50500-5,00050,000+
并发数同时在线用户<5005,000-50,0001,000,000+
响应时间单次请求耗时不限<200ms<50ms
生活类比

高并发就像春运抢票:同一秒钟有 100 万人在刷 12306 买票。系统要同时处理这 100 万个请求——有人在查询余票、有人在下单、有人在支付、有人在退票。如果系统扛不住,就会崩溃("服务器繁忙"),用户体验极差。

3.3 什么是微服务?

微服务架构(Microservices Architecture)是一种架构风格:把一个大型应用拆分成一组小型、独立、可独立部署的服务。每个服务:

┌─────────────────────────────────────────────────────┐ │ API 网关 │ │ (统一入口、路由、鉴权) │ └──────┬──────────┬──────────┬──────────┬─────────────┘ │ │ │ │ ▼ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │用户服务 │ │订单服务 │ │商品服务 │ │支付服务 │ │ │ │ │ │ │ │ │ │ MySQL │ │ MySQL │ │ Redis │ │ MySQL │ └─────────┘ └─────────┘ └─────────┘ └─────────┘

3.4 三者的关系

分布式、高并发、微服务三者不是独立的,而是紧密关联的:

1
微服务是架构设计:决定"怎么拆"——把大系统拆成小服务
2
分布式是部署方式:决定"怎么跑"——把拆好的服务部署到多台机器上
3
高并发是性能目标:决定"怎么扛"——让系统能同时处理大量请求
简单来说 微服务告诉你"把系统拆成哪些零件",分布式告诉你"这些零件怎么分布在多台机器上",高并发告诉你"怎么让这些零件配合起来扛住海量流量"。三者缺一不可。

第四章:计算机基础回顾——进程、线程、协程

4.1 为什么需要了解这些?

分布式和高并发的底层,都离不开并发编程。而并发编程的基础,就是理解进程、线程、协程。如果你不理解这些,后面学再多框架也是空中楼阁。

4.2 进程:程序的一次执行

进程(Process)是操作系统分配资源的最小单位。简单来说,你每打开一个应用程序,操作系统就为它创建一个进程。

生活类比

进程就像一家公司:每个公司有自己独立的办公室(内存空间)、独立的财务(资源)、独立的员工(线程)。公司之间互不干扰——A 公司倒闭了不会影响 B 公司。

Java 中查看和创建进程
// 每个 Java 应用启动后就是一个进程
// 在命令行中查看 Java 进程
// jps -l

// 进程之间是隔离的,不能直接访问对方的内存
// 进程 A 的变量 x 和进程 B 的变量 x 是完全独立的

4.3 线程:进程中的执行单元

线程(Thread)是 CPU 调度的最小单位。一个进程可以包含多个线程,它们共享进程的内存空间。

生活类比

线程就像公司里的员工:同一个公司的员工共享办公室、共享打印机、共享会议室(共享内存)。但每个员工有自己的工位和任务(独立的栈和程序计数器)。

Java 创建线程的几种方式
// 方式1:继承 Thread 类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行: " + Thread.currentThread().getName());
    }
}
new MyThread().start();

// 方式2:实现 Runnable 接口(推荐)
new Thread(() -> {
    System.out.println("线程运行: " + Thread.currentThread().getName());
}).start();

// 方式3:线程池(生产环境推荐)
ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(() -> System.out.println("线程池执行任务"));
pool.shutdown();

4.4 进程 vs 线程 vs 协程

对比项进程线程协程
定义资源分配的最小单位CPU调度的最小单位用户态的轻量级线程
内存独立内存空间共享进程内存共享线程内存
切换开销最大(需切换内存映射)中等(需切换内核态)最小(用户态切换)
创建开销大(几MB内存)中(几KB栈空间)极小(几百字节)
数量几十个几百到几千个几十万个
代表技术Linux forkJava ThreadGo goroutine
为什么 Go 语言在高并发领域这么火? 因为 Go 的 goroutine 是协程,创建一个 goroutine 只需要几 KB 内存,一台服务器可以轻松创建几十万个。而 Java 的线程每个至少需要 1MB 栈空间,1000 个线程就要 1GB 内存。这就是为什么 Go 天生适合高并发。

4.5 Java 21 虚拟线程(Virtual Threads)

Java 21 引入了虚拟线程(Project Loom),这是 Java 并发编程的一次革命。虚拟线程由 JVM 而非操作系统管理,轻量级程度接近 Go 的 goroutine。

虚拟线程 vs 平台线程

平台线程(传统线程)就像正式员工:每人一间办公室(1MB栈),公司(JVM)最多养几千人。
虚拟线程就像共享工位:几千个虚拟线程共享几十个平台线程(载体线程),有人去打电话(IO阻塞)了,工位立刻让给别人用。

Java 21 虚拟线程使用
// 方式1:直接创建虚拟线程
Thread vthread = Thread.ofVirtual().name("my-vthread").start(() -> {
    System.out.println("我在虚拟线程中运行: " + Thread.currentThread());
});

// 方式2:虚拟线程池(推荐)
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // 轻松创建10万个虚拟线程
    for (int i = 0; i < 100_000; i++) {
        executor.submit(() -> {
            // IO操作时虚拟线程会自动让出载体线程
            Thread.sleep(Duration.ofSeconds(1));
            return "done";
        });
    }
}  // 自动关闭

// 方式3:Spring Boot 3.2+ 配置虚拟线程
// application.yml
// spring:
//   threads:
//     virtual:
//       enabled: true
对比项平台线程虚拟线程Go goroutine
管理方操作系统JVMGo Runtime
内存开销~1MB/线程~几KB/线程~几KB/goroutine
创建数量几千个百万级百万级
阻塞代价占用OS线程自动卸载载体线程自动切换
适用场景CPU密集IO密集IO密集
虚拟线程的核心价值 以前 Java 处理高并发需要引入 WebFlux、CompletableFuture 等异步编程模型,代码复杂难维护。有了虚拟线程,用同步写法就能获得异步的性能——每个请求一个虚拟线程,阻塞时自动让出 CPU,无需改代码。

4.6 线程安全问题

当多个线程同时访问共享资源时,就会出现线程安全问题。这是并发编程中最常见也最危险的 bug。

经典的线程安全问题:卖票
// 假设还剩 1 张票,两个线程同时来买
int tickets = 1;  // 共享变量

// 线程 A 执行:
if (tickets > 0) {     // A 读到 tickets=1,条件成立
    // ← 这里线程 B 也读到 tickets=1
    tickets = tickets - 1;  // A 买票成功,tickets=0
}
// 线程 B 执行:
// B 之前已经读到 tickets=1,继续执行
tickets = tickets - 1;  // B 也买票成功,tickets=-1 ← 超卖了!

// 结果:1 张票卖给了 2 个人!

解决方案:

使用 synchronized 加锁
synchronized (lock) {
    if (tickets > 0) {
        tickets = tickets - 1;
        System.out.println("买票成功,剩余: " + tickets);
    }
}
// 同一时刻只有一个线程能进入这个代码块,避免了超卖

第五章:网络基础——TCP/IP、HTTP、RPC

5.1 为什么分布式系统必须懂网络?

分布式系统的核心就是多台机器通过网络通信。如果不懂网络,你就无法理解服务之间是怎么调用的、为什么会有延迟、为什么会丢数据。

5.2 OSI 七层模型与 TCP/IP 四层模型

应用层
HTTP、FTP、DNS、RPC你写的代码直接打交道的层
传输层
TCP、UDP保证数据可靠传输(TCP)或追求速度(UDP)
网络层
IP、ICMP负责寻址和路由,找到目标机器
链路层
以太网、WiFi物理传输,网线/光纤/无线信号

5.3 TCP 三次握手与四次挥手

TCP 是面向连接的协议。在传输数据之前,必须先"握手"建立连接。这是面试高频考点,也是理解网络通信的基础。

三次握手就像打电话

你:"喂,能听到吗?"(SYN)
对方:"能听到,你能听到我吗?"(SYN+ACK)
你:"我也能听到,咱们开始聊吧。"(ACK)
至此,双方都确认了对方能听到,通话正式开始。

客户端 服务器 | | |-------- SYN (seq=x) -------->| 第1次握手:客户端发起连接 | | |--- SYN+ACK (seq=y,ack=x+1) ->| 第2次握手:服务器确认并回复 | | |-------- ACK (ack=y+1) ------>| 第3次握手:客户端确认 | | |======= 连接建立,开始传数据 =======|

5.4 HTTP 协议详解

HTTP 是应用层协议,也是微服务之间最常用的通信方式。你需要掌握的核心内容:

HTTP 请求报文结构
POST /api/users HTTP/1.1              ← 请求行:方法 + 路径 + 版本
Host: www.example.com                 ← 请求头
Content-Type: application/json
Authorization: Bearer eyJhbGciOi...
Content-Length: 42

{"name":"张三","age":25}              ← 请求体
HTTP 响应报文结构
HTTP/1.1 200 OK                       ← 状态行:版本 + 状态码 + 描述
Content-Type: application/json        ← 响应头
Content-Length: 53

{"id":1,"name":"张三","age":25}       ← 响应体
状态码含义常见场景
200成功请求正常处理
301/302重定向URL 变更、短链接跳转
400客户端错误参数格式错误
401未认证未登录或 Token 过期
403无权限登录了但没有访问权限
404未找到URL 不存在
500服务器错误代码抛异常了
502网关错误后端服务挂了
503服务不可用服务器过载或维护

5.5 RPC:远程过程调用

微服务之间调用,用 HTTP(RESTful)当然可以,但性能不是最优。RPC(Remote Procedure Call)是一种更高效的通信方式——让你调用远程方法就像调用本地方法一样。

RPC vs HTTP 对比
// HTTP 调用方式(RESTful)
Response resp = httpClient.post("http://user-service/api/users", body);
User user = JSON.parse(resp.body());

// RPC 调用方式(gRPC/Dubbo)
// 就像调用本地方法一样,完全不用关心网络细节
User user = userService.getUserById(123);
对比项HTTP (RESTful)RPC (gRPC/Dubbo)
协议HTTP/1.1 或 HTTP/2自定义二进制协议
序列化JSON(文本,体积大)Protobuf(二进制,体积小)
性能一般高性能(比 HTTP 快 2-5 倍)
易用性简单直观需要定义接口文件(.proto)
跨语言天然支持需要代码生成
适用场景对外 API、前后端交互内部服务间调用

5.6 gRPC 实战:定义 .proto 文件

gRPC 使用 Protocol Buffers(Protobuf)作为接口定义语言。先定义 .proto 文件,然后自动生成各语言的客户端和服务端代码。

user.proto — 用户服务接口定义
syntax = "proto3";

option java_package = "com.example.user";
option java_outer_classname = "UserProto";

// 用户服务定义
service UserService {
    // 获取用户(一元调用)
    rpc GetUser (GetUserRequest) returns (UserResponse);

    // 批量获取(服务端流式)
    rpc ListUsers (ListUsersRequest) returns (stream UserResponse);

    // 实时聊天(双向流式)
    rpc Chat (stream ChatMessage) returns (stream ChatMessage);
}

// 请求消息
message GetUserRequest {
    int64 id = 1;
}

message ListUsersRequest {
    repeated int64 ids = 1;
}

// 响应消息
message UserResponse {
    int64 id = 1;
    string name = 2;
    string email = 3;
    int32 age = 4;
}

message ChatMessage {
    string user = 1;
    string content = 2;
    int64 timestamp = 3;
}

// 生成Java代码:
// protoc --java_out=./src user.proto
// 或使用Gradle插件自动编译
gRPC 服务端实现(Java)
// 继承生成的抽象类,实现接口
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {

    @Override
    public void getUser(GetUserRequest request,
                        StreamObserver<UserResponse> responseObserver) {
        // 查询用户
        User user = userDao.findById(request.getId());
        // 构建响应
        UserResponse response = UserResponse.newBuilder()
            .setId(user.getId())
            .setName(user.getName())
            .setEmail(user.getEmail())
            .setAge(user.getAge())
            .build();
        // 返回结果
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

// 启动gRPC服务器
Server server = ServerBuilder.forPort(9090)
    .addService(new UserServiceImpl())
    .build()
    .start();
实际项目中的选择 对外暴露的 API 用 HTTP(RESTful),内部服务之间的调用用 RPC(gRPC 或 Dubbo)。这是业界的最佳实践。

第六章:CAP定理——分布式系统的不可能三角

6.1 什么是CAP定理?

CAP定理是分布式系统中最重要的理论,由加州大学的Eric Brewer教授在2000年提出。它告诉我们:在一个分布式系统中,最多只能同时满足以下三个特性中的两个:

C
Consistency(一致性)所有节点在同一时间看到的数据是一样的。你写入的数据,所有节点立刻都能读到。
A
Availability(可用性)每个请求都能收到一个响应(不保证是最新数据)。系统不能挂,永远要能用。
P
Partition Tolerance(分区容错)网络分区(节点之间通信中断)时,系统仍然能继续工作。
生活类比:三角恋的抉择

想象你在一个异地恋的关系中(分布式系统):
一致性(C) = 你和对象的信息永远同步——你说"我在吃饭",对方立刻知道。
可用性(A) = 随时都能联系到对方——打电话永远有人接。
分区容错(P) = 即使网络断了(手机没信号),关系还能维持。

现实是:如果手机没信号(网络分区),你要么等信号恢复再联系(放弃可用性,保证一致性),要么用另一个方式联系但信息可能不同步(放弃一致性,保证可用性)。你不可能同时保证"信号断了还能实时同步信息"。

6.2 为什么P是必须满足的?

在分布式系统中,网络分区是一定会发生的——网线可能被挖断、交换机可能宕机、机房可能断电。所以 P 是必须满足的,我们实际上只能在 C 和 A 之间二选一。

重要结论 CAP定理的实际含义是:当网络分区发生时,你只能在一致性和可用性之间选一个。
- 选 CP:保证数据一致,但系统可能暂时不可用(银行系统)
- 选 AP:保证系统可用,但数据可能暂时不一致(电商系统)

6.3 CP系统 vs AP系统

对比项CP系统(强一致性)AP系统(高可用)
典型代表ZooKeeper、etcd、HBaseEureka、Cassandra、DynamoDB
核心思想数据不能错,宁可不可用系统不能挂,宁可数据暂时不一致
适用场景金融交易、库存扣减、分布式锁社交动态、商品浏览、新闻推送
用户体验可能需要等待或重试随时能用,但可能看到旧数据
一致性保证强一致最终一致

6.4 CAP定理的代码示例

以一个简单的分布式缓存为例,理解CP和AP的区别:

CP系统:写入时等待所有节点确认(强一致,但慢)
// CP策略:写入必须等所有节点都确认才算成功
public boolean cpWrite(String key, String value) {
    int successCount = 0;
    for (Node node : allNodes) {
        boolean ok = node.write(key, value);  // 同步写入每个节点
        if (ok) successCount++;
    }
    // 所有节点都写成功才返回true
    if (successCount == allNodes.length) {
        return true;
    } else {
        // 有节点失败了,回滚已成功的节点,返回false
        rollback(key);
        return false;  // 牺牲可用性:写入失败
    }
}
AP系统:写入成功一个节点就算成功(可用,但可能不一致)
// AP策略:只要有一个节点写成功就返回
public boolean apWrite(String key, String value) {
    for (Node node : allNodes) {
        try {
            node.writeAsync(key, value);  // 异步写入
            return true;  // 有一个成功就返回
        } catch (Exception e) {
            continue;  // 失败了就试下一个节点
        }
    }
    return false;  // 所有节点都失败
}
// 后台线程会慢慢把数据同步到其他节点(最终一致性)

第七章:BASE理论——CAP的妥协方案

7.1 为什么需要BASE?

CAP定理告诉我们"鱼和熊掌不可兼得",但在实际业务中,我们既不能完全放弃一致性(钱不能算错),也不能完全放弃可用性(系统不能挂)。怎么办?

BASE理论就是对CAP中AP方案的进一步补充——既然做不到"强一致",那就做到"最终一致"。

7.2 BASE的三个核心思想

BA
Basically Available(基本可用)系统出现故障时,允许损失部分功能或性能,但核心功能必须可用。比如:大促时商品详情页可以降级显示缓存数据,但下单功能必须正常。
S
Soft State(软状态)允许系统中的数据存在中间状态,这个中间状态不影响系统的整体可用性。比如:订单"支付中"、数据"同步中"。
E
Eventually Consistent(最终一致性)经过一段时间的同步后,系统所有节点的数据最终会达到一致。不需要实时一致,但最终要一致。
生活类比:微信群消息

你在微信群发了一条消息。你发出去的瞬间,群里100个人不一定同时收到——有人网络好秒收,有人网络差可能延迟几秒。但最终,所有人都会收到这条消息。这就是"最终一致性"。

如果要求"强一致性",那就得等所有人都收到消息后,你才能继续发下一条——这太慢了,体验极差。

7.3 最终一致性的常见实现模式

1
读时修复:读取数据时,发现某个节点的数据是旧的,从其他节点同步最新数据过来
2
写时修复:写入数据时,同时更新所有节点(异步),失败的节点后续重试
3
定时同步:后台定时任务扫描各节点数据,发现不一致就修复
4
消息队列:写入成功后发消息通知其他节点更新,保证最终一致

7.4 BASE在实际项目中的应用

电商下单场景:BASE思想的实际应用
// 用户下单后,需要:
// 1. 创建订单(MySQL)
// 2. 扣减库存(Redis + MySQL)
// 3. 通知用户(短信/推送)
// 4. 更新统计数据(ES/数据仓库)

// 用BASE思想来设计:
public void createOrder(Order order) {
    // 1. 核心操作:同步执行,必须成功
    orderDao.save(order);           // 写入订单
    stockService.deduct(order);     // 扣减库存

    // 2. 非核心操作:异步执行,允许延迟
    mq.send("order_created", order); // 发消息到MQ
    // ↓ 以下操作由MQ消费者异步处理
    // - 短信通知用户(允许延迟几秒)
    // - 更新ES索引(允许延迟几秒)
    // - 更新统计报表(允许延迟几分钟)
}
BASE理论的核心思想 把操作分为"核心操作"和"非核心操作"。核心操作同步执行,保证强一致;非核心操作异步执行,允许最终一致。这样既保证了数据正确性,又保证了系统性能和可用性。

第八章:分布式共识——Paxos与Raft

8.1 什么是分布式共识?

分布式共识(Consensus)是指:在分布式系统中,多个节点就某个值达成一致。听起来简单,但在网络可能分区、节点可能宕机的情况下,这非常困难。

生活类比:微信群投票

你们10个人在微信群里投票决定今晚吃什么。问题是:
- 有人可能没看到消息(节点故障)
- 有人可能网络延迟收到重复消息(消息重复)
- 有人可能同时发起不同的投票(并发冲突)

你需要一个规则,让所有人最终达成一致的决定——这就是共识算法要解决的问题。

8.2 Paxos算法(了解即可)

Paxos是第一个被证明可行的共识算法,由Leslie Lamport在1990年提出。它非常正确但也非常难懂,连Lamport自己用故事形式描述都被吐槽看不懂。

Paxos的核心思想是多数派投票:只要超过半数的节点同意一个值,这个值就被接受了。

Paxos 的两个阶段: 阶段1 - Prepare(准备阶段): Proposer → 所有Acceptor:我要提议一个值,你们有没有更高的提议号? Acceptor → Proposer:我没有更高的,我承诺不接受比你低的提议 阶段2 - Accept(接受阶段): Proposer → 所有Acceptor:我的提议号是N,值是V,你们接受吗? Acceptor → Proposer:我接受!(超过半数接受就算通过) 关键点:超过半数(N/2 + 1)同意就算达成共识
Paxos的痛点 Paxos虽然理论完美,但工程实现极其复杂。Google的Chubby团队花了几年才实现一个正确的Paxos。所以后来有了Raft——一个"为了可理解性而设计"的共识算法。

8.3 Raft算法(重点掌握)

Raft是2014年提出的共识算法,它的目标就是让工程师能看懂。目前几乎所有主流分布式系统(etcd、Consul、Nacos CP模式)都用Raft。

Raft把共识问题分解成三个子问题:

1
Leader选举:从所有节点中选出一个Leader,所有写操作都由Leader处理
2
日志复制:Leader把写操作复制到所有Follower节点
3
安全性:保证所有节点最终执行相同的命令序列,状态一致

Leader选举过程

所有节点初始状态都是 Follower │ ▼ Follower 等待 Leader 心跳超时(选举超时) │ ▼ Follower 变成 Candidate,发起投票请求 │ ▼ 其他节点投票(每个节点只能投一票) │ ┌────┴────┐ ▼ ▼ 获得多数票 未获得多数票 │ │ ▼ ▼ 成为 Leader 等待超时,重新选举 │ ▼ Leader 定期发送心跳,维持权威

日志复制过程

Client Leader Follower1 Follower2 │ │ │ │ │──写请求─────>│ │ │ │ │──追加日志──────>│ │ │ │──追加日志─────────────────────>│ │ │ │ │ │ │<──确认─────────│ │ │ │<──确认──────────────────────│ │ │ (收到多数确认) │ │──提交─────────>│ │ │ │──提交──────────────────────│ │<──响应──────│ │ │
Raft的关键数字:多数派 3个节点最多容忍1个故障,5个节点最多容忍2个故障。公式:N个节点最多容忍 (N-1)/2 个故障。所以生产环境通常用3或5个节点。

第九章:分布式事务——2PC、TCC与Saga

9.1 什么是分布式事务?

在单体架构中,一个数据库事务就能保证数据一致性。但在微服务架构中,一个业务操作可能涉及多个服务、多个数据库——跨服务的事务就是分布式事务。

生活类比:转账

你从工商银行转1000元到建设银行。这个操作涉及两家银行:
1. 工商银行:扣你1000元
2. 建设银行:给对方加1000元

这两步必须要么都成功,要么都失败。如果工商扣了钱但建设没加上,你的1000元就"消失"了。这就是分布式事务要解决的问题。

9.2 2PC(两阶段提交)

2PC是最经典的分布式事务方案,由一个协调者统一指挥所有参与者。

阶段1 - Prepare(准备阶段): 协调者 → 参与者A:你能提交吗? 协调者 → 参与者B:你能提交吗? 参与者A → 协调者:我准备好了(锁定资源) 参与者B → 协调者:我准备好了(锁定资源) 阶段2 - Commit(提交阶段): 如果所有人都准备好了: 协调者 → 参与者A:提交! 协调者 → 参与者B:提交! 如果有人失败了: 协调者 → 参与者A:回滚! 协调者 → 参与者B:回滚!
2PC的问题 1. 同步阻塞:准备阶段所有参与者都锁定资源,等待其他人,性能很差
2. 单点故障:协调者挂了,所有参与者都在等待,系统卡住
3. 数据不一致:提交阶段如果网络分区,部分参与者收到提交、部分收到回滚

9.3 TCC(Try-Confirm-Cancel)

TCC是一种业务层面的分布式事务方案,把每个操作拆成三步:

1
Try(预留资源):检查并预留资源。比如:检查余额够不够,冻结1000元
2
Confirm(确认提交):所有Try都成功后,正式执行。比如:扣除冻结的1000元
3
Cancel(取消回滚):任何Try失败,释放所有预留资源。比如:解冻1000元
TCC代码示例:转账
// 转账:A转1000给B
// Try阶段
boolean tryA = accountService.tryDeduct("A", 1000);  // 冻结A的1000元
boolean tryB = accountService.tryAdd("B", 1000);     // 预留B的1000元

if (tryA && tryB) {
    // Confirm阶段:都成功了,正式提交
    accountService.confirmDeduct("A");  // 正式扣除
    accountService.confirmAdd("B");     // 正式增加
} else {
    // Cancel阶段:有失败,全部回滚
    accountService.cancelDeduct("A");   // 解冻A的钱
    accountService.cancelAdd("B");      // 释放B的预留
}

9.4 TCC的三大难题(生产环境必须解决)

TCC在实际使用中会遇到三个棘手的问题,不解决就会导致资金损失:

难题1:空回滚

Try请求没有到达(网络超时),但Cancel请求先到了。此时Cancel不能做任何操作。

空回滚场景: 协调者 → 参与者:Try请求(网络超时,未到达) 协调者 → 参与者:Cancel请求(到达了) 问题:参与者没有执行过Try,但收到了Cancel 正确做法:Cancel判断如果没有Try记录,直接跳过(空回滚) 代码实现: // Cancel方法中先检查Try是否执行过 public void cancel(Long txId) { TccRecord record = tccRecordDao.selectByTxId(txId); if (record == null) { // Try没有执行过,空回滚,直接返回 log.info("空回滚,txId={}", txId); return; } // Try执行过,执行真正的回滚 accountDao.unfreeze(txId); tccRecordDao.deleteByTxId(txId); }

难题2:悬挂

Cancel执行完了,Try才到达(网络延迟)。此时Try不能做任何操作。

悬挂场景: 协调者 → 参与者:Try请求(网络延迟,很久才到) 协调者 → 参与者:Cancel请求(先到达并执行了) 参与者:Try请求终于到达了 问题:Cancel已经执行完了,Try才来 正确做法:Try执行前先检查是否已经Cancel过,如果Cancel过则拒绝 代码实现: // Try方法中检查是否已经Cancel过 public boolean tryDeduct(Long txId, Long userId, BigDecimal amount) { TccRecord record = tccRecordDao.selectByTxId(txId); if (record != null && record.getStatus() == CANCELLED) { // 已经Cancel过了,拒绝Try(防止悬挂) log.info("防止悬挂,拒绝Try,txId={}", txId); return false; } // 执行Try逻辑 accountDao.freeze(userId, amount); tccRecordDao.insert(new TccRecord(txId, TRIED)); return true; }

难题3:幂等防重

Confirm/Cancel可能因为网络重试被多次调用,必须保证幂等性。

幂等防重实现: // 用事务ID做幂等控制 public void confirm(Long txId) { TccRecord record = tccRecordDao.selectByTxId(txId); if (record == null || record.getStatus() != TRIED) { // 已经Confirm过了或状态不对,直接返回 return; } // 正式扣款 accountDao.deduct(txId); // 更新状态为CONFIRMED(用乐观锁保证幂等) int rows = tccRecordDao.updateStatus(txId, TRIED, CONFIRMED); if (rows == 0) { // 状态已被其他线程修改,说明是重复调用 return; } }
TCC三大难题总结 1. 空回滚:Cancel时Try没执行过 → 用事务记录表判断
2. 悬挂:Cancel执行完Try才到 → Try前检查是否已Cancel
3. 幂等:Confirm/Cancel重复执行 → 用事务ID+状态做幂等控制

核心方案:维护一张TCC事务记录表,记录每个事务ID的状态(TRIED/CONFIRMED/CANCELLED),所有操作都基于这张表做判断。

9.5 Saga模式详解

Saga把一个长事务拆成多个本地事务,每个本地事务都有一个对应的补偿操作。如果某一步失败,就逆序执行前面所有步骤的补偿操作。

Saga的两种实现方式: 1. 编排模式(Orchestration)— 推荐 由一个中央协调者(Orchestrator)统一指挥所有参与者 协调者知道整个流程,按顺序调用每个步骤 协调者 → 步骤1(创建订单) 协调者 → 步骤2(扣减库存) 协调者 → 步骤3(扣款)← 失败了! 协调者 → 补偿2(恢复库存) 协调者 → 补偿1(取消订单) 优点:流程清晰,集中管理 缺点:协调者逻辑复杂 2. 编舞模式(Choreography)— 简单场景 没有中央协调者,每个服务监听事件并做出反应 订单服务发事件 → 库存服务监听并扣减 → 发事件 库存服务发事件 → 支付服务监听并扣款 → 发事件 支付失败发事件 → 库存服务监听并恢复 → 订单服务监听并取消 优点:去中心化,服务解耦 缺点:流程分散在各服务中,难以理解和维护
Saga编排模式实现(以订单创建为例)
// Saga协调者
@Component
public class CreateOrderSaga {

    @Autowired
    private OrderService orderService;
    @Autowired
    private StockService stockService;
    @Autowired
    private AccountService accountService;

    // 定义Saga步骤
    private List<SagaStep> steps = Arrays.asList(
        // 步骤1:创建订单
        new SagaStep(
            ctx -> orderService.create(ctx.getOrderDTO()),      // 正向操作
            ctx -> orderService.cancel(ctx.getOrderId())        // 补偿操作
        ),
        // 步骤2:扣减库存
        new SagaStep(
            ctx -> stockService.deduct(ctx.getProductId(), ctx.getCount()),
            ctx -> stockService.restore(ctx.getProductId(), ctx.getCount())
        ),
        // 步骤3:扣减余额
        new SagaStep(
            ctx -> accountService.deduct(ctx.getUserId(), ctx.getAmount()),
            ctx -> accountService.refund(ctx.getUserId(), ctx.getAmount())
        )
    );

    // 执行Saga
    @Transactional
    public void execute(OrderDTO orderDTO) {
        SagaContext ctx = new SagaContext(orderDTO);
        int completedStep = -1;

        try {
            for (int i = 0; i < steps.size(); i++) {
                steps.get(i).execute(ctx);  // 执行正向操作
                completedStep = i;
            }
        } catch (Exception e) {
            // 某一步失败,逆序补偿
            for (int i = completedStep; i >= 0; i--) {
                try {
                    steps.get(i).compensate(ctx);
                } catch (Exception ce) {
                    // 补偿也失败了,记录日志,人工介入
                    log.error("Saga补偿失败,步骤={}, 需人工处理", i, ce);
                    alertService.sendAlert("Saga补偿失败,请人工处理: " + ctx.getOrderId());
                }
            }
            throw new RuntimeException("Saga执行失败,已补偿", e);
        }
    }
}

9.6 三种方案对比

对比项2PCTCCSaga
一致性强一致最终一致最终一致
性能低(锁资源)中高(无锁)
实现复杂度低高中
业务侵入无大(需写Try/Confirm/Cancel)中(需写补偿逻辑)
适用场景同构数据库资金、库存等核心业务长流程业务(如旅行预订)
实际项目中的选择 涉及钱的核心业务用TCC(如支付、转账),长流程业务用Saga(如订单创建流程),对一致性要求不高的场景用消息队列+本地事务表(最终一致)。2PC因为性能太差,实际项目中很少直接使用。

第十章:一致性哈希与数据分片

10.1 为什么需要数据分片?

当数据量大到一台机器存不下时,就需要把数据分散到多台机器上。这个"分散"的策略就是数据分片(Sharding)。

生活类比:图书馆分馆

一个城市有100万本书,一个图书馆放不下。于是建了5个分馆。问题来了:哪本书放哪个分馆?
- 按首字母分:A-E放分馆1,F-J放分馆2...
- 按出版社分:人民文学放分馆1,机械工业放分馆2...

分得好,每个分馆负载均衡;分得不好,有的分馆塞满了,有的空荡荡。

10.2 传统哈希的问题

最简单的分片方式是对key取模:

传统哈希分片
// 3台服务器
int serverIndex = hashCode(key) % 3;

// 问题:如果加一台服务器变成4台
int serverIndex = hashCode(key) % 4;

// 几乎所有key的映射都变了!
// 原来在服务器0的数据,可能要跑到服务器2
// 大规模数据迁移,系统可能被压垮
传统哈希的致命问题 当服务器数量变化时(增减节点),几乎所有数据的映射关系都会改变,导致大规模数据迁移。这在生产环境中是不可接受的。

10.3 一致性哈希的原理

一致性哈希(Consistent Hashing)的核心思想是:把哈希值空间组织成一个环(0 ~ 2^32),服务器和数据都映射到这个环上。

一致性哈希环(0 ~ 2^32): 0 │ Node C ──┤── Node A │ │ ← 数据key顺时针找到第一个Node │ Node B ──┤ │ 2^32 规则:每个数据key顺时针找到的第一个节点,就是它应该存储的节点
一致性哈希的简单实现
public class ConsistentHash {
    private final TreeMap<Long, String> ring = new TreeMap<>();

    // 添加节点
    public void addNode(String node) {
        long hash = hash(node);
        ring.put(hash, node);
    }

    // 查找key应该存储在哪个节点
    public String getNode(String key) {
        long hash = hash(key);
        // 顺时针找到第一个大于等于hash的节点
        Map.Entry<Long, String> entry = ring.ceilingEntry(hash);
        // 如果没找到,说明在环的末尾,取第一个节点
        if (entry == null) {
            entry = ring.firstEntry();
        }
        return entry.getValue();
    }

    private long hash(String key) {
        // 使用MD5或MurmurHash
        return Math.abs(key.hashCode());
    }
}

10.4 虚拟节点:解决数据倾斜

基本的一致性哈希有个问题:如果节点太少,数据分布可能非常不均匀。解决方案是引入虚拟节点——每个物理节点对应多个虚拟节点。

没有虚拟节点(3个物理节点,数据分布不均): Node A ──── 60%的数据 Node B ──── 30%的数据 Node C ──── 10%的数据 有虚拟节点(每个物理节点100个虚拟节点,数据均匀分布): Node A ──── 33%的数据 Node B ──── 34%的数据 Node C ──── 33%的数据
带虚拟节点的一致性哈希
public class ConsistentHashWithVNode {
    private final TreeMap<Long, String> ring = new TreeMap<>();
    private static final int VNODE_COUNT = 150;  // 每个物理节点150个虚拟节点

    public void addNode(String node) {
        for (int i = 0; i < VNODE_COUNT; i++) {
            long hash = hash(node + "#vnode" + i);
            ring.put(hash, node);
        }
    }
}

10.5 哈希分片策略对比

策略原理优点缺点适用场景
取模哈希hash(key) % N简单增减节点需全量迁移节点数固定
一致性哈希哈希环+虚拟节点增减节点影响小实现复杂缓存集群
范围分片按key的范围分支持范围查询可能热点数据库分表
哈希取模分表hash(key) % 表数均匀分布扩容困难分库分表

第十一章:分布式缓存——Redis集群实战

11.1 为什么需要缓存?

数据库的读写速度远慢于内存。MySQL的QPS大约在几千到几万,而Redis的QPS可以达到10万+。缓存的核心思想就是:把热点数据放在内存里,用户请求先查内存,查不到再去查数据库。

生活类比:书桌与书柜

你正在写论文,需要频繁查阅几本参考书。你不会每次都跑到书柜去拿——你会把最常用的几本放在书桌上(缓存),不常用的放回书柜(数据库)。书桌虽然小,但拿书的速度快10倍。

11.2 Redis的三种集群模式

主从复制(Replication)

┌─────────┐ │ Master │ ← 写操作 │ (主节点) │ └────┬─────┘ │ 数据同步 ┌─────┴─────┐ ▼ ▼ ┌──────────┐ ┌──────────┐ │ Slave1 │ │ Slave2 │ ← 读操作 │ (从节点) │ │ (从节点) │ └──────────┘ └──────────┘ 特点:读写分离,主写从读,从节点自动同步主节点数据 问题:主节点挂了需要手动切换

哨兵模式(Sentinel)

┌───────────┐ ┌───────────┐ ┌───────────┐ │ Sentinel1 │ │ Sentinel2 │ │ Sentinel3 │ ← 监控+自动故障转移 └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ │ │ │ └─────────────┼─────────────┘ │ 监控 ┌─────┴─────┐ │ Master │ └─────┬─────┘ ┌───────┴───────┐ ▼ ▼ ┌──────────┐ ┌──────────┐ │ Slave1 │ │ Slave2 │ 特点:自动监控,主节点挂了自动选举新主节点 问题:单主节点写能力有限,存储能力有限

Cluster集群模式(推荐)

┌─────────┐ ┌─────────┐ ┌─────────┐ │ Node A │────│ Node B │────│ Node C │ ← 三主 │ 0-5460 │ │5461-10922│ │10923-16383│ │ Slave A1│ │ Slave B1│ │ Slave C1│ ← 三从 └─────────┘ └─────────┘ └─────────┘ 特点: - 数据自动分片到16384个slot - 每个节点负责一部分slot - 支持水平扩展,加节点自动迁移数据 - 每个主节点有从节点做备份

11.3 Redis Cluster 部署实战

快速搭建6节点Cluster(3主3从)
# 1. 准备6个Redis配置文件(redis-7001.conf ~ redis-7006.conf)
# 每个文件关键配置:
port 7001
cluster-enabled yes
cluster-config-file nodes-7001.conf
cluster-node-timeout 5000
appendonly yes

# 2. 启动6个实例
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf
redis-server redis-7006.conf

# 3. 创建集群(自动分配主从)
redis-cli --cluster create \
  127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 \
  127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006 \
  --cluster-replicas 1

# 4. 验证集群状态
redis-cli -p 7001 cluster info
redis-cli -p 7001 cluster nodes

# 5. 测试(注意加 -c 参数,自动路由到正确的节点)
redis-cli -c -p 7001
> set user:1001 "张三"
-> Redirected to slot [5798] located at 127.0.0.1:7002
OK

# 6. 动态扩容:添加新节点
redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7001
# 分配slot
redis-cli --cluster reshard 127.0.0.1:7001

11.4 缓存三大问题

缓存穿透

请求的数据在缓存和数据库中都不存在,每次都穿透缓存查数据库。恶意用户可能利用这个漏洞攻击系统。

缓存穿透的解决方案
// 方案1:缓存空值
public User getUser(Long id) {
    // 先查缓存
    String cache = redis.get("user:" + id);
    if (cache != null) {
        if ("NULL".equals(cache)) return null;  // 缓存的空值
        return JSON.parse(cache);
    }
    // 查数据库
    User user = userDao.selectById(id);
    if (user == null) {
        // 数据库也没有,缓存空值,设置较短过期时间
        redis.setex("user:" + id, 300, "NULL");
    } else {
        redis.setex("user:" + id, 3600, JSON.stringify(user));
    }
    return user;
}

// 方案2:布隆过滤器(更优雅)
// 先判断key是否可能存在,不存在直接返回
if (!bloomFilter.mightContain("user:" + id)) {
    return null;  // 一定不存在,直接返回
}

缓存击穿

某个热点key过期的瞬间,大量请求同时打到数据库。

缓存击穿的解决方案:互斥锁
public User getHotUser(Long id) {
    String cache = redis.get("user:" + id);
    if (cache != null) return JSON.parse(cache);

    // 加分布式锁,只让一个请求去查数据库
    String lockKey = "lock:user:" + id;
    if (redis.setnx(lockKey, "1", 10)) {  // 获取锁
        try {
            User user = userDao.selectById(id);
            redis.setex("user:" + id, 3600, JSON.stringify(user));
            return user;
        } finally {
            redis.del(lockKey);  // 释放锁
        }
    } else {
        // 没获取到锁,等一下再试
        Thread.sleep(50);
        return getHotUser(id);  // 重试
    }
}

缓存雪崩

大量key同时过期,或者Redis集群整体宕机,所有请求直接打到数据库。

缓存雪崩的解决方案 1. 过期时间加随机值:避免同时过期
2. 多级缓存:本地缓存(Caffeine)+ 分布式缓存(Redis)
3. 限流降级:缓存失效时,对数据库请求做限流
4. Redis高可用:使用Cluster模式,避免单点故障
过期时间加随机值
// 原来:所有key都1小时过期
redis.setex(key, 3600, value);

// 优化:过期时间 = 基础时间 + 随机时间(0~600秒)
int expireTime = 3600 + new Random().nextInt(600);
redis.setex(key, expireTime, value);

第十二章:消息队列——Kafka与RocketMQ

12.1 什么是消息队列?

消息队列(Message Queue,MQ)是一种异步通信机制:生产者把消息发送到队列,消费者从队列中取出消息处理。生产者和消费者不需要同时在线。

生活类比:快递柜

消息队列就像快递柜:
- 快递员(生产者)把包裹放进快递柜
- 你(消费者)有空了再去取
- 快递员不需要等你在家才能送
- 你不需要知道是哪个快递员送的

这就是解耦——发送方和接收方互不依赖。

12.2 消息队列的三大作用

1
异步:用户下单后,不需要等短信发送、积分更新全部完成才返回。把这些操作丢到MQ,后台慢慢处理。
2
解耦:订单服务不需要知道谁在关心"订单创建"事件。它只需要发一条消息,关心的服务自己去订阅。
3
削峰:秒杀时1秒10万个请求,但数据库只能扛1万。用MQ把请求排队,1秒处理1万个,10秒处理完。

12.3 主流消息队列对比

对比项RabbitMQRocketMQKafka
开发语言ErlangJavaScala/Java
单机吞吐量万级十万级百万级
消息延迟微秒级毫秒级毫秒级
消息可靠性高高高
适用场景中小规模、复杂路由大规模、事务消息大数据、日志收集
典型用户中小企业阿里、滴滴LinkedIn、字节

12.4 Kafka核心概念

Producer(生产者) │ ▼ 发送消息到Topic ┌─────────────────────────────────────┐ │ Topic: order-created │ │ ┌─────────┐ ┌─────────┐ ┌────────┐│ │ │Partition0│ │Partition1│ │Part.2 ││ │ │ msg1,4,7│ │ msg2,5,8│ │msg3,6,9││ │ └─────────┘ └─────────┘ └────────┘│ └─────────────────────────────────────┘ │ │ │ ▼ ▼ ▼ Consumer Group(消费者组) ┌──────────┐ ┌──────────┐ ┌──────────┐ │Consumer1 │ │Consumer2 │ │Consumer3 │ │消费Part.0│ │消费Part.1│ │消费Part.2│ └──────────┘ └──────────┘ └──────────┘ 核心概念: - Topic:消息的主题,逻辑上的消息分类 - Partition:Topic的物理分区,并行处理的单位 - Consumer Group:一组消费者,共同消费一个Topic - Offset:消息在Partition中的位置,消费者记录消费进度

12.5 消息可靠性保证

消息从生产到消费,可能在任何环节丢失。Kafka通过以下机制保证可靠性:

1
生产者确认(acks):acks=all 表示所有副本都写入成功才返回确认
2
多副本机制:每个Partition有多个副本,Leader挂了Follower自动接管
3
消费者手动提交offset:处理完消息才提交,避免消息丢失
4
消息持久化:消息写入磁盘,支持回溯消费
消息丢失 vs 消息重复 消息队列通常保证至少一次(at-least-once)投递——消息不会丢,但可能重复消费。消费端需要做幂等处理(同一个消息处理多次结果一样)。比如:用唯一ID去重,或者用数据库唯一约束。

12.6 消息队列高级特性

死信队列(Dead Letter Queue)

当消息消费失败达到最大重试次数后,会被投递到死信队列。避免一条异常消息阻塞整个消费链路。

RocketMQ 死信队列处理
// 消费者:处理失败时抛异常,触发重试
@RocketMQMessageListener(topic = "order-topic", consumerGroup = "order-group")
public class OrderConsumer implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        try {
            processOrder(message);
        } catch (Exception e) {
            // 抛异常触发重试(默认重试16次)
            throw new RuntimeException("消费失败", e);
        }
    }
}

// 重试16次后,消息进入死信队列:"%DLQ%order-group"
// 需要单独消费死信队列,做人工处理或告警
@RocketMQMessageListener(
    topic = "%DLQ%order-group",
    consumerGroup = "order-dlq-group"
)
public class OrderDlqConsumer implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        // 记录日志、发告警、人工介入
        log.error("消息进入死信队列: {}", message);
        alertService.sendAlert("订单消息消费失败,请人工处理");
    }
}

消息顺序性

某些业务场景需要保证消息的顺序消费(如订单状态变更:创建→支付→发货→完成)。

1
生产端:同一业务ID的消息发送到同一个Partition(如按orderId取模)
2
存储端:Partition内消息天然有序
3
消费端:单线程消费同一个Partition,或使用顺序消费模式
顺序性 vs 吞吐量的权衡 保证全局顺序需要只有一个Partition,吞吐量极低。实际项目中通常只保证局部顺序——同一个订单的消息有序,不同订单之间不需要有序。通过将同一业务ID路由到同一Partition实现。

第十三章:分布式锁——Redis与ZooKeeper

13.1 为什么需要分布式锁?

在单机应用中,用Java的synchronized或ReentrantLock就能解决并发问题。但在分布式系统中,多个进程部署在不同机器上,JVM级别的锁无法跨机器生效。你需要一把"全局锁"——这就是分布式锁。

生活类比:公共厕所的门锁

分布式锁就像公共厕所的门锁:不管谁来上厕所,都要先拿到钥匙(获取锁)才能进去。用完之后把钥匙还回去(释放锁)。如果钥匙被拿走了,其他人只能排队等。

13.2 Redis实现分布式锁

最简单的Redis分布式锁
// 加锁:SET key value NX EX
// NX = 不存在才设置(互斥)
// EX = 设置过期时间(防止死锁)
String lockKey = "lock:order:" + orderId;
String requestId = UUID.randomUUID().toString();

boolean locked = redis.set(lockKey, requestId, "NX", "EX", 30);
if (locked) {
    try {
        // 业务逻辑
        processOrder(orderId);
    } finally {
        // 释放锁:必须判断是不是自己加的锁
        // 用Lua脚本保证原子性
        String luaScript =
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "  return redis.call('del', KEYS[1]) " +
            "else " +
            "  return 0 " +
            "end";
        redis.eval(luaScript, lockKey, requestId);
    }
}
为什么要用requestId? 如果不判断"是不是自己加的锁",可能出现这种情况:A加了锁,A的业务执行太久锁过期了,B也加了锁,A执行完释放锁——结果释放的是B的锁!所以必须用requestId标识"这把锁是谁加的"。

13.3 Redisson(生产环境推荐)

手写Redis分布式锁容易出错。生产环境推荐使用Redisson,它内置了可重入锁、看门狗自动续期等高级特性。

Redisson分布式锁
// 引入Redisson依赖
RLock lock = redissonClient.getLock("lock:order:" + orderId);

try {
    // 尝试加锁,最多等待10秒,锁自动过期30秒
    boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (locked) {
        processOrder(orderId);
    }
} finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}
// Redisson的看门狗会自动给锁续期,不用担心业务执行太久锁过期

13.4 ZooKeeper实现分布式锁

ZooKeeper通过临时顺序节点实现分布式锁,天然支持公平锁和锁释放通知。

ZooKeeper分布式锁原理: 1. 在/lock目录下创建临时顺序节点 /lock/lock-0000000001 ← 客户端A /lock/lock-0000000002 ← 客户端B /lock/lock-0000000003 ← 客户端C 2. 获取/lock下所有子节点,判断自己是不是最小的 - 是最小的 → 获取锁成功 - 不是最小的 → 监听比自己小的那个节点 3. 当比你小的节点被删除(释放锁),你会收到通知 - 收到通知后,再次判断自己是不是最小的 - 如果是 → 获取锁成功

13.5 Redis锁 vs ZooKeeper锁

对比项Redis分布式锁ZooKeeper分布式锁
性能高(内存操作)中(需要写ZNode)
可靠性主从切换可能丢锁强一致(ZAB协议)
公平性非公平(需要额外实现)天然公平(顺序节点)
锁释放通知不支持(需要轮询)支持(Watcher机制)
适用场景高性能、允许极端情况丢锁强一致、不能丢锁

第十四章:分布式ID生成——雪花算法

14.1 为什么需要分布式ID?

在单体应用中,数据库自增ID就够了。但在分布式系统中,多个数据库同时生成ID,自增ID会冲突。你需要一个全局唯一的ID生成方案。

14.2 常见方案对比

方案优点缺点适用场景
UUID简单、无依赖太长、无序、不适合做主键日志traceId
数据库自增简单、有序单点瓶颈、分库后冲突单库
号段模式高性能、有序需要额外的ID服务美团Leaf
雪花算法高性能、有序、全局唯一依赖时钟大部分场景

14.3 雪花算法详解

Snowflake(雪花算法)是Twitter开源的分布式ID生成方案。它生成一个64位的Long型ID,由以下部分组成:

64位ID结构: ┌─────────────────────────────────────────────────────────────┐ │ 0 │ 41位时间戳 │ 10位机器ID │ 12位序列号 │ │符号│ │ │ │ └─────────────────────────────────────────────────────────────┘ 1位 41位 10位 12位 - 1位符号位:永远是0(正数) - 41位时间戳:毫秒级,可以用69年 - 10位机器ID:最多1024台机器 - 12位序列号:同一毫秒内最多生成4096个ID 理论QPS:4096 * 1000 = 409.6万/秒
雪花算法Java实现
public class SnowflakeIdGenerator {
    private final long startTimestamp = 1609459200000L; // 2021-01-01
    private final long machineIdBits = 10L;
    private final long sequenceBits = 12L;
    private final long maxMachineId = ~(-1L << machineIdBits); // 1023
    private final long maxSequence = ~(-1L << sequenceBits);   // 4095

    private final long machineId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;

    public SnowflakeIdGenerator(long machineId) {
        if (machineId > maxMachineId || machineId < 0) {
            throw new IllegalArgumentException("机器ID超出范围");
        }
        this.machineId = machineId;
    }

    public synchronized long nextId() {
        long currentTimestamp = System.currentTimeMillis();
        if (currentTimestamp < lastTimestamp) {
            throw new RuntimeException("时钟回拨,拒绝生成ID");
        }
        if (currentTimestamp == lastTimestamp) {
            sequence = (sequence + 1) & maxSequence;
            if (sequence == 0) {
                // 同一毫秒序列号用完了,等待下一毫秒
                currentTimestamp = waitNextMillis();
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = currentTimestamp;
        return ((currentTimestamp - startTimestamp) << (machineIdBits + sequenceBits))
             | (machineId << sequenceBits)
             | sequence;
    }

    private long waitNextMillis() {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

// 使用
SnowflakeIdGenerator generator = new SnowflakeIdGenerator(1);
long id = generator.nextId(); // 例如:1420154325778432

14.4 时钟回拨问题详解

时钟回拨是雪花算法的最大隐患。当NTP同步、闰秒调整或手动修改系统时间时,系统时钟可能倒退,导致生成重复ID。

生产级时钟回拨处理方案
// 方案1:小范围回拨等待(推荐)
public synchronized long nextId() {
    long currentTimestamp = System.currentTimeMillis();
    long offset = lastTimestamp - currentTimestamp;

    if (offset > 0) {
        if (offset <= 5) {  // 5ms内的小回拨,等待追上
            try {
                Thread.sleep(offset << 1);  // 等待2倍偏移时间
                currentTimestamp = System.currentTimeMillis();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        } else {
            // 大范围回拨,拒绝生成,抛异常告警
            throw new RuntimeException(
                "时钟回拨超过5ms,拒绝生成ID,偏移量: " + offset + "ms");
        }
    }
    // ... 后续正常逻辑
}

// 方案2:扩展位记录回拨次数(美团Leaf方案)
// 在ID中预留几位作为回拨标记,每次回拨递增
// 优点:不阻塞,不拒绝;缺点:ID结构更复杂

// 方案3:使用美团Leaf、百度UidGenerator等成熟方案
// 它们已经处理了各种边界情况,生产环境推荐直接使用
生产环境建议 不要自己从零实现雪花算法。推荐使用成熟的开源方案:
- 美团Leaf:支持号段模式和雪花模式,经过大规模验证
- 百度UidGenerator:基于雪花算法,使用RingBuffer预生成ID,性能更高
- Hutool IdUtil:轻量级工具类,适合中小项目

第十五章:分布式配置中心——Nacos

15.1 为什么需要配置中心?

在微服务架构中,有几十上百个服务实例。如果每个实例都有自己的配置文件,改一个配置就要重启所有实例——这在生产环境中是不可接受的。

生活类比:中央广播系统

配置中心就像学校的广播系统:校长在广播室说一句话,全校所有教室都能听到。不需要一个教室一个教室去通知。

15.2 Nacos配置中心的使用

1. 在Nacos控制台创建配置
# Data ID: order-service.yaml
# Group: DEFAULT_GROUP
# 配置内容:
server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/order_db
    username: root
    password: 123456
order:
  timeout: 30  # 订单超时时间(分钟)
  max-retry: 3  # 最大重试次数
2. 服务中读取配置
// 引入依赖
// spring-cloud-starter-alibaba-nacos-config

// bootstrap.yml 配置
spring:
  application:
    name: order-service
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        file-extension: yaml

// 代码中使用配置
@RestController
@RefreshScope  // 支持动态刷新配置
public class OrderController {
    @Value("${order.timeout}")
    private int timeout;

    @Value("${order.max-retry}")
    private int maxRetry;

    @GetMapping("/config")
    public String showConfig() {
        return "超时: " + timeout + "分钟, 重试: " + maxRetry + "次";
    }
}

15.3 Nacos的核心概念

1
Namespace(命名空间):用于环境隔离。dev、test、prod三个命名空间互不影响
2
Group(分组):用于业务分组。订单组、用户组、支付组
3
Data ID:配置的唯一标识,通常是 服务名.yaml 的格式
配置的优先级 服务名-profile.yaml > 服务名.yaml > application.yml。Nacos配置优先级高于本地配置,实现了"远程覆盖本地"。

15.4 Nacos长轮询(Long Polling)底层原理

Nacos配置中心能做到秒级推送,靠的不是客户端不停轮询(那样太浪费连接),而是一种巧妙的长轮询机制。

生活类比:挂号候诊

你去医院挂号看专家号。与其每5分钟去问一次"轮到我了吗?"(短轮询),不如在护士站登记后坐在候诊区等——护士有号了会叫你(长轮询)。如果30秒没人叫你,你再去确认一次(重新建立长轮询)。这样既不浪费你跑腿的次数,又能第一时间知道结果。

Nacos长轮询时序(每30秒一次"挂号"): 客户端(Nacos SDK) Nacos Server │ │ │─── GET /listener 配置MD5 ────→│ ① 发起长轮询请求 │ │ │ (服务端hold住连接30秒)│ ② 服务端不立即返回 │ │ 每隔几秒检查配置是否变更 │ │ │←── 30秒超时,返回"无变更" ────│ ③ 超时返回,客户端对比MD5 │ │ │─── GET /listener 配置MD5 ────→│ ④ 立即重新建立长轮询 │ │ │ (配置发生变更!) │ │←── 立即返回变更的配置 ────────│ ⑤ 配置变更时秒级推送 │ │ │ 客户端收到新配置,触发监听器 │ │ @RefreshScope自动刷新Bean │ 关键设计: - 客户端:本地缓存配置的MD5值,每次长轮询携带MD5 - 服务端:对比MD5,有变化立即返回,无变化hold住连接 - 超时时间:默认30秒,超时后客户端立即重连 - 效果:配置变更延迟 < 3秒,且不会频繁建立HTTP连接
Nacos客户端长轮询核心源码逻辑(简化)
// Nacos客户端的长轮询调度线程(伪代码)
public class ConfigRpcClient {

    // 长轮询任务:定期检查远程配置
    public void startLongPolling() {
        scheduler.scheduleWithFixedDelay(() -> {
            try {
                // 1. 收集所有监听的配置的MD5
                List<String> changedDataIds = new ArrayList<>();
                for (CacheData cacheData : cacheMap.values()) {
                    changedDataIds.add(cacheData.getMd5());
                }

                // 2. 发起长轮询请求(服务端会hold住30秒)
                ServerHttpResponse response = rpcClient.request(
                    new ConfigQueryRequest(namespace, changedDataIds),
                    30000L  // 超时时间30秒
                );

                // 3. 服务端返回变更的配置列表
                if (response.hasChangedConfigs()) {
                    for (String changedId : response.getChangedConfigs()) {
                        // 4. 拉取最新配置
                        String newContent = getConfig(changedId);
                        CacheData cacheData = cacheMap.get(changedId);
                        cacheData.setContent(newContent);
                        // 5. 通知所有监听器(@RefreshScope等)
                        cacheData.notifyListener();
                    }
                }
            } catch (Exception e) {
                // 异常时延长重试间隔,避免风暴
                logger.error("长轮询异常,5秒后重试", e);
            }
        }, 0, 1, TimeUnit.SECONDS);  // 超时后立即重试
    }
}
长轮询 vs WebSocket vs 短轮询 - 短轮询:每隔1秒请求一次,浪费连接,延迟最高1秒
- WebSocket:实时推送,但需要维护长连接,Nacos集群模式下实现复杂
- 长轮询(Nacos选择):兼顾实时性和连接数,集群模式下天然支持,是配置中心场景的最优解

15.5 配置灰度发布(Beta)

生产环境改配置是高风险操作。Nacos支持Beta发布:新配置先推送到指定IP的实例,验证无误后再全量发布。

Nacos Beta发布流程
// 1. 在Nacos控制台操作:
//    配置管理 → 编辑配置 → 勾选"Beta发布"
//    填入Beta IP列表:192.168.1.10, 192.168.1.11
//    → 只有这两个IP的实例会收到新配置

// 2. 在Beta实例上验证:
//    观察日志、监控指标、接口返回值
//    确认无异常后,点击"全量发布"

// 3. 如果Beta验证失败,点击"停止Beta"
//    Beta实例回滚到旧配置,其他实例不受影响

// 代码中获取Beta标签(用于灰度路由)
@GetMapping("/api/config/debug")
public String debugConfig() {
    // Nacos会自动在请求头中注入Beta标签
    return "当前配置版本: " + configVersion;
}

15.6 Nacos集群高可用架构

生产环境必须部署Nacos集群,至少3节点,容忍1个节点故障。

Nacos集群架构(3节点,Raft协议选主): ┌─────────────────────────────────────────────────┐ │ Nacos Cluster │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ Node 1 │ │ Node 2 │ │ Node 3 │ │ │ │ (Leader) │◄─►│(Follower)│◄─►│(Follower)│ │ │ │ │ │ │ │ │ │ │ │ Raft协议 │ │ Raft协议 │ │ Raft协议 │ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ │ │ │ │ └──────────────┼──────────────┘ │ │ │ 数据同步 │ │ ┌──────┴──────┐ │ │ ▼ ▼ │ │ ┌──────────┐ ┌──────────┐ │ │ │ MySQL │ │ MySQL │ │ │ │ (主) │ │ (从) │ │ │ └──────────┘ └──────────┘ │ └─────────────────────────────────────────────────┘ 配置要点: 1. 至少3个Nacos节点,端口8848/9848/9849 2. 共享数据库(MySQL主从),存储配置和注册信息 3. Raft协议保证配置数据一致性 4. Nginx做负载均衡,客户端连接Nginx地址
Nacos集群部署配置
# 每个节点的 application.properties 关键配置
# Node 1 (192.168.1.10)
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://192.168.1.100:3306/nacos?characterEncoding=utf8
db.user=root
db.password=123456

# 集群配置(cluster.conf)
# 所有节点的IP:端口
192.168.1.10:8848
192.168.1.11:8848
192.168.1.12:8848

# Nginx负载均衡配置
upstream nacos-cluster {
    server 192.168.1.10:8848;
    server 192.168.1.11:8848;
    server 192.168.1.12:8848;
}
server {
    listen 8848;
    location /nacos/ {
        proxy_pass http://nacos-cluster;
    }
}
# 客户端连接:server-addr: nginx-ip:8848
Nacos生产环境避坑 1. 不要用嵌入式数据库:Derby只适合单机测试,集群必须用MySQL
2. MySQL必须主从:Nacos集群共享数据库,数据库挂了全部挂
3. 不要频繁发布配置:每次发布都会触发所有客户端长轮询返回,大量客户端同时拉取配置可能打爆网络
4. 配置内容不要超过1MB:大配置会导致长轮询响应超时

第十六章:分布式任务调度——XXL-JOB

16.1 为什么需要分布式任务调度?

在单体应用中,用Spring的@Scheduled就能做定时任务。但在分布式系统中,多个实例同时执行同一个定时任务,会导致重复执行——比如:3台机器同时给用户发了3条相同的短信。

16.2 XXL-JOB架构

┌───────────────────────────────────────────────────────────┐ │ XXL-JOB Admin(调度中心) │ │ 管理任务、触发调度、查看执行日志、报警通知 │ └──────────────────────────┬────────────────────────────────┘ │ 调度 ┌────────────┼────────────┐ ▼ ▼ ▼ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ 执行器A │ │ 执行器B │ │ 执行器C │ │ (服务实例)│ │ (服务实例)│ │ (服务实例)│ └──────────┘ └──────────┘ └──────────┘ 特点: - 调度中心和执行器分离 - 支持分片广播(任务拆分到多个执行器并行执行) - 支持失败重试、报警通知 - 可视化管理界面

16.3 XXL-JOB使用示例

定义定时任务
@Component
public class OrderJobHandler {

    // 简单任务:每天凌晨清理过期订单
    @XxlJob("cleanExpiredOrder")
    public void cleanExpiredOrder() {
        List<Order> expiredOrders = orderDao.findExpired();
        for (Order order : expiredOrders) {
            orderDao.cancel(order.getId());
        }
        XxlJobHelper.log("清理了 " + expiredOrders.size() + " 个过期订单");
    }

    // 分片广播任务:大数据量任务拆分到多台机器并行执行
    @XxlJob("syncOrderData")
    public void syncOrderData() {
        // 获取当前分片参数
        int shardIndex = XxlJobHelper.getShardIndex();  // 当前是第几个分片
        int shardTotal = XxlJobHelper.getShardTotal();  // 总共有几个分片

        // 根据分片参数查询数据
        List<Order> orders = orderDao.findByShard(shardIndex, shardTotal);
        for (Order order : orders) {
            syncService.syncToES(order);
        }
    }
}
分片广播的威力 假设要同步100万条订单数据到ES。单台机器执行要1小时。用3台机器分片执行,每台处理33万条,20分钟就完成了。这就是分片广播的价值——任务并行化。

16.4 分片倾斜问题与解决

上面的分片方案用的是id % shardTotal取模。但当数据量动态变化时(比如某些月份数据集中在某些分片),会导致分片倾斜——有的执行器干10分钟就完了,有的要干1小时。

生活类比:按尾号限行

北京按车牌尾号限行:尾号1和6周一限行。如果恰好尾号1和6的车特别多(比如某批次车牌大量以1结尾),周一限行的效果就很差。分片取模也一样——如果数据分布不均匀,分片就不均匀。

问题示例:按日期取模导致分片倾斜
// 问题:按日期分片,月初数据多,月末数据少
// shardIndex=0 负责1号、4号、7号...的数据(月初数据密集)
// shardIndex=2 负责3号、6号、9号...的数据(月末数据稀疏)
// 结果:执行器0要处理3倍于执行器2的数据量

// 错误的分片方式
List<Order> orders = orderDao.findByDateMod(
    currentDate.getDayOfMonth() % shardTotal, shardTotal);

// 正确的方式:按数据ID范围分片(均匀分布)
// 方法1:按ID范围分片
long idRange = (maxId - minId) / shardTotal;
List<Order> orders = orderDao.findByIdRange(
    minId + shardIndex * idRange,
    minId + (shardIndex + 1) * idRange
);

// 方法2:一致性哈希分片(数据量不均匀时推荐)
// 使用MurmurHash保证数据均匀分布
int bucket = Hashing.murmur3_32().hashLong(orderId).asInt() % shardTotal;
if (bucket == shardIndex) {
    processOrder(order);
}

16.5 任务依赖(DAG)与阻塞策略

实际业务中,任务之间往往有依赖关系。比如:先同步商品数据,再同步订单数据(因为订单需要关联商品信息)。

任务依赖(DAG)示例: 同步商品数据 ──→ 同步订单数据 ──→ 生成统计报表 │ │ │ ▼ ▼ ▼ 10:00执行 10:15执行 10:30执行 XXL-JOB实现方式: 1. 父任务执行成功后,通过API触发子任务 2. 或者使用任务组+前置任务ID配置
任务依赖的代码实现
// 父任务:同步商品数据
@XxlJob("syncProductData")
public void syncProductData() {
    try {
        // 执行商品数据同步
        List<Product> products = productDao.findAll();
        for (Product p : products) {
            esClient.index("products", p);
        }
        XxlJobHelper.log("商品数据同步完成,共" + products.size() + "条");

        // 触发子任务:同步订单数据
        // 通过XXL-JOB的API触发,而不是直接调用
        xxlJobClient.triggerJob(2, null);  // 2是syncOrderData的任务ID
    } catch (Exception e) {
        XxlJobHelper.log("商品数据同步失败: " + e.getMessage());
        throw e;  // 失败时不触发子任务
    }
}

// 子任务:同步订单数据
@XxlJob("syncOrderData")
public void syncOrderData() {
    // 依赖父任务已同步的商品数据
    List<Order> orders = orderDao.findAll();
    for (Order o : orders) {
        // 关联商品信息(已由父任务同步到ES)
        Product product = esClient.get("products", o.getProductId());
        o.setProductName(product.getName());
        esClient.index("orders", o);
    }
}

阻塞处理策略

当上一次任务还没执行完,下一次调度就来了怎么办?XXL-JOB提供了4种策略:

策略行为适用场景
串行执行(默认)新任务等待上一次执行完再执行数据同步类任务
丢弃后续调度上一次没执行完,新调度直接丢弃实时性要求不高
覆盖之前调度中断上一次执行,立即执行新调度实时数据推送
并行执行新旧任务同时执行幂等性任务
XXL-JOB生产环境避坑 1. 分片任务必须幂等:执行器重启后可能重新执行,确保重复执行不产生副作用
2. 不要在任务中写死分片逻辑:用XxlJobHelper.getShardIndex()动态获取
3. 告警邮件要配置:任务失败时XXL-JOB会发告警邮件,确保邮箱有人看
4. 执行器要注册到所有环境:dev和prod的执行器要分开,避免dev任务在prod执行器上跑

第十七章:分布式文件存储——MinIO

17.1 为什么不用本地文件系统?

在单体应用中,文件存在服务器本地硬盘上就行。但在分布式系统中,有多个服务器实例,用户上传的文件存在A服务器上,下次请求被负载均衡到B服务器——文件找不到了。

17.2 MinIO简介

MinIO是一个高性能的对象存储服务,兼容Amazon S3 API。它可以存储图片、视频、文档等任意类型的文件。

应用服务器 ──上传──→ MinIO集群 ──存储──→ 磁盘 │ 应用服务器 ←──下载────┘ MinIO集群部署: ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ Node 1 │ │ Node 2 │ │ Node 3 │ │ Node 4 │ │ Disk 1 │ │ Disk 2 │ │ Disk 3 │ │ Disk 4 │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ 数据自动纠删码,任意2块盘坏了数据不丢

17.3 Spring Boot集成MinIO

文件上传下载示例
// 配置
minio:
  endpoint: http://localhost:9000
  access-key: minioadmin
  secret-key: minioadmin
  bucket-name: my-bucket

// 上传文件
@PostMapping("/upload")
public String upload(@RequestParam("file") MultipartFile file) {
    String objectName = UUID.randomUUID() + getExtension(file.getOriginalFilename());
    minioClient.putObject(
        PutObjectArgs.builder()
            .bucket(bucketName)
            .object(objectName)
            .stream(file.getInputStream(), file.getSize(), -1)
            .contentType(file.getContentType())
            .build()
    );
    return minioEndpoint + "/" + bucketName + "/" + objectName;
}

// 下载文件
@GetMapping("/download/{objectName}")
public void download(@PathVariable String objectName, HttpServletResponse response) {
    InputStream stream = minioClient.getObject(
        GetObjectArgs.builder().bucket(bucketName).object(objectName).build()
    );
    IOUtils.copy(stream, response.getOutputStream());
}

17.4 大文件分片上传与断点续传

当上传几百MB甚至几GB的文件时,一次传完容易超时或中断。MinIO兼容S3的Multipart Upload(分片上传):把大文件切成小块逐个上传,最后合并。配合"查询已上传分片"接口,就能实现断点续传。

分片上传流程: 前端 MinIO │ │ │── 创建分片上传任务 ──────→│ 返回uploadId │ │ │── 上传分片1 (5MB) ───────→│ 返回ETag1 │── 上传分片2 (5MB) ───────→│ 返回ETag2 │── 上传分片3 (网络断了!) │ │ │ │ (用户重新选择文件) │ │── 查询已上传分片 ────────→│ 返回[分片1,分片2] │ │ │── 上传分片3 (5MB) ───────→│ 返回ETag3 │── 上传分片4 (5MB) ───────→│ 返回ETag4 │ │ │── 合并所有分片 ──────────→│ 文件合并完成 │ │
分片上传完整实现
// 大文件分片上传服务
@Service
public class MultipartUploadService {

    @Autowired
    private MinioClient minioClient;

    private static final long PART_SIZE = 5 * 1024 * 1024; // 5MB per part

    /**
     * 初始化分片上传,返回uploadId
     */
    public String initUpload(String bucket, String objectName) {
        CreateMultipartUploadResponse response = minioClient.createMultipartUpload(
            CreateMultipartUploadArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .build());
        return response.result().uploadId();
    }

    /**
     * 上传单个分片
     */
    public String uploadPart(String bucket, String objectName, String uploadId,
                             int partNumber, InputStream data, long size) {
        UploadPartResponse response = minioClient.uploadPart(
            UploadPartArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .uploadId(uploadId)
                .partNumber(partNumber)
                .stream(data, size, -1)
                .build());
        return response.etag();  // 每个分片的ETag,合并时需要
    }

    /**
     * 查询已上传的分片(实现断点续传的关键)
     */
    public List<Integer> listParts(String bucket, String objectName, String uploadId) {
        ListPartsResponse response = minioClient.listParts(
            ListPartsArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .uploadId(uploadId)
                .build());
        return response.result().partList().stream()
            .map(Part::partNumber)
            .collect(Collectors.toList());
    }

    /**
     * 合并所有分片,完成上传
     */
    public void completeUpload(String bucket, String objectName, String uploadId,
                               List<PartSource> partSources) {
        minioClient.completeMultipartUpload(
            CompleteMultipartUploadArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .uploadId(uploadId)
                .parts(partSources)
                .build());
    }

    /**
     * 取消分片上传(清理未完成的分片)
     */
    public void abortUpload(String bucket, String objectName, String uploadId) {
        minioClient.abortMultipartUpload(
            AbortMultipartUploadArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .uploadId(uploadId)
                .build());
    }
}

17.5 预签名URL直传方案

传统方案中,文件先传到应用服务器,再由应用服务器传到MinIO——应用服务器成了带宽瓶颈。预签名URL让前端直接上传到MinIO,绕过应用服务器。

生活类比:快递柜取件码

你网购了一个大件,快递员不是送到你家(应用服务器中转),而是给你一个快递柜取件码(预签名URL),你自己去快递柜(MinIO)取。快递员不用跑腿,你也不用等。

预签名URL直传方案
// 1. 后端生成预签名URL(有效期15分钟)
@GetMapping("/api/upload/presign")
public Map<String, String> getPresignUrl(@RequestParam String filename) {
    String objectName = UUID.randomUUID() + getExtension(filename);

    // 生成PUT预签名URL(上传用)
    String uploadUrl = minioClient.getPresignedObjectUrl(
        GetPresignedObjectUrlArgs.builder()
            .method(Method.PUT)
            .bucket(bucketName)
            .object(objectName)
            .expiry(15, TimeUnit.MINUTES)
            .build());

    // 生成GET预签名URL(预览用,有效期7天)
    String previewUrl = minioClient.getPresignedObjectUrl(
        GetPresignedObjectUrlArgs.builder()
            .method(Method.GET)
            .bucket(bucketName)
            .object(objectName)
            .expiry(7, TimeUnit.DAYS)
            .build());

    Map<String, String> result = new HashMap<>();
    result.put("uploadUrl", uploadUrl);
    result.put("previewUrl", previewUrl);
    result.put("objectName", objectName);
    return result;
}

// 2. 前端直接用预签名URL上传(不经过应用服务器)
// JavaScript:
// const { uploadUrl, previewUrl } = await fetch('/api/upload/presign?filename=a.jpg');
// await fetch(uploadUrl, { method: 'PUT', body: file });
// // 上传完成,previewUrl就是文件的访问地址

17.6 纠删码(Erasure Code)原理

MinIO使用纠删码保证数据可靠性:4块数据盘+2块校验盘,任意坏2块数据不丢。这比传统的3副本方案节省50%存储空间。

生活类比:快递分仓

你有一个100寸的大电视要存放在仓库。传统方案(3副本):租3个100寸的仓库各放一台电视,成本3倍。
纠删码方案:把电视拆成4个零件(数据块),再额外算出2个备用零件(校验块),分放在6个小仓库里。任何一个仓库着火(硬盘坏了),用剩余5个仓库的零件就能重新组装出完整的电视。

纠删码(Reed-Solomon编码)原理: 原始数据:D1 D2 D3 D4(4个数据块) 编码计算: P1 = D1 ⊕ D2 ⊕ D3 (校验块1) P2 = D1 × 2 ⊕ D2 × 3 ⊕ D3 × 5 ⊕ D4 × 7 (校验块2,实际是GF域运算) 存储:D1 D2 D3 D4 P1 P2(分散到6块盘) 恢复(假设D2和P1损坏): D2 = D1 ⊕ D3 ⊕ P1(但P1也坏了,用P2反推) → 用剩余4个块联立方程解出D2和P1 关键:6块盘中任意坏2块,数据都能恢复 存储开销:6/4 = 1.5倍(比3副本的3倍节省50%)
MinIO生产环境避坑 1. 分片上传要清理:用户中断上传后,未合并的分片会占用空间,设置生命周期规则自动清理
2. 预签名URL要限制过期时间:生产环境不超过15分钟,避免泄露后被滥用
3. 纠删码最少需要4块数据盘+2块校验盘:单机部署时所有磁盘不能在同一物理磁盘上
4. 大文件不要同步上传:超过100MB的文件必须用分片上传,否则网络抖动导致前功尽弃

第十八章:分布式链路追踪——SkyWalking

18.1 为什么需要链路追踪?

在微服务架构中,一个用户请求可能经过 10 个以上的服务。当请求变慢或出错时,你需要知道到底是哪个环节出了问题。没有链路追踪,你就像在黑暗中找一只黑猫。

生活类比:快递追踪

你寄了一个快递,可以在APP上看到:
北京收件 → 上海中转 → 杭州派送 → 已签收

如果快递丢了,你一看就知道丢在哪个环节。链路追踪就是给每个请求一个快递单号,记录它经过了哪些服务、每个服务花了多少时间。

18.2 核心概念

1
Trace:一次完整的请求链路,由一个全局唯一的TraceId标识
2
Span:链路中的一个操作单元(如一次HTTP调用、一次数据库查询)
3
SpanContext:跨服务传递的上下文信息(TraceId、SpanId等)

18.3 SkyWalking架构

┌────────────┐ ┌────────────┐ ┌────────────┐ │ Service A │────│ Service B │────│ Service C │ │ (Agent) │ │ (Agent) │ │ (Agent) │ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ │ │ │ └──────────────────┼──────────────────┘ │ 上报数据 ▼ ┌─────────────────────┐ │ SkyWalking OAP │ ← 数据收集和分析 │ Server │ └──────────┬──────────┘ │ ┌──────────┴──────────┐ ▼ ▼ ┌──────────────┐ ┌──────────────┐ │ SkyWalking │ │ ElasticSearch│ │ UI (可视化) │ │ (存储) │ └──────────────┘ └──────────────┘

18.4 使用方式

SkyWalking是无侵入的——不需要改一行代码,只需要在启动时加一个Java Agent:

启动时挂载SkyWalking Agent
# 启动服务时加上-javaagent参数
java -javaagent:/path/to/skywalking-agent.jar \
     -Dskywalking.agent.service_name=order-service \
     -Dskywalking.collector.backend_service=localhost:11800 \
     -jar order-service.jar

# 之后在SkyWalking UI上就能看到:
# - 每个请求的完整调用链
# - 每个环节的耗时
# - 服务间的依赖关系
# - 慢查询、异常请求的自动发现

18.5 自定义告警规则与Webhook推送

SkyWalking内置了告警引擎,支持基于指标阈值触发告警,并通过Webhook推送到钉钉、企微等IM工具。

alarm-settings.yml — 自定义告警规则
# SkyWalking告警规则配置文件
rules:
  # 规则1:服务P99延迟超过500ms
  service_p99_alert:
    metrics-name: service_p99  # 指标名(P99延迟)
    op: ">"
    threshold: 500             # 阈值:500ms
    period: 5                  # 统计窗口:5分钟
    count: 3                   # 连续3个窗口超阈值才告警
    silence-period: 10         # 告警后静默10分钟
    message: "服务 {name} 的P99延迟超过500ms,当前: {value}ms"

  # 规则2:服务成功率低于99%
  service_sla_alert:
    metrics-name: service_sla
    op: "<"
    threshold: 9900            # 99.00%(SkyWalking用万分比)
    period: 5
    count: 2
    message: "服务 {name} 成功率下降至 {value}%"

  # 规则3:服务响应时间超过1秒
  service_resp_time_alert:
    metrics-name: service_resp_time
    op: ">"
    threshold: 1000
    period: 3
    count: 3
    message: "服务 {name} 响应时间超过1秒"

# Webhook配置(推送到钉钉/企微)
webhooks:
  - url: http://dingtalk-webhook:12800/send
    # SkyWalking会POST JSON到这个URL
    # 包含告警规则名、服务名、指标值、告警时间
钉钉Webhook推送服务
// 接收SkyWalking告警并推送到钉钉
@RestController
public class AlarmWebhookController {

    private static final String DINGTALK_WEBHOOK =
        "https://oapi.dingtalk.com/robot/send?access_token=YOUR_TOKEN";

    @PostMapping("/send")
    public void handleAlarm(@RequestBody List<AlarmMessage> alarms) {
        for (AlarmMessage alarm : alarms) {
            // 构建钉钉消息
            String content = String.format(
                "⚠️ **SkyWalking告警**\n" +
                "- 规则: %s\n" +
                "- 服务: %s\n" +
                "- 指标值: %s\n" +
                "- 时间: %s\n" +
                "- 详情: %s",
                alarm.getRuleName(),
                alarm.getName(),
                alarm.getValue(),
                new SimpleDateFormat("HH:mm:ss").format(alarm.getStartTime()),
                alarm.getMessage()
            );

            // 推送到钉钉
            Map<String, Object> body = Map.of(
                "msgtype", "markdown",
                "markdown", Map.of("title", "SkyWalking告警", "text", content)
            );
            restTemplate.postForObject(DINGTALK_WEBHOOK, body, String.class);
        }
    }
}

18.6 日志与链路追踪的TraceId联动

线上排查问题时,最大的痛点是:链路追踪看到某个Span报错了,但找不到对应的日志。解决方案是把SkyWalking的TraceId注入到日志中,实现日志和链路的双向跳转。

方案:Logback日志中注入SkyWalking TraceId
<!-- logback-spring.xml 配置 -->
<configuration>
    <!-- SkyWalking TraceId注入到日志 -->
    <conversionRule conversionWord="tid"
        converterClass="org.apache.skywalking.apm.toolkit.log.logback.v1.x.TraceIdConverter"/>

    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- %tid 会被替换为SkyWalking的TraceId -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%tid] [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 输出JSON格式(方便ELK解析) -->
    <appender name="JSON" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp/>
                <logLevel/>
                <message/>
                <mdc/>
                <!-- TraceId自动注入到JSON日志 -->
                <mdc>
                    <fieldName>traceId</fieldName>
                    <mdcKey>tid</mdcKey>
                </mdc>
            </providers>
        </encoder>
    </appender>
</configuration>

// 日志输出效果:
// 2024-01-15 10:30:00.123 [TID:abc123def456] [http-nio-8080-exec-1] ERROR OrderService - 库存不足

// 在SkyWalking UI中:
// 点击某个Span → 可以直接跳转到ELK查看该TraceId的所有日志
// 在Kibana中:
// 搜索 traceId:abc123def456 → 查看该请求的所有日志
SkyWalking生产环境避坑 1. Agent版本与OAP版本必须一致:版本不匹配会导致数据丢失或UI显示异常
2. 不要在Agent中开过多插件:每个插件都会增加性能开销,只开需要的
3. 存储用ElasticSearch而非H2:H2只适合测试,生产必须用ES,且ES要3节点以上
4. 告警规则不要设太敏感:P99偶尔抖动到600ms是正常的,用"连续N次"机制避免误报
5. TraceId注入需要SkyWalking Toolkit依赖:pom.xml中引入apm-toolkit-logback-1.x

第十九章:高并发的本质——IO模型详解

19.1 为什么IO模型这么重要?

高并发的本质就是IO问题。CPU的速度是纳秒级,而网络IO是毫秒级——两者相差100万倍。大部分时间CPU都在等IO。理解IO模型,是理解高并发架构的基础。

19.2 五种IO模型

1
阻塞IO(BIO):你去餐厅点餐,站在柜台前一直等,饭做好了才走。期间什么都干不了。
2
非阻塞IO(NIO):你去餐厅点餐,服务员说"还没好",你过一会儿再来问,反复问直到做好。
3
IO多路复用:你同时点了10家餐厅的外卖,用一个APP统一监控——哪家做好了就去取哪家的。
4
信号驱动IO:你点了餐留下电话号码,做好了餐厅打电话通知你。
5
异步IO(AIO):你点了餐,餐厅直接给你送到家,你什么都不用管。

19.3 Reactor模式

Reactor模式是高性能网络框架的核心设计模式,Nginx、Netty、Redis都用到了它。

Reactor模式(单线程): ┌─────────────────────────────────────────┐ │ EventLoop(事件循环) │ │ │ │ ┌──────────┐ ┌───────────────────┐ │ │ │ Selector │───→│ 事件分发器 │ │ │ │ (epoll) │ │ │ │ │ └──────────┘ │ Accept → 处理连接 │ │ │ │ Read → 处理读取 │ │ │ │ Write → 处理写入 │ │ │ └───────────────────┘ │ └─────────────────────────────────────────┘ 核心思想:一个线程通过IO多路复用监听多个连接的IO事件 只有在IO事件就绪时才处理,避免了线程阻塞等待

19.4 select、poll、epoll 详解

IO多路复用的三种实现方式,理解它们的差异是理解Nginx、Redis、Netty高性能的关键:

select(1983年,POSIX标准): 调用方式:fd_set(位图),最大支持1024个连接 工作流程: 1. 将所有fd拷贝到内核空间 2. 内核遍历所有fd检查是否就绪 3. 将就绪的fd标记,拷贝回用户空间 4. 用户空间再次遍历找到就绪fd 缺点: - 最大1024个连接(FD_SETSIZE限制) - 每次调用都要拷贝全部fd_set(O(n)) - 每次都要遍历所有fd(O(n)) - 水平触发(LT):有数据没读完会一直通知 poll(1997年,System V): 改进:用pollfd数组替代位图,没有1024限制 缺点:仍然要遍历所有fd(O(n)),仍然要拷贝 epoll(2002年,Linux独有): 核心改进: 1. epoll_create:在内核创建事件表(只需一次) 2. epoll_ctl:增删改fd(增量操作,不用每次全量拷贝) 3. epoll_wait:只返回就绪的fd(O(1)通知) 优势: - 没有连接数限制(10万+轻松支持) - 事件驱动,只通知就绪的fd - 支持边缘触发(ET):只通知一次,效率更高 - mmap共享内存,减少拷贝
对比项selectpollepoll
最大连接数1024无限制无限制
fd传递每次全量拷贝每次全量拷贝mmap共享
就绪通知遍历全部fd遍历全部fd只返回就绪fd
时间复杂度O(n)O(n)O(1)
触发模式LTLTLT/ET
操作系统全平台全平台Linux
使用者早期框架较少使用Nginx、Redis、Netty
LT vs ET 模式 LT(水平触发):只要fd有数据可读,每次epoll_wait都会通知。编程简单,但可能重复通知。
ET(边缘触发):只在fd状态变化时通知一次。必须一次性读完所有数据(循环read直到EAGAIN),否则剩余数据不会再通知。效率高但编程复杂。
Nginx用ET,Redis用LT,Netty默认LT(可配置ET)。

19.5 零拷贝(Zero Copy)

传统文件传输需要4次拷贝和4次上下文切换,零拷贝技术将其减少到2次拷贝和2次切换:

传统文件传输(read + write): 磁盘 → 内核缓冲区 → 用户缓冲区 → Socket缓冲区 → 网卡 4次拷贝,4次上下文切换,CPU全程参与 sendfile零拷贝(Linux 2.1+): 磁盘 → 内核缓冲区 → 网卡(通过DMA直接传输) 2次拷贝(都是DMA),2次上下文切换,CPU不参与数据拷贝 mmap零拷贝(适合小数据量): 磁盘 → 内核缓冲区(与用户空间共享) → Socket缓冲区 → 网卡 3次拷贝,但用户空间和内核空间共享同一块内存,省去一次拷贝 Java中的零拷贝: - FileChannel.transferTo() → 底层调用sendfile - MappedByteBuffer → 底层调用mmap - Netty的FileRegion → 封装了transferTo
Java零拷贝示例
// 方式1:sendfile(适合大文件传输,如文件下载)
FileChannel fileChannel = new FileInputStream(file).getChannel();
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress(host, port));
fileChannel.transferTo(0, fileChannel.size(), socketChannel);
// 底层调用sendfile,数据不经过用户空间

// 方式2:mmap(适合小文件随机读写,如RocketMQ存储)
MappedByteBuffer mappedBuffer = fileChannel.map(
    FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());
// 直接操作内存映射,读写文件像读写内存一样快

// 方式3:Netty的零拷贝
// 1. ByteBuf使用堆外内存(DirectBuffer),减少一次拷贝
// 2. CompositeByteBuf组合多个Buffer,不拷贝数据
// 3. FileRegion传输文件,底层用sendfile
FileRegion region = new DefaultFileRegion(file, 0, file.length());
ctx.writeAndFlush(region);  // 零拷贝发送文件

19.6 Java中的IO模型

模型框架特点适用场景
BIOjava.net.ServerSocket一连接一线程连接数少(<1000)
NIOJava NIO、NettyIO多路复用、非阻塞高并发网络编程
AIOJava AIO(NIO.2)异步回调文件IO(Linux不成熟)
为什么AIO没有流行起来? Linux上的AIO实现不成熟(基于线程池模拟),性能不如epoll。Windows的IOCP是真正的异步IO,但服务器大多是Linux。所以Java领域主流是NIO(Netty),而不是AIO。

19.7 Netty线程模型详解

Netty是Java领域最流行的NIO框架,Dubbo、gRPC、Elasticsearch底层都用Netty。它的线程模型是高性能的关键:

Netty线程模型(主从Reactor多线程): ┌─────────────────────────────────────────────────────────┐ │ BossGroup(1个线程) │ │ ┌──────────────────────────────────────────────────┐ │ │ │ 轮询Accept事件 → 接收连接 → 注册到WorkerGroup │ │ │ └──────────────────────────────────────────────────┘ │ └───────────────────────────┬─────────────────────────────┘ │ 注册Channel ▼ ┌─────────────────────────────────────────────────────────┐ │ WorkerGroup(默认CPU核心数×2个线程) │ │ ┌──────────────────────────────────────────────────┐ │ │ │ 轮询Read/Write事件 → 执行IO读写 │ │ │ │ → 交给Pipeline中的Handler处理 │ │ │ └──────────────────────────────────────────────────┘ │ └───────────────────────────┬─────────────────────────────┘ │ 耗时业务逻辑 ▼ ┌─────────────────────────────────────────────────────────┐ │ BusinessGroup(自定义线程池) │ │ ┌──────────────────────────────────────────────────┐ │ │ │ 处理耗时业务:数据库查询、RPC调用、复杂计算 │ │ │ │ 避免阻塞Worker线程 │ │ │ └──────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────┘
Netty高性能服务器完整示例
// Netty是Java领域最流行的NIO框架
// BossGroup:负责接收连接(1个线程就够了)
// WorkerGroup:负责IO读写(默认CPU核心数×2)
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
// 业务线程池:处理耗时逻辑,避免阻塞Worker
EventLoopGroup businessGroup = new DefaultEventLoopGroup(16);

ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
    .channel(NioServerSocketChannel.class)
    .option(ChannelOption.SO_BACKLOG, 1024)      // TCP全连接队列大小
    .childOption(ChannelOption.SO_KEEPALIVE, true) // TCP保活
    .childOption(ChannelOption.TCP_NODELAY, true)  // 禁用Nagle算法,减少延迟
    .childHandler(new ChannelInitializer<SocketChannel>() {
        @Override
        protected void initChannel(SocketChannel ch) {
            ch.pipeline()
                .addLast(new LengthFieldBasedFrameDecoder(65535, 0, 4))  // 拆包
                .addLast(new StringDecoder())                            // 解码
                .addLast(businessGroup, new BusinessHandler());          // 业务处理(用业务线程池)
        }
    });

ChannelFuture future = bootstrap.bind(8080).sync();
// 单机可以轻松支持几十万连接
Netty高性能的核心设计 1. 主从Reactor:Boss线程只接收连接,Worker线程只做IO,互不干扰
2. 零拷贝:DirectBuffer、CompositeByteBuf、FileRegion
3. 内存池:PooledByteBufAllocator复用ByteBuf,减少GC
4. 无锁化:每个Channel绑定一个EventLoop,避免锁竞争
5. 对象池:Recycler复用对象,减少创建和GC开销

第二十章:负载均衡——Nginx与LVS

20.1 什么是负载均衡?

负载均衡(Load Balancing)是把大量用户请求分发到多台服务器上,避免单台服务器压力过大。

生活类比:银行叫号

银行有10个窗口,100个人排队。大堂经理(负载均衡器)会把客户分配到空闲的窗口,而不是所有人都挤在一个窗口前。

20.2 负载均衡的层次

L4
四层负载均衡(传输层)基于IP+端口转发,不看内容。LVS、F5。性能极高。
L7
七层负载均衡(应用层)基于HTTP内容转发(URL、Header等)。Nginx、HAProxy。功能丰富。

20.3 负载均衡算法

算法原理优点缺点
轮询依次分配请求简单均匀不考虑服务器性能差异
加权轮询按权重分配考虑性能差异权重固定
最少连接分配给连接数最少的动态均衡需要统计连接数
IP哈希同一IP固定访问同一服务器会话保持可能不均衡
一致性哈希哈希环节点变化影响小实现复杂

20.4 Nginx配置详解

Nginx负载均衡完整配置
# 定义上游服务器组
upstream backend {
    # 加权轮询(默认算法)
    server 192.168.1.1:8080 weight=5;  # 权重5,处理更多请求
    server 192.168.1.2:8080 weight=3;
    server 192.168.1.3:8080 weight=2;

    # 最少连接算法
    # least_conn;

    # IP哈希(会话保持)
    # ip_hash;

    # 响应时间最短优先(Nginx 1.7+)
    # least_time;

    # 连接超时和失败重试
    server 192.168.1.4:8080 weight=2 max_fails=3 fail_timeout=30s;

    # 备用服务器(其他都挂了才启用)
    server 192.168.1.5:8080 backup;

    # 长连接复用(减少TCP握手开销)
    keepalive 32;  # 保持32个空闲连接
}

server {
    listen 80;
    server_name www.example.com;

    # 静态资源直接返回
    location /static/ {
        root /data/www;
        expires 7d;  # 浏览器缓存7天
    }

    # 动态请求代理到后端
    location / {
        proxy_pass http://backend;
        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_connect_timeout 5s;   # 连接超时
        proxy_read_timeout 60s;     # 读取超时
        proxy_send_timeout 10s;     # 发送超时

        # 开启长连接
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }
}

20.5 Nginx健康检查

Nginx会自动检测后端服务器是否健康,不健康的服务器会被自动剔除,避免请求打到挂掉的服务上:

被动健康检查(开源版)
# 被动健康检查:Nginx根据请求失败情况判断服务器是否健康
upstream backend {
    server 192.168.1.1:8080 max_fails=3 fail_timeout=30s;
    # max_fails=3:连续失败3次标记为不健康
    # fail_timeout=30s:30秒后重新尝试(恢复检测)
    server 192.168.1.2:8080 max_fails=3 fail_timeout=30s;
}

# 主动健康检查(Nginx Plus商业版,或使用第三方模块)
# 主动定期发送探测请求,不依赖真实流量
# health_check interval=5s fails=3 passes=2 uri=/health;

20.6 LVS工作模式

LVS(Linux Virtual Server)是Linux内核级别的四层负载均衡,性能极高:

LVS三种工作模式: 1. NAT模式(Network Address Translation) 客户端 → LVS(修改目标IP) → 后端服务器 → LVS(修改源IP) → 客户端 优点:后端服务器可以是任意操作系统 缺点:LVS是瓶颈(所有流量都经过LVS),支持约10台后端 2. DR模式(Direct Routing,最常用) 客户端 → LVS(修改MAC地址) → 后端服务器 → 客户端(直接返回) 优点:响应不经过LVS,性能极高,支持100+台后端 缺点:LVS和后端必须在同一局域网 3. TUN模式(IP Tunneling) 客户端 → LVS(封装IP) → 后端服务器(解封装) → 客户端 优点:LVS和后端可以在不同机房 缺点:后端服务器需要支持IP隧道 性能对比: NAT:~10万QPS DR:~100万QPS(推荐) TUN:~50万QPS
LVS + Nginx 的多层架构 生产环境中,通常是 LVS(四层)→ Nginx(七层)→ 应用服务器 的多层架构:

LVS:做最外层的流量入口,基于IP+端口转发,性能极高(百万级QPS),扛住海量连接。
Nginx:做七层负载均衡,基于URL路由、限流、缓存、静态资源,功能丰富。
应用服务器:处理业务逻辑。

这种架构的优势:LVS保证性能,Nginx保证灵活性。即使Nginx挂了一台,LVS会自动把流量切到其他Nginx。
四层 vs 七层负载均衡的选择 选四层:纯TCP/UDP流量、数据库代理、游戏服务器、对性能要求极高
选七层:HTTP/HTTPS流量、需要URL路由、需要限流/缓存、需要灰度发布
两者都用:大型互联网公司通常是LVS+Nginx多层架构

第二十一章:数据库优化——读写分离与分库分表

21.1 数据库的性能瓶颈

当并发量上来后,数据库往往是最先扛不住的。MySQL单机QPS大约在几千到几万,而Redis可以达到10万+。数据库优化是高并发架构中最关键的一环。

21.2 读写分离

大部分业务场景都是读多写少(读写比可能是 8:2 甚至 9:1)。读写分离的思路是:主库负责写,从库负责读,通过主从复制同步数据。

应用程序 │ ├──写请求──→ Master(主库)──主从复制──→ Slave1(从库1) │ ↑ └──读请求──→ Slave1 / Slave2 轮询读 Slave2(从库2) 实现方式: 1. 代码层面:用不同的数据源(写用master,读用slave) 2. 中间件层面:用MyCat、ShardingSphere代理
Spring Boot读写分离配置
// 使用ShardingSphere实现读写分离
spring:
  shardingsphere:
    datasource:
      names: master,slave0,slave1
      master:
        url: jdbc:mysql://master:3306/db
        username: root
        password: 123456
      slave0:
        url: jdbc:mysql://slave0:3306/db
        username: root
        password: 123456
      slave1:
        url: jdbc:mysql://slave1:3306/db
        username: root
        password: 123456
    rules:
      readwrite-splitting:
        data-sources:
          myds:
            write-data-source-name: master
            read-data-source-names: slave0,slave1
            load-balancer-name: round-robin
        load-balancers:
          round-robin:
            type: ROUND_ROBIN

21.3 分库分表

当单表数据量超过2000万行或单库超过100GB时,数据库性能会急剧下降。这时需要分库分表。

垂直拆分 vs 水平拆分

垂直拆分(按业务拆): 一个大数据库 → 用户库 + 订单库 + 商品库 优点:业务隔离,故障不扩散 适合:微服务架构,每个服务有自己的库 水平拆分(按数据拆): order表(5000万行)→ order_0 + order_1 + ... + order_7(每表625万行) 优点:单表数据量减少,查询更快 适合:单表数据量过大

分片策略

按用户ID取模分表
// 订单表按user_id % 8分片
// user_id=100 的订单存在 order_4(100 % 8 = 4)
public String getTableName(Long userId) {
    int tableIndex = (int)(userId % 8);
    return "order_" + tableIndex;
}

// 查询某用户的所有订单
String table = getTableName(100L);
String sql = "SELECT * FROM " + table + " WHERE user_id = 100";

// 注意:分表后,跨表查询变得困难
// 比如"查询所有金额>1000的订单"需要查8张表再合并
// 所以分表键的选择非常重要
分表键选择原则 1. 选择查询频率最高的字段作为分表键(如user_id)
2. 分表键要能让大部分查询落在单表内
3. 避免跨表查询,必要时冗余数据
4. 常见分表键:user_id、order_id、tenant_id

21.4 跨分片查询的OOM风险与解决方案

分库分表后,跨分片的排序分页查询是最危险的操作。如果不加控制,中间结果集可能撑爆内存。

生活类比:全校排名

校长要查"全校成绩排名前10"。每个班(分片)先按成绩排好序,然后把所有人的成绩单送到校长办公室(内存归并)。如果全校有10000人,校长办公室要堆10000份成绩单——这就是OOM的风险。

跨分片分页查询的三种方案
// 方案1:禁止跳页,只允许"上一页/下一页"(推荐)
// 原理:用上一页最后一条的排序值作为下一页的查询条件
// 第一页:SELECT * FROM order_0..order_7 ORDER BY create_time DESC LIMIT 10
// 第二页:SELECT * FROM order_0..order_7
//         WHERE create_time < '上一页最后一条的时间'
//         ORDER BY create_time DESC LIMIT 10
// 优点:每个分片只需返回10条,不会OOM
// 缺点:不支持"跳到第100页"

// 方案2:流式归并(ShardingSphere的做法)
// 原理:每个分片只查LIMIT offset+size条,用最小堆归并
public List<Order> crossShardPage(int page, int pageSize) {
    // 每个分片只查当前页需要的数据量(而非全部)
    int limit = (page - 1) * pageSize + pageSize;

    // 并行查询所有分片
    List<Future<List<Order>>> futures = new ArrayList<>();
    for (int i = 0; i < SHARD_COUNT; i++) {
        final int shard = i;
        futures.add(executor.submit(() -> {
            String sql = "SELECT * FROM order_" + shard
                + " ORDER BY create_time DESC LIMIT " + limit;
            return jdbcTemplate.query(sql, orderRowMapper);
        }));
    }

    // 流式归并:用最小堆,每次只保留topN
    PriorityQueue<Order> minHeap = new PriorityQueue<>(
        pageSize, Comparator.comparing(Order::getCreateTime));
    for (Future<List<Order>> future : futures) {
        for (Order order : future.get()) {
            minHeap.offer(order);
            if (minHeap.size() > pageSize) {
                minHeap.poll();  // 移除最小的,堆中只保留最大的N个
            }
        }
    }

    // 取出当前页的数据
    List<Order> result = new ArrayList<>(minHeap);
    result.sort(Comparator.comparing(Order::getCreateTime).reversed());
    return result;
}

// 方案3:全局表(冗余排序字段到ES)
// 把需要排序/搜索的字段冗余到ElasticSearch
// 先从ES查出当前页的ID列表,再回查各分片获取完整数据

21.5 在线扩容与数据平滑迁移

分库分表最大的挑战不是初始分片,而是扩容。从4个分片扩展到8个分片,数据怎么迁移?停机迁移是不可接受的——必须做到不停机平滑迁移。

方案1:双写方案(简单直接) 迁移期间(写操作同时写新旧库): 应用层 │ ├──写→ 旧库(order_0..order_3) ← 始终写入 │ └──写→ 新库(order_0..order_7) ← 同时写入 迁移步骤: 1. 开启双写(同时写新旧库) 2. 后台任务:把旧库数据按新分片规则迁移到新库 3. 迁移完成后,读切到新库 4. 验证数据一致后,停掉双写,清理旧库 优点:实现简单,可控性强 缺点:双写期间有性能损耗,迁移代码侵入业务
方案2:Canal订阅Binlog(推荐) 应用层 → 旧库 ──Binlog──→ Canal ──→ 新库 迁移步骤: 1. 旧库开启Binlog 2. Canal订阅旧库的Binlog 3. Canal消费Binlog,按新分片规则写入新库 4. 历史数据用DataX/Spark批量迁移 5. 增量数据由Canal实时同步 6. 数据追平后,读切到新库 7. 写切到新库,停掉Canal 优点:对业务代码零侵入,数据延迟可控(秒级) 缺点:需要部署Canal集群,运维复杂度高
对比项双写方案Canal Binlog方案
业务侵入高(需要改写入代码)零侵入
数据一致性需要对账Binlog保证最终一致
性能影响双写期间有损耗几乎无影响
运维复杂度低高(Canal集群运维)
适用场景小规模、快速迁移大规模、不能停机
分库分表生产环境避坑 1. 不要过早分表:单表不到2000万行就别分,分了之后运维成本翻倍
2. 分表键一旦确定不能改:改分表键意味着全量数据迁移,所以初始选择要慎重
3. 全局ID必须提前规划:分表后不能用自增ID,必须用雪花算法或Leaf
4. 跨分片JOIN要避免:分表后无法JOIN,需要在应用层组装或冗余数据
5. 扩容时不要一次性切流:先切1%流量到新库,观察无异常后再逐步放量

第二十二章:缓存架构设计——多级缓存策略

22.1 为什么需要多级缓存?

单层缓存(只用Redis)在极端高并发下仍然可能成为瓶颈。多级缓存的思路是:不同层次的缓存承担不同的职责,层层过滤,最终只有少量请求打到数据库。

请求流向: 用户请求 → 本地缓存(Caffeine) → 分布式缓存(Redis) → 数据库(MySQL) ↓ 命中率60% ↓ 命中率30% ↓ 命中率10% 直接返回 直接返回 查询后回写缓存 总命中率:60% + 30% × 40% = 72%,只有28%的请求打到数据库 如果只用Redis:命中率80%,20%打到数据库

22.2 本地缓存:Caffeine

Caffeine本地缓存使用
// Caffeine是Java最好的本地缓存库
Cache<String, User> localCache = Caffeine.newBuilder()
    .maximumSize(10000)        // 最多缓存10000条
    .expireAfterWrite(60, TimeUnit.SECONDS)  // 写入60秒后过期
    .build();

// 使用
public User getUser(Long id) {
    String key = "user:" + id;

    // 1. 先查本地缓存
    User user = localCache.getIfPresent(key);
    if (user != null) return user;

    // 2. 再查Redis
    String json = redis.get(key);
    if (json != null) {
        user = JSON.parse(json);
        localCache.put(key, user);  // 回填本地缓存
        return user;
    }

    // 3. 最后查数据库
    user = userDao.selectById(id);
    if (user != null) {
        redis.setex(key, 3600, JSON.stringify(user));
        localCache.put(key, user);
    }
    return user;
}

22.3 热Key问题

某个key的访问量特别大(比如热门商品),导致Redis单节点压力过大。

1
本地缓存:热Key在本地缓存中就能命中,不会打到Redis
2
Key拆分:把一个热Key拆成多个子Key,分散到不同Redis节点
3
读写分离:读请求分散到多个从节点

22.4 缓存与数据库双写一致性

这是缓存领域最经典也最头疼的问题:更新数据库后,缓存里的旧数据怎么办?

生活类比:黑板与笔记本

老师在黑板上改了一道题的答案(数据库更新),但你的笔记本上(缓存)还是旧答案。如果你不更新笔记本,考试就会写错。问题是:老师先擦黑板还是先让你改笔记本?如果顺序不对,中间有同学来抄笔记就会抄到旧答案。

方案流程一致性性能复杂度
先删缓存再更新DB删缓存→更新DB差(并发时脏读)高低
先更新DB再删缓存更新DB→删缓存较好(极小概率脏读)高低
延迟双删删缓存→更新DB→等500ms→再删缓存好中中
Canal订阅Binlog更新DB→Canal监听Binlog→异步删缓存最终一致高高
终极方案:Canal订阅Binlog异步刷新缓存
// 架构:应用只更新DB,Canal自动同步缓存

// 1. MySQL开启Binlog(my.cnf)
// server-id=1
// log-bin=mysql-bin
// binlog-format=ROW

// 2. Canal客户端监听Binlog,自动刷新缓存
@CanalEventListener
public class CacheSyncListener {

    @Autowired
    private StringRedisTemplate redisTemplate;

    // 监听所有表的变更
    @UpdateListenPoint
    public void onUpdate(CanalEntry.RowData rowData) {
        String tableName = rowData.getAfterColumnsList().stream()
            .filter(CanalEntry.Column::getIsKey)
            .findFirst()
            .map(CanalEntry.Column::getValue)
            .orElse("");

        // 获取变更的主键
        String pkValue = rowData.getAfterColumnsList().stream()
            .filter(col -> "id".equals(col.getName()))
            .findFirst()
            .map(CanalEntry.Column::getValue)
            .orElse("");

        // 删除对应的缓存key
        String cacheKey = tableName + ":" + pkValue;
        redisTemplate.delete(cacheKey);

        log.info("Canal监听到变更: table={}, id={}, 已删除缓存",
            tableName, pkValue);
    }

    @DeleteListenPoint
    public void onDelete(CanalEntry.RowData rowData) {
        // 同样处理删除事件
        onUpdate(rowData);
    }
}

// 3. 应用代码只管更新DB,不用管缓存
public void updateUser(User user) {
    userDao.updateById(user);
    // 不需要手动删缓存!Canal会自动处理
}

// 4. 本地缓存也需要同步:Canal变更后发MQ通知所有实例清除本地缓存
@CanalEventListener
public class LocalCacheSyncListener {
    @UpdateListenPoint
    public void onUpdate(CanalEntry.RowData rowData) {
        // 发MQ广播通知所有实例清除本地缓存
        mq.send("cache:invalidate", tableName + ":" + pkValue);
    }
}

22.5 大Key(BigKey)治理

当单个Key的Value过大(如超过10KB的String或超过5000个元素的Hash/List/Set),就形成了大Key。大Key是Redis性能的隐形杀手。

大Key的危害 1. 阻塞其他请求:Redis单线程,读写大Key时其他请求都在等
2. 网络带宽消耗:一个10MB的Key,每次读取消耗10MB带宽
3. 内存不均:Cluster模式下大Key所在的节点内存压力远大于其他节点
4. 删除时卡顿:DEL一个100万元素的Set可能阻塞Redis几十毫秒
5. 主从同步延迟:大Key同步耗时长,导致主从数据不一致
大Key发现与清理方案
# 1. 发现大Key(生产环境用scan,不要用keys)
redis-cli --bigkeys -i 0.1  # 扫描所有Key,找出最大的
# 输出示例:
# [00.00%] Biggest string found so far 'user:profile:10001' with 52428 bytes
# [00.00%] Biggest set found so far 'online:user:20240115' with 1000000 members

# 2. 精确分析大Key
redis-cli memory usage "user:profile:10001"  # 查看内存占用
redis-cli strlen "user:profile:10001"        # String长度
redis-cli scard "online:user:20240115"       # Set元素数
redis-cli hlen "user:detail:10001"           # Hash字段数

# 3. 安全删除大Key(不要直接DEL!)
# 使用UNLINK(异步删除,不阻塞)
redis-cli UNLINK "user:profile:10001"

# 或者分批删除Hash/List/Set
# HSCAN分批删除Hash
redis-cli HSCAN "user:detail:10001" 0 COUNT 100
# 每次删100个字段
大Key拆分方案
// 问题:一个Hash存储了用户的10000条浏览记录
// HSET user:browse:10001 "20240115:product:1001" "{\"name\":\"手机\",\"time\":\"10:30\"}"
// ... 10000个field

// 方案:按时间拆分成多个小Hash
// 原来:user:browse:10001(10000个field)
// 拆分后:
//   user:browse:10001:202401(300个field)
//   user:browse:10001:202402(280个field)
//   ...
// 每个月一个Hash,自动过期旧月份

public void addBrowseRecord(Long userId, BrowseRecord record) {
    String month = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMM"));
    String key = "user:browse:" + userId + ":" + month;
    String field = record.getDate() + ":" + record.getProductId();
    redisTemplate.opsForHash().put(key, field, JSON.toJSONString(record));
    redisTemplate.expire(key, 90, TimeUnit.DAYS);  // 保留90天
}

// 查询最近浏览:只查最近2个月的Hash
public List<BrowseRecord> getRecentBrowse(Long userId, int months) {
    List<BrowseRecord> result = new ArrayList<>();
    for (int i = 0; i < months; i++) {
        String month = LocalDate.now().minusMonths(i)
            .format(DateTimeFormatter.ofPattern("yyyyMM"));
        String key = "user:browse:" + userId + ":" + month;
        Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
        entries.values().forEach(v -> result.add(JSON.parseObject(v.toString(), BrowseRecord.class)));
    }
    return result;
}
多级缓存生产环境避坑 1. 本地缓存失效要广播:一台机器清了缓存,其他机器不知道,需要用MQ广播
2. Canal延迟要监控:Canal消费Binlog有延迟(通常1-2秒),延迟期间读到旧数据是正常的
3. 大Key要定期巡检:用定时任务扫描Redis,发现大Key及时告警
4. 不要用KEYS命令:KEYS *会阻塞Redis,用SCAN替代
5. 缓存预热要有节制:上线时不要一次性加载所有缓存,用渐进式预热避免打爆DB

第二十三章:限流熔断——Sentinel实战

23.1 为什么需要限流?

系统的处理能力是有上限的。当请求量超过系统承受能力时,如果不做限制,系统会崩溃——一个服务崩溃可能引发连锁反应,导致整个系统雪崩。

生活类比:地铁限流

地铁站客流量太大时,工作人员会在入口处拦住乘客,分批放行。如果不拦,站台挤满了人,可能发生踩踏事故。限流就是在保护系统不被"踩踏"。

23.2 四种限流算法详解

算法原理特点适用场景
固定窗口计数器固定时间窗口内计数简单,但有临界突发问题简单场景
滑动窗口计数器窗口随时间滑动,统计更精确解决临界问题,Sentinel默认生产环境推荐
漏桶固定速率流出平滑流量,但不允许突发流量整形
令牌桶固定速率生成令牌允许突发流量Guava RateLimiter

固定窗口计数器(最简单,有缺陷)

固定窗口计数器: 时间轴: |--窗口1(0-60s)--|--窗口2(60-120s)--| 计数: | 99个请求 | 99个请求 | 限制: | 最多100个/分钟 | 问题(临界突发): 窗口1的最后1秒来了99个请求 窗口2的第1秒又来了99个请求 → 在2秒内实际处理了198个请求,远超100个/分钟的限制! 解决:用滑动窗口

滑动窗口计数器(Sentinel默认)

滑动窗口计数器(将窗口细分为多个小格子): 时间轴: |---1s---|---1s---|---1s---|---1s---|---1s---|---1s---| | 格子1 | 格子2 | 格子3 | 格子4 | 格子5 | 格子6 | 窗口大小 = 5秒(包含5个格子) 每秒检查最近5秒的总请求数 例如当前在第6秒: 统计格子2-6的总请求数(最近5秒) 如果超过阈值,拒绝请求 优点:统计精确,不存在临界问题 缺点:内存开销稍大(需要存储每个格子的计数)

漏桶算法(Leaky Bucket)

漏桶算法: 请求涌入 ↓ ┌──────────────┐ │ 漏桶 │ ← 容量固定(如100个请求) │ (队列) │ │ ●●●●●●●● │ └──────┬───────┘ │ 固定速率流出(如每秒10个) ↓ 处理请求 特点: - 流入速率可以变化(突发流量) - 流出速率恒定(平滑处理) - 桶满则丢弃新请求 - 缺点:不允许突发流量(即使系统空闲也是固定速率)

令牌桶算法(Token Bucket,Guava RateLimiter)

令牌桶算法: 令牌生成器(固定速率,如每秒10个) ↓ ┌──────────────┐ │ 令牌桶 │ ← 最多存100个令牌 │ ○○○○○○○○ │ └──────┬───────┘ │ 请求来了先拿令牌 ↓ 有令牌 → 处理请求 无令牌 → 排队等待或拒绝 特点: - 允许突发流量(桶里可以积攒令牌) - 空闲时积攒令牌,突发时可以瞬间消耗 - 适合"突发流量"场景
Guava RateLimiter 令牌桶示例
// 创建令牌桶:每秒生成10个令牌(即QPS=10)
RateLimiter limiter = RateLimiter.create(10.0);

// 方式1:阻塞等待(适合允许排队的场景)
double waitTime = limiter.acquire();  // 阻塞直到拿到令牌
// waitTime = 实际等待的秒数
processRequest();

// 方式2:立即判断(适合需要快速失败的场景)
if (limiter.tryAcquire()) {
    processRequest();  // 拿到令牌,处理请求
} else {
    return "系统繁忙,请稍后再试";  // 没拿到令牌,直接拒绝
}

// 方式3:预消费(突发场景)
limiter.acquire(10);  // 一次性拿10个令牌,预支后续配额
// 适合批处理场景:先处理一批,后续慢慢恢复

23.3 Sentinel限流配置

Sentinel流控规则
// 1. 引入Sentinel依赖
// spring-cloud-starter-alibaba-sentinel

// 2. 定义资源
@GetMapping("/api/orders")
@SentinelResource(value = "getOrders", blockHandler = "getOrdersBlock")
public List<Order> getOrders() {
    return orderService.findAll();
}

// 3. 限流降级方法
public List<Order> getOrdersBlock(BlockException ex) {
    return Collections.emptyList();  // 返回空列表
}

// 4. 配置限流规则(可在Sentinel控制台配置)
// QPS限制:每秒最多100个请求
// 超过100个请求直接走降级方法返回空列表
Sentinel限流规则代码配置
// 流控规则1:QPS限流
FlowRule rule = new FlowRule();
rule.setResource("getOrders");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);  // QPS模式
rule.setCount(100);                           // 阈值100
rule.setControlBehavior(
    RuleConstant.CONTROL_BEHAVIOR_WARM_UP);   // 预热模式
rule.setWarmUpPeriodSec(10);                  // 10秒预热期
FlowRuleManager.loadRules(Collections.singletonList(rule));

// 流控规则2:并发线程数限流
FlowRule rule2 = new FlowRule();
rule2.setResource("getOrders");
rule2.setGrade(RuleConstant.FLOW_GRADE_THREAD);  // 线程数模式
rule2.setCount(50);                               // 最多50个并发线程

// 流控规则3:热点参数限流
// 只对特定参数值限流,如:商品ID=1001的请求限流
ParamFlowRule paramRule = new ParamFlowRule("getOrder")
    .setParamIdx(0)           // 第0个参数
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(10);
// 针对特定参数值单独配置
ParamFlowItem item = new ParamFlowItem()
    .setObject(String.valueOf(1001))  // 商品ID=1001
    .setClassType(long.class)
    .setCount(2);                     // 限流为2 QPS
paramRule.setParamFlowItemList(Collections.singletonList(item));
ParamFlowRuleManager.loadRules(Collections.singletonList(paramRule));

23.4 熔断降级

当调用某个服务的错误率超过阈值时,自动熔断,不再调用该服务,直接返回降级结果。等一段时间后,再尝试恢复。

熔断状态机: 关闭(正常调用) │ 错误率>50% 或 慢调用比例>60% ▼ 打开(直接降级)──────→ 5秒后 ──────→ 半开(试探性调用) │ │ │ 成功率低 │ 成功率高 └──────────────────────────────────────┘ Sentinel熔断策略: 1. 慢调用比例:响应时间超过阈值的请求占比超过比例,触发熔断 2. 异常比例:异常请求占比超过比例,触发熔断 3. 异常数:异常请求数超过阈值,触发熔断
Sentinel熔断规则配置
// 熔断规则:慢调用比例
DegradeRule rule = new DegradeRule("getUserInfo")
    .setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType())
    .setCount(0.5)           // 慢调用比例阈值50%
    .setSlowRatioThreshold(200)  // RT超过200ms算慢调用
    .setTimeWindow(10)       // 熔断持续时间10秒
    .setMinRequestAmount(10) // 最少10个请求才触发熔断
    .setStatIntervalMs(10000);  // 统计窗口10秒

// 熔断规则:异常比例
DegradeRule rule2 = new DegradeRule("createOrder")
    .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType())
    .setCount(0.2)           // 异常比例阈值20%
    .setTimeWindow(10)       // 熔断持续时间10秒
    .setMinRequestAmount(10);

// 熔断降级方法
@SentinelResource(value = "getUserInfo",
    fallback = "getUserInfoFallback",
    fallbackClass = Fallback.class)
public User getUserInfo(Long userId) {
    return userFeignClient.getUser(userId);
}

// 降级方法:返回兜底数据
public class Fallback {
    public static User getUserInfoFallback(Long userId, Throwable e) {
        User user = new User();
        user.setName("用户信息暂时不可用");
        return user;
    }
}
服务雪崩的连锁反应 A调用B,B调用C。如果C挂了,B的线程全在等C的响应,B也挂了。然后A的线程全在等B,A也挂了。一个服务的故障像雪崩一样扩散到整个系统。熔断就是在这条链路上设置"保险丝"——C一出问题,B立刻放弃调用C,返回降级结果,保护自己不被拖垮。
限流 vs 熔断 vs 降级 的区别 限流:保护自己不被流量压垮。主动限制进入系统的请求量。
熔断:保护自己不被下游拖垮。当下游故障时,快速失败,不再调用。
降级:给用户一个兜底体验。限流或熔断触发后,返回默认数据或友好提示。

三者通常配合使用:限流控制入口流量 → 熔断保护下游依赖 → 降级保证用户体验。

第二十四章:异步化设计——响应式编程

24.1 同步 vs 异步

同步调用就像排队买奶茶——前面的人没拿到,你只能干等。异步调用就像扫码点餐——下单后你可以去逛街,奶茶做好了APP通知你。

24.2 CompletableFuture

Java 8引入的CompletableFuture是异步编程的利器:

异步并行调用多个服务
// 同步方式(总耗时 = 200 + 300 + 100 = 600ms)
User user = userService.getUser(1L);       // 200ms
List<Order> orders = orderService.getOrders(1L);  // 300ms
Wallet wallet = walletService.getWallet(1L);      // 100ms

// 异步方式(总耗时 = max(200, 300, 100) = 300ms)
CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(
    () -> userService.getUser(1L));
CompletableFuture<List<Order>> orderFuture = CompletableFuture.supplyAsync(
    () -> orderService.getOrders(1L));
CompletableFuture<Wallet> walletFuture = CompletableFuture.supplyAsync(
    () -> walletService.getWallet(1L));

// 等待所有完成
CompletableFuture.allOf(userFuture, orderFuture, walletFuture).join();

// 获取结果
User user = userFuture.get();
List<Order> orders = orderFuture.get();
Wallet wallet = walletFuture.get();
异步化的威力 三个服务调用,同步要600ms,异步只要300ms。如果并行调用10个服务,同步要2000ms,异步只要200ms。在高并发场景下,异步化能成倍提升系统吞吐量。

24.3 WebFlux响应式编程

Spring WebFlux是Spring的响应式Web框架,基于Reactor库,少量线程就能处理大量并发请求。

WebFlux vs Spring MVC
// Spring MVC(同步阻塞):一个请求占一个线程
@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
    return userService.getUser(id);  // 线程阻塞等待结果
}
// 200个并发请求需要200个线程

// WebFlux(异步非阻塞):一个线程处理多个请求
@GetMapping("/users/{id}")
public Mono<User> getUser(@PathVariable Long id) {
    return userService.getUserReactive(id);  // 非阻塞,线程去处理其他请求
}
// 200个并发请求可能只需要4个线程

24.4 背压(Backpressure)机制

异步编程中一个关键问题是:如果生产者速度远快于消费者怎么办?数据会堆积在内存中,最终 OOM。背压就是让消费者告诉生产者"慢点发"。

生活类比:自助餐

你去吃自助餐(消费者),厨师不断往台上加菜(生产者)。如果你吃不过来,你不会把所有菜都堆到自己盘子里——你只取你能吃完的量。这就是背压。

没有背压的系统就像一条流水线,上游不停往传送带放东西,下游处理不过来,东西就掉地上了(OOM)。

Reactor 背压示例
// 生产者每秒产生1000条数据
Flux<Integer> fastProducer = Flux.range(1, 100000)
    .delayElements(Duration.ofMillis(1));

// 消费者:限制每次只请求10条
fastProducer
    .limitRate(10)  // 每次只请求10条,处理完再请求下一批
    .subscribe(
        data -> processData(data),      // 处理数据
        error -> log.error(error),       // 错误处理
        () -> log.info("完成"),          // 完成回调
        subscription -> subscription.request(10)  // 初始请求10条
    );

// WebFlux中,Spring自动处理背压
// 当响应写满缓冲区时,自动暂停从上游拉取数据
背压策略 - BUFFER:缓存溢出的数据(可能OOM,默认策略)
- DROP:丢弃来不及处理的数据
- LATEST:只保留最新的数据
- ERROR:抛出异常

生产环境中,LIMIT_RATE(限制请求速率)是最安全的策略,既不会OOM也不会丢数据。

24.5 Reactor核心操作符实战

Reactor的操作符是响应式编程的核心。掌握flatMap和zip,就能解决90%的异步场景。

flatMap:解决嵌套异步调用
// 问题:用户→订单→商品 三层嵌套调用
// 同步写法:getUser → getOrders → getProduct(串行,总耗时=300+200+100=600ms)

// 响应式写法:flatMap链式调用(非阻塞,总耗时≈300ms)
public Mono<OrderDetail> getOrderDetail(Long orderId) {
    return orderReactiveDao.findById(orderId)              // Mono<Order>
        .flatMap(order -> {
            // 订单→用户(flatMap让两个Mono"嵌套"执行)
            return userReactiveClient.getUser(order.getUserId())
                .map(user -> {
                    OrderDetail detail = new OrderDetail();
                    detail.setOrder(order);
                    detail.setUser(user);
                    return detail;
                });
        })
        .flatMap(detail -> {
            // 订单详情→商品信息
            return productReactiveClient.getProduct(detail.getOrder().getProductId())
                .map(product -> {
                    detail.setProduct(product);
                    return detail;
                });
        });
}

// 关键理解:
// map:同步转换,T → U
// flatMap:异步转换,T → Mono<U>(解决嵌套Mono问题)
// 如果用map返回Mono<Mono<U>>,会变成"套娃"
zip:并行聚合多个异步结果
// 场景:首页需要同时获取用户信息、订单列表、推荐商品
// 三个请求互不依赖,应该并行执行

public Mono<HomePageData> getHomePage(Long userId) {
    Mono<User> userMono = userClient.getUser(userId);
    Mono<List<Order>> ordersMono = orderClient.getOrders(userId);
    Mono<List<Product>> productsMono = productClient.getRecommendations(userId);

    // zip:等所有Mono都完成后,把结果合并
    return Mono.zip(userMono, ordersMono, productsMono)
        .map(tuple -> {
            // tuple.getT1() = User
            // tuple.getT2() = List<Order>
            // tuple.getT3() = List<Product>
            HomePageData data = new HomePageData();
            data.setUser(tuple.getT1());
            data.setOrders(tuple.getT2());
            data.setRecommendations(tuple.getT3());
            return data;
        });
    // 总耗时 = max(200ms, 300ms, 150ms) = 300ms(并行!)
}

// 对比CompletableFuture:
// CompletableFuture.allOf(f1, f2, f3).join()  ← 阻塞式等待
// Mono.zip(f1, f2, f3)  ← 非阻塞式等待,不占线程

24.6 Context传播机制——WebFlux最大痛点

在传统MVC中,用ThreadLocal传递用户信息、TraceId等上下文。但在WebFlux中,一个请求可能在多个线程间切换——ThreadLocal会丢失。这就是WebFlux的Context传播问题。

生活类比:快递单号不能写在手上

传统MVC:一个快递员全程负责你的包裹,你把单号写在他手上(ThreadLocal),全程都能看到。
WebFlux:你的包裹在传送带上流动,经过不同快递员的手。单号写在手上就丢了——你得把单号写在包裹上(Reactor Context),包裹到哪,单号到哪。

对比项ThreadLocalReactor Context
绑定对象线程订阅链路(Subscriber)
跨线程不支持(线程切换就丢失)天然支持(跟着数据流走)
生命周期线程存活期间Publisher订阅期间
APIget()/set()contextWrite()/contextRead()
适用场景传统MVCWebFlux/Reactor
Reactor Context传播TraceId完整方案
// 1. 定义Context Key
public class ReactiveContext {
    public static final String TRACE_ID = "traceId";
    public static final String USER_ID = "userId";

    // 写入Context(在过滤器中设置)
    public static Mono<Void> put(String key, Object value) {
        return Mono.deferContextual(ctx -> Mono.empty())
            .contextWrite(Context.of(key, value));
    }

    // 读取Context(在业务代码中使用)
    public static <T> Mono<T> get(String key, Class<T> type) {
        return Mono.deferContextual(ctx -> {
            if (ctx.hasKey(key)) {
                return Mono.just(ctx.get(key));
            }
            return Mono.empty();
        });
    }
}

// 2. 全局过滤器:从请求头提取TraceId,写入Context
@Component
public class TraceFilter implements WebFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String traceId = exchange.getRequest().getHeaders()
            .getFirst("X-Trace-Id");
        if (traceId == null) {
            traceId = UUID.randomUUID().toString().replace("-", "");
        }

        String userId = exchange.getRequest().getHeaders()
            .getFirst("X-User-Id");

        // 将上下文信息写入Reactor Context
        return chain.filter(exchange)
            .contextWrite(Context.of(
                ReactiveContext.TRACE_ID, traceId,
                ReactiveContext.USER_ID, userId != null ? Long.parseLong(userId) : 0L
            ));
    }
}

// 3. 业务代码中读取Context
public Mono<Order> createOrder(OrderDTO dto) {
    return ReactiveContext.get(ReactiveContext.USER_ID, Long.class)
        .flatMap(userId -> {
            // 这里的userId是从Context中读取的,不依赖ThreadLocal
            Order order = new Order();
            order.setUserId(userId);
            order.setCreateTime(LocalDateTime.now());
            return orderReactiveDao.save(order);
        })
        .flatMap(order -> {
            // 记录日志时也能拿到TraceId
            return ReactiveContext.get(ReactiveContext.TRACE_ID, String.class)
                .doOnNext(traceId -> {
                    log.info("[{}] 订单创建成功: {}", traceId, order.getId());
                })
                .thenReturn(order);
        });
}

// 4. 日志配置中自动注入TraceId(logback + MDC)
// 在WebFilter中同时设置MDC:
// MDC.put("traceId", traceId);
// WebFlux的每个Mono执行时,MDC会自动从Context中恢复
WebFlux生产环境避坑 1. 不要在Reactor链路中使用ThreadLocal:线程切换后数据丢失,用Context替代
2. 不要在flatMap中调用阻塞方法:如JDBC查询,会阻塞EventLoop线程,用R2DBC或subscribeOn(Schedulers.boundedElastic())
3. 错误处理要用onErrorResume:不要用try-catch,catch不到异步异常
4. Context是只读的:contextWrite只能在链路下游写入,上游读取(反直觉但很重要)
5. 不要混用MVC和WebFlux:一个应用只能选一种,混用会导致不可预期的问题

第二十五章:连接池与线程池调优

25.1 为什么需要池化?

创建和销毁连接/线程是非常昂贵的操作。连接池的思路是:提前创建一批连接/线程,用完了放回去复用,而不是每次都新建。

生活类比:出租车 vs 私家车

每次出门都买一辆新车(创建连接),用完就报废(销毁连接),太浪费了。连接池就像出租车队:车提前准备好,你用完还回去,下一个人继续用。

25.2 数据库连接池(HikariCP)

HikariCP配置
spring:
  datasource:
    hikari:
      maximum-pool-size: 20       # 最大连接数
      minimum-idle: 5             # 最小空闲连接数
      idle-timeout: 300000        # 空闲连接最大存活时间(5分钟)
      max-lifetime: 1800000       # 连接最大存活时间(30分钟)
      connection-timeout: 30000   # 获取连接超时时间(30秒)

# 经验公式:
# 最大连接数 = CPU核心数 * 2 + 磁盘数
# 8核CPU的服务器:最大连接数 ≈ 16-20

25.3 线程池调优

自定义线程池
@Configuration
public class ThreadPoolConfig {

    @Bean("businessPool")
    public ExecutorService businessPool() {
        return new ThreadPoolExecutor(
            10,                     // 核心线程数
            50,                     // 最大线程数
            60, TimeUnit.SECONDS,   // 空闲线程存活时间
            new LinkedBlockingQueue<>(1000),  // 任务队列
            new ThreadFactoryBuilder().setNameFormat("biz-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
        );
    }
}

线程池参数调优公式

线程池参数计算
// 经验公式(来自《Java并发编程实战》)
// CPU密集型任务:核心线程数 = CPU核心数 + 1
// IO密集型任务:核心线程数 = CPU核心数 × (1 + IO等待时间/CPU计算时间)

// 示例1:CPU密集型(如加密、压缩)
// 8核CPU,纯计算,无IO等待
int cpuThreads = Runtime.getRuntime().availableProcessors() + 1;  // 9

// 示例2:IO密集型(如HTTP调用、数据库查询)
// 8核CPU,IO等待时间50ms,CPU计算时间5ms
// 核心线程数 = 8 × (1 + 50/5) = 88
int ioThreads = Runtime.getRuntime().availableProcessors() * 11;  // 88

// 示例3:混合型(如微服务接口:查数据库+调远程+计算)
// 建议拆分成两个线程池:IO池 + 计算池
// 或者通过压测确定最佳值

// 更精确的计算方式:
// 最佳线程数 = CPU核心数 × 目标CPU利用率 × (1 + 等待时间/计算时间)
// 目标CPU利用率通常设为70%-80%
int optimalThreads = (int)(8 * 0.75 * (1 + 50.0/5.0));  // 66

线程池监控与动态调整

生产环境必须监控线程池状态,并支持动态调整参数:

线程池监控
// 获取线程池运行状态
ThreadPoolExecutor pool = (ThreadPoolExecutor) businessPool;

// 核心监控指标
int activeCount = pool.getActiveCount();          // 活跃线程数
int poolSize = pool.getPoolSize();                 // 当前线程数
int corePoolSize = pool.getCorePoolSize();         // 核心线程数
int maxPoolSize = pool.getMaximumPoolSize();       // 最大线程数
long completedTaskCount = pool.getCompletedTaskCount(); // 已完成任务数
int queueSize = pool.getQueue().size();            // 队列积压数
int queueRemaining = pool.getQueue().remainingCapacity(); // 队列剩余容量

// 告警规则:
// 1. 队列积压 > 队列容量的80% → 告警(可能要溢出)
// 2. 活跃线程数 = 最大线程数 → 告警(线程池已满)
// 3. 拒绝策略触发 → 立即告警

// 动态调整线程池参数(运行时修改,无需重启)
pool.setCorePoolSize(20);      // 调整核心线程数
pool.setMaximumPoolSize(100);  // 调整最大线程数
// 注意:不能调整队列大小(LinkedBlockingQueue创建后不可变)
// 如果需要动态队列,使用VariableLinkedBlockingQueue或美团的思路
美团线程池动态调优方案 美团开源了动态线程池方案(dynamic-tp),核心思路:
1. 线程池参数注册到Nacos配置中心
2. 监控线程池的活跃线程数、队列积压、拒绝次数
3. 配置变更时自动调整线程池参数
4. 队列积压超过阈值时自动告警

这种方式可以在不重启服务的情况下调整线程池,非常适合生产环境。

线程池常见坑与最佳实践

线程池的5个常见坑 1. 不要用Executors创建线程池:newFixedThreadPool和newSingleThreadExecutor的队列是无界的(LinkedBlockingQueue),任务堆积会OOM
2. 队列不要太大:队列太大 → 任务堆积 → 响应延迟 → 用户超时 → 更多重试 → 更多堆积 → OOM
3. 拒绝策略要选对:默认AbortPolicy会抛异常,推荐CallerRunsPolicy(让调用者线程执行,起到限流作用)
4. 线程池要命名:不命名的话dump线程时全是pool-1-thread-1,根本分不清是哪个线程池
5. 父子线程池要注意上下文传递:线程池中的线程拿不到主线程的ThreadLocal(如用户信息、TraceId),需要用InheritableThreadLocal或阿里TTL
线程池的拒绝策略详解 当队列满了且线程数达到最大值时,新任务会被拒绝。四种拒绝策略:
- AbortPolicy:抛RejectedExecutionException(默认)。适合:需要感知限流
- CallerRunsPolicy:让提交任务的线程自己执行(推荐)。适合:不丢任务,且能自动降速
- DiscardPolicy:静默丢弃。适合:允许丢失的场景(如日志)
- DiscardOldestPolicy:丢弃队列中最老的任务。适合:只要最新的数据

生产环境推荐CallerRunsPolicy:当线程池满了,调用者线程(如Tomcat线程)自己执行任务,这样Tomcat线程被占用,自然就无法接收新请求,起到了自适应限流的作用。

25.4 HTTP连接池

除了数据库连接池,HTTP连接池同样重要。微服务之间的HTTP调用如果不复用连接,每次都要TCP握手,性能极差:

RestTemplate + Apache HttpClient连接池
// 配置HTTP连接池
@Configuration
public class HttpClientConfig {

    @Bean
    public CloseableHttpClient httpClient() {
        PoolingHttpClientConnectionManager manager =
            new PoolingHttpClientConnectionManager();
        manager.setMaxTotal(200);           // 最大连接数
        manager.setDefaultMaxPerRoute(50);  // 每个路由最大连接数

        return HttpClients.custom()
            .setConnectionManager(manager)
            .setKeepAliveStrategy((response, context) -> {
                return 60 * 1000;  // 长连接保持60秒
            })
            .build();
    }

    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
            .setConnectTimeout(Duration.ofSeconds(5))   // 连接超时
            .setReadTimeout(Duration.ofSeconds(30))     // 读取超时
            .build();
    }
}

// OpenFeign底层也用连接池,配置方式:
feign:
  httpclient:
    hc5:
      enabled: true
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 30000

第二十六章:高并发实战——秒杀系统设计

26.1 秒杀的挑战

秒杀系统是高并发的终极考验:100万人同时抢100件商品。核心挑战是超卖问题和系统扛压。

生活类比:限量球鞋发售

100双限量球鞋,10万人排队抢购。如果不做任何限制,所有人都会同时冲向柜台——柜台被挤塌(服务器崩溃),球鞋被抢超卖(库存变成负数)。你需要:门口限流(每次放100人)→ 排队取号(Redis扣库存)→ 凭号领鞋(异步下单)→ 核验身份(防黄牛)。

26.2 秒杀系统架构

用户 → CDN(静态资源) → Nginx(限流+负载均衡) → API网关(鉴权+限流) → 秒杀服务 → Redis(库存预扣减) → MQ(异步下单) → 订单服务 → 数据库 关键设计: 1. 前端:按钮倒计时、验证码、防重复提交 2. Nginx:限制每秒请求数 3. 网关:限制每用户每秒只能请求1次 4. Redis:用Lua脚本原子扣减库存 5. MQ:异步创建订单,削峰填谷 6. 数据库:乐观锁扣减库存,防止超卖

26.3 核心代码:Redis+Lua扣减库存

Lua脚本保证原子性
-- 秒杀扣减库存的Lua脚本
-- KEYS[1]: 库存key
-- KEYS[2]: 已购买用户集合key
-- ARGV[1]: 用户ID

-- 1. 判断用户是否已购买
local bought = redis.call('sismember', KEYS[2], ARGV[1])
if bought == 1 then
    return -1  -- 已购买,不能重复抢
end

-- 2. 判断库存是否充足
local stock = tonumber(redis.call('get', KEYS[1]))
if stock <= 0 then
    return 0  -- 库存不足
end

-- 3. 扣减库存,记录用户
redis.call('decr', KEYS[1])
redis.call('sadd', KEYS[2], ARGV[1])
return 1  -- 抢购成功

// Java端调用
String script = "...上面的Lua脚本...";
Long result = redisClient.eval(script,
    Arrays.asList("stock:1001", "bought:1001"),
    Collections.singletonList(userId));

if (result == 1) {
    // 抢购成功,发送MQ消息异步创建订单
    mq.send("seckill_order", new SeckillOrder(userId, goodsId));
} else if (result == 0) {
    return "库存不足";
} else {
    return "不能重复抢购";
}

26.4 完整秒杀流程

1
前端防刷:按钮倒计时、验证码、防重复提交(同一用户3秒内只能点一次)
2
Nginx限流:limit_req_zone限制每秒请求数,漏桶算法平滑流量
3
网关限流:Sentinel限制每用户每秒只能请求1次,IP级别限流
4
Redis预扣减:Lua脚本原子判断库存+扣减+防重复,99.9%请求到此结束
5
MQ异步下单:扣减成功后发送MQ消息,削峰填谷
6
数据库落库:MQ消费者创建订单,乐观锁扣减数据库库存
MQ消费者:异步创建订单
@Component
@RocketMQMessageListener(topic = "seckill_order", consumerGroup = "seckill-group")
public class SeckillOrderConsumer implements RocketMQListener<SeckillOrder> {

    @Override
    @Transactional
    public void onMessage(SeckillOrder seckillOrder) {
        try {
            // 1. 数据库乐观锁扣减库存(防止Redis与DB数据不一致)
            int rows = stockDao.deductStock(seckillOrder.getProductId(), 1);
            if (rows == 0) {
                // 库存不足(可能Redis和DB不一致),发送告警
                alertService.sendAlert("秒杀库存不一致: " + seckillOrder.getProductId());
                return;
            }

            // 2. 创建订单
            Order order = new Order();
            order.setUserId(seckillOrder.getUserId());
            order.setProductId(seckillOrder.getProductId());
            order.setStatus(0);  // 待支付
            order.setCreateTime(LocalDateTime.now());
            orderDao.insert(order);

            // 3. 发送延时消息:30分钟未支付自动取消
            rocketMQTemplate.syncSend("order_timeout",
                MessageBuilder.withPayload(order.getId())
                    .setHeader("DELAY", 2).build());  // 延时Level 2 = 5秒(示例)

            log.info("秒杀订单创建成功: userId={}, productId={}",
                seckillOrder.getUserId(), seckillOrder.getProductId());
        } catch (Exception e) {
            log.error("秒杀订单创建失败", e);
            // 消费失败,MQ会自动重试
            throw new RuntimeException("秒杀订单创建失败", e);
        }
    }
}

// 数据库层:乐观锁防超卖
@Update("UPDATE stock SET count = count - #{count}, version = version + 1 " +
        "WHERE product_id = #{productId} AND count >= #{count} AND version = #{version}")
int deductStockWithVersion(@Param("productId") Long productId,
                           @Param("count") int count,
                           @Param("version") int version);

26.5 秒杀系统的6层防护体系

秒杀系统的层层过滤(漏斗模型): 100万请求 ──→ CDN(静态页面缓存) 过滤掉:纯静态资源请求 剩余:~50万 50万请求 ──→ Nginx(限流+验证码) 过滤掉:超频请求、无验证码请求 剩余:~10万 10万请求 ──→ API网关(Sentinel限流+鉴权) 过滤掉:未登录、超频、黑名单 剩余:~5万 5万请求 ──→ Redis(库存预扣减) 过滤掉:库存不足、重复抢购 剩余:~100(等于库存数) 100请求 ──→ MQ(异步下单) 削峰填谷,平稳写入数据库 100请求 ──→ MySQL(创建订单) 乐观锁防超卖,事务保证一致性 核心思想:99.99%的请求在Redis层被拦截,只有极少数请求到达数据库
秒杀系统的核心思想 1. 尽量把请求拦在外面:CDN → Nginx → 网关 → Redis,层层过滤
2. 异步处理:Redis扣成功就行,订单异步创建
3. 原子操作:用Lua脚本保证"判断+扣减"的原子性
4. 防止超卖:数据库用乐观锁 UPDATE stock SET count=count-1 WHERE id=? AND count>0
5. 兜底方案:即使Redis和DB数据不一致,数据库乐观锁是最后一道防线
秒杀系统生产环境避坑 1. 库存预热:秒杀开始前把库存加载到Redis,不要秒杀时才查数据库
2. Redis和DB一致性:Redis扣减成功但MQ消费失败怎么办?用定时任务对账,或用本地事务表
3. 热点商品:如果所有请求打到同一个Redis Key,用本地缓存+Redis集群分散压力
4. 防黄牛:设备指纹、IP限频、人机验证(滑块验证码)、黑名单
5. 降级开关:秒杀系统必须有降级开关,出问题时一键关闭秒杀功能,返回"活动已结束"

第二十七章:微服务拆分原则与DDD

27.1 拆分的时机

不是所有系统都需要微服务。以下信号出现时,才应该考虑拆分:

27.2 DDD领域驱动设计

DDD是微服务拆分的方法论。核心思想是:按照业务领域来拆分服务,而不是按照技术层次。

生活类比:公司部门划分

公司可以按"技术"划分:前端部、后端部、数据库部——这是按技术层次划分。
也可以按"业务"划分:电商事业部、金融事业部、物流事业部——这是按业务领域划分。

DDD建议按业务领域划分,因为每个部门(服务)都能独立完成一件事。

27.3 限界上下文(Bounded Context)

限界上下文是DDD中最核心的概念——每个微服务就是一个限界上下文。

电商系统的限界上下文划分: ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ 用户上下文 │ │ 商品上下文 │ │ 订单上下文 │ │ │ │ │ │ │ │ - 用户注册 │ │ - 商品管理 │ │ - 创建订单 │ │ - 用户登录 │ │ - 分类管理 │ │ - 订单查询 │ │ - 用户信息 │ │ - 库存管理 │ │ - 订单取消 │ └──────────────┘ └──────────────┘ └──────────────┘ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ 支付上下文 │ │ 营销上下文 │ │ 物流上下文 │ │ │ │ │ │ │ │ - 支付下单 │ │ - 优惠券 │ │ - 发货管理 │ │ - 支付回调 │ │ - 满减活动 │ │ - 物流追踪 │ │ - 退款 │ │ - 秒杀 │ │ - 签收确认 │ └──────────────┘ └──────────────┘ └──────────────┘ 每个上下文有自己的: - 独立的数据库 - 独立的代码仓库 - 独立的团队负责 - 独立的部署和扩容

27.4 拆分原则

1
高内聚低耦合:服务内部的代码紧密相关,服务之间的依赖尽可能少
2
单一职责:每个服务只负责一个业务领域
3
数据独立:每个服务有自己的数据库,不共享数据库
4
团队对齐:一个服务由一个小团队(2-5人)负责

27.5 战术设计:实体、值对象、聚合根

DDD的战术设计是"概念科普"和"代码落地"之间的桥梁。很多教程只讲概念,不讲代码——这里补上。

实体 vs 值对象 vs 聚合根——代码级区别
// ===== 值对象(Value Object)=====
// 特征:没有唯一标识,靠属性值判断相等,不可变
// 例子:金额、地址、坐标
public class Money {
    private final BigDecimal amount;  // final = 不可变
    private final String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    // 值对象相等:属性值相同就是相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        Money money = (Money) o;
        return Objects.equals(amount, money.amount)
            && Objects.equals(currency, money.currency);
    }

    // 业务方法:金额运算返回新对象(不修改自身)
    public Money add(Money other) {
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

// ===== 实体(Entity)=====
// 特征:有唯一标识(ID),靠ID判断相等,可变
// 例子:订单项
public class OrderItem {
    private Long id;         // 唯一标识
    private Long productId;
    private String productName;
    private Money price;     // 值对象作为属性
    private int quantity;

    // 实体相等:ID相同就是相等(即使其他属性不同)
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        OrderItem item = (OrderItem) o;
        return Objects.equals(id, item.id);
    }

    // 业务方法
    public Money getSubtotal() {
        return new Money(
            price.getAmount().multiply(BigDecimal.valueOf(quantity)),
            price.getCurrency());
    }
}

// ===== 聚合根(Aggregate Root)=====
// 特征:是实体的一种,是聚合的"门卫",外部只能通过聚合根访问内部实体
// 例子:订单(聚合根包含订单项)
public class Order {
    private Long id;                    // 聚合根的唯一标识
    private Long userId;
    private List<OrderItem> items;      // 内部实体
    private Money totalAmount;          // 值对象
    private OrderStatus status;
    private LocalDateTime createTime;

    // 聚合根负责维护业务不变量(业务规则)
    public void addItem(Long productId, String productName, Money price, int qty) {
        // 业务规则:已支付的订单不能添加商品
        if (status != OrderStatus.CREATED) {
            throw new BusinessException("已支付的订单不能修改");
        }
        // 业务规则:订单项不能超过50个
        if (items.size() >= 50) {
            throw new BusinessException("订单项不能超过50个");
        }
        OrderItem item = new OrderItem(productId, productName, price, qty);
        items.add(item);
        recalculateTotal();  // 重新计算总金额
    }

    // 聚合根控制状态流转
    public void pay() {
        if (status != OrderStatus.CREATED) {
            throw new BusinessException("只有待支付订单才能支付");
        }
        if (items.isEmpty()) {
            throw new BusinessException("空订单不能支付");
        }
        this.status = OrderStatus.PAID;
    }

    private void recalculateTotal() {
        this.totalAmount = items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }
}

27.6 领域事件(Domain Event)解耦聚合根

聚合根之间不应该直接调用——用领域事件解耦。订单创建后,不需要直接调用库存服务和通知服务,而是发一个"订单已创建"事件。

领域事件实现
// 1. 定义领域事件
public class OrderCreatedEvent {
    private final Long orderId;
    private final Long userId;
    private final Money totalAmount;
    private final List<OrderItem> items;
    private final LocalDateTime occurredOn;

    public OrderCreatedEvent(Order order) {
        this.orderId = order.getId();
        this.userId = order.getUserId();
        this.totalAmount = order.getTotalAmount();
        this.items = order.getItems();
        this.occurredOn = LocalDateTime.now();
    }
    // getter省略
}

// 2. 聚合根发布事件
public class Order {
    // 领域事件列表(聚合根内部维护)
    private final List<Object> domainEvents = new ArrayList<>();

    public void create() {
        // ... 业务逻辑
        this.status = OrderStatus.CREATED;
        // 发布领域事件
        registerEvent(new OrderCreatedEvent(this));
    }

    protected void registerEvent(Object event) {
        domainEvents.add(event);
    }

    public List<Object> pullEvents() {
        List<Object> events = new ArrayList<>(domainEvents);
        domainEvents.clear();
        return events;
    }
}

// 3. Repository保存聚合根后,发布事件
public class OrderRepositoryImpl {
    @Autowired
    private ApplicationEventPublisher publisher;

    @Transactional
    public void save(Order order) {
        orderDao.save(order);
        // 事务提交后发布领域事件
        for (Object event : order.pullEvents()) {
            publisher.publishEvent(event);
        }
    }
}

// 4. 事件监听器(跨聚合根/跨服务解耦)
@Component
public class OrderEventListener {

    @EventListener
    @Async  // 异步执行,不阻塞主流程
    public void onOrderCreated(OrderCreatedEvent event) {
        // 扣减库存
        stockService.deduct(event.getItems());
        // 发送通知
        notificationService.sendOrderCreated(event.getUserId(), event.getOrderId());
        // 更新统计数据
        statisticsService.updateDailySales(event.getTotalAmount());
    }
}

27.7 六边形架构(端口与适配器)

六边形架构是DDD的工程化落地方式。核心思想是:业务逻辑在内层,技术实现在外层,通过端口和适配器连接。

六边形架构分层: ┌─────────────────────────┐ │ 适配器(Adapter) │ │ ┌─────────────────────┐ │ │ │ 入站适配器(驱动) │ │ │ │ - REST Controller │ │ │ │ - MQ Consumer │ │ │ │ - gRPC Service │ │ │ └────────┬────────────┘ │ │ │ 调用端口 │ │ ┌────────▼────────────┐ │ │ │ 端口(Port) │ │ │ │ - UseCase接口 │ │ │ │ - Repository接口 │ │ │ └────────┬────────────┘ │ │ │ 实现端口 │ │ ┌────────▼────────────┐ │ │ │ 领域层(Domain) │ │ │ │ - Entity │ │ │ │ - ValueObject │ │ │ │ - DomainService │ │ │ │ - DomainEvent │ │ │ └────────┬────────────┘ │ │ │ 实现端口 │ │ ┌────────▼────────────┐ │ │ │ 出站适配器(被驱动) │ │ │ │ - MySQL Repository │ │ │ │ - Redis Cache │ │ │ │ - HTTP Client │ │ │ │ - MQ Producer │ │ │ └─────────────────────┘ │ └─────────────────────────┘ 核心规则: - 领域层不依赖任何外部框架(无Spring注解、无JPA注解) - 外层依赖内层,内层不知道外层的存在 - 端口是接口,适配器是实现(依赖倒置)
标准工程目录结构
order-service/
├── src/main/java/com/example/order/
│   ├── domain/                          ← 领域层(最内层,零依赖)
│   │   ├── model/
│   │   │   ├── Order.java               ← 聚合根
│   │   │   ├── OrderItem.java           ← 实体
│   │   │   ├── OrderStatus.java         ← 枚举
│   │   │   ├── Money.java               ← 值对象
│   │   │   └── event/
│   │   │       └── OrderCreatedEvent.java ← 领域事件
│   │   ├── service/
│   │   │   └── OrderDomainService.java  ← 领域服务
│   │   └── repository/
│   │       └── OrderRepository.java     ← 出站端口(接口)
│   │
│   ├── application/                     ← 应用层(编排领域对象)
│   │   ├── usecase/
│   │   │   ├── CreateOrderUseCase.java  ← 入站端口(接口)
│   │   │   └── CreateOrderHandler.java  ← 用例实现
│   │   └── event/
│   │       └── OrderEventListener.java  ← 事件监听器
│   │
│   ├── adapter/                         ← 适配器层(最外层)
│   │   ├── inbound/                     ← 入站适配器(驱动)
│   │   │   ├── rest/
│   │   │   │   └── OrderController.java
│   │   │   └── mq/
│   │   │       └── OrderConsumer.java
│   │   └── outbound/                    ← 出站适配器(被驱动)
│   │       ├── persistence/
│   │       │   ├── OrderRepositoryImpl.java  ← 实现出站端口
│   │       │   ├── OrderJpaEntity.java       ← JPA实体(非领域实体)
│   │       │   └── OrderJpaRepository.java   ← Spring Data JPA
│   │       └── cache/
│   │           └── OrderCacheAdapter.java
│   │
│   └── infrastructure/                  ← 基础设施
│       ├── config/
│       │   └── BeanConfig.java
│       └── mq/
│           └── RocketMQProducer.java
│
└── pom.xml
DDD落地避坑 1. 不要过度设计:简单的CRUD不需要DDD,只有业务复杂(如金融、电商核心链路)才值得
2. 领域层不要有框架注解:@Entity、@Table是JPA的,不属于领域层
3. 聚合根不要太大:一个聚合根控制20个实体会导致性能问题,适当拆分
4. 领域事件要异步处理:同步事件会导致聚合根之间强耦合
5. Repository接口在领域层,实现在适配器层:这是依赖倒置的关键

第二十八章:Spring Cloud全景图

28.1 什么是Spring Cloud?

Spring Cloud是一套微服务开发工具集,它不是单个框架,而是多个组件的集合。用它可以快速搭建一个完整的微服务系统。

28.2 Spring Cloud核心组件

网关
Spring Cloud Gateway统一入口、路由转发、限流、鉴权
注册中心
Nacos / Eureka服务注册与发现,自动检测服务上下线
配置中心
Nacos Config集中管理配置,动态刷新
服务调用
OpenFeign / Dubbo声明式HTTP调用 / RPC调用
熔断限流
Sentinel流量控制、熔断降级、系统保护
分布式事务
SeataAT/TCC/Saga模式分布式事务

28.3 项目搭建

父工程pom.xml
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<properties>
    <spring-cloud.version>2023.0.0</spring-cloud.version>
    <spring-cloud-alibaba.version>2023.0.0.0</spring-cloud-alibaba.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

第二十九章:服务注册与发现——Nacos

29.1 为什么需要服务注册?

在微服务架构中,服务实例的IP和端口是动态变化的(扩容、缩容、重启)。如果硬编码地址,每次变动都要改配置。服务注册中心的作用就是:服务启动时自动注册自己的地址,调用方自动发现可用的服务地址。

生活类比:通讯录

服务注册中心就像手机通讯录:你不需要记住每个朋友的电话号码,你只需要在通讯录里搜名字。朋友换号了,更新通讯录就行。

29.2 Nacos服务注册

服务提供者
// pom.xml引入依赖
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

// application.yml
spring:
  application:
    name: user-service  # 服务名
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

// 启动后自动注册到Nacos
// 可在Nacos控制台看到服务列表
服务消费者
// 通过服务名调用,而不是IP地址
// 使用OpenFeign声明式调用
@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/api/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

// 使用
@Autowired
private UserServiceClient userServiceClient;

public Order getOrder(Long orderId) {
    Order order = orderDao.selectById(orderId);
    // 通过服务名调用,自动从Nacos获取地址
    User user = userServiceClient.getUser(order.getUserId());
    order.setUserName(user.getName());
    return order;
}

29.3 健康检查

Nacos会定期检查服务实例是否健康。不健康的实例会被自动剔除,避免请求打到挂掉的服务上。

1
临时实例(AP模式):客户端定期发送心跳(默认5秒),超时15秒未收到心跳则标记为不健康,30秒未收到则剔除。适合K8s等动态环境
2
永久实例(CP模式):Nacos主动探测(TCP/HTTP),不依赖客户端心跳。适合传统部署,手动注册和下线

Nacos服务发现的AP/CP模式

Nacos支持AP和CP两种模式(通过临时实例/永久实例切换): AP模式(临时实例,默认): - 服务注册信息存储在内存中,不持久化 - 客户端心跳保活,超时自动剔除 - 一致性要求低,可用性高 - 适合:大多数微服务场景 - 底层协议:Distro(Nacos自研,最终一致性) CP模式(永久实例): - 服务注册信息持久化到磁盘 - Nacos主动探测实例健康状态 - 一致性要求高,可用性稍低 - 适合:需要手动管理的实例(如传统部署的数据库) - 底层协议:Raft(强一致性) 选择建议: - 微服务用临时实例(AP):动态扩缩容,自动注册下线 - 中间件用永久实例(CP):MySQL、Redis等手动管理的实例

服务发现的两种方式

客户端发现 vs 服务端发现
// 方式1:客户端发现(Nacos默认,OpenFeign/Ribbon)
// 客户端从注册中心获取所有实例地址,自己做负载均衡
// 流程:客户端 → Nacos(获取实例列表) → 客户端负载均衡 → 目标实例
// 优点:简单,没有额外的代理层
// 缺点:客户端需要集成SDK,每种语言都要实现一遍

// 方式2:服务端发现(K8s Service、Istio)
// 客户端只访问固定地址,由代理层做负载均衡
// 流程:客户端 → Service/VirtualIP → kube-proxy/Envoy → 目标Pod
// 优点:客户端无需SDK,语言无关
// 缺点:多一跳网络开销

// Nacos也支持服务端发现(通过Nginx+upstream_nacos模块)
// 但主流用法是客户端发现(OpenFeign + Ribbon)
Nacos服务注册生产环境避坑 1. 临时实例 vs 永久实例要选对:临时实例适合K8s等动态环境,永久实例适合传统部署。混用会导致健康检查混乱
2. 心跳间隔不要改太短:默认5秒,改太短会增加Nacos Server压力
3. 服务名不要用大写:Nacos对服务名大小写敏感,统一用小写避免调用不到
4. 元数据不要放太多:元数据会随心跳上报,数据量大会增加网络开销
5. 保护阈值要配置:当健康实例比例低于阈值时,Nacos会返回所有实例(包括不健康的),避免服务全部不可用

第三十章:API网关——Spring Cloud Gateway

30.1 为什么需要API网关?

没有网关时,客户端需要知道每个服务的地址。有了网关,所有请求都先经过网关,由网关路由到对应的服务。

没有网关: 客户端 → 用户服务(localhost:8081) 客户端 → 订单服务(localhost:8082) 客户端 → 商品服务(localhost:8083) 问题:客户端要知道所有服务地址,每个服务都要做鉴权 有网关: 客户端 → API网关(统一入口) ├── /api/users/** → 用户服务 ├── /api/orders/** → 订单服务 └── /api/products/** → 商品服务 优势:统一入口、统一鉴权、统一路由

30.2 Gateway配置

路由配置
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service  # lb://表示负载均衡
          predicates:
            - Path=/api/users/**  # 匹配路径
          filters:
            - StripPrefix=1       # 去掉第一段路径
            - name: RequestRateLimiter  # 限流过滤器
              args:
                redis-rate-limiter.replenishRate: 10  # 每秒10个令牌
                redis-rate-limiter.burstCapacity: 20  # 令牌桶容量20

        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - name: CircuitBreaker  # 熔断过滤器
              args:
                name: orderService
                fallbackUri: forward:/fallback/order

        - id: product-service
          uri: lb://product-service
          predicates:
            - Path=/api/products/**
            - Header=X-Token, .+  # 必须携带Token

# 效果:
# 访问 http://gateway/api/users/123
# → 转发到 http://user-service/users/123

30.3 Gateway限流(Redis + 令牌桶)

Gateway限流配置
// 1. 引入Redis依赖
// spring-boot-starter-data-redis-reactive

// 2. 自定义限流Key(按用户ID限流,而不是按IP)
@Component
public class UserKeyResolver implements KeyResolver {
    @Override
    public Mono<String> resolve(ServerWebExchange exchange) {
        String userId = exchange.getRequest().getHeaders().getFirst("X-User-Id");
        if (userId != null) {
            return Mono.just(userId);
        }
        // 降级为按IP限流
        String ip = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
        return Mono.just(ip);
    }
}

// 3. 在路由配置中使用
// filters:
//   - name: RequestRateLimiter
//     args:
//       redis-rate-limiter.replenishRate: 10   # 每秒生成10个令牌
//       redis-rate-limiter.burstCapacity: 20   # 令牌桶容量20
//       key-resolver: "#{@userKeyResolver}"    # 按用户限流

// 4. 全局默认限流
// spring.cloud.gateway.default-filters:
//   - name: RequestRateLimiter
//     args:
//       redis-rate-limiter.replenishRate: 100
//       redis-rate-limiter.burstCapacity: 200
//       key-resolver: "#{@ipKeyResolver}"

30.4 Gateway熔断降级

Gateway熔断配置
// 路由配置中的熔断
// filters:
//   - name: CircuitBreaker
//     args:
//       name: orderService
//       fallbackUri: forward:/fallback/order
//       statusCodes: 500,502,503

// 降级接口
@RestController
public class FallbackController {

    @GetMapping("/fallback/order")
    public Map<String, Object> orderFallback() {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 503);
        result.put("message", "订单服务暂时不可用,请稍后重试");
        result.put("data", null);
        return result;
    }

    @GetMapping("/fallback/user")
    public Map<String, Object> userFallback() {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 503);
        result.put("message", "用户服务暂时不可用,请稍后重试");
        result.put("data", null);
        return result;
    }
}

30.5 全局过滤器:统一鉴权

JWT鉴权过滤器
@Component
public class AuthFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");

        // 白名单路径不需要鉴权
        String path = exchange.getRequest().getPath().toString();
        if (path.startsWith("/api/auth/login") || path.startsWith("/api/auth/register")) {
            return chain.filter(exchange);
        }

        // 验证Token
        if (token == null || !JwtUtils.verify(token)) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }

        // 把用户信息放到请求头中传递给下游服务
        Claims claims = JwtUtils.parseToken(token);
        ServerHttpRequest request = exchange.getRequest().mutate()
            .header("X-User-Id", claims.getSubject())
            .build();

        return chain.filter(exchange.mutate().request(request).build());
    }

    @Override
    public int getOrder() {
        return -1;  // 最高优先级
    }
}
Gateway生产环境避坑 1. 全局过滤器异常处理必须完善:Token解析失败、Redis连接超时等异常都要捕获,返回友好错误而非500
2. 跨域配置要在Gateway统一处理:不要在每个微服务里配CORS,Gateway一处配置全局生效
3. 限流要用Redis+Lua:本地限流在多实例场景下不准确,必须用分布式限流
4. 路由ID要唯一:重复的路由ID会导致启动失败
5. 大请求要配置缓冲区:Gateway默认限制请求体1MB,上传文件需要调大max-in-memory-size

第三十一章:服务调用——OpenFeign与gRPC

31.1 OpenFeign:声明式HTTP调用

OpenFeign让你像调用本地方法一样调用远程服务。只需要定义一个接口,Feign自动生成实现类。

OpenFeign使用
// 1. 定义Feign接口
@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceClient {

    @GetMapping("/api/users/{id}")
    User getUser(@PathVariable("id") Long id);

    @PostMapping("/api/users")
    User createUser(@RequestBody User user);

    @GetMapping("/api/users")
    List<User> listUsers(@RequestParam("ids") List<Long> ids);
}

// 2. 降级处理(服务不可用时的兜底方案)
@Component
public class UserServiceFallback implements UserServiceClient {
    @Override
    public User getUser(Long id) {
        return new User(id, "默认用户", "服务暂时不可用");
    }
    // ... 其他方法的降级实现
}

// 3. 使用(和调用本地方法一样)
@Service
public class OrderService {
    @Autowired
    private UserServiceClient userServiceClient;

    public OrderDetail getOrderDetail(Long orderId) {
        Order order = orderDao.selectById(orderId);
        User user = userServiceClient.getUser(order.getUserId());
        return new OrderDetail(order, user);
    }
}

31.2 Feign调用流程

调用流程: OrderService │ ▼ UserServiceClient.getUser(123) ← 接口调用 │ ▼ Feign代理类(自动生成) │ ▼ 从Nacos获取user-service的地址列表 │ ▼ 负载均衡选择一个实例 │ ▼ 发送HTTP请求: GET http://192.168.1.5:8081/api/users/123 │ ▼ 接收响应,反序列化为User对象 │ ▼ 返回User对象
Feign的最佳实践 1. 超时配置:必须设置合理的超时时间,避免线程长时间阻塞
2. 降级处理:每个Feign接口都要有fallback,服务不可用时返回兜底数据
3. 请求压缩:大请求开启GZIP压缩,减少网络传输
4. 日志级别:生产环境用BASIC级别,开发环境用FULL级别

31.3 gRPC 实战:Spring Boot集成

当内部服务间调用对性能要求极高时,gRPC 是比 OpenFeign 更好的选择。gRPC 基于 HTTP/2 和 Protobuf,性能比 RESTful 快 2-5 倍。

gRPC + Spring Boot 完整示例
// 1. 定义 .proto 文件(user-service.proto)
syntax = "proto3";
option java_package = "com.example.grpc";

service UserService {
    rpc GetUser (UserRequest) returns (UserResponse);
    rpc BatchGetUsers (BatchRequest) returns (stream UserResponse); // 服务端流式
}

message UserRequest { int64 id = 1; }
message BatchRequest { repeated int64 ids = 1; }
message UserResponse {
    int64 id = 1;
    string name = 2;
    string email = 3;
}

// 2. 服务端实现
@GrpcService
public class UserGrpcService extends UserServiceGrpc.UserServiceImplBase {
    @Override
    public void getUser(UserRequest request,
                        StreamObserver<UserResponse> responseObserver) {
        User user = userDao.findById(request.getId());
        UserResponse response = UserResponse.newBuilder()
            .setId(user.getId())
            .setName(user.getName())
            .setEmail(user.getEmail())
            .build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }

    // 流式返回:批量查询不占内存
    @Override
    public void batchGetUsers(BatchRequest request,
                              StreamObserver<UserResponse> responseObserver) {
        for (Long id : request.getIdsList()) {
            User user = userDao.findById(id);
            responseObserver.onNext(toResponse(user)); // 逐个返回
        }
        responseObserver.onCompleted();
    }
}

// 3. 客户端调用
@GrpcClient("user-service")
private UserServiceGrpc.UserServiceBlockingStub userStub;

public User getUser(Long id) {
    UserResponse resp = userStub.getUser(
        UserRequest.newBuilder().setId(id).build());
    return toUser(resp);
}

31.4 OpenFeign vs gRPC 选型建议

对比项OpenFeigngRPC
协议HTTP/1.1 + JSONHTTP/2 + Protobuf
性能一般高(快2-5倍)
易用性简单,注解驱动需要定义.proto文件
流式传输不支持支持双向流
浏览器兼容直接支持需要gRPC-Web
适用场景对外API、简单调用内部高频调用、大数据传输
服务调用生产环境避坑 1. Feign超时必须配置:默认不超时,下游服务挂了会一直等。配置connect-timeout和read-timeout
2. Feign日志级别不要用FULL:生产环境用BASIC,FULL会打印请求体和响应体,影响性能且可能泄露敏感数据
3. gRPC的.proto文件要版本管理:客户端和服务端的.proto版本不一致会导致反序列化失败
4. gRPC异常要用StatusRuntimeException捕获:不要用通用Exception捕获,会丢失错误码信息
5. Feign重试要谨慎:POST请求重试可能导致重复提交,非幂等接口要禁用重试

第三十二章:服务熔断与降级——Sentinel

32.1 Sentinel核心概念

1
资源(Resource):需要保护的代码块,用@SentinelResource注解标记
2
规则(Rule):对资源的保护策略,包括流控规则、降级规则、热点规则等
3
链路(Node):资源之间的调用关系,形成一棵调用树

32.2 热点参数限流

针对特定参数值做限流。比如:某个商品ID的请求特别多,只限制这个商品的访问频率。

热点参数限流
@GetMapping("/api/products/{id}")
@SentinelResource(value = "getProduct", blockHandler = "getProductBlock")
public Product getProduct(@PathVariable("id") Long id) {
    return productService.getById(id);
}

// 热点规则:商品ID=1001的QPS限制为10,其他商品QPS限制为100
// 在Sentinel控制台配置:
// 资源名:getProduct
// 参数索引:0(第一个参数)
// 参数例外项:参数值=1001时,限流阈值=10

32.3 系统保护规则

Sentinel可以根据系统整体指标做保护:

指标含义建议阈值
系统负载Linux load值CPU核心数 * 2
CPU使用率CPU占用百分比70%-80%
入口QPS每秒总请求数根据压测结果
平均RT平均响应时间200ms

32.4 熔断降级原理详解

生活类比:电路保险丝

家里的电路都有保险丝:当电流过大时,保险丝熔断,切断电路,保护电器不被烧毁。等故障排除后,换上新保险丝,电路恢复。

服务熔断就是调用链路上的"保险丝":当调用某个服务的错误率过高时,自动切断调用,返回降级结果,保护调用方不被拖垮。等一段时间后,试探性恢复。

Sentinel熔断状态机(五状态模型): CLOSED(关闭,正常调用) │ │ 慢调用比例 > 阈值 或 异常比例 > 阈值 │ 统计窗口内达到最小请求数 ▼ OPEN(打开,直接降级) │ │ 等待熔断超时时长(默认5秒) ▼ HALF_OPEN(半开,试探性调用) │ ├─ 试探成功(1个请求正常)→ 回到 CLOSED │ └─ 试探失败 → 回到 OPEN 三种降级策略: 1. 慢调用比例:RT超过阈值的比例 > 设定值 → 熔断 2. 异常比例:异常请求的比例 > 设定值 → 熔断 3. 异常数:异常请求数 > 设定值 → 熔断
Sentinel熔断降级完整配置
// 1. 定义资源(带降级处理)
@GetMapping("/api/orders/{id}")
@SentinelResource(
    value = "getOrder",
    fallback = "getOrderFallback",      // 业务异常降级
    blockHandler = "getOrderBlock"       // 限流/熔断降级
)
public Order getOrder(@PathVariable Long id) {
    // 调用订单服务(可能超时或异常)
    return orderService.getById(id);
}

// 2. 业务异常降级(代码抛异常时触发)
public Order getOrderFallback(Long id, Throwable e) {
    log.warn("订单查询降级: id={}, error={}", id, e.getMessage());
    // 返回缓存数据或默认值
    Order cached = redisTemplate.opsForValue().get("order:" + id);
    return cached != null ? cached : Order.defaultOrder(id);
}

// 3. 限流/熔断降级(Sentinel规则触发时)
public Order getOrderBlock(Long id, BlockException ex) {
    log.warn("订单查询被限流或熔断: id={}, rule={}", id, ex.getRule());
    return Order.defaultOrder(id);
}

// 4. 在Sentinel控制台配置熔断规则
// 资源名:getOrder
// 策略:慢调用比例
// 最大RT:200ms(超过200ms算慢调用)
// 慢调用比例阈值:50%(50%的请求超过200ms就熔断)
// 熔断时长:5秒
// 最小请求数:5(至少5个请求才统计)
// 统计窗口时长:1秒

32.5 Sentinel vs Hystrix 对比

对比项SentinelHystrix
开发方阿里巴巴Netflix(已停止维护)
隔离策略信号量(并发数控制)线程池隔离/信号量
熔断策略慢调用比例/异常比例/异常数异常比例/异常数
热点限流支持(按参数值限流)不支持
控制台自带完善控制台需要配合Dashboard
规则推送动态推送(Nacos/ZK)需重启或轮询
扩展性丰富的SPI扩展点扩展性一般
社区活跃活跃,持续更新已停止维护
Sentinel生产环境避坑 1. 熔断规则不要设太敏感:最小请求数设太低(如5),少量抖动就会触发熔断
2. 降级方法必须返回合理数据:不要返回null或空对象,会导致调用方NPE
3. blockHandler和fallback的区别:blockHandler处理Sentinel规则触发的降级,fallback处理业务异常。两者都要写
4. 热点参数限流的参数类型:只支持基本类型和String,不支持复杂对象
5. 集群限流需要Token Server:单机限流足够时不要引入集群模式,增加复杂度

第三十三章:分布式事务——Seata实战

33.1 Seata简介

Seata是阿里开源的分布式事务框架,支持AT、TCC、Saga三种模式。其中AT模式是最常用的——对业务代码零侵入。

33.2 AT模式原理

AT模式的两个阶段: 阶段1(执行本地事务): 1. 解析SQL,记录修改前的数据快照(before image) 2. 执行SQL 3. 记录修改后的数据快照(after image) 4. 生成行锁,本地事务提交 阶段2(提交或回滚): 如果所有分支事务都成功 → 删除快照和行锁(提交) 如果有分支事务失败 → 用before image反向补偿(回滚) 优点:对业务代码零侵入,只需要加@GlobalTransactional注解 缺点:性能有一定损耗(需要记录快照)

33.3 Seata使用示例

下单扣库存+扣款的分布式事务
// 订单服务:创建订单 + 远程调用扣库存 + 远程调用扣款
@Service
public class OrderService {

    @GlobalTransactional(name = "create-order", timeoutMills = 30000)
    public void createOrder(OrderDTO orderDTO) {
        // 1. 本地事务:创建订单
        Order order = new Order();
        order.setUserId(orderDTO.getUserId());
        order.setAmount(orderDTO.getAmount());
        order.setStatus(0);  // 待支付
        orderDao.insert(order);

        // 2. 远程调用:扣减库存(库存服务的本地事务)
        stockFeignClient.deduct(orderDTO.getProductId(), orderDTO.getCount());

        // 3. 远程调用:扣减余额(账户服务的本地事务)
        accountFeignClient.deduct(orderDTO.getUserId(), orderDTO.getAmount());

        // 如果任何一步失败,所有操作自动回滚
    }
}

// 库存服务
@Service
public class StockService {
    public void deduct(Long productId, Integer count) {
        stockDao.deduct(productId, count);  // 扣减库存
    }
}

// 账户服务
@Service
public class AccountService {
    public void deduct(Long userId, BigDecimal amount) {
        accountDao.deduct(userId, amount);  // 扣减余额
    }
}
Seata的魔法 你只需要在入口方法上加一个@GlobalTransactional注解,Seata会自动:
1. 开启全局事务
2. 拦截所有数据库操作,记录快照
3. 如果任何分支事务失败,自动用快照回滚所有操作
对业务代码零侵入,这就是AT模式的魅力。

33.4 Seata Saga模式

Saga模式适合长流程业务(如订单创建流程),不需要锁定资源,性能好。Seata通过状态机定义Saga流程:

Seata Saga状态机定义(JSON)
{
  "Name": "createOrderSaga",
  "StartState": "CreateOrder",
  "States": {
    "CreateOrder": {
      "Type": "ServiceTask",
      "ServiceName": "orderService",
      "ServiceMethod": "create",
      "CompensateState": "CancelOrder",
      "Next": "DeductStock"
    },
    "DeductStock": {
      "Type": "ServiceTask",
      "ServiceName": "stockService",
      "ServiceMethod": "deduct",
      "CompensateState": "RestoreStock",
      "Next": "DeductBalance"
    },
    "DeductBalance": {
      "Type": "ServiceTask",
      "ServiceName": "accountService",
      "ServiceMethod": "deduct",
      "CompensateState": "RefundBalance",
      "Next": "End"
    },
    "CancelOrder": { "Type": "Compensate" },
    "RestoreStock": { "Type": "Compensate" },
    "RefundBalance": { "Type": "Compensate" },
    "End": { "Type": "Succeed" }
  }
}

// 执行Saga
@Autowired
private StateMachineEngine stateMachineEngine;

public void createOrder(OrderDTO orderDTO) {
    Map<String, Object> startParams = new HashMap<>();
    startParams.put("orderDTO", orderDTO);
    // 启动Saga状态机,某一步失败时自动逆序补偿
    stateMachineEngine.start("createOrderSaga", orderDTO.getOrderId(), startParams);
}

33.5 Seata三种模式对比

对比项AT模式TCC模式Saga模式
业务侵入零侵入(自动拦截SQL)高(需写Try/Confirm/Cancel)中(需写补偿逻辑)
一致性最终一致最终一致最终一致
性能中(需要记录快照和行锁)高(无全局锁)高(无全局锁)
适用场景单库/同构数据库资金、库存等核心业务长流程业务(如旅行预订)
回滚方式快照反向补偿调用Cancel方法逆序调用补偿操作
Seata生产环境避坑 1. AT模式的脏写问题:如果全局事务回滚时,数据已被其他本地事务修改,回滚会失败。需要设置lockRetryTimes重试
2. 全局事务超时要设合理:timeoutMills默认60秒,业务执行太久会导致全局锁持有时间过长
3. 不要在循环中开启全局事务:每次@GlobalTransactional都会注册分支事务,循环开启会导致TC压力过大
4. Seata Server必须高可用:TC(事务协调器)是单点,必须部署集群+数据库持久化
5. AT模式需要额外的undo_log表:每个业务库都要建这张表,用于存储回滚快照

第三十四章:微服务安全——OAuth2与JWT

34.1 认证 vs 授权

34.2 OAuth2 授权流程

OAuth2 是一个授权框架,允许第三方应用在用户授权的情况下访问用户的资源,而不需要获取用户的密码。微信登录、GitHub登录都是基于OAuth2。

OAuth2 四种授权模式: 1. 授权码模式(最安全,推荐) 用户 → 授权服务器:我要授权 授权服务器 → 用户:给你一个授权码 code 用户 → 应用服务器:这是授权码 应用服务器 → 授权服务器:用code换Token 授权服务器 → 应用服务器:给你access_token 2. 简单模式(不推荐,已废弃) 直接返回token给前端,不安全 3. 密码模式(内部系统用) 用户把账号密码给应用,应用直接换Token 4. 客户端模式(服务间调用) 应用自己的身份获取Token,不涉及用户
Spring Security OAuth2 授权码模式
// 1. 授权服务器配置
@Configuration
public class AuthServerConfig {

    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        RegisteredClient webClient = RegisteredClient.withId(UUID.randomUUID().toString())
            .clientId("web-app")
            .clientSecret("{noop}secret")
            .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
            .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
            .redirectUri("http://localhost:8080/login/oauth2/code/callback")
            .scope(OidcScopes.OPENID)
            .scope("read")
            .scope("write")
            .build();
        return new InMemoryRegisteredClientRepository(webClient);
    }
}

// 2. 资源服务器配置(保护API)
@Configuration
public class ResourceServerConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(auth -> auth
            .requestMatchers("/api/public/**").permitAll()
            .requestMatchers("/api/admin/**").hasAuthority("SCOPE_admin")
            .anyRequest().authenticated()
        );
        http.oauth2ResourceServer(oauth2 -> oauth2
            .jwt(Customizer.withDefaults())
        );
        return http.build();
    }
}

// 3. 客户端配置(application.yml)
// spring:
//   security:
//     oauth2:
//       client:
//         registration:
//           github:
//             client-id: your-client-id
//             client-secret: your-client-secret
//             scope: read:user,user:email
OAuth2 + JWT 的组合 OAuth2 负责"授权"(让用户授权第三方访问),JWT 负责"认证"(携带用户信息的Token)。实际项目中通常是:
1. 用户通过 OAuth2 授权登录(如微信扫码)
2. 服务器验证后生成 JWT Token
3. 后续请求携带 JWT Token,服务器验证身份和权限

34.3 JWT(JSON Web Token)

JWT是目前最流行的无状态认证方案。服务器不需要存储session,所有信息都在token里。

JWT结构:Header.Payload.Signature Header(头部): {"alg": "HS256", "typ": "JWT"} ← 算法和类型 Payload(载荷): {"sub": "123", "name": "张三", "role": "admin", "exp": 1700000000} ← 用户ID、姓名、角色、过期时间 Signature(签名): HMACSHA256(base64(header) + "." + base64(payload), secret) ← 用密钥签名,防止被篡改 最终:eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjMifQ.xxx
JWT工具类
public class JwtUtils {
    private static final String SECRET = "my-secret-key";
    private static final long EXPIRE = 7200000; // 2小时

    // 生成Token
    public static String generateToken(Long userId, String role) {
        return Jwts.builder()
            .setSubject(String.valueOf(userId))
            .claim("role", role)
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
            .signWith(SignatureAlgorithm.HS256, SECRET)
            .compact();
    }

    // 解析Token
    public static Claims parseToken(String token) {
        return Jwts.parser()
            .setSigningKey(SECRET)
            .parseClaimsJws(token)
            .getBody();
    }

    // 验证Token
    public static boolean verify(String token) {
        try {
            parseToken(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

双Token机制(Access Token + Refresh Token)

JWT最大的问题是:Token一旦签发无法主动失效,且过期时间太短用户体验差。双Token机制解决这个问题:

双Token机制: 登录时: 服务端 → 客户端:access_token(2小时) + refresh_token(7天) 正常请求: 客户端 → 服务端:携带access_token 服务端:验证access_token,返回数据 access_token过期后: 客户端 → 服务端:携带refresh_token请求新token 服务端:验证refresh_token → 签发新的access_token 客户端:用新的access_token重新请求 安全设计: 1. access_token短期(2小时):泄露后影响窗口小 2. refresh_token长期(7天):存储在HttpOnly Cookie中,JS无法读取 3. refresh_token只能使用一次:使用后立即失效,签发新的refresh_token 4. 用户改密/登出:refresh_token立即失效
Refresh Token实现
@RestController
@RequestMapping("/api/auth")
public class AuthController {

    @PostMapping("/login")
    public TokenVO login(@RequestBody LoginDTO dto) {
        // 1. 验证用户名密码
        User user = userService.validate(dto.getUsername(), dto.getPassword());

        // 2. 生成双Token
        String accessToken = JwtUtils.generateToken(user.getId(), user.getRoles(), 7200);   // 2小时
        String refreshToken = JwtUtils.generateRefreshToken(user.getId(), 604800);  // 7天

        // 3. 存储refresh_token到Redis(支持吊销)
        redis.setex("refresh:" + user.getId(), 604800, refreshToken);

        return new TokenVO(accessToken, refreshToken);
    }

    @PostMapping("/refresh")
    public TokenVO refreshToken(@RequestParam String refreshToken) {
        // 1. 验证refresh_token
        Claims claims = JwtUtils.parseToken(refreshToken);
        Long userId = Long.parseLong(claims.getSubject());

        // 2. 检查refresh_token是否在Redis中(防止已吊销的token被使用)
        String storedToken = redis.get("refresh:" + userId);
        if (!refreshToken.equals(storedToken)) {
            throw new UnauthorizedException("refresh_token已失效");
        }

        // 3. 签发新的双Token(refresh_token轮转:旧的失效,新的生效)
        String newAccessToken = JwtUtils.generateToken(userId, claims.get("roles"), 7200);
        String newRefreshToken = JwtUtils.generateRefreshToken(userId, 604800);
        redis.setex("refresh:" + userId, 604800, newRefreshToken);

        return new TokenVO(newAccessToken, newRefreshToken);
    }

    @PostMapping("/logout")
    public void logout(@RequestHeader("Authorization") String token) {
        // 1. 解析token获取用户ID
        Claims claims = JwtUtils.parseToken(token.replace("Bearer ", ""));
        Long userId = Long.parseLong(claims.getSubject());

        // 2. 删除refresh_token(使其失效)
        redis.del("refresh:" + userId);

        // 3. 将access_token加入黑名单(可选:等它自然过期)
        long ttl = claims.getExpiration().getTime() - System.currentTimeMillis();
        if (ttl > 0) {
            redis.setex("blacklist:" + token, ttl / 1000, "1");
        }
    }
}
OAuth2/JWT生产环境避坑 1. JWT密钥不要硬编码:示例中的SECRET应从环境变量或密钥管理服务读取,泄露密钥等于系统沦陷
2. Token过期时间不要太长:建议2小时,配合Refresh Token机制续期
3. 要支持Token吊销:JWT无状态,无法主动失效。用Redis维护Token黑名单,用户登出/改密时加入黑名单
4. 密钥要定期轮换:密钥泄露后所有已签发的Token都失效,定期轮换降低风险
5. Payload不要放敏感信息:JWT的Payload只是Base64编码,不是加密,任何人都能解码看到内容
6. Refresh Token要一次性使用:使用后立即轮转,防止Refresh Token泄露后被长期滥用

第三十五章:微服务网关鉴权设计

35.1 统一鉴权架构

请求流程: 客户端 │ 携带JWT Token ▼ API网关(鉴权过滤器) │ 验证Token → 解析用户ID和角色 │ 把用户信息放到请求头 ▼ 业务服务 │ 从请求头获取用户信息 │ 不需要重复验证Token ▼ 返回结果 优势: - 鉴权逻辑集中在网关,业务服务不用关心 - Token只在网关验证一次,减少重复计算 - 统一处理Token过期、无效等情况

35.2 RBAC权限模型

企业级微服务通常采用RBAC(Role-Based Access Control)权限模型:用户→角色→权限。网关鉴权时需要验证用户的角色和权限:

RBAC数据模型
-- 用户表
CREATE TABLE sys_user (
    id BIGINT PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    password VARCHAR(200) NOT NULL,
    status TINYINT DEFAULT 1  -- 1:启用 0:禁用
);

-- 角色表
CREATE TABLE sys_role (
    id BIGINT PRIMARY KEY,
    role_name VARCHAR(50) NOT NULL,  -- 如:admin、user、auditor
    description VARCHAR(200)
);

-- 用户-角色关联表
CREATE TABLE sys_user_role (
    user_id BIGINT NOT NULL,
    role_id BIGINT NOT NULL,
    PRIMARY KEY (user_id, role_id)
);

-- 权限表
CREATE TABLE sys_permission (
    id BIGINT PRIMARY KEY,
    permission_code VARCHAR(100) NOT NULL,  -- 如:order:create、user:delete
    url_pattern VARCHAR(200),               -- 如:/api/orders/**
    method VARCHAR(10)                      -- 如:GET、POST、DELETE
);

-- 角色-权限关联表
CREATE TABLE sys_role_permission (
    role_id BIGINT NOT NULL,
    permission_id BIGINT NOT NULL,
    PRIMARY KEY (role_id, permission_id)
);
网关权限校验(从JWT中解析角色,校验权限)
// JWT Token中存储的信息:
// {
//   "sub": "10001",           // 用户ID
//   "username": "zhangsan",   // 用户名
//   "roles": ["admin", "user"], // 角色列表
//   "permissions": ["order:create", "order:query"], // 权限列表
//   "exp": 1700000000         // 过期时间
// }

// 网关鉴权过滤器:校验权限
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    String path = exchange.getRequest().getPath().toString();
    String method = exchange.getRequest().getMethod().name();

    // 1. 白名单直接放行
    if (isWhiteListed(path)) {
        return chain.filter(exchange);
    }

    // 2. 解析JWT获取用户信息
    String token = extractToken(exchange);
    Claims claims = JwtUtils.parseToken(token);
    List<String> roles = claims.get("roles", List.class);
    List<String> permissions = claims.get("permissions", List.class);

    // 3. 校验权限(超级管理员跳过)
    if (roles.contains("SUPER_ADMIN")) {
        return chain.filter(exchange);
    }

    // 4. 检查是否有访问该URL的权限
    boolean hasPermission = permissions.stream()
        .anyMatch(p -> matchUrl(p, path, method));
    if (!hasPermission) {
        exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
        return exchange.getResponse().setComplete();
    }

    // 5. 传递用户信息到下游服务
    ServerHttpRequest request = exchange.getRequest().mutate()
        .header("X-User-Id", claims.getSubject())
        .header("X-User-Roles", String.join(",", roles))
        .build();
    return chain.filter(exchange.mutate().request(request).build());
}

35.3 接口防重放攻击

重放攻击是指:攻击者截获一个合法请求,反复发送。解决方案是给每个请求加唯一标识和时间戳。

防重放攻击方案
// 请求头中添加:
// X-Nonce: 唯一随机ID(每个请求不同)
// X-Timestamp: 请求时间戳
// X-Sign: 签名 = MD5(参数 + nonce + timestamp + secret)

// 网关验证逻辑:
public boolean checkReplay(String nonce, String timestamp, String sign) {
    // 1. 检查时间戳是否在5分钟内
    long time = Long.parseLong(timestamp);
    if (Math.abs(System.currentTimeMillis() - time) > 300000) {
        return false;  // 请求过期
    }

    // 2. 检查nonce是否已经使用过(用Redis存储)
    if (redis.exists("nonce:" + nonce)) {
        return false;  // 重复请求
    }
    redis.setex("nonce:" + nonce, 300, "1");

    // 3. 验证签名
    return sign.equals(MD5(params + nonce + timestamp + secret));
}
网关鉴权生产环境避坑 1. 白名单要严格控制:登录、注册、健康检查等接口放白名单,其他一律鉴权
2. Nonce要用Redis存储:本地内存存储在多实例场景下不防重放
3. 签名密钥要定期更换:密钥泄露后攻击者可以伪造任意请求
4. 时间戳校验要容忍时钟偏差:允许±5分钟的偏差,避免服务器时钟不同步导致合法请求被拒
5. 鉴权失败要返回标准错误码:401未认证、403无权限,前端统一处理

第三十六章:微服务配置与治理

36.1 多环境配置管理

Nacos多环境配置
# 命名空间隔离
spring:
  cloud:
    nacos:
      config:
        namespace: dev  # 开发环境命名空间
        # 其他选项:test、staging、prod

# Data ID命名规范:
# {服务名}-{环境}.yaml
# 例如:order-service-dev.yaml
#       order-service-prod.yaml

# Group分组:
# DEFAULT_GROUP(默认)
# ORDER_GROUP(订单业务组)
# USER_GROUP(用户业务组)

36.2 服务元数据管理

服务元数据配置
spring:
  cloud:
    nacos:
      discovery:
        metadata:
          version: v1.0.0          # 服务版本
          region: east-china        # 机房区域
          env: production           # 环境标识
          owner: order-team         # 负责团队
          gray: false               # 是否灰度实例

# 灰度发布:新版本只有部分流量
# 通过metadata标记灰度实例
# 网关根据规则把特定用户路由到灰度实例

36.3 配置加密(敏感信息保护)

数据库密码、密钥等敏感信息不能明文存储在Nacos中。推荐使用jasypt加密:

jasypt配置加密
// 1. 引入依赖
// com.github.ulisesbocchio:jasypt-spring-boot-starter

// 2. 加密敏感配置
// 命令行加密:
// java -cp jasypt-1.9.3.jar org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI
//   input="123456" password=my-secret-key algorithm=PBEWithMD5AndDES
// 输出:ENC(加密后的密文)

// 3. Nacos配置中使用加密值
spring:
  datasource:
    password: ENC(密文)  # 用ENC()包裹密文
  redis:
    password: ENC(密文)

// 4. 启动时传入解密密钥(不要写在配置文件中!)
// java -jar app.jar --jasypt.encryptor.password=my-secret-key
// 或通过环境变量:JASYPT_ENCRYPTOR_PASSWORD=my-secret-key

// 5. 也可以用K8s Secret管理:
// - secretKeyRef注入环境变量
// - 应用启动时从环境变量读取解密密钥

36.4 灰度发布

灰度发布流程: v1.0(99%流量) ──→ ┌─────────────────┐ │ Nacos注册中心 │ v1.1(1%流量) ──→ └─────────────────┘ │ ┌──────┴──────┐ ▼ ▼ v1.0实例(3台) v1.1实例(1台) 网关路由规则: - 默认路由到v1.0 - 请求头带 X-Gray: true 的路由到v1.1 - 或者特定用户ID路由到v1.1 逐步放量:1% → 10% → 50% → 100%
配置治理生产环境避坑 1. 敏感配置要加密:数据库密码、密钥等不要明文写在Nacos中,用jasypt或Vault加密
2. 配置变更要有审批:生产环境配置变更走审批流程,避免误操作
3. 灰度发布要先小流量验证:新配置先推送到1-2台机器,观察无异常再全量
4. 配置回滚要快:Nacos支持配置历史版本,发现异常立即回滚到上一个版本
5. 不要用Nacos做服务间消息传递:Nacos是配置中心,不是消息队列,频繁变更配置会导致大量推送

第三十七章:Docker容器化基础

37.1 什么是Docker?

Docker是一种容器化技术。它把应用程序和它的所有依赖打包在一起,形成一个"容器"——在任何环境下都能一模一样地运行。

生活类比:集装箱

Docker就像集装箱:不管里面装的是什么货物,集装箱的尺寸是标准的。吊车、卡车、轮船都能运输它。Docker容器也一样——不管里面是什么应用,运行方式是标准的,任何装了Docker的机器都能运行。

37.2 Docker核心概念

1
镜像(Image):应用的只读模板,包含代码、运行时、依赖。类比:安装包
2
容器(Container):镜像的运行实例,一个镜像可以启动多个容器。类比:正在运行的程序
3
Dockerfile:构建镜像的脚本。类比:安装步骤说明
4
仓库(Registry):存储和分发镜像。类比:应用商店

37.3 Dockerfile编写

Spring Boot应用的Dockerfile
# 基础镜像
FROM eclipse-temurin:17-jre-alpine

# 设置工作目录
WORKDIR /app

# 复制jar包
COPY target/order-service.jar app.jar

# 暴露端口
EXPOSE 8080

# 启动命令
ENTRYPOINT ["java", "-jar", "app.jar"]

# 构建镜像
# docker build -t order-service:1.0 .

# 运行容器
# docker run -d -p 8080:8080 --name order order-service:1.0

37.4 多阶段构建(Multi-stage Build)

多阶段构建是减小镜像体积的关键技术:构建阶段用完整的JDK,运行阶段只用JRE:

多阶段构建Dockerfile
# 阶段1:构建(用JDK,包含编译工具)
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B    # 先下载依赖(利用Docker缓存)
COPY src ./src
RUN mvn package -DskipTests -B      # 编译打包

# 阶段2:运行(只用JRE,体积小)
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app

# 创建非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

COPY --from=builder /app/target/order-service.jar app.jar
EXPOSE 8080

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -q --spider http://localhost:8080/actuator/health || exit 1

ENTRYPOINT ["java", "-jar", "app.jar"]

# 镜像大小对比:
# 不用多阶段构建:~800MB(包含JDK+Maven+源码+依赖)
# 用多阶段构建:~200MB(只有JRE+jar包)

37.5 Docker网络

Docker容器之间需要通信,理解Docker网络是微服务部署的基础:

Docker四种网络模式: 1. bridge(默认) 每个容器有独立的IP,通过docker0网桥通信 容器之间用容器名通信(DNS解析) 适合:大多数场景 2. host 容器直接使用宿主机的网络(无隔离) 性能最好,但端口可能冲突 适合:对网络性能要求极高的场景 3. none 容器没有网络(完全隔离) 适合:安全敏感场景 4. overlay 跨主机的容器通信(Docker Swarm/K8s) 适合:多机部署的集群环境
Docker网络操作
# 创建自定义网络(推荐,支持DNS解析)
docker network create my-network

# 启动容器并加入网络
docker run -d --name order-service --network my-network order-service:1.0
docker run -d --name user-service --network my-network user-service:1.0

# 同一网络中的容器可以用容器名互相访问
# order-service中可以直接访问 http://user-service:8080/api/users/1

# 查看网络
docker network ls                    # 列出所有网络
docker network inspect my-network    # 查看网络详情
docker network connect my-network container_id  # 将容器加入网络

37.6 Docker数据卷

容器是临时的,数据不会持久化。Docker Volume用于持久化数据:

Docker Volume操作
# 创建数据卷
docker volume create mysql-data

# 使用数据卷启动容器
docker run -d \
  --name mysql \
  -v mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

# 数据卷的好处:
# 1. 容器删除后数据不丢失
# 2. 多个容器可以共享同一个数据卷
# 3. 数据卷由Docker管理,备份方便

# 绑定挂载(Bind Mount):直接挂载宿主机目录
docker run -d \
  --name nginx \
  -v /data/nginx/conf:/etc/nginx/conf.d \
  -v /data/nginx/html:/usr/share/nginx/html \
  -p 80:80 \
  nginx:latest

# 查看和管理数据卷
docker volume ls                     # 列出所有数据卷
docker volume inspect mysql-data     # 查看数据卷详情
docker volume rm mysql-data          # 删除数据卷
Docker生产环境避坑 1. 不要用latest标签:每次构建可能拉到不同版本,用明确的版本号如17-jre-alpine
2. 多阶段构建减小镜像:构建阶段用JDK(大),运行阶段只用JRE(小),镜像从800MB降到200MB
3. 不要以root用户运行:在Dockerfile中创建非root用户,降低容器逃逸风险
4. 健康检查必须配置:HEALTHCHECK指令让Docker自动检测容器是否正常
5. .dockerignore要配置:排除.git、node_modules等无用文件,加速构建减小上下文
6. 数据库数据必须用Volume:不要把数据库数据放在容器内,容器删除数据就丢了
7. 一个容器只运行一个进程:不要在一个容器里装Nginx+Java+MySQL,违背容器化理念

第三十八章:Docker Compose编排

38.1 为什么需要Compose?

一个微服务系统通常有多个服务(用户服务、订单服务、数据库、Redis、MQ等)。用Docker一个个启动太麻烦。Docker Compose可以用一个文件定义和管理多个容器。

38.2 docker-compose.yml示例

完整的微服务编排文件
version: '3.8'

services:
  # MySQL数据库
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: order_db
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - micro-net

  # Redis
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    networks:
      - micro-net

  # Nacos注册中心
  nacos:
    image: nacos/nacos-server:v2.3.0
    ports:
      - "8848:8848"
    environment:
      MODE: standalone
    networks:
      - micro-net

  # 用户服务
  user-service:
    build: ./user-service
    ports:
      - "8081:8081"
    depends_on:
      - mysql
      - redis
      - nacos
    environment:
      SPRING_PROFILES_ACTIVE: docker
    networks:
      - micro-net

  # 订单服务
  order-service:
    build: ./order-service
    ports:
      - "8082:8082"
    depends_on:
      - mysql
      - redis
      - nacos
      - user-service
    environment:
      SPRING_PROFILES_ACTIVE: docker
    networks:
      - micro-net

  # API网关
  gateway:
    build: ./gateway
    ports:
      - "8080:8080"
    depends_on:
      - nacos
    environment:
      SPRING_PROFILES_ACTIVE: docker
    networks:
      - micro-net

volumes:
  mysql-data:

networks:
  micro-net:
    driver: bridge

# 启动:docker-compose up -d
# 停止:docker-compose down
# 查看日志:docker-compose logs -f order-service
Compose的核心价值 一个命令 docker-compose up -d 就能启动整个微服务系统。新人入职不需要花一天配环境,一条命令搞定。
Docker Compose生产环境避坑 1. depends_on不等于wait-for-it:depends_on只保证容器启动顺序,不保证服务就绪。用healthcheck+condition: service_healthy
2. 环境变量要分离:用.env文件管理变量,不要在docker-compose.yml中硬编码密码
3. 数据卷要挂载到宿主机:不挂载卷,容器重建后数据丢失
4. 不要用docker-compose做生产部署:Compose适合开发和测试,生产用K8s或Docker Swarm
5. 网络要显式定义:不定义网络时Compose会自动创建,但名称可能冲突

第三十九章:Kubernetes入门

39.1 什么是Kubernetes?

Kubernetes(K8s)是一个容器编排平台。Docker解决了"怎么打包"的问题,K8s解决了"怎么管理成百上千个容器"的问题。

生活类比:码头管理系统

Docker是集装箱,K8s是码头管理系统。码头上有成千上万个集装箱,管理系统负责:
- 把集装箱放到哪里(调度)
- 集装箱坏了自动换新的(自愈)
- 货物多了自动增加集装箱(扩缩容)
- 集装箱之间的网络连接(服务发现)

39.2 K8s核心概念详解

Pod
最小部署单元一个Pod包含一个或多个容器,共享网络(同一IP)和存储。通常一个Pod只放一个主容器+若干Sidecar
Deployment
部署控制器管理Pod的副本数、滚动更新、回滚。声明式管理:你告诉K8s"我要3个Pod",K8s自动维持
Service
服务发现与负载均衡Pod的IP会变,Service提供稳定的访问入口(固定DNS+IP),自动负载均衡到后端Pod
Ingress
外部访问入口HTTP/HTTPS路由,类似Nginx。根据域名/路径路由到不同Service
ConfigMap/Secret
配置管理ConfigMap存普通配置,Secret存敏感信息(密码、密钥),和Pod解耦
Namespace
资源隔离不同团队/环境使用不同的Namespace,类似数据库的schema

Pod的生命周期

Pod生命周期: Pending → Running → Succeeded/Failed │ │ │ └── 容器状态: │ Running → 容器正在运行 │ Waiting → 容器在等待(如拉取镜像) │ Terminated → 容器已终止 │ └── Pod可能卡在Pending的原因: 1. 资源不足(CPU/Memory不够) 2. 镜像拉取失败 3. PVC绑定失败 探针(Probe): livenessProbe(存活探针):容器是否存活?失败→重启容器 readinessProbe(就绪探针):容器是否就绪?失败→从Service摘除 startupProbe(启动探针):容器是否启动完成?用于慢启动应用 重启策略(restartPolicy): Always(默认):容器退出后总是重启 OnFailure:只在非正常退出时重启 Never:从不重启

Service的四种类型

类型说明适用场景
ClusterIP只能集群内部访问(默认)服务间内部调用
NodePort在每个节点上开放一个端口开发测试环境
LoadBalancer创建云厂商的负载均衡器云环境(AWS/阿里云)
ExternalName映射到外部域名访问集群外部服务

39.3 Deployment YAML

部署一个Spring Boot应用
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  namespace: production
spec:
  replicas: 3  # 3个副本
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: order-service:1.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "500m"
          livenessProbe:   # 存活探针
            httpGet:
              path: /actuator/health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:  # 就绪探针
            httpGet:
              path: /actuator/health
              port: 8080
            initialDelaySeconds: 20
            periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: order-service
  namespace: production
spec:
  selector:
    app: order-service
  ports:
    - port: 80
      targetPort: 8080
  type: ClusterIP  # 集群内部访问
K8s的自愈能力 如果某个Pod挂了,K8s会自动创建一个新的Pod替换它。如果某个节点宕机了,K8s会把该节点上的Pod调度到其他节点。这就是为什么K8s被称为"永不宕机的系统"。
K8s生产环境避坑 1. 资源限制必须配置:不设limits的Pod会无限制消耗资源,一个Pod可能拖垮整个节点
2. 探针要配置:livenessProbe检测存活,readinessProbe检测就绪。不配探针,K8s不知道容器是否正常
3. 不要用latest标签:滚动更新时latest不会触发更新,用明确的版本号
4. Namespace要规划好:按环境(dev/staging/prod)或团队划分,不要所有服务都放default
5. ConfigMap更新后Pod不会自动重启:需要手动重启或用Reloader工具自动触发

第四十章:Kubernetes进阶

40.1 HPA自动扩缩容

HPA(Horizontal Pod Autoscaler)根据CPU/内存使用率自动调整Pod数量。

HPA配置
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: order-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: order-service
  minReplicas: 2     # 最少2个Pod
  maxReplicas: 10    # 最多10个Pod
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70  # CPU使用率超过70%就扩容
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80  # 内存使用率超过80%就扩容

# 效果:
# 平时2个Pod → 流量高峰自动扩到10个Pod → 高峰过后自动缩回2个Pod

40.2 Ingress路由

Ingress配置
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    nginx.ingress.kubernetes.io/rate-limit: "100"  # 限流
spec:
  ingressClassName: nginx
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /api/users
            pathType: Prefix
            backend:
              service:
                name: user-service
                port:
                  number: 80
          - path: /api/orders
            pathType: Prefix
            backend:
              service:
                name: order-service
                port:
                  number: 80

# 效果:
# api.example.com/api/users → user-service
# api.example.com/api/orders → order-service

40.3 ConfigMap与Secret

生产环境的配置不能硬编码在Dockerfile或Deployment中,要用ConfigMap和Secret管理:

ConfigMap(存储普通配置)
# 创建ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: order-service-config
  namespace: production
data:
  APPLICATION.YAML: |
    server:
      port: 8080
    spring:
      datasource:
        url: jdbc:mysql://mysql:3306/order_db
    order:
      timeout: 30
      max-retry: 3

---
# 在Deployment中使用ConfigMap
spec:
  containers:
    - name: order-service
      env:
        - name: SPRING_PROFILES_ACTIVE
          value: "production"
      volumeMounts:
        - name: config-volume
          mountPath: /app/config
  volumes:
    - name: config-volume
      configMap:
        name: order-service-config
Secret(存储敏感信息)
# 创建Secret(值必须是Base64编码)
apiVersion: v1
kind: Secret
metadata:
  name: order-service-secret
  namespace: production
type: Opaque
data:
  DB_PASSWORD: MTIzNDU2          # echo -n "123456" | base64
  REDIS_PASSWORD: cmVkaXMxMjM=   # echo -n "redis123" | base64

---
# 在Deployment中使用Secret
spec:
  containers:
    - name: order-service
      env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: order-service-secret
              key: DB_PASSWORD
        - name: REDIS_PASSWORD
          valueFrom:
            secretKeyRef:
              name: order-service-secret
              key: REDIS_PASSWORD
ConfigMap vs Secret ConfigMap:存储不敏感的配置(端口、URL、业务参数)。明文存储在etcd中。
Secret:存储敏感信息(密码、密钥、Token)。Base64编码存储(注意:Base64不是加密!生产环境建议用外部密钥管理如Vault)。
两者都可以以环境变量或文件挂载的方式注入到Pod中。

40.4 滚动更新与回滚

1
滚动更新:逐步用新版Pod替换旧版Pod,过程中始终有Pod在服务
2
查看历史:kubectl rollout history deployment order-service
3
一键回滚:kubectl rollout undo deployment order-service
K8s进阶避坑 1. HPA最小副本数不要设1:设为1时Pod挂了会有短暂不可用,至少设2
2. Ingress的TLS证书要自动续期:用cert-manager自动管理Let's Encrypt证书
3. 滚动更新要设maxUnavailable:默认25%,确保更新期间有足够Pod在服务
4. PDB(PodDisruptionBudget)要配置:节点维护时保证最少可用Pod数
5. 不要在Pod里存状态:Pod随时可能被调度到其他节点,状态必须存在外部存储

第四十一章:服务网格——Istio入门

41.1 什么是服务网格?

服务网格(Service Mesh)是一种基础设施层,负责处理服务间通信。它的核心思想是:把服务间通信的逻辑从业务代码中抽离出来,放到一个独立的代理层。

传统方式:业务代码 + 服务调用逻辑 + 重试 + 熔断 + 鉴权 服务网格:业务代码 + Sidecar代理(处理所有通信逻辑) ┌─────────────────────────────────┐ │ Pod │ │ ┌──────────┐ ┌──────────────┐│ │ │ 业务容器 │ │ Sidecar代理 ││ │ │ (你的代码)│ │ (Envoy) ││ │ └──────────┘ └──────────────┘│ └─────────────────────────────────┘ Sidecar代理负责: - 服务发现 - 负载均衡 - 熔断限流 - 链路追踪 - mTLS加密通信 - 流量管理(灰度、金丝雀)

41.2 Spring Cloud vs Istio 功能对比

功能Spring CloudIstio
服务发现Nacos/Eureka客户端K8s Service / Istio自动发现
负载均衡Ribbon/LoadBalancerEnvoy代理内置
熔断限流Sentinel/Resilience4jEnvoy + DestinationRule
链路追踪SkyWalking/Zipkin AgentEnvoy自动注入Header
配置中心Nacos ConfigConfigMap / Istio CRD
加密通信需自行实现mTLS自动开启
语言依赖仅Java语言无关
代码侵入需要SDK和注解零侵入
Spring Cloud 还是 Istio? - Java单语言团队:Spring Cloud 更成熟,学习资料多
- 多语言/云原生团队:Istio 更合适,语言无关,运维能力强
- 渐进式迁移:可以先用 Spring Cloud,后期逐步迁移到 Istio

41.3 Istio流量管理

金丝雀发布:90%流量到v1,10%到v2
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - route:
        - destination:
            host: order-service
            subset: v1
          weight: 90
        - destination:
            host: order-service
            subset: v2
          weight: 10

---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  subsets:
    - name: v1
      labels:
        version: v1
    - name: v2
      labels:
        version: v2

41.4 Istio故障注入与熔断

故障注入测试:模拟服务延迟
# 故障注入:对10%的请求添加5秒延迟,测试系统的容错能力
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - fault:
        delay:
          percentage:
            value: 10
          fixedDelay: 5s
      route:
        - destination:
            host: order-service

---
# 熔断配置:连续5个5xx错误后触发熔断
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        h2UpgradePolicy: DEFAULT
        http1MaxPendingRequests: 100
        http2MaxRequests: 1000
    outlierDetection:
      consecutive5xxErrors: 5
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50
Istio 的核心优势 1. 零侵入:不需要改一行代码,所有通信逻辑由Sidecar代理处理
2. 语言无关:Java、Go、Python、Node.js 服务统一管理
3. 统一观测:自动收集指标、日志、链路追踪数据
4. 安全默认:自动开启 mTLS 加密通信,无需手动配置
Istio生产环境避坑 1. Sidecar资源开销不可忽视:每个Pod多一个Envoy容器,增加约50MB内存和0.1 CPU
2. mTLS迁移要渐进:从PERMISSIVE(兼容明文和加密)逐步迁移到STRICT(只允许加密)
3. VirtualService规则不要太多:规则过多会导致Envoy配置下发延迟
4. 金丝雀发布要配合监控:只靠流量比例不够,要观察新版本的错误率和延迟
5. Istio版本升级要谨慎:大版本升级可能有Breaking Changes,先在测试环境验证

第四十二章:CI/CD流水线

42.1 什么是CI/CD?

42.2 流水线流程

1
代码提交:开发者push代码到Git仓库
2
自动构建:CI工具拉取代码,执行 mvn package,构建Docker镜像
3
自动测试:运行单元测试、集成测试
4
镜像推送:测试通过后,推送镜像到镜像仓库
5
自动部署:更新K8s Deployment,滚动更新Pod

42.3 GitHub Actions示例

CI/CD流水线配置(含质量门禁与安全扫描)
# .github/workflows/deploy.yml
name: Build, Test, Scan and Deploy

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  # ===== 阶段1:构建与测试 =====
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
          cache: 'maven'

      # ⚠️ 绝对不要加 -DskipTests!测试是质量的最后防线
      - name: Build and Test
        run: mvn clean verify

      # 上传测试报告
      - name: Upload Test Report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-report
          path: target/surefire-reports/

  # ===== 阶段2:代码质量门禁(SonarQube) =====
  sonarqube:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # 需要完整git历史

      - name: SonarQube Scan
        uses: sonarqube/scan-action@v2
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
          SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
        with:
          args: >
            -Dsonar.projectKey=order-service
            -Dsonar.qualitygate.wait=true
            # 质量门禁条件(在SonarQube控制台配置):
            # - 新代码覆盖率 >= 80%
            # - 新代码重复率 <= 3%
            # - 0个严重Bug
            # - 0个安全漏洞

  # ===== 阶段3:构建镜像与安全扫描 =====
  image:
    needs: sonarqube
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Build Docker image
        run: |
          docker build -t myregistry/order-service:${{ github.sha }} .

      # Trivy镜像漏洞扫描
      - name: Trivy Vulnerability Scan
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'myregistry/order-service:${{ github.sha }}'
          format: 'table'
          exit-code: '1'              # 发现高危漏洞则流水线失败
          severity: 'CRITICAL,HIGH'   # 只关注高危和严重漏洞
          ignore-unfixed: true        # 忽略暂无修复的漏洞

      - name: Push Docker image
        run: |
          docker push myregistry/order-service:${{ github.sha }}

  # ===== 阶段4:多环境部署(Helm) =====
  deploy-dev:
    needs: image
    runs-on: ubuntu-latest
    environment: development
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to Dev
        run: |
          helm upgrade --install order-service ./helm/order-service \
            --namespace dev \
            --values ./helm/order-service/values-dev.yaml \
            --set image.tag=${{ github.sha }} \
            --wait --timeout=300s

  deploy-prod:
    needs: deploy-dev
    runs-on: ubuntu-latest
    environment: production    # 需要手动审批
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to Production
        run: |
          helm upgrade --install order-service ./helm/order-service \
            --namespace production \
            --values ./helm/order-service/values-prod.yaml \
            --set image.tag=${{ github.sha }} \
            --wait --timeout=600s

42.4 镜像漏洞扫描(Trivy)

Docker镜像可能包含有漏洞的基础镜像和依赖包。Trivy在CI流水线中自动扫描,发现高危漏洞直接阻断部署。

Trivy扫描结果示例
# trivy扫描输出(简化)
order-service:abc123 (ubuntu 22.04)
====================================
Total: 5 (HIGH: 3, CRITICAL: 2)

┌──────────────┬──────────────┬──────────┬─────────────────┐
│   Library    │   Severity   │  Fixed   │   Title         │
├──────────────┼──────────────┼──────────┼─────────────────┤
│ openssl      │ CRITICAL     │ 3.0.13   │ CVE-2024-xxxxx  │
│ libcurl      │ HIGH         │ 8.5.0    │ CVE-2024-xxxxx  │
│ log4j-core   │ CRITICAL     │ 2.21.0   │ CVE-2021-44228  │
└──────────────┴──────────────┴──────────┴─────────────────┘

# 发现CRITICAL漏洞 → 流水线失败 → 修复后重新构建
# 修复方式:
# 1. 升级基础镜像:FROM eclipse-temurin:17-jre-alpine → 最新版
# 2. 升级依赖版本:log4j 2.14 → 2.21+
# 3. 如果是误报,在.trivyignore中排除

42.5 Helm多环境配置管理

不同环境(Dev/Prod)的配置不同(副本数、资源限制、数据库地址等)。Helm通过values-{env}.yaml实现一份模板,多环境差异化。

Helm Chart目录结构
helm/order-service/
├── Chart.yaml                 # Chart元信息
├── values.yaml                # 默认配置(公共值)
├── values-dev.yaml            # 开发环境覆盖
├── values-prod.yaml           # 生产环境覆盖
└── templates/
    ├── deployment.yaml        # Deployment模板
    ├── service.yaml           # Service模板
    ├── configmap.yaml         # ConfigMap模板
    └── ingress.yaml           # Ingress模板
values-dev.yaml(开发环境)
# 开发环境:资源少,单副本,宽松限制
replicaCount: 1

image:
  registry: myregistry
  repository: order-service
  tag: latest

resources:
  requests:
    cpu: "250m"
    memory: "256Mi"
  limits:
    cpu: "500m"
    memory: "512Mi"

env:
  SPRING_PROFILES_ACTIVE: dev
  DB_HOST: mysql-dev.internal
  REDIS_HOST: redis-dev.internal
  LOG_LEVEL: DEBUG

ingress:
  enabled: true
  host: order-service.dev.internal
values-prod.yaml(生产环境)
# 生产环境:多副本,严格资源限制,HPA自动扩缩
replicaCount: 3

image:
  registry: myregistry
  repository: order-service
  tag: ""  # 由CI/CD动态注入

resources:
  requests:
    cpu: "500m"
    memory: "512Mi"
  limits:
    cpu: "1000m"
    memory: "1Gi"

autoscaling:
  enabled: true
  minReplicas: 3
  maxReplicas: 10
  targetCPUUtilization: 70

env:
  SPRING_PROFILES_ACTIVE: prod
  DB_HOST: mysql-prod.internal
  REDIS_HOST: redis-cluster.internal
  LOG_LEVEL: WARN

ingress:
  enabled: true
  host: order-service.example.com
  tls:
    enabled: true
    secretName: order-service-tls

# 生产环境额外配置
podDisruptionBudget:
  enabled: true
  minAvailable: 2  # 至少2个Pod可用

readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10
CI/CD生产环境避坑 1. 永远不要-DskipTests:跳过测试=把炸弹埋到生产环境
2. SonarQube质量门禁必须卡住:qualitygate.wait=true,不通过不部署
3. 镜像漏洞扫描不能跳过:一个log4j漏洞就能让整个系统沦陷
4. 生产部署要手动审批:用GitHub Environment的Required Reviewers功能
5. Helm values文件要版本管理:不要把密码写在values里,用K8s Secret或Vault

第四十三章:日志收集——ELK架构

43.1 为什么需要统一日志?

在微服务架构中,有几十上百个服务实例。如果日志分散在每台服务器上,排查问题时需要一台台登录去查——这在生产环境中是不可接受的。ELK架构把所有日志集中收集、统一存储、可视化查询。

43.2 ELK架构

┌──────────┐ ┌──────────┐ ┌──────────┐ │ 服务A │ │ 服务B │ │ 服务C │ │ (日志) │ │ (日志) │ │ (日志) │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ ▼ ▼ ▼ ┌─────────────────────────────────────┐ │ Filebeat(采集) │ │ 轻量级日志采集器 │ └──────────────────┬──────────────────┘ │ ▼ ┌─────────────────────────────────────┐ │ Logstash(处理) │ │ 过滤、解析、转换日志格式 │ └──────────────────┬──────────────────┘ │ ▼ ┌─────────────────────────────────────┐ │ Elasticsearch(存储) │ │ 分布式搜索引擎,存储日志 │ └──────────────────┬──────────────────┘ │ ▼ ┌─────────────────────────────────────┐ │ Kibana(可视化) │ │ 日志查询、图表、报警 │ └─────────────────────────────────────┘

43.3 日志规范

结构化日志输出
// 使用JSON格式输出日志,方便Logstash解析
{
  "timestamp": "2024-01-15T10:30:00.123Z",
  "level": "ERROR",
  "service": "order-service",
  "traceId": "abc123def456",
  "spanId": "span789",
  "userId": "10001",
  "method": "createOrder",
  "message": "库存不足",
  "exception": "java.lang.RuntimeException: 库存不足",
  "duration": 150
}

// 关键字段说明:
// traceId:用于跨服务追踪,一个请求的traceId贯穿所有服务
// userId:用于按用户查询日志
// duration:用于性能分析
ELK日志架构生产环境避坑 1. 日志量要控制:DEBUG级别日志在生产环境必须关闭,一天产生的日志可能达到TB级
2. ES索引要按日期切割:按天创建索引(如order-2024.01.15),配合ILM策略自动清理旧索引
3. Filebeat要配置多行合并:Java异常堆栈是多行的,不配置会拆成多条日志
4. 敏感信息要脱敏:日志中不要出现密码、身份证号、手机号等,用正则脱敏
5. 日志格式要统一:所有服务用JSON格式输出,方便Logstash解析和Kibana查询

第四十四章:指标监控——Prometheus+Grafana

44.1 Prometheus简介

Prometheus是云原生时代最流行的指标监控系统。它定期从应用中"拉取"指标数据,存储在时序数据库中,支持强大的查询语言。

44.2 监控架构

┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ 应用A │ │ 应用B │ │ 应用C │ │ /actuator/ │ │ /actuator/ │ │ /actuator/ │ │ prometheus │ │ prometheus │ │ prometheus │ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │ │ │ └─────────────────┼─────────────────┘ │ 拉取指标 ▼ ┌─────────────────────┐ │ Prometheus │ │ (时序数据库) │ └──────────┬──────────┘ │ ┌──────────┴──────────┐ ▼ ▼ ┌──────────────┐ ┌──────────────┐ │ Grafana │ │ AlertManager│ │ (可视化) │ │ (告警) │ └──────────────┘ └──────────────┘

44.3 核心指标

Prometheus指标类型
# Counter(计数器):只增不减
http_requests_total{service="order", method="GET", status="200"} 1500
http_requests_total{service="order", method="POST", status="500"} 3

# Gauge(仪表盘):可增可减
jvm_memory_used_bytes{service="order", area="heap"} 256000000
jvm_threads_live_threads{service="order"} 45

# Histogram(直方图):统计分布
http_request_duration_seconds_bucket{le="0.1"} 1200  # 1200个请求在100ms内
http_request_duration_seconds_bucket{le="0.5"} 1450  # 1450个请求在500ms内
http_request_duration_seconds_bucket{le="1.0"} 1500  # 1500个请求在1s内

44.4 告警规则

Prometheus告警规则
# prometheus-rules.yml
groups:
  - name: application-alerts
    rules:
      # 错误率超过5%触发告警
      - alert: HighErrorRate
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[5m]))
          /
          sum(rate(http_requests_total[5m]))
          > 0.05
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "错误率超过5%"
          description: "服务 {{ $labels.service }} 错误率 {{ $value | humanizePercentage }}"

      # 响应时间超过500ms触发告警
      - alert: HighLatency
        expr: |
          histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 0.5
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "P95响应时间超过500ms"
Prometheus+Grafana生产环境避坑 1. 指标基数不要太高:每个指标的label组合不要超过1万,否则Prometheus内存爆炸
2. 告警不要设太敏感:用for: 2m持续2分钟才告警,避免瞬时抖动误报
3. Grafana面板要分层:总览面板→服务面板→实例面板,从宏观到微观逐层下钻
4. Prometheus数据保留期要设:默认15天,根据磁盘空间调整,不要无限保留
5. AlertManager要配置静默规则:维护窗口期间静默告警,避免打扰值班人员

第四十五章:全链路压测与调优

45.1 为什么要压测?

上线前不压测,就像考试前不复习——你不知道系统能扛多少流量。压测的目的是:找到系统的性能瓶颈,在上线前解决它。

45.2 压测指标

指标含义参考值
QPS每秒处理的请求数越高越好
RT响应时间P99 < 500ms
错误率失败请求占比< 0.1%
CPU使用率CPU占用< 70%
内存使用率内存占用< 80%
GC频率垃圾回收频率Full GC < 1次/小时

45.3 JMeter压测实战

JMeter测试计划
# 创建线程组
线程数: 100        # 100个并发用户
Ramp-Up: 10        # 10秒内启动所有线程
循环次数: 100      # 每个线程执行100次

# 添加HTTP请求
协议: http
服务器: api.example.com
端口: 80
方法: POST
路径: /api/orders
Body: {"productId": 1001, "count": 1}

# 添加监听器
- 聚合报告:查看QPS、RT、错误率
- 响应时间图表:查看RT趋势
- 活跃线程图表:查看并发数

# 压测策略:
# 第1轮:100并发,找基准
# 第2轮:500并发,观察变化
# 第3轮:1000并发,找到瓶颈
# 第4轮:2000并发,确认极限

45.4 性能调优思路

1
找到瓶颈:用监控工具(Prometheus+Grafana)找到CPU/内存/IO/网络哪个是瓶颈
2
代码优化:慢SQL、N+1查询、不必要的对象创建、死锁
3
架构优化:加缓存、异步化、读写分离、分库分表
4
参数调优:JVM参数、线程池大小、连接池大小
5
扩容:增加服务器实例、升级硬件配置
性能优化的80/20法则 80%的性能问题来自20%的代码。常见的"性能杀手":
1. 没有索引的SQL查询
2. 循环中的远程调用(N+1问题)
3. 大对象序列化/反序列化
4. 不合理的日志输出(同步打印大对象)
5. 线程池配置不当
压测与调优生产环境避坑 1. 压测环境要和生产一致:硬件配置、网络拓扑、数据量都要接近,否则压测结果不可信
2. 压测数据要脱敏:不要用生产真实数据压测,用脱敏后的数据或造数工具
3. 压测要有监控:压测过程中同时看CPU、内存、GC、连接池,找到真正的瓶颈
4. 不要在生产环境随意压测:必须在低峰期进行,且有快速止损方案
5. 调优要先测量再优化:不要凭直觉改参数,用数据说话

第四十六章:故障排查与应急响应

46.1 故障排查思路

1
确认现象:是什么问题?影响范围多大?什么时候开始的?
2
查看监控:Prometheus/Grafana看CPU、内存、QPS、RT、错误率
3
查看日志:ELK查错误日志,看异常堆栈
4
查看链路:SkyWalking看调用链,找到慢在哪
5
定位根因:是代码bug?资源不足?依赖服务故障?
6
修复验证:修复问题,验证效果,复盘总结

46.2 常用排查命令

Linux排查命令
# CPU相关
top                           # 查看CPU使用率和进程
top -Hp                 # 查看进程的线程CPU使用
vmstat 1 10                   # 查看系统整体状态

# 内存相关
free -h                       # 查看内存使用
jmap -heap               # 查看JVM堆内存
jstat -gcutil  1000      # 查看GC情况

# 网络相关
netstat -tlnp                 # 查看端口占用
ss -s                         # 查看连接统计

# 磁盘相关
df -h                         # 查看磁盘使用
iostat -x 1 10                # 查看磁盘IO

# Java相关
jstack                   # 查看线程堆栈(排查死锁)
jmap -dump:format=b,file=heap.hprof   # 导出堆内存(分析内存泄漏)
arthas                        # 阿里开源的Java诊断工具

JVM排查实战:CPU 100%排查步骤

CPU 100%排查完整流程
# 步骤1:找到CPU最高的Java进程
top
# 记下PID,比如 12345

# 步骤2:找到该进程中CPU最高的线程
top -Hp 12345
# 记下线程ID,比如 12367

# 步骤3:将线程ID转换为16进制
printf "%x\n" 12367
# 输出:304f

# 步骤4:在线程堆栈中查找该线程
jstack 12345 | grep "304f" -A 30
# 找到对应的堆栈,定位到具体代码

# 常见原因:
# 1. 死循环(while(true)没有sleep)
# 2. 正则回溯(恶意正则导致CPU飙升)
# 3. 频繁Full GC(内存泄漏导致GC占满CPU)
# 4. 序列化/反序列化大对象

JVM排查实战:内存泄漏排查步骤

内存泄漏排查完整流程
# 步骤1:查看GC情况
jstat -gcutil 12345 1000
# 关注:FGC(Full GC次数)和 FGCT(Full GC耗时)
# 如果FGC频繁(每分钟多次),说明内存泄漏

# 步骤2:查看堆内存使用
jmap -heap 12345
# 关注:老年代使用率,如果持续>90%且GC后不下降,确认内存泄漏

# 步骤3:导出堆内存快照
jmap -dump:format=b,file=heap.hprof 12345
# 注意:导出会触发Full GC,生产环境谨慎使用

# 步骤4:用MAT或JProfiler分析
# MAT(Memory Analyzer Tool):
#   1. 打开heap.hprof
#   2. 查看"Leak Suspects"(泄漏嫌疑对象)
#   3. 查看"Dominator Tree"(占用内存最多的对象)
#   4. 查看GC Root引用链,找到为什么对象不能被回收

# 常见内存泄漏原因:
# 1. 静态集合(static Map)不断添加但不清理
# 2. 数据库连接/IO流没有关闭
# 3. ThreadLocal没有remove
# 4. 监听器/回调没有注销
# 5. 内部类持有外部类引用

Arthas在线诊断(推荐)

Arthas常用命令
# 下载并启动Arthas
curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar

# 1. 查看方法耗时(找出慢方法)
trace com.example.service.OrderService createOrder
# 输出每个方法的耗时,找出最慢的调用

# 2. 监控方法调用(统计QPS和成功率)
monitor com.example.service.OrderService createOrder -c 5
# 每5秒统计一次:调用次数、成功次数、平均耗时

# 3. 反编译线上代码(确认部署的代码版本)
jad com.example.service.OrderService

# 4. 查看方法参数和返回值(线上调试)
watch com.example.service.OrderService createOrder "{params, returnObj}" -x 2

# 5. 查看线程堆栈(找出阻塞线程)
thread -n 3  # 查看CPU使用最高的3个线程
thread -b    # 查看阻塞其他线程的线程(死锁检测)

# 6. 查看JVM信息
dashboard   # 实时仪表盘(CPU、内存、GC、线程)
memory      # 内存使用详情
heapdump    # 导出堆内存(和jmap一样)

46.3 故障复盘模板

故障复盘文档
# 故障复盘报告

## 基本信息
- 故障时间:2024-01-15 14:30 - 15:00(持续30分钟)
- 影响范围:订单服务不可用,影响约10万用户
- 严重等级:P1(最高级)

## 故障现象
- 用户下单时返回500错误
- 订单服务CPU使用率飙升到100%

## 根因分析
- 慢SQL导致数据库连接池耗尽
- 某个查询没有走索引,全表扫描

## 处理过程
14:30 - 监控告警:订单服务错误率超过5%
14:35 - 确认问题:查看日志发现大量数据库超时
14:40 - 临时处理:重启服务,问题缓解
14:50 - 根因定位:发现慢SQL
15:00 - 永久修复:添加索引,优化SQL

## 改进措施
1. 上线前必须做慢SQL检查
2. 增加数据库监控告警
3. 完善压测流程
故障排查生产环境避坑 1. 不要慌:故障时第一件事是确认影响范围,不是急着重启
2. 操作要记录:故障期间的每一步操作都要记录时间戳,复盘时需要
3. 回滚优先于修复:能快速回滚就回滚,修复可以事后慢慢做
4. 不要在故障时改配置:改配置可能引入新问题,先恢复服务再说
5. 复盘要追根溯源:不要停在"重启好了",要找到根因并修复,否则下次还会出

第四十七章:实战项目——电商秒杀系统

47.1 系统架构

┌─────────────────────────────────────────────────────────────┐ │ 用户端 │ │ 前端页面 → 倒计时 → 验证码 → 点击秒杀 → 查看结果 │ └────────────────────────────┬────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ CDN + Nginx集群 │ │ 静态资源CDN → Nginx限流(每IP每秒10次) → 负载均衡 │ └────────────────────────────┬────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ API网关 │ │ 鉴权 → 限流(每用户每秒1次) → 路由 │ └────────────────────────────┬────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ 秒杀服务 │ │ Redis Lua脚本扣减库存 → 发送MQ消息 → 返回结果 │ └────────────────────────────┬────────────────────────────────┘ │ ┌────────┴────────┐ ▼ ▼ ┌──────────┐ ┌──────────────┐ │ Redis │ │ RocketMQ │ │ (库存) │ │ (异步下单) │ └──────────┘ └──────┬───────┘ │ ▼ ┌──────────────┐ │ 订单服务 │ │ MySQL │ └──────────────┘

47.2 核心代码

秒杀接口
@RestController
@RequestMapping("/api/seckill")
public class SeckillController {

    @Autowired
    private SeckillService seckillService;

    // 秒杀接口
    @PostMapping("/{goodsId}")
    public Result seckill(@PathVariable Long goodsId,
                          @RequestHeader("X-User-Id") Long userId) {
        // 1. Redis Lua脚本扣减库存
        int result = seckillService.trySeckill(goodsId, userId);

        if (result == 1) {
            // 2. 扣减成功,发送MQ消息异步创建订单
            seckillService.sendSeckillOrder(userId, goodsId);
            return Result.success("秒杀成功,正在创建订单");
        } else if (result == 0) {
            return Result.fail("库存不足");
        } else {
            return Result.fail("不能重复秒杀");
        }
    }

    // 查询秒杀结果
    @GetMapping("/result/{goodsId}")
    public Result getResult(@PathVariable Long goodsId,
                            @RequestHeader("X-User-Id") Long userId) {
        // 查询MQ消费结果
        SeckillResult result = seckillService.getResult(userId, goodsId);
        if (result == null) {
            return Result.success("排队中...");
        }
        return Result.success(result);
    }
}
秒杀系统生产环境避坑 1. 库存预热要提前:秒杀开始前把库存加载到Redis,不要秒杀时才查数据库
2. Redis Lua脚本要测试边界:并发10万时Lua脚本的执行时间要压测确认
3. MQ消费要幂等:网络抖动可能导致同一条消息被消费多次,用唯一ID去重
4. 前端要防重复提交:按钮点击后立即置灰,不要依赖后端去重
5. 要有兜底方案:Redis挂了怎么办?降级到数据库乐观锁,虽然慢但不会超卖

第四十八章:实战项目——社交Feed流系统

48.1 Feed流的两种模式

推模式(Push):发件人模式 用户A发了一条动态 → 系统把这条动态推送到所有粉丝的收件箱 → 粉丝打开APP,直接从收件箱读取 优点:读取快(直接查收件箱) 缺点:大V发一条动态要推送给几百万粉丝,写入量巨大 拉模式(Pull):收件人模式 用户B打开APP → 系统去关注列表找B关注的人 → 去这些人的时间线取最新动态 → 合并排序后返回 优点:写入少(不用推送给所有人) 缺点:读取慢(要查多个时间线再合并) 推拉结合(实际方案): 普通用户:推模式(粉丝少,推送量小) 大V(粉丝>10万):拉模式(避免推送量过大)

48.2 数据模型设计

Feed流数据表设计
-- 动态表(存储用户发布的动态)
CREATE TABLE feeds (
    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    content TEXT,
    images JSON,
    created_at DATETIME,
    INDEX idx_user_id (user_id)
);

-- 收件箱表(推模式,存储每个用户收到的动态)
CREATE TABLE inbox (
    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL,     -- 收件人
    feed_id BIGINT NOT NULL,     -- 动态ID
    created_at DATETIME,
    INDEX idx_user_id_created (user_id, created_at DESC)
);

-- 关注关系表
CREATE TABLE follows (
    follower_id BIGINT NOT NULL,  -- 关注者
    following_id BIGINT NOT NULL, -- 被关注者
    created_at DATETIME,
    PRIMARY KEY (follower_id, following_id),
    INDEX idx_following (following_id)
);

48.3 大V问题的解决方案

大V问题 一个大V有5000万粉丝。如果他发一条动态要推送给5000万人,写入量太大。
解决方案:
1. 粉丝数 < 10万:用推模式,发帖时写入所有粉丝的收件箱
2. 粉丝数 ≥ 10万:用拉模式,粉丝读取时实时拉取大V的动态
3. 读取时合并:收件箱数据 + 大V实时数据 → 排序 → 返回
Feed流系统生产环境避坑 1. 推模式要限流:大V发帖时不要一次性推送给所有粉丝,用MQ分批异步推送
2. 收件箱要设置上限:每个用户的收件箱最多保留1000条,超出的按时间淘汰
3. 关注关系要缓存:判断是否关注的查询量极大,必须用Redis Set缓存
4. Feed排序不要只按时间:纯时间排序会导致优质内容被淹没,加入互动权重
5. 删除操作要级联:用户删帖时要同时删除所有粉丝收件箱中的副本

第四十九章:实战项目——实时数据大屏

49.1 系统架构

数据源 实时计算 展示端 ┌──────────┐ ┌──────────────────┐ ┌──────────────┐ │ MySQL │────→│ │ │ │ │ 业务数据 │ │ Flink/Spark │ │ 数据大屏 │ └──────────┘ │ Streaming │────→│ (WebSocket) │ ┌──────────┐ │ │ │ │ │ Kafka │────→│ 实时聚合计算 │ │ 前端可视化 │ │ 日志数据 │ │ │ │ (ECharts) │ └──────────┘ └──────────────────┘ └──────────────┘ 核心指标: - 实时销售额(每秒更新) - 订单量趋势(每分钟) - 热门商品TOP10 - 用户地域分布 - 系统QPS监控

49.2 WebSocket实时推送

Spring WebSocket
@ServerEndpoint("/ws/dashboard")
@Component
public class DashboardWebSocket {

    private static final Set<Session> sessions = ConcurrentHashMap.newKeySet();

    @OnOpen
    public void onOpen(Session session) {
        sessions.add(session);
    }

    @OnClose
    public void onClose(Session session) {
        sessions.remove(session);
    }

    // 推送数据到所有客户端
    public static void broadcast(String message) {
        for (Session session : sessions) {
            if (session.isOpen()) {
                session.getAsyncRemote().sendText(message);
            }
        }
    }
}

// 定时推送(每秒更新一次)
@Scheduled(fixedRate = 1000)
public void pushDashboardData() {
    DashboardData data = dashboardService.getRealtimeData();
    DashboardWebSocket.broadcast(JSON.toJSONString(data));
}

49.3 前端ECharts示例

实时折线图
// 建立WebSocket连接
const ws = new WebSocket('ws://api.example.com/ws/dashboard');

ws.onmessage = function(event) {
    const data = JSON.parse(event.data);

    // 更新销售额折线图
    salesChart.setOption({
        xAxis: { data: data.timePoints },
        series: [{ data: data.salesAmounts }]
    });

    // 更新订单量柱状图
    orderChart.setOption({
        series: [{ data: data.orderCounts }]
    });

    // 更新数字翻牌器
    document.getElementById('totalSales').innerText =
        '¥' + data.totalSales.toLocaleString();
};
实时数据大屏生产环境避坑 1. WebSocket要加心跳:每30秒发一次ping,超时自动重连,否则连接会因NAT超时断开
2. 推送频率要控制:大屏数据每秒更新一次就够了,频率太高前端渲染跟不上
3. 数据量大时用增量推送:不要每次推送全量数据,只推送变化的部分
4. WebSocket要鉴权:连接时验证Token,防止未授权访问
5. 大屏要考虑降级:实时计算挂了时,降级到展示最近一次缓存的数据

第五十章:架构师成长之路

50.1 架构师的核心能力

1
技术广度:了解各种技术的优缺点,能根据场景选择最合适的技术
2
技术深度:至少在1-2个领域有深入研究(如分布式事务、高并发)
3
业务理解:理解业务需求,能用技术解决业务问题
4
沟通能力:能把复杂的技术方案用简单的语言解释给非技术人员
5
决策能力:在多种方案中做出权衡,选择最适合当前阶段的方案

50.2 技术选型方法论

技术选型评估框架
# 技术选型评估表

## 1. 功能匹配度(权重30%)
- 是否满足核心需求?
- 是否有缺失的关键功能?

## 2. 性能(权重20%)
- QPS/TPS能达到多少?
- 延迟是否满足要求?

## 3. 社区活跃度(权重15%)
- GitHub Star数
- 最近更新频率
- Issue响应速度

## 4. 学习成本(权重10%)
- 团队是否熟悉?
- 文档是否完善?

## 5. 运维成本(权重10%)
- 部署复杂度
- 监控告警支持
- 故障恢复难度

## 6. 生态兼容性(权重10%)
- 是否和现有技术栈兼容?
- 是否有成熟的集成方案?

## 7. 成本(权重5%)
- 开源 vs 商业
- 硬件资源需求

50.3 架构设计原则

合适
选择合适的,而非最好的初创公司不需要K8s,单体架构就够用
简单
能简单就简单复杂方案维护成本高,简单方案出问题好排查
演进
架构是演进的,不是设计出来的根据业务增长逐步优化,不要过度设计
权衡
没有完美方案,只有合适方案每个决策都有trade-off,要清楚取舍

50.4 推荐学习资源

类别资源说明
书籍《分布式系统:概念与设计》分布式系统理论经典
书籍《微服务架构设计模式》Chris Richardson著,微服务圣经
书籍《高性能MySQL》数据库优化必读
书籍《Redis设计与实现》深入理解Redis
论文Google MapReduce/GFS/BigTable分布式系统奠基论文
开源Spring Cloud源码学习微服务框架实现
社区InfoQ、掘金、CSDN技术文章和实践经验
给读者的话 学习分布式和微服务不是一蹴而就的。本教程覆盖了从基础到实战的完整知识体系,但真正的成长来自于实践。建议:
1. 跟着教程搭建一个完整的微服务项目
2. 在项目中遇到问题时,回到对应章节深入学习
3. 多读源码,理解框架的实现原理
4. 多做压测,感受系统的性能瓶颈
5. 多参与开源社区,和其他开发者交流

技术之路没有捷径,但每一步都算数。加油!