50 章完整教程 · 从零基础到架构师
假设你开了一家小饭馆。一开始,你一个人既是厨师、又是收银员、又是服务员。客人不多的时候,完全忙得过来。这就是单体架构——所有功能都在一个系统里,简单、直接、好管理。
但有一天,你的饭馆火了。门口排起了长队,你一个人根本忙不过来。于是你开始招人:一个专职厨师、一个收银员、两个服务员。每个人只负责一件事,但配合起来效率极高。这就是微服务架构——把一个大系统拆成多个小服务,各司其职。
再后来,你的饭馆成了连锁品牌,全城有 50 家分店。你需要一套系统来管理所有分店的库存、订单、会员。这套系统每秒钟要处理上万次请求——双十一那天更是要扛住 10 倍的流量。这就是高并发——系统要能同时处理海量请求,不能崩。
分布式 = 把事情分给多台机器一起干
高并发 = 同时扛住大量用户的请求
微服务 = 把一个大系统拆成多个小服务
不管你是在校学生还是工作几年的开发者,掌握分布式和微服务技术都是涨薪最快的路径之一。来看看真实的数据:
| 技术栈 | 初级(1-3年) | 中级(3-5年) | 高级(5年+) |
|---|---|---|---|
| 单体架构 | 8-12K | 12-18K | 18-25K |
| 微服务架构 | 12-18K | 18-30K | 30-50K |
| 分布式+高并发 | 15-20K | 25-40K | 40-70K+ |
几乎所有互联网大厂和中大型公司都在用分布式微服务架构:
本教程按照以下顺序组织,建议从头到尾循序渐进:
单体架构(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
别小看单体架构,它在很多场景下是最佳选择:
当业务增长到一定程度,单体架构的问题就会暴露出来:
| 问题 | 具体表现 | 后果 |
|---|---|---|
| 代码耦合 | 改一个功能可能影响其他功能 | 开发效率越来越低,改一个 bug 冒出三个 |
| 部署风险 | 改一行代码就要重新部署整个系统 | 每次上线都心惊胆战 |
| 无法水平扩展 | 订单模块压力大,但只能整体扩容 | 浪费服务器资源,成本飙升 |
| 技术栈绑定 | 整个项目只能用一种语言和框架 | 无法根据场景选择最合适的技术 |
| 团队协作困难 | 20 个人改同一个代码仓库 | 代码冲突不断,合并痛苦 |
想象一个自助餐厅:一开始只有 10 个菜品,一个厨师就能搞定。后来菜品增加到 100 个,一个厨房根本放不下那么多锅碗瓢盆。更要命的是,做菜的油烟会飘到甜品区,做甜品的面粉会飘到炒菜区——互相干扰。你需要把它们拆成独立的厨房。
当你的系统出现以下信号时,就该考虑从单体转向微服务了:
分布式系统(Distributed System)的定义很简单:一组通过网络互相通信、协同工作的计算机,对外表现为一个整体。
分布式系统就像一个快递公司:全国有成千上万个网点(节点),每个网点只负责自己区域的收发(分工),但它们通过统一的系统协同工作——你在新疆下单,北京的仓库发货,中间经过多个中转站,最终送到你手上。你不需要知道包裹经过了哪些站,你只知道"下单→收货"。
分布式系统的核心特征:
高并发(High Concurrency)是指系统在同一时间内需要处理大量并发请求的能力。注意两个关键词:同一时间和大量请求。
| 指标 | 含义 | 小系统 | 中型系统 | 大型系统 |
|---|---|---|---|---|
| QPS | 每秒查询数 | <100 | 1,000-10,000 | 100,000+ |
| TPS | 每秒事务数 | <50 | 500-5,000 | 50,000+ |
| 并发数 | 同时在线用户 | <500 | 5,000-50,000 | 1,000,000+ |
| 响应时间 | 单次请求耗时 | 不限 | <200ms | <50ms |
高并发就像春运抢票:同一秒钟有 100 万人在刷 12306 买票。系统要同时处理这 100 万个请求——有人在查询余票、有人在下单、有人在支付、有人在退票。如果系统扛不住,就会崩溃("服务器繁忙"),用户体验极差。
微服务架构(Microservices Architecture)是一种架构风格:把一个大型应用拆分成一组小型、独立、可独立部署的服务。每个服务:
分布式、高并发、微服务三者不是独立的,而是紧密关联的:
分布式和高并发的底层,都离不开并发编程。而并发编程的基础,就是理解进程、线程、协程。如果你不理解这些,后面学再多框架也是空中楼阁。
进程(Process)是操作系统分配资源的最小单位。简单来说,你每打开一个应用程序,操作系统就为它创建一个进程。
进程就像一家公司:每个公司有自己独立的办公室(内存空间)、独立的财务(资源)、独立的员工(线程)。公司之间互不干扰——A 公司倒闭了不会影响 B 公司。
// 每个 Java 应用启动后就是一个进程
// 在命令行中查看 Java 进程
// jps -l
// 进程之间是隔离的,不能直接访问对方的内存
// 进程 A 的变量 x 和进程 B 的变量 x 是完全独立的
线程(Thread)是 CPU 调度的最小单位。一个进程可以包含多个线程,它们共享进程的内存空间。
线程就像公司里的员工:同一个公司的员工共享办公室、共享打印机、共享会议室(共享内存)。但每个员工有自己的工位和任务(独立的栈和程序计数器)。
// 方式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();
| 对比项 | 进程 | 线程 | 协程 |
|---|---|---|---|
| 定义 | 资源分配的最小单位 | CPU调度的最小单位 | 用户态的轻量级线程 |
| 内存 | 独立内存空间 | 共享进程内存 | 共享线程内存 |
| 切换开销 | 最大(需切换内存映射) | 中等(需切换内核态) | 最小(用户态切换) |
| 创建开销 | 大(几MB内存) | 中(几KB栈空间) | 极小(几百字节) |
| 数量 | 几十个 | 几百到几千个 | 几十万个 |
| 代表技术 | Linux fork | Java Thread | Go goroutine |
Java 21 引入了虚拟线程(Project Loom),这是 Java 并发编程的一次革命。虚拟线程由 JVM 而非操作系统管理,轻量级程度接近 Go 的 goroutine。
平台线程(传统线程)就像正式员工:每人一间办公室(1MB栈),公司(JVM)最多养几千人。
虚拟线程就像共享工位:几千个虚拟线程共享几十个平台线程(载体线程),有人去打电话(IO阻塞)了,工位立刻让给别人用。
// 方式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 |
|---|---|---|---|
| 管理方 | 操作系统 | JVM | Go Runtime |
| 内存开销 | ~1MB/线程 | ~几KB/线程 | ~几KB/goroutine |
| 创建数量 | 几千个 | 百万级 | 百万级 |
| 阻塞代价 | 占用OS线程 | 自动卸载载体线程 | 自动切换 |
| 适用场景 | CPU密集 | IO密集 | IO密集 |
当多个线程同时访问共享资源时,就会出现线程安全问题。这是并发编程中最常见也最危险的 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 (lock) {
if (tickets > 0) {
tickets = tickets - 1;
System.out.println("买票成功,剩余: " + tickets);
}
}
// 同一时刻只有一个线程能进入这个代码块,避免了超卖
分布式系统的核心就是多台机器通过网络通信。如果不懂网络,你就无法理解服务之间是怎么调用的、为什么会有延迟、为什么会丢数据。
TCP 是面向连接的协议。在传输数据之前,必须先"握手"建立连接。这是面试高频考点,也是理解网络通信的基础。
你:"喂,能听到吗?"(SYN)
对方:"能听到,你能听到我吗?"(SYN+ACK)
你:"我也能听到,咱们开始聊吧。"(ACK)
至此,双方都确认了对方能听到,通话正式开始。
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/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 | 服务不可用 | 服务器过载或维护 |
微服务之间调用,用 HTTP(RESTful)当然可以,但性能不是最优。RPC(Remote Procedure Call)是一种更高效的通信方式——让你调用远程方法就像调用本地方法一样。
// 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、前后端交互 | 内部服务间调用 |
gRPC 使用 Protocol Buffers(Protobuf)作为接口定义语言。先定义 .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插件自动编译
// 继承生成的抽象类,实现接口
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();
CAP定理是分布式系统中最重要的理论,由加州大学的Eric Brewer教授在2000年提出。它告诉我们:在一个分布式系统中,最多只能同时满足以下三个特性中的两个:
想象你在一个异地恋的关系中(分布式系统):
一致性(C) = 你和对象的信息永远同步——你说"我在吃饭",对方立刻知道。
可用性(A) = 随时都能联系到对方——打电话永远有人接。
分区容错(P) = 即使网络断了(手机没信号),关系还能维持。
现实是:如果手机没信号(网络分区),你要么等信号恢复再联系(放弃可用性,保证一致性),要么用另一个方式联系但信息可能不同步(放弃一致性,保证可用性)。你不可能同时保证"信号断了还能实时同步信息"。
在分布式系统中,网络分区是一定会发生的——网线可能被挖断、交换机可能宕机、机房可能断电。所以 P 是必须满足的,我们实际上只能在 C 和 A 之间二选一。
| 对比项 | CP系统(强一致性) | AP系统(高可用) |
|---|---|---|
| 典型代表 | ZooKeeper、etcd、HBase | Eureka、Cassandra、DynamoDB |
| 核心思想 | 数据不能错,宁可不可用 | 系统不能挂,宁可数据暂时不一致 |
| 适用场景 | 金融交易、库存扣减、分布式锁 | 社交动态、商品浏览、新闻推送 |
| 用户体验 | 可能需要等待或重试 | 随时能用,但可能看到旧数据 |
| 一致性保证 | 强一致 | 最终一致 |
以一个简单的分布式缓存为例,理解CP和AP的区别:
// 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策略:只要有一个节点写成功就返回
public boolean apWrite(String key, String value) {
for (Node node : allNodes) {
try {
node.writeAsync(key, value); // 异步写入
return true; // 有一个成功就返回
} catch (Exception e) {
continue; // 失败了就试下一个节点
}
}
return false; // 所有节点都失败
}
// 后台线程会慢慢把数据同步到其他节点(最终一致性)
CAP定理告诉我们"鱼和熊掌不可兼得",但在实际业务中,我们既不能完全放弃一致性(钱不能算错),也不能完全放弃可用性(系统不能挂)。怎么办?
BASE理论就是对CAP中AP方案的进一步补充——既然做不到"强一致",那就做到"最终一致"。
你在微信群发了一条消息。你发出去的瞬间,群里100个人不一定同时收到——有人网络好秒收,有人网络差可能延迟几秒。但最终,所有人都会收到这条消息。这就是"最终一致性"。
如果要求"强一致性",那就得等所有人都收到消息后,你才能继续发下一条——这太慢了,体验极差。
// 用户下单后,需要:
// 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索引(允许延迟几秒)
// - 更新统计报表(允许延迟几分钟)
}
分布式共识(Consensus)是指:在分布式系统中,多个节点就某个值达成一致。听起来简单,但在网络可能分区、节点可能宕机的情况下,这非常困难。
你们10个人在微信群里投票决定今晚吃什么。问题是:
- 有人可能没看到消息(节点故障)
- 有人可能网络延迟收到重复消息(消息重复)
- 有人可能同时发起不同的投票(并发冲突)
你需要一个规则,让所有人最终达成一致的决定——这就是共识算法要解决的问题。
Paxos是第一个被证明可行的共识算法,由Leslie Lamport在1990年提出。它非常正确但也非常难懂,连Lamport自己用故事形式描述都被吐槽看不懂。
Paxos的核心思想是多数派投票:只要超过半数的节点同意一个值,这个值就被接受了。
Raft是2014年提出的共识算法,它的目标就是让工程师能看懂。目前几乎所有主流分布式系统(etcd、Consul、Nacos CP模式)都用Raft。
Raft把共识问题分解成三个子问题:
在单体架构中,一个数据库事务就能保证数据一致性。但在微服务架构中,一个业务操作可能涉及多个服务、多个数据库——跨服务的事务就是分布式事务。
你从工商银行转1000元到建设银行。这个操作涉及两家银行:
1. 工商银行:扣你1000元
2. 建设银行:给对方加1000元
这两步必须要么都成功,要么都失败。如果工商扣了钱但建设没加上,你的1000元就"消失"了。这就是分布式事务要解决的问题。
2PC是最经典的分布式事务方案,由一个协调者统一指挥所有参与者。
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的预留
}
TCC在实际使用中会遇到三个棘手的问题,不解决就会导致资金损失:
Try请求没有到达(网络超时),但Cancel请求先到了。此时Cancel不能做任何操作。
Cancel执行完了,Try才到达(网络延迟)。此时Try不能做任何操作。
Confirm/Cancel可能因为网络重试被多次调用,必须保证幂等性。
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);
}
}
}
| 对比项 | 2PC | TCC | Saga |
|---|---|---|---|
| 一致性 | 强一致 | 最终一致 | 最终一致 |
| 性能 | 低(锁资源) | 中 | 高(无锁) |
| 实现复杂度 | 低 | 高 | 中 |
| 业务侵入 | 无 | 大(需写Try/Confirm/Cancel) | 中(需写补偿逻辑) |
| 适用场景 | 同构数据库 | 资金、库存等核心业务 | 长流程业务(如旅行预订) |
当数据量大到一台机器存不下时,就需要把数据分散到多台机器上。这个"分散"的策略就是数据分片(Sharding)。
一个城市有100万本书,一个图书馆放不下。于是建了5个分馆。问题来了:哪本书放哪个分馆?
- 按首字母分:A-E放分馆1,F-J放分馆2...
- 按出版社分:人民文学放分馆1,机械工业放分馆2...
分得好,每个分馆负载均衡;分得不好,有的分馆塞满了,有的空荡荡。
最简单的分片方式是对key取模:
// 3台服务器
int serverIndex = hashCode(key) % 3;
// 问题:如果加一台服务器变成4台
int serverIndex = hashCode(key) % 4;
// 几乎所有key的映射都变了!
// 原来在服务器0的数据,可能要跑到服务器2
// 大规模数据迁移,系统可能被压垮
一致性哈希(Consistent Hashing)的核心思想是:把哈希值空间组织成一个环(0 ~ 2^32),服务器和数据都映射到这个环上。
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());
}
}
基本的一致性哈希有个问题:如果节点太少,数据分布可能非常不均匀。解决方案是引入虚拟节点——每个物理节点对应多个虚拟节点。
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);
}
}
}
| 策略 | 原理 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| 取模哈希 | hash(key) % N | 简单 | 增减节点需全量迁移 | 节点数固定 |
| 一致性哈希 | 哈希环+虚拟节点 | 增减节点影响小 | 实现复杂 | 缓存集群 |
| 范围分片 | 按key的范围分 | 支持范围查询 | 可能热点 | 数据库分表 |
| 哈希取模分表 | hash(key) % 表数 | 均匀分布 | 扩容困难 | 分库分表 |
数据库的读写速度远慢于内存。MySQL的QPS大约在几千到几万,而Redis的QPS可以达到10万+。缓存的核心思想就是:把热点数据放在内存里,用户请求先查内存,查不到再去查数据库。
你正在写论文,需要频繁查阅几本参考书。你不会每次都跑到书柜去拿——你会把最常用的几本放在书桌上(缓存),不常用的放回书柜(数据库)。书桌虽然小,但拿书的速度快10倍。
# 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
请求的数据在缓存和数据库中都不存在,每次都穿透缓存查数据库。恶意用户可能利用这个漏洞攻击系统。
// 方案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集群整体宕机,所有请求直接打到数据库。
// 原来:所有key都1小时过期
redis.setex(key, 3600, value);
// 优化:过期时间 = 基础时间 + 随机时间(0~600秒)
int expireTime = 3600 + new Random().nextInt(600);
redis.setex(key, expireTime, value);
消息队列(Message Queue,MQ)是一种异步通信机制:生产者把消息发送到队列,消费者从队列中取出消息处理。生产者和消费者不需要同时在线。
消息队列就像快递柜:
- 快递员(生产者)把包裹放进快递柜
- 你(消费者)有空了再去取
- 快递员不需要等你在家才能送
- 你不需要知道是哪个快递员送的
这就是解耦——发送方和接收方互不依赖。
| 对比项 | RabbitMQ | RocketMQ | Kafka |
|---|---|---|---|
| 开发语言 | Erlang | Java | Scala/Java |
| 单机吞吐量 | 万级 | 十万级 | 百万级 |
| 消息延迟 | 微秒级 | 毫秒级 | 毫秒级 |
| 消息可靠性 | 高 | 高 | 高 |
| 适用场景 | 中小规模、复杂路由 | 大规模、事务消息 | 大数据、日志收集 |
| 典型用户 | 中小企业 | 阿里、滴滴 | LinkedIn、字节 |
消息从生产到消费,可能在任何环节丢失。Kafka通过以下机制保证可靠性:
当消息消费失败达到最大重试次数后,会被投递到死信队列。避免一条异常消息阻塞整个消费链路。
// 消费者:处理失败时抛异常,触发重试
@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("订单消息消费失败,请人工处理");
}
}
某些业务场景需要保证消息的顺序消费(如订单状态变更:创建→支付→发货→完成)。
在单机应用中,用Java的synchronized或ReentrantLock就能解决并发问题。但在分布式系统中,多个进程部署在不同机器上,JVM级别的锁无法跨机器生效。你需要一把"全局锁"——这就是分布式锁。
分布式锁就像公共厕所的门锁:不管谁来上厕所,都要先拿到钥匙(获取锁)才能进去。用完之后把钥匙还回去(释放锁)。如果钥匙被拿走了,其他人只能排队等。
// 加锁: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);
}
}
手写Redis分布式锁容易出错。生产环境推荐使用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的看门狗会自动给锁续期,不用担心业务执行太久锁过期
ZooKeeper通过临时顺序节点实现分布式锁,天然支持公平锁和锁释放通知。
| 对比项 | Redis分布式锁 | ZooKeeper分布式锁 |
|---|---|---|
| 性能 | 高(内存操作) | 中(需要写ZNode) |
| 可靠性 | 主从切换可能丢锁 | 强一致(ZAB协议) |
| 公平性 | 非公平(需要额外实现) | 天然公平(顺序节点) |
| 锁释放通知 | 不支持(需要轮询) | 支持(Watcher机制) |
| 适用场景 | 高性能、允许极端情况丢锁 | 强一致、不能丢锁 |
在单体应用中,数据库自增ID就够了。但在分布式系统中,多个数据库同时生成ID,自增ID会冲突。你需要一个全局唯一的ID生成方案。
| 方案 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| UUID | 简单、无依赖 | 太长、无序、不适合做主键 | 日志traceId |
| 数据库自增 | 简单、有序 | 单点瓶颈、分库后冲突 | 单库 |
| 号段模式 | 高性能、有序 | 需要额外的ID服务 | 美团Leaf |
| 雪花算法 | 高性能、有序、全局唯一 | 依赖时钟 | 大部分场景 |
Snowflake(雪花算法)是Twitter开源的分布式ID生成方案。它生成一个64位的Long型ID,由以下部分组成:
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
时钟回拨是雪花算法的最大隐患。当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等成熟方案
// 它们已经处理了各种边界情况,生产环境推荐直接使用
在微服务架构中,有几十上百个服务实例。如果每个实例都有自己的配置文件,改一个配置就要重启所有实例——这在生产环境中是不可接受的。
配置中心就像学校的广播系统:校长在广播室说一句话,全校所有教室都能听到。不需要一个教室一个教室去通知。
# 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 # 最大重试次数
// 引入依赖
// 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 + "次";
}
}
Nacos配置中心能做到秒级推送,靠的不是客户端不停轮询(那样太浪费连接),而是一种巧妙的长轮询机制。
你去医院挂号看专家号。与其每5分钟去问一次"轮到我了吗?"(短轮询),不如在护士站登记后坐在候诊区等——护士有号了会叫你(长轮询)。如果30秒没人叫你,你再去确认一次(重新建立长轮询)。这样既不浪费你跑腿的次数,又能第一时间知道结果。
// 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); // 超时后立即重试
}
}
生产环境改配置是高风险操作。Nacos支持Beta发布:新配置先推送到指定IP的实例,验证无误后再全量发布。
// 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;
}
生产环境必须部署Nacos集群,至少3节点,容忍1个节点故障。
# 每个节点的 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
在单体应用中,用Spring的@Scheduled就能做定时任务。但在分布式系统中,多个实例同时执行同一个定时任务,会导致重复执行——比如:3台机器同时给用户发了3条相同的短信。
@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);
}
}
}
上面的分片方案用的是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);
}
实际业务中,任务之间往往有依赖关系。比如:先同步商品数据,再同步订单数据(因为订单需要关联商品信息)。
// 父任务:同步商品数据
@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种策略:
| 策略 | 行为 | 适用场景 |
|---|---|---|
| 串行执行(默认) | 新任务等待上一次执行完再执行 | 数据同步类任务 |
| 丢弃后续调度 | 上一次没执行完,新调度直接丢弃 | 实时性要求不高 |
| 覆盖之前调度 | 中断上一次执行,立即执行新调度 | 实时数据推送 |
| 并行执行 | 新旧任务同时执行 | 幂等性任务 |
XxlJobHelper.getShardIndex()动态获取在单体应用中,文件存在服务器本地硬盘上就行。但在分布式系统中,有多个服务器实例,用户上传的文件存在A服务器上,下次请求被负载均衡到B服务器——文件找不到了。
MinIO是一个高性能的对象存储服务,兼容Amazon S3 API。它可以存储图片、视频、文档等任意类型的文件。
// 配置
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());
}
当上传几百MB甚至几GB的文件时,一次传完容易超时或中断。MinIO兼容S3的Multipart Upload(分片上传):把大文件切成小块逐个上传,最后合并。配合"查询已上传分片"接口,就能实现断点续传。
// 大文件分片上传服务
@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());
}
}
传统方案中,文件先传到应用服务器,再由应用服务器传到MinIO——应用服务器成了带宽瓶颈。预签名URL让前端直接上传到MinIO,绕过应用服务器。
你网购了一个大件,快递员不是送到你家(应用服务器中转),而是给你一个快递柜取件码(预签名URL),你自己去快递柜(MinIO)取。快递员不用跑腿,你也不用等。
// 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就是文件的访问地址
MinIO使用纠删码保证数据可靠性:4块数据盘+2块校验盘,任意坏2块数据不丢。这比传统的3副本方案节省50%存储空间。
你有一个100寸的大电视要存放在仓库。传统方案(3副本):租3个100寸的仓库各放一台电视,成本3倍。
纠删码方案:把电视拆成4个零件(数据块),再额外算出2个备用零件(校验块),分放在6个小仓库里。任何一个仓库着火(硬盘坏了),用剩余5个仓库的零件就能重新组装出完整的电视。
在微服务架构中,一个用户请求可能经过 10 个以上的服务。当请求变慢或出错时,你需要知道到底是哪个环节出了问题。没有链路追踪,你就像在黑暗中找一只黑猫。
你寄了一个快递,可以在APP上看到:
北京收件 → 上海中转 → 杭州派送 → 已签收
如果快递丢了,你一看就知道丢在哪个环节。链路追踪就是给每个请求一个快递单号,记录它经过了哪些服务、每个服务花了多少时间。
SkyWalking是无侵入的——不需要改一行代码,只需要在启动时加一个Java 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上就能看到:
# - 每个请求的完整调用链
# - 每个环节的耗时
# - 服务间的依赖关系
# - 慢查询、异常请求的自动发现
SkyWalking内置了告警引擎,支持基于指标阈值触发告警,并通过Webhook推送到钉钉、企微等IM工具。
# 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
# 包含告警规则名、服务名、指标值、告警时间
// 接收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);
}
}
}
线上排查问题时,最大的痛点是:链路追踪看到某个Span报错了,但找不到对应的日志。解决方案是把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 → 查看该请求的所有日志
apm-toolkit-logback-1.x
高并发的本质就是IO问题。CPU的速度是纳秒级,而网络IO是毫秒级——两者相差100万倍。大部分时间CPU都在等IO。理解IO模型,是理解高并发架构的基础。
Reactor模式是高性能网络框架的核心设计模式,Nginx、Netty、Redis都用到了它。
IO多路复用的三种实现方式,理解它们的差异是理解Nginx、Redis、Netty高性能的关键:
| 对比项 | select | poll | epoll |
|---|---|---|---|
| 最大连接数 | 1024 | 无限制 | 无限制 |
| fd传递 | 每次全量拷贝 | 每次全量拷贝 | mmap共享 |
| 就绪通知 | 遍历全部fd | 遍历全部fd | 只返回就绪fd |
| 时间复杂度 | O(n) | O(n) | O(1) |
| 触发模式 | LT | LT | LT/ET |
| 操作系统 | 全平台 | 全平台 | Linux |
| 使用者 | 早期框架 | 较少使用 | Nginx、Redis、Netty |
传统文件传输需要4次拷贝和4次上下文切换,零拷贝技术将其减少到2次拷贝和2次切换:
// 方式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); // 零拷贝发送文件
| 模型 | 框架 | 特点 | 适用场景 |
|---|---|---|---|
| BIO | java.net.ServerSocket | 一连接一线程 | 连接数少(<1000) |
| NIO | Java NIO、Netty | IO多路复用、非阻塞 | 高并发网络编程 |
| AIO | Java AIO(NIO.2) | 异步回调 | 文件IO(Linux不成熟) |
Netty是Java领域最流行的NIO框架,Dubbo、gRPC、Elasticsearch底层都用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();
// 单机可以轻松支持几十万连接
负载均衡(Load Balancing)是把大量用户请求分发到多台服务器上,避免单台服务器压力过大。
银行有10个窗口,100个人排队。大堂经理(负载均衡器)会把客户分配到空闲的窗口,而不是所有人都挤在一个窗口前。
| 算法 | 原理 | 优点 | 缺点 |
|---|---|---|---|
| 轮询 | 依次分配请求 | 简单均匀 | 不考虑服务器性能差异 |
| 加权轮询 | 按权重分配 | 考虑性能差异 | 权重固定 |
| 最少连接 | 分配给连接数最少的 | 动态均衡 | 需要统计连接数 |
| IP哈希 | 同一IP固定访问同一服务器 | 会话保持 | 可能不均衡 |
| 一致性哈希 | 哈希环 | 节点变化影响小 | 实现复杂 |
# 定义上游服务器组
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 "";
}
}
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;
LVS(Linux Virtual Server)是Linux内核级别的四层负载均衡,性能极高:
当并发量上来后,数据库往往是最先扛不住的。MySQL单机QPS大约在几千到几万,而Redis可以达到10万+。数据库优化是高并发架构中最关键的一环。
大部分业务场景都是读多写少(读写比可能是 8:2 甚至 9:1)。读写分离的思路是:主库负责写,从库负责读,通过主从复制同步数据。
// 使用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
当单表数据量超过2000万行或单库超过100GB时,数据库性能会急剧下降。这时需要分库分表。
// 订单表按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张表再合并
// 所以分表键的选择非常重要
分库分表后,跨分片的排序分页查询是最危险的操作。如果不加控制,中间结果集可能撑爆内存。
校长要查"全校成绩排名前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列表,再回查各分片获取完整数据
分库分表最大的挑战不是初始分片,而是扩容。从4个分片扩展到8个分片,数据怎么迁移?停机迁移是不可接受的——必须做到不停机平滑迁移。
| 对比项 | 双写方案 | Canal Binlog方案 |
|---|---|---|
| 业务侵入 | 高(需要改写入代码) | 零侵入 |
| 数据一致性 | 需要对账 | Binlog保证最终一致 |
| 性能影响 | 双写期间有损耗 | 几乎无影响 |
| 运维复杂度 | 低 | 高(Canal集群运维) |
| 适用场景 | 小规模、快速迁移 | 大规模、不能停机 |
单层缓存(只用Redis)在极端高并发下仍然可能成为瓶颈。多级缓存的思路是:不同层次的缓存承担不同的职责,层层过滤,最终只有少量请求打到数据库。
// 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;
}
某个key的访问量特别大(比如热门商品),导致Redis单节点压力过大。
这是缓存领域最经典也最头疼的问题:更新数据库后,缓存里的旧数据怎么办?
老师在黑板上改了一道题的答案(数据库更新),但你的笔记本上(缓存)还是旧答案。如果你不更新笔记本,考试就会写错。问题是:老师先擦黑板还是先让你改笔记本?如果顺序不对,中间有同学来抄笔记就会抄到旧答案。
| 方案 | 流程 | 一致性 | 性能 | 复杂度 |
|---|---|---|---|---|
| 先删缓存再更新DB | 删缓存→更新DB | 差(并发时脏读) | 高 | 低 |
| 先更新DB再删缓存 | 更新DB→删缓存 | 较好(极小概率脏读) | 高 | 低 |
| 延迟双删 | 删缓存→更新DB→等500ms→再删缓存 | 好 | 中 | 中 |
| Canal订阅Binlog | 更新DB→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);
}
}
当单个Key的Value过大(如超过10KB的String或超过5000个元素的Hash/List/Set),就形成了大Key。大Key是Redis性能的隐形杀手。
# 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个字段
// 问题:一个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;
}
KEYS *会阻塞Redis,用SCAN替代系统的处理能力是有上限的。当请求量超过系统承受能力时,如果不做限制,系统会崩溃——一个服务崩溃可能引发连锁反应,导致整个系统雪崩。
地铁站客流量太大时,工作人员会在入口处拦住乘客,分批放行。如果不拦,站台挤满了人,可能发生踩踏事故。限流就是在保护系统不被"踩踏"。
| 算法 | 原理 | 特点 | 适用场景 |
|---|---|---|---|
| 固定窗口计数器 | 固定时间窗口内计数 | 简单,但有临界突发问题 | 简单场景 |
| 滑动窗口计数器 | 窗口随时间滑动,统计更精确 | 解决临界问题,Sentinel默认 | 生产环境推荐 |
| 漏桶 | 固定速率流出 | 平滑流量,但不允许突发 | 流量整形 |
| 令牌桶 | 固定速率生成令牌 | 允许突发流量 | 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个令牌,预支后续配额
// 适合批处理场景:先处理一批,后续慢慢恢复
// 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个请求直接走降级方法返回空列表
// 流控规则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));
当调用某个服务的错误率超过阈值时,自动熔断,不再调用该服务,直接返回降级结果。等一段时间后,再尝试恢复。
// 熔断规则:慢调用比例
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;
}
}
同步调用就像排队买奶茶——前面的人没拿到,你只能干等。异步调用就像扫码点餐——下单后你可以去逛街,奶茶做好了APP通知你。
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();
Spring WebFlux是Spring的响应式Web框架,基于Reactor库,少量线程就能处理大量并发请求。
// 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个线程
异步编程中一个关键问题是:如果生产者速度远快于消费者怎么办?数据会堆积在内存中,最终 OOM。背压就是让消费者告诉生产者"慢点发"。
你去吃自助餐(消费者),厨师不断往台上加菜(生产者)。如果你吃不过来,你不会把所有菜都堆到自己盘子里——你只取你能吃完的量。这就是背压。
没有背压的系统就像一条流水线,上游不停往传送带放东西,下游处理不过来,东西就掉地上了(OOM)。
// 生产者每秒产生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自动处理背压
// 当响应写满缓冲区时,自动暂停从上游拉取数据
Reactor的操作符是响应式编程的核心。掌握flatMap和zip,就能解决90%的异步场景。
// 问题:用户→订单→商品 三层嵌套调用
// 同步写法: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>>,会变成"套娃"
// 场景:首页需要同时获取用户信息、订单列表、推荐商品
// 三个请求互不依赖,应该并行执行
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) ← 非阻塞式等待,不占线程
在传统MVC中,用ThreadLocal传递用户信息、TraceId等上下文。但在WebFlux中,一个请求可能在多个线程间切换——ThreadLocal会丢失。这就是WebFlux的Context传播问题。
传统MVC:一个快递员全程负责你的包裹,你把单号写在他手上(ThreadLocal),全程都能看到。
WebFlux:你的包裹在传送带上流动,经过不同快递员的手。单号写在手上就丢了——你得把单号写在包裹上(Reactor Context),包裹到哪,单号到哪。
| 对比项 | ThreadLocal | Reactor Context |
|---|---|---|
| 绑定对象 | 线程 | 订阅链路(Subscriber) |
| 跨线程 | 不支持(线程切换就丢失) | 天然支持(跟着数据流走) |
| 生命周期 | 线程存活期间 | Publisher订阅期间 |
| API | get()/set() | contextWrite()/contextRead() |
| 适用场景 | 传统MVC | WebFlux/Reactor |
// 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中恢复
subscribeOn(Schedulers.boundedElastic())contextWrite只能在链路下游写入,上游读取(反直觉但很重要)创建和销毁连接/线程是非常昂贵的操作。连接池的思路是:提前创建一批连接/线程,用完了放回去复用,而不是每次都新建。
每次出门都买一辆新车(创建连接),用完就报废(销毁连接),太浪费了。连接池就像出租车队:车提前准备好,你用完还回去,下一个人继续用。
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
@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或美团的思路
除了数据库连接池,HTTP连接池同样重要。微服务之间的HTTP调用如果不复用连接,每次都要TCP握手,性能极差:
// 配置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
秒杀系统是高并发的终极考验:100万人同时抢100件商品。核心挑战是超卖问题和系统扛压。
100双限量球鞋,10万人排队抢购。如果不做任何限制,所有人都会同时冲向柜台——柜台被挤塌(服务器崩溃),球鞋被抢超卖(库存变成负数)。你需要:门口限流(每次放100人)→ 排队取号(Redis扣库存)→ 凭号领鞋(异步下单)→ 核验身份(防黄牛)。
-- 秒杀扣减库存的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 "不能重复抢购";
}
@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);
UPDATE stock SET count=count-1 WHERE id=? AND count>0不是所有系统都需要微服务。以下信号出现时,才应该考虑拆分:
DDD是微服务拆分的方法论。核心思想是:按照业务领域来拆分服务,而不是按照技术层次。
公司可以按"技术"划分:前端部、后端部、数据库部——这是按技术层次划分。
也可以按"业务"划分:电商事业部、金融事业部、物流事业部——这是按业务领域划分。
DDD建议按业务领域划分,因为每个部门(服务)都能独立完成一件事。
限界上下文是DDD中最核心的概念——每个微服务就是一个限界上下文。
DDD的战术设计是"概念科普"和"代码落地"之间的桥梁。很多教程只讲概念,不讲代码——这里补上。
// ===== 值对象(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);
}
}
聚合根之间不应该直接调用——用领域事件解耦。订单创建后,不需要直接调用库存服务和通知服务,而是发一个"订单已创建"事件。
// 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());
}
}
六边形架构是DDD的工程化落地方式。核心思想是:业务逻辑在内层,技术实现在外层,通过端口和适配器连接。
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
@Entity、@Table是JPA的,不属于领域层Spring Cloud是一套微服务开发工具集,它不是单个框架,而是多个组件的集合。用它可以快速搭建一个完整的微服务系统。
<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>
在微服务架构中,服务实例的IP和端口是动态变化的(扩容、缩容、重启)。如果硬编码地址,每次变动都要改配置。服务注册中心的作用就是:服务启动时自动注册自己的地址,调用方自动发现可用的服务地址。
服务注册中心就像手机通讯录:你不需要记住每个朋友的电话号码,你只需要在通讯录里搜名字。朋友换号了,更新通讯录就行。
// 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;
}
Nacos会定期检查服务实例是否健康。不健康的实例会被自动剔除,避免请求打到挂掉的服务上。
// 方式1:客户端发现(Nacos默认,OpenFeign/Ribbon)
// 客户端从注册中心获取所有实例地址,自己做负载均衡
// 流程:客户端 → Nacos(获取实例列表) → 客户端负载均衡 → 目标实例
// 优点:简单,没有额外的代理层
// 缺点:客户端需要集成SDK,每种语言都要实现一遍
// 方式2:服务端发现(K8s Service、Istio)
// 客户端只访问固定地址,由代理层做负载均衡
// 流程:客户端 → Service/VirtualIP → kube-proxy/Envoy → 目标Pod
// 优点:客户端无需SDK,语言无关
// 缺点:多一跳网络开销
// Nacos也支持服务端发现(通过Nginx+upstream_nacos模块)
// 但主流用法是客户端发现(OpenFeign + Ribbon)
没有网关时,客户端需要知道每个服务的地址。有了网关,所有请求都先经过网关,由网关路由到对应的服务。
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
// 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}"
// 路由配置中的熔断
// 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;
}
}
@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; // 最高优先级
}
}
max-in-memory-size
OpenFeign让你像调用本地方法一样调用远程服务。只需要定义一个接口,Feign自动生成实现类。
// 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);
}
}
当内部服务间调用对性能要求极高时,gRPC 是比 OpenFeign 更好的选择。gRPC 基于 HTTP/2 和 Protobuf,性能比 RESTful 快 2-5 倍。
// 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);
}
| 对比项 | OpenFeign | gRPC |
|---|---|---|
| 协议 | HTTP/1.1 + JSON | HTTP/2 + Protobuf |
| 性能 | 一般 | 高(快2-5倍) |
| 易用性 | 简单,注解驱动 | 需要定义.proto文件 |
| 流式传输 | 不支持 | 支持双向流 |
| 浏览器兼容 | 直接支持 | 需要gRPC-Web |
| 适用场景 | 对外API、简单调用 | 内部高频调用、大数据传输 |
connect-timeout和read-timeout针对特定参数值做限流。比如:某个商品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
Sentinel可以根据系统整体指标做保护:
| 指标 | 含义 | 建议阈值 |
|---|---|---|
| 系统负载 | Linux load值 | CPU核心数 * 2 |
| CPU使用率 | CPU占用百分比 | 70%-80% |
| 入口QPS | 每秒总请求数 | 根据压测结果 |
| 平均RT | 平均响应时间 | 200ms |
家里的电路都有保险丝:当电流过大时,保险丝熔断,切断电路,保护电器不被烧毁。等故障排除后,换上新保险丝,电路恢复。
服务熔断就是调用链路上的"保险丝":当调用某个服务的错误率过高时,自动切断调用,返回降级结果,保护调用方不被拖垮。等一段时间后,试探性恢复。
// 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秒
| 对比项 | Sentinel | Hystrix |
|---|---|---|
| 开发方 | 阿里巴巴 | Netflix(已停止维护) |
| 隔离策略 | 信号量(并发数控制) | 线程池隔离/信号量 |
| 熔断策略 | 慢调用比例/异常比例/异常数 | 异常比例/异常数 |
| 热点限流 | 支持(按参数值限流) | 不支持 |
| 控制台 | 自带完善控制台 | 需要配合Dashboard |
| 规则推送 | 动态推送(Nacos/ZK) | 需重启或轮询 |
| 扩展性 | 丰富的SPI扩展点 | 扩展性一般 |
| 社区活跃 | 活跃,持续更新 | 已停止维护 |
Seata是阿里开源的分布式事务框架,支持AT、TCC、Saga三种模式。其中AT模式是最常用的——对业务代码零侵入。
// 订单服务:创建订单 + 远程调用扣库存 + 远程调用扣款
@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); // 扣减余额
}
}
@GlobalTransactional注解,Seata会自动:Saga模式适合长流程业务(如订单创建流程),不需要锁定资源,性能好。Seata通过状态机定义Saga流程:
{
"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);
}
| 对比项 | AT模式 | TCC模式 | Saga模式 |
|---|---|---|---|
| 业务侵入 | 零侵入(自动拦截SQL) | 高(需写Try/Confirm/Cancel) | 中(需写补偿逻辑) |
| 一致性 | 最终一致 | 最终一致 | 最终一致 |
| 性能 | 中(需要记录快照和行锁) | 高(无全局锁) | 高(无全局锁) |
| 适用场景 | 单库/同构数据库 | 资金、库存等核心业务 | 长流程业务(如旅行预订) |
| 回滚方式 | 快照反向补偿 | 调用Cancel方法 | 逆序调用补偿操作 |
lockRetryTimes重试timeoutMills默认60秒,业务执行太久会导致全局锁持有时间过长@GlobalTransactional都会注册分支事务,循环开启会导致TC压力过大OAuth2 是一个授权框架,允许第三方应用在用户授权的情况下访问用户的资源,而不需要获取用户的密码。微信登录、GitHub登录都是基于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
JWT是目前最流行的无状态认证方案。服务器不需要存储session,所有信息都在token里。
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;
}
}
}
JWT最大的问题是:Token一旦签发无法主动失效,且过期时间太短用户体验差。双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");
}
}
}
企业级微服务通常采用RBAC(Role-Based Access Control)权限模型:用户→角色→权限。网关鉴权时需要验证用户的角色和权限:
-- 用户表
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 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());
}
重放攻击是指:攻击者截获一个合法请求,反复发送。解决方案是给每个请求加唯一标识和时间戳。
// 请求头中添加:
// 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));
}
# 命名空间隔离
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(用户业务组)
spring:
cloud:
nacos:
discovery:
metadata:
version: v1.0.0 # 服务版本
region: east-china # 机房区域
env: production # 环境标识
owner: order-team # 负责团队
gray: false # 是否灰度实例
# 灰度发布:新版本只有部分流量
# 通过metadata标记灰度实例
# 网关根据规则把特定用户路由到灰度实例
数据库密码、密钥等敏感信息不能明文存储在Nacos中。推荐使用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注入环境变量
// - 应用启动时从环境变量读取解密密钥
Docker是一种容器化技术。它把应用程序和它的所有依赖打包在一起,形成一个"容器"——在任何环境下都能一模一样地运行。
Docker就像集装箱:不管里面装的是什么货物,集装箱的尺寸是标准的。吊车、卡车、轮船都能运输它。Docker容器也一样——不管里面是什么应用,运行方式是标准的,任何装了Docker的机器都能运行。
# 基础镜像
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
多阶段构建是减小镜像体积的关键技术:构建阶段用完整的JDK,运行阶段只用JRE:
# 阶段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包)
Docker容器之间需要通信,理解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 # 将容器加入网络
容器是临时的,数据不会持久化。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 # 删除数据卷
17-jre-alpineHEALTHCHECK指令让Docker自动检测容器是否正常一个微服务系统通常有多个服务(用户服务、订单服务、数据库、Redis、MQ等)。用Docker一个个启动太麻烦。Docker Compose可以用一个文件定义和管理多个容器。
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
docker-compose up -d 就能启动整个微服务系统。新人入职不需要花一天配环境,一条命令搞定。
healthcheck+condition: service_healthy.env文件管理变量,不要在docker-compose.yml中硬编码密码Kubernetes(K8s)是一个容器编排平台。Docker解决了"怎么打包"的问题,K8s解决了"怎么管理成百上千个容器"的问题。
Docker是集装箱,K8s是码头管理系统。码头上有成千上万个集装箱,管理系统负责:
- 把集装箱放到哪里(调度)
- 集装箱坏了自动换新的(自愈)
- 货物多了自动增加集装箱(扩缩容)
- 集装箱之间的网络连接(服务发现)
| 类型 | 说明 | 适用场景 |
|---|---|---|
| ClusterIP | 只能集群内部访问(默认) | 服务间内部调用 |
| NodePort | 在每个节点上开放一个端口 | 开发测试环境 |
| LoadBalancer | 创建云厂商的负载均衡器 | 云环境(AWS/阿里云) |
| ExternalName | 映射到外部域名 | 访问集群外部服务 |
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 # 集群内部访问
HPA(Horizontal Pod Autoscaler)根据CPU/内存使用率自动调整Pod数量。
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
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
生产环境的配置不能硬编码在Dockerfile或Deployment中,要用ConfigMap和Secret管理:
# 创建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(值必须是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
kubectl rollout history deployment order-servicekubectl rollout undo deployment order-service服务网格(Service Mesh)是一种基础设施层,负责处理服务间通信。它的核心思想是:把服务间通信的逻辑从业务代码中抽离出来,放到一个独立的代理层。
| 功能 | Spring Cloud | Istio |
|---|---|---|
| 服务发现 | Nacos/Eureka客户端 | K8s Service / Istio自动发现 |
| 负载均衡 | Ribbon/LoadBalancer | Envoy代理内置 |
| 熔断限流 | Sentinel/Resilience4j | Envoy + DestinationRule |
| 链路追踪 | SkyWalking/Zipkin Agent | Envoy自动注入Header |
| 配置中心 | Nacos Config | ConfigMap / Istio CRD |
| 加密通信 | 需自行实现 | mTLS自动开启 |
| 语言依赖 | 仅Java | 语言无关 |
| 代码侵入 | 需要SDK和注解 | 零侵入 |
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
# 故障注入:对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
# .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
Docker镜像可能包含有漏洞的基础镜像和依赖包。Trivy在CI流水线中自动扫描,发现高危漏洞直接阻断部署。
# 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中排除
不同环境(Dev/Prod)的配置不同(副本数、资源限制、数据库地址等)。Helm通过values-{env}.yaml实现一份模板,多环境差异化。
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模板
# 开发环境:资源少,单副本,宽松限制
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
# 生产环境:多副本,严格资源限制,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
qualitygate.wait=true,不通过不部署在微服务架构中,有几十上百个服务实例。如果日志分散在每台服务器上,排查问题时需要一台台登录去查——这在生产环境中是不可接受的。ELK架构把所有日志集中收集、统一存储、可视化查询。
// 使用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:用于性能分析
order-2024.01.15),配合ILM策略自动清理旧索引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内
# 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"
for: 2m持续2分钟才告警,避免瞬时抖动误报上线前不压测,就像考试前不复习——你不知道系统能扛多少流量。压测的目的是:找到系统的性能瓶颈,在上线前解决它。
| 指标 | 含义 | 参考值 |
|---|---|---|
| QPS | 每秒处理的请求数 | 越高越好 |
| RT | 响应时间 | P99 < 500ms |
| 错误率 | 失败请求占比 | < 0.1% |
| CPU使用率 | CPU占用 | < 70% |
| 内存使用率 | 内存占用 | < 80% |
| GC频率 | 垃圾回收频率 | Full GC < 1次/小时 |
# 创建线程组
线程数: 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并发,确认极限
# 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诊断工具
# 步骤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. 序列化/反序列化大对象
# 步骤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
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一样)
# 故障复盘报告
## 基本信息
- 故障时间: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. 完善压测流程
@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);
}
}
-- 动态表(存储用户发布的动态)
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)
);
@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));
}
// 建立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. 功能匹配度(权重30%)
- 是否满足核心需求?
- 是否有缺失的关键功能?
## 2. 性能(权重20%)
- QPS/TPS能达到多少?
- 延迟是否满足要求?
## 3. 社区活跃度(权重15%)
- GitHub Star数
- 最近更新频率
- Issue响应速度
## 4. 学习成本(权重10%)
- 团队是否熟悉?
- 文档是否完善?
## 5. 运维成本(权重10%)
- 部署复杂度
- 监控告警支持
- 故障恢复难度
## 6. 生态兼容性(权重10%)
- 是否和现有技术栈兼容?
- 是否有成熟的集成方案?
## 7. 成本(权重5%)
- 开源 vs 商业
- 硬件资源需求
| 类别 | 资源 | 说明 |
|---|---|---|
| 书籍 | 《分布式系统:概念与设计》 | 分布式系统理论经典 |
| 书籍 | 《微服务架构设计模式》 | Chris Richardson著,微服务圣经 |
| 书籍 | 《高性能MySQL》 | 数据库优化必读 |
| 书籍 | 《Redis设计与实现》 | 深入理解Redis |
| 论文 | Google MapReduce/GFS/BigTable | 分布式系统奠基论文 |
| 开源 | Spring Cloud源码 | 学习微服务框架实现 |
| 社区 | InfoQ、掘金、CSDN | 技术文章和实践经验 |