
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
Generated by kimi-k2.6 model
Spring Cloud Alibaba 微服务面试
目录
- Spring Cloud Alibaba 生态全景与版本演进
- Nacos 服务注册与发现
- Nacos 配置中心
- Sentinel 流量治理
- Sentinel 热点参数与系统保护
- Seata 分布式事务
- Dubbo 与 OpenFeign 服务通信
- Spring Cloud Gateway 网关
- 全链路治理实战
- 微服务安全与运维
1. Spring Cloud Alibaba 生态全景与版本演进
TL;DR
Spring Cloud Alibaba 是阿里巴巴开源的微服务一站式解决方案,以 Nacos(注册/配置)、Sentinel(流量治理)、Seata(分布式事务)为核心,配合 Dubbo(RPC)、RocketMQ(消息)构建完整的微服务技术栈。
1.1 场景与背景
面试场景:"你们微服务选型为什么用 Spring Cloud Alibaba 而不是原生 Spring Cloud Netflix?"
Netflix 组件停更背景:
- Eureka 2.x 停止开发,1.x 进入维护模式
- Hystrix 停止开发, resilience4j 成为替代
- Zuul 1.x 性能瓶颈,Zuul 2.x 未集成 Spring
- Ribbon 进入维护模式
阿里巴巴解决方案:
| Netflix 组件 | Alibaba 替代 | 优势 |
|---|---|---|
| Eureka | Nacos | 同时支持注册中心和配置中心,AP+CP 可选 |
| Hystrix | Sentinel | 流量控制更丰富,支持热点、系统保护 |
| Zuul | Spring Cloud Gateway | 基于 WebFlux,性能更高 |
| Ribbon | Dubbo / Spring Cloud LoadBalancer | Dubbo 支持 Triple 协议,性能更优 |
| Config | Nacos Config | 实时推送,长轮询实现 |
| - | Seata | 分布式事务,支持 AT/TCC/Saga/XA |
1.2 版本演进与兼容性
Spring Boot 2.4+ / Spring Cloud 2020.0+(Spring Cloud Alibaba 2021.x)
└── 移除 Netflix Ribbon,使用 Spring Cloud LoadBalancer
└── 适配 Spring Cloud Gateway 3.x
Spring Boot 3.x / Spring Cloud 2022.0+(Spring Cloud Alibaba 2022.x)
└── Jakarta EE 命名空间迁移(javax → jakarta)
└── Spring Cloud Gateway 4.x
└── Nacos 2.x(gRPC 长连接替代 HTTP 心跳)
版本矩阵(面试常考):
| Spring Boot | Spring Cloud | Spring Cloud Alibaba | Nacos | Sentinel |
|---|---|---|---|---|
| 2.3.x | Hoxton.SR12 | 2.2.9.RELEASE | 1.4.x | 1.8.6 |
| 2.4.x | 2020.0.x | 2021.1 | 1.4.x / 2.0.x | 1.8.6 |
| 2.6.x | 2021.0.x | 2021.0.5.0 | 2.1.x | 1.8.6 |
| 3.0.x | 2022.0.x | 2022.0.0.0 | 2.2.x | 1.8.6 |
| 3.2.x | 2023.0.x | 2023.0.1.0 | 2.3.x | 1.8.8 |
1.3 核心架构全景
┌─────────────────────────────────────────────────────────────┐
│ 接入层 │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ SLB/CLB │ │ CDN/WAF │ │ DDoS防护 │ │
│ └──────┬───────┘ └──────────────┘ └──────────────┘ │
└───────────┼─────────────────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ API Gateway │
│ Spring Cloud Gateway + Sentinel 网关流控 │
│ 路由断言 │ 过滤器链 │ 限流熔断 │ JWT鉴权 │ 灰度路由 │
└───────────┼─────────────────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ 业务服务层(多泳道) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Order │ │ Payment │ │ Inventory│ │ User │ │
│ │ Service │ │ Service │ │ Service │ │ Service │ │
│ │ (Sentinel)│ │ (Seata) │ │ (Sentinel)│ │ (Dubbo) │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ └─────────────┴─────────────┴─────────────┘ │
│ │ │
│ Nacos Discovery(服务注册发现) │
│ Nacos Config(动态配置) │
│ Dubbo(RPC通信)/ OpenFeign │
│ Seata(分布式事务) │
└────────────────────────┬────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ 基础设施层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ MySQL │ │ Redis │ │ RocketMQ │ │ ES │ │
│ │ (Seata) │ │ (Cache) │ │ (Async) │ │ (Search) │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────────┘
1.4 业界案例
阿里巴巴双11:
- Nacos 集群承载百万级服务实例注册
- Sentinel 全链路限流保障核心交易链路
- Seata AT 模式处理亿级分布式事务
- Dubbo 3.x Triple 协议支撑异构语言互通
美团外卖:
- Nacos 作为配置中心管理千万级配置项
- Sentinel 热点参数限流防止商家刷单
- 全链路灰度发布实现分钟级线上验证
小红书:
- Spring Cloud Gateway 作为统一入口,QPS 峰值 100w+
- 自定义 GlobalFilter 实现用户鉴权与风控
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "Spring Cloud Alibaba 是 Spring Cloud 的子项目" | Alibaba 是 Spring Cloud 的 官方第三方实现,不是 Spring 官方子项目 |
| "Nacos 只能做注册中心" | Nacos 同时支持 注册中心 + 配置中心,一体化降低运维成本 |
| "Dubbo 和 Spring Cloud 二选一" | Dubbo 3.x 支持 Spring Cloud 生态集成,可共存 |
| "Seata 只能用于 Java" | Seata 支持 Go、Python 等多语言 SDK(Go-SEATA) |
延伸问题
- Spring Cloud 2020.0 为什么移除 Ribbon?LoadBalancer 与 Ribbon 区别?
- Nacos 1.x 与 2.x 的通信协议差异?
- Dubbo 3.x 的 Mesh 架构演进方向?
2. Nacos 服务注册与发现
TL;DR
Nacos 服务注册中心通过 Distro 协议实现 AP 模式的高可用注册表,支持临时实例(心跳保活)与持久化实例(健康检查),2.x 版本使用 gRPC 长连接替代 1.x 的 HTTP 心跳,大幅提升性能。
2.1 场景与背景
面试问题: "Nacos 作为注册中心,服务上下线是怎么通知消费者的?Eureka 和 Nacos 有什么区别?"
核心需求:
- 服务提供者启动时注册到注册中心
- 消费者从注册中心拉取服务列表
- 服务宕机时自动剔除,消费者及时感知
- 支持大规模集群(万级服务实例)
2.2 Nacos 服务注册表架构
┌────────────────────────────────────────────┐
│ Nacos Server 集群 │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ Server A │◄────►│ Server B │ │
│ │ (Distro) │ sync │ (Distro) │ │
│ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │
│ ┌──────▼───────┐ ┌──────▼───────┐ │
│ │ Service Map │ │ Service Map │ │
│ │ (Namespace) │ │ (Namespace) │ │
│ │ │ │ │ │
│ │ Service A │ │ Service A │ │
│ │ ├── Instance1│ │ ├── Instance1│ │
│ │ ├── Instance2│ │ ├── Instance2│ │
│ │ └── Instance3│ │ └── Instance3│ │
│ └──────────────┘ └──────────────┘ │
└────────────────────────────────────────────┘
核心数据结构:
// Service:命名空间下的一个服务
public class Service implements Serializable {
private String name; // 服务名
private String groupName; // 分组名
private String namespaceId; // 命名空间(环境隔离)
private Map<String, Cluster> clusterMap; // 集群分组
private boolean ephemeral; // 是否为临时实例
}
// Instance:服务实例
public class Instance implements Serializable {
private String ip;
private int port;
private double weight = 1.0D; // 权重(负载均衡用)
private boolean healthy = true; // 健康状态
private boolean enabled = true; // 是否启用
private boolean ephemeral = true; // 临时/持久化
private Map<String, String> metadata; // 元数据(版本、区域等)
}2.3 临时实例 vs 持久化实例
| 特性 | 临时实例(Ephemeral) | 持久化实例(Persistent) |
|---|---|---|
| 健康检查 | 客户端心跳(5s 默认) | 服务端主动探测(TCP/HTTP/MySQL) |
| 实例移除 | 心跳超时自动剔除 | 手动删除或探测失败剔除 |
| 适用场景 | 无状态服务(Spring Cloud) | 有状态服务(DB、缓存、网关) |
| 一致性协议 | Distro(AP) | Raft(CP) |
| 存储位置 | 内存 + 异步持久化 | 持久化存储 |
Java 配置:
spring:
cloud:
nacos:
discovery:
server-addr: nacos:8848
namespace: prod
group: DEFAULT_GROUP
ephemeral: true # 临时实例(默认)
metadata:
version: v1
region: cn-hangzhou2.4 心跳机制演进(1.x vs 2.x)
Nacos 1.x — HTTP 心跳:
// 客户端每 5s 发送心跳请求
public class BeatTask implements Runnable {
@Override
public void run() {
// POST /nacos/v1/ns/instance/beat
// 参数:serviceName, ip, port, namespaceId
serverProxy.sendBeat(beatInfo);
// 下次心跳延迟 5s
executorService.schedule(this, beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
}
}
// 服务端处理:更新 lastBeatTime
public void processBeat(BeatInfo beatInfo) {
String key = buildKey(beatInfo);
ClientBeatProcessor processor = new ClientBeatProcessor();
processor.setBeatInfo(beatInfo);
// 异步处理,更新实例健康状态
HealthCheckReactor.scheduleCheck(processor);
}问题: HTTP 心跳在大规模集群下连接开销大,QPS 高。
Nacos 2.x — gRPC 长连接:
// 建立 gRPC 双向流连接
public class GrpcConnection implements Connection {
private StreamObserver<Payload> streamObserver;
// 连接建立后,服务端通过流推送变更
public void requestBiStream(Payload payload, StreamObserver<Payload> observer) {
this.streamObserver = observer;
// 绑定连接与服务,后续变更直接推送
}
}
// 服务端推送服务列表变更
public void pushServiceChange(String serviceName, List<Instance> instances) {
for (Connection connection : getClients(serviceName)) {
connection.push(new NotifySubscriberRequest(serviceName, instances));
}
}性能对比:
| 指标 | Nacos 1.x | Nacos 2.x |
|---|---|---|
| 单机支撑实例数 | ~5w | ~20w |
| 服务发现延迟 | ~10s(心跳周期+推送延迟) | ~100ms(长连接推送) |
| 心跳 QPS | 实例数/5 | 连接级保活,极低 |
2.5 Distro 协议详解
Distro 是 Nacos 自研的 AP 协议,参考了 Eureka 的 Peer Replication + 一致性哈希改进:
// Distro 责任节点计算(一致性哈希)
public class DistroMapper {
public String mapSrv(String serviceName) {
// 对 serviceName 取 hash,找到对应的 Nacos Server
int index = distroHash(serviceName) % servers.size();
return servers.get(index);
}
}
// 数据写入:只写责任节点,异步同步到其他节点
public void onApply(DistroData data) {
String responsibleServer = distroMapper.mapSrv(data.getDistroKey());
if (isResponsible(responsibleServer)) {
// 写入本地注册表
distroProtocol.store(data);
// 异步广播给其他节点
distroProtocol.sync(data, Servers.all());
}
}2.6 源码级:服务发现客户端缓存
// Nacos 客户端本地缓存(Failover 机制)
public class HostReactor {
// 本地服务列表缓存
private Map<String, ServiceInfo> serviceInfoMap = new ConcurrentHashMap<>();
// 更新机制:Push(服务端推送)+ Pull(定时轮询兜底)
public ServiceInfo getServiceInfo(String serviceName, String clusters) {
String key = getKey(serviceName, clusters);
ServiceInfo serviceInfo = serviceInfoMap.get(key);
if (serviceInfo == null || isExpired(serviceInfo)) {
// 从服务端拉取(Pull 兜底)
serviceInfo = updateServiceNow(serviceName, clusters);
serviceInfoMap.put(key, serviceInfo);
}
return serviceInfo;
}
// 服务端推送更新(Push)
public void processServiceJson(String json) {
ServiceInfo serviceInfo = JacksonUtils.toObj(json, ServiceInfo.class);
serviceInfoMap.put(serviceInfo.getKey(), serviceInfo);
// 通知 LoadBalancer 更新服务列表
notifyListener(serviceInfo);
}
}2.7 业界案例:阿里巴巴
双11 百万实例注册:
- Nacos 集群 50+ 节点,承载 100w+ 服务实例
- 按业务域拆分 Namespace(交易、支付、物流)
- 临时实例用于业务服务,持久化实例用于中间件(MySQL、Redis)
- 通过
preserved.register.source=spring-cloud标记来源,便于治理
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "Nacos 是 CP 系统" | Nacos 同时支持 AP(Distro)和 CP(Raft),默认 AP |
| "心跳间隔越短越好" | 默认 5s 是平衡,过短增加服务端压力,过长延长故障发现时间 |
| "服务下线会立即通知" | 临时实例需等待心跳超时(默认 15s 无心跳才剔除),可配置更短 |
| "Nacos 2.x 完全不兼容 1.x" | 2.x Server 兼容 1.x 客户端,但推荐使用 2.x SDK 获得长连接优势 |
延伸问题
- Nacos 的 Namespace、Group、Service 三级模型如何设计多环境隔离?
- Nacos 集群脑裂时如何保证注册表一致性?
- 如果 Nacos 全部宕机,消费者还能调用服务吗?(本地缓存)
3. Nacos 配置中心
TL;DR
Nacos 配置中心通过长轮询(Long Polling)实现配置的准实时推送(延迟 < 1s),支持 Namespace + DataId + Group 三级隔离,配合 @RefreshScope 实现 Spring Bean 动态刷新。
3.1 场景与背景
面试问题: "你们配置中心怎么做的?配置变更后应用怎么感知?为什么不直接用数据库?"
核心需求:
- 集中管理应用配置,不用每个服务发版改配置
- 配置变更实时生效,不用重启服务
- 多环境配置隔离(开发/测试/预发/生产)
- 灰度发布:先在小范围验证配置变更
3.2 配置数据模型
Namespace(环境隔离)
└── Group(配置分组)
└── DataId(配置标识)
└── Content(配置内容)
设计规范:
# 命名规范
DataId = ${prefix}-${spring.profiles.active}.${file-extension}
prefix = ${spring.application.name}(默认)
# 示例
order-service-dev.yaml # 开发环境
order-service-test.yaml # 测试环境
order-service-prod.yaml # 生产环境
YAML 配置:
spring:
application:
name: order-service
profiles:
active: dev
cloud:
nacos:
config:
server-addr: nacos:8848
namespace: dev-namespace-id
group: DEFAULT_GROUP
file-extension: yaml
# 共享配置
shared-configs:
- data-id: common.yaml
group: DEFAULT_GROUP
refresh: true
# 扩展配置
extension-configs:
- data-id: redis.yaml
group: INFRA
refresh: true3.3 长轮询机制(Long Polling)
Nacos 1.x 使用 HTTP 长轮询实现配置监听:
// 客户端长轮询实现
public class ClientWorker {
// 监听配置变更
public void addListeners(String dataId, String group, Listener listener) {
cacheMap.put(GroupKey.getKey(dataId, group), new CacheData(dataId, group));
// 启动长轮询线程
startLongPolling();
}
// 长轮询核心逻辑
class LongPollingRunnable implements Runnable {
@Override
public void run() {
// 1. 获取本地缓存配置的 MD5
List<String> cacheDatas = getCacheDataKeys();
// 2. 发送长轮询请求(超时 30s)
// POST /nacos/v1/cs/configs/listener
// 参数:Listening-Configs=dataId%02group%02md5%02tenant
HttpResult result = agent.httpPost(
"/listener",
getListeningConfigs(),
30000 // 长轮询超时 30s
);
// 3. 服务端返回变更的 DataId 列表
if (HttpURLConnection.HTTP_OK == result.code) {
Set<String> changedKeys = parseChangedData(result.content);
// 4. 拉取最新配置
for (String key : changedKeys) {
String content = agent.getServerConfig(dataId, group, tenant);
updateCache(key, content);
}
}
// 5. 继续下一轮长轮询
executorService.execute(this);
}
}
}服务端实现:
// 服务端挂起请求,配置变更时唤醒
public class ConfigServletInner {
public String doPollingConfig(HttpServletRequest request, HttpServletResponse response) {
// 解析客户端监听的配置列表
List<String> clientMd5Map = parseClientMd5(request);
// 挂起请求(30s 超时)
ConfigChangeListenContext context = new ConfigChangeListenContext();
ConfigCacheService.addListenClient(clientMd5Map, context);
// 阻塞等待配置变更或超时
boolean changed = context.waiting(ConfigConstant.LONG_POLLING_TIMEOUT);
if (changed) {
// 配置变更,返回变更的 DataId
return generateResponse(clientMd5Map);
} else {
// 超时,返回空(客户端重新发起请求)
return "";
}
}
}长轮询 vs 其他推送方案:
| 方案 | 实时性 | 资源消耗 | 复杂度 | Nacos 版本 |
|---|---|---|---|---|
| 定时轮询 | 差(依赖间隔) | 高(空轮询多) | 低 | - |
| 长轮询 | 中(< 1s) | 中 | 中 | 1.x |
| WebSocket | 高 | 高(连接维护) | 高 | - |
| gRPC 双向流 | 高(~100ms) | 低 | 中 | 2.x |
3.4 配置动态刷新原理
// Spring Cloud 集成:@RefreshScope 刷新机制
@RestController
@RefreshScope // 标记此 Bean 可被动态刷新
public class OrderController {
@Value("${order.timeout:5000}")
private Long timeout;
@GetMapping("/config")
public String getConfig() {
return "timeout: " + timeout;
}
}刷新原理:
// RefreshScope 通过代理 Bean 实现
public class RefreshScope implements Scope {
// 缓存代理 Bean
private ConcurrentHashMap<String, BeanWrapper> cache = new ConcurrentHashMap<>();
// 配置变更时销毁缓存
@EventListener(RefreshScopeRefreshedEvent.class)
public void onRefresh(RefreshScopeRefreshedEvent event) {
// 1. 清空所有 @RefreshScope Bean 的缓存
cache.clear();
// 2. 重新从 Environment 读取配置
// 3. 下次访问时重新创建 Bean(使用新配置)
}
@Override
public Object get(String name, ObjectFactory<?> objectFactory) {
BeanWrapper wrapper = cache.get(name);
if (wrapper == null) {
// 创建新 Bean(会读取最新 @Value)
Object bean = objectFactory.getObject();
wrapper = new BeanWrapper(bean);
cache.put(name, wrapper);
}
return wrapper.getBean();
}
}3.5 灰度发布配置
// 按 IP 灰度发布配置
@Configuration
public class GrayConfig {
@NacosValue(value = "${feature.newPayment:false}", autoRefreshed = true)
private boolean newPaymentEnabled;
@NacosValue(value = "${feature.grayIps:}", autoRefreshed = true)
private String grayIps; // 灰度 IP 列表
public boolean isEnabled(String clientIp) {
if (!newPaymentEnabled) return false;
if (StringUtils.isEmpty(grayIps)) return false;
return Arrays.asList(grayIps.split(",")).contains(clientIp);
}
}常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "配置变更立即全局生效" | 长轮询有 < 1s 延迟;且客户端需 @RefreshScope 才能刷新 Bean |
| "所有配置都适合放 Nacos" | 敏感配置(密码、密钥)应放 KMS/ Vault,或 Nacos 加密配置 |
| "Namespace 就是环境" | Namespace 是逻辑隔离,建议按 环境 + 业务域 划分 |
| "shared-configs 和 extension-configs 一样" | shared-configs 优先级更低,适合公共配置;extension-configs 用于特定扩展 |
延伸问题
- Nacos 配置监听过多会有什么性能问题?如何优化?
- 配置变更历史如何回滚?
- Nacos 配置中心与 Apollo 对比,各有什么优劣?
4. Sentinel 流量治理
TL;DR
Sentinel 以流量为切入点,通过滑动窗口统计实现精准的 QPS/并发限流,支持直接拒绝、Warm Up(冷启动)、匀速排队三种流控效果,以及慢调用比例、异常比例、异常数三种熔断策略。
4.1 场景与背景
面试问题: "秒杀场景下怎么防止系统被流量打垮?Sentinel 和 Hystrix 有什么区别?"
核心需求:
- 限制接口 QPS,防止突发流量拖垮系统
- 服务故障时自动熔断,快速失败
- 系统负载过高时自动保护(CPU、Load、RT)
- 热点参数限流(如针对特定用户 ID、商品 ID)
4.2 滑动窗口统计
Sentinel 使用 滑动时间窗口 统计指标,解决固定窗口的临界突变问题:
固定窗口问题:
窗口1 [0, 1000ms]:100 请求(限流 100,刚好通过)
窗口2 [1000, 2000ms]:100 请求(刚好通过)
但在 500ms-1500ms 这 1s 内实际有 200 请求!
滑动窗口解决:
将 1s 分为 2 个 500ms 的格子
[0, 500ms]: 80 请求
[500, 1000ms]: 20 请求
[1000, 1500ms]: 80 请求 ← 当前时间落在 1000-1500ms
统计范围 [500, 1500ms] = 20 + 80 = 100 请求 ✅
源码实现:
// 滑动窗口核心:LeapArray
public abstract class LeapArray<T> {
protected int windowLengthInMs; // 格子时间长度(默认 500ms)
protected int sampleCount; // 格子数量(默认 2)
protected final AtomicReferenceArray<WindowWrap<T>> array;
// 获取当前时间窗口
public WindowWrap<T> currentWindow(long timeMillis) {
// 计算时间戳对应的格子索引
int idx = calculateTimeIdx(timeMillis);
// 计算窗口开始时间
long windowStart = calculateWindowStart(timeMillis);
WindowWrap<T> wrap = array.get(idx);
if (wrap == null || wrap.windowStart() < windowStart) {
// 窗口过期,重置
WindowWrap<T> newWrap = new WindowWrap<>(windowLengthInMs, windowStart, newEmptyBucket());
if (array.compareAndSet(idx, wrap, newWrap)) {
return newWrap;
}
}
return wrap;
}
}4.3 限流算法详解
1. 快速失败(直接拒绝):
// 规则配置:QPS 超过 1000 直接拒绝
FlowRule rule = new FlowRule();
rule.setResource("orderCreate");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // QPS 限流
rule.setCount(1000); // 阈值 1000
rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 快速失败
FlowRuleManager.loadRules(Collections.singletonList(rule));2. Warm Up(冷启动/预热):
// 场景:系统刚启动,缓存未预热,直接高流量会压垮 DB
// 效果:QPS 从 threshold/3 开始,经过 warmUpPeriod 慢慢升到 threshold
FlowRule rule = new FlowRule();
rule.setResource("hotDataQuery");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(1000);
rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
rule.setWarmUpPeriodSec(10); // 预热时间 10s
// 流量曲线:
// 0s: 333 QPS (1000/3)
// 5s: 667 QPS
// 10s: 1000 QPS(达到上限)3. 匀速排队(Rate Limiter):
// 场景:消息消费、DB 批量写入,需要严格控制速率
// 效果:请求以固定间隔处理,超时的请求排队等待
FlowRule rule = new FlowRule();
rule.setResource("msgConsume");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(100); // 每秒匀速处理 100 个
rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER);
rule.setMaxQueueingTimeMs(500); // 最大排队时间 500ms
// 实现:基于虚拟队列的漏桶算法4. 并发线程数限流:
// 场景:防止慢查询占满线程池
FlowRule rule = new FlowRule();
rule.setResource("slowQuery");
rule.setGrade(RuleConstant.FLOW_GRADE_THREAD); // 并发线程数
rule.setCount(50); // 最多 50 个线程同时执行
// 当第 51 个请求来时,直接拒绝(快速失败)或降级4.4 熔断策略
Sentinel 熔断基于三种统计维度:
// 1. 慢调用比例
DegradeRule slowCallRule = new DegradeRule("apiQuery");
slowCallRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
slowCallRule.setCount(0.5); // 慢调用比例阈值 50%
slowCallRule.setTimeWindow(10); // 熔断时长 10s
slowCallRule.setSlowRatioThreshold(500); // 慢调用定义:RT > 500ms
slowCallRule.setMinRequestAmount(10); // 最小请求数(防止样本过少)
slowCallRule.setStatIntervalMs(1000); // 统计时长 1s
// 2. 异常比例
DegradeRule errorRatioRule = new DegradeRule("payment");
errorRatioRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
errorRatioRule.setCount(0.5); // 异常比例阈值 50%
errorRatioRule.setTimeWindow(30); // 熔断 30s
// 3. 异常数
DegradeRule errorCountRule = new DegradeRule("syncData");
errorCountRule.setGrade(CircuitBreakerStrategy.ERROR_COUNT.getType());
errorCountRule.setCount(10); // 近 1 分钟异常数超过 10
errorCountRule.setTimeWindow(60); // 熔断 60s熔断器状态机:
┌──────────────┐
│ CLOSED │ 正常放行,统计指标
│ (关闭) │
└──────┬───────┘
│ 异常比例/数/慢调用 超过阈值
▼
┌──────────────┐
│ OPEN │ 快速失败,拒绝请求
│ (打开) │ 持续 timeWindow 秒
└──────┬───────┘
│ 熔断时间结束
▼
┌──────────────┐
│ HALF-OPEN │ 放行少量请求试探
│ (半开) │
└──────┬───────┘
│ 试探成功 → 关闭
│ 试探失败 → 打开
4.5 与 Hystrix 对比
| 特性 | Sentinel | Hystrix |
|---|---|---|
| 隔离策略 | 信号量(并发线程) | 线程池/信号量 |
| 流控粒度 | QPS、并发线程、热点参数 | 仅线程池/信号量 |
| 熔断策略 | 慢调用、异常比例、异常数 | 异常比例、异常数 |
| 流量整形 | Warm Up、匀速排队 | 无 |
| 热点参数 | 支持 | 不支持 |
| 系统保护 | 支持(CPU/Load/RT) | 不支持 |
| 规则配置 | 动态规则中心 | 静态配置/Archaius |
| 活跃度 | 活跃维护 | 停止维护 |
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "Sentinel 限流就是设置一个数字" | 需考虑 Warm Up(冷启动保护)、匀速排队(削峰填谷)、并发线程(防阻塞) |
| "熔断时间越长越好" | 过长降低可用性,过短频繁熔断,通常 10-30s 根据业务调整 |
| "Sentinel 只保护服务端" | Sentinel 也支持 Gateway 流控(入口限流)、集群流控 |
| "慢调用比例和异常比例可以一起用" | 一个资源只能配 一种熔断策略,需根据场景选择 |
延伸问题
- Sentinel 的滑动窗口统计在高并发下会有性能瓶颈吗?
- 如何实现集群级别的统一限流?
- Sentinel 规则如何持久化?为什么默认存储在内存?
5. Sentinel 热点参数与系统保护
TL;DR
Sentinel 热点参数限流可对同一资源下的不同参数值分别限流(如针对爆品商品 ID 限流),系统保护规则则根据系统负载(CPU、Load、RT)自动限流,防止雪崩。
5.1 热点参数限流
场景: 商品详情接口,普通商品正常访问,但爆品(如 iPhone 新品)需要单独限流。
@RestController
public class ProductController {
@GetMapping("/product/{productId}")
@SentinelResource(
value = "productDetail",
blockHandler = "productDetailBlockHandler"
)
public Product getProduct(@PathVariable String productId) {
return productService.getById(productId);
}
// 限流降级方法
public Product productDetailBlockHandler(String productId, BlockException ex) {
return Product.builder()
.id(productId)
.name("商品信息加载中,请稍后重试")
.build();
}
}
// 热点参数规则配置
ParamFlowRule rule = new ParamFlowRule("productDetail");
rule.setParamIdx(0); // 第 0 个参数(productId)
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(1000); // 默认每个参数值限流 1000 QPS
// 针对特定参数值单独限流
ParamFlowItem hotItem = new ParamFlowItem();
hotItem.setObject("IPhone16"); // 爆品商品 ID
hotItem.setCount(100); // 单独限流 100 QPS
rule.setParamFlowItemList(Collections.singletonList(hotItem));
ParamFlowRuleManager.loadRules(Collections.singletonList(rule));热点参数原理:
// 使用 LRU Cache 统计参数访问频率
public class ParameterMetric {
// 每个资源对应一个参数统计
private Map<String, CacheMap> metricsMap = new ConcurrentHashMap<>();
public void addValue(String resourceName, int paramIdx, Object value) {
CacheMap cache = metricsMap.computeIfAbsent(resourceName, k -> new CacheMap());
// LRU 统计每个参数值的 QPS
cache.put(value, cache.getOrDefault(value, 0) + 1);
}
}5.2 系统保护规则
// 系统保护规则:当系统负载过高时自动限流
SystemRule rule = new SystemRule();
rule.setHighestSystemLoad(10.0); // Load 阈值
rule.setHighestCpuUsage(0.8); // CPU 使用率阈值 80%
rule.setAvgRt(500); // 平均 RT 阈值 500ms
rule.setMaxThread(500); // 最大并发线程数
rule.setQps(10000); // 全局 QPS 阈值
SystemRuleManager.loadRules(Collections.singletonList(rule));保护优先级:
- CPU 使用率 > 阈值:拒绝所有入口流量
- Load > 阈值:拒绝所有入口流量
- RT 持续升高:逐步拒绝请求
- 线程数 > 阈值:拒绝新请求
- QPS > 阈值:拒绝超出的请求
5.3 规则持久化到 Nacos
Sentinel 默认规则存储在内存,重启丢失。生产环境需持久化:
// 读取 Nacos 配置的 DataSource
@Configuration
public class SentinelNacosConfig {
@Bean
public ReadableDataSource<String, List<FlowRule>> flowRuleDataSource() {
// Nacos 配置:sentinel-flow-rules
NacosDataSource<String> nacosDataSource = new NacosDataSource<>(
remoteAddress, groupId, dataId,
source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {})
);
// 注册到 Sentinel 规则管理器
FlowRuleManager.register2Property(nacosDataSource.getProperty());
return nacosDataSource;
}
}Nacos 配置示例:
[
{
"resource": "orderCreate",
"grade": 1,
"count": 1000,
"controlBehavior": 0,
"strategy": 0
},
{
"resource": "hotProduct",
"grade": 1,
"count": 100,
"paramIdx": 0,
"paramFlowItemList": [
{"object": "IPhone16", "count": 10}
]
}
]5.4 集群流控
单机限流无法满足集群场景(如总共只能卖 1000 张票):
// Token Server 模式:集中式 token 分发
ClusterFlowConfig clusterConfig = new ClusterFlowConfig();
clusterConfig.setFlowId(123456); // 全局唯一规则 ID
clusterConfig.setThresholdType(1); // 全局阈值
clusterConfig.setStrategy(0); // 快速失败
FlowRule rule = new FlowRule();
rule.setResource("seckillOrder");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(1000); // 集群总 QPS 1000
rule.setClusterMode(true); // 开启集群模式
rule.setClusterConfig(clusterConfig);架构:
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ App Node 1 │ │ App Node 2 │ │ App Node N │
│ (Token Client)│ │ (Token Client)│ │ (Token Client)│
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │
└───────────────────┼───────────────────┘
▼
┌─────────────┐
│ Token Server │
│ (Standalone)│
│ 管理全局 Token│
└─────────────┘
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "热点参数限流对所有参数都生效" | 只针对配置了 参数索引 的方法生效,且需使用 @SentinelResource |
| "系统保护规则可以保护单个接口" | 系统保护是 全局入口流量 控制,不是单接口 |
| "集群流控 Token Server 是必选的" | 小规模集群可用 本地集群均摊(总阈值/节点数),大规模再用 Token Server |
| "规则持久化后修改立即生效" | Nacos 推送有延迟(~1s),且 Sentinel 规则是覆盖式更新 |
延伸问题
- 热点参数限流的 LRU Cache 内存占用如何控制?
- Token Server 宕机后集群流控怎么降级到本地模式?
- Sentinel 控制台修改规则如何同步到 Nacos?(双向同步)
6. Seata 分布式事务
TL;DR
Seata 提供 AT(自动补偿)、TCC(业务补偿)、Saga(状态机)、XA(强一致)四种事务模式。AT 模式通过 UndoLog 实现自动回滚,是业务侵入最低的模式,适用于 80% 的互联网业务场景。
6.1 场景与背景
面试问题: "电商下单涉及库存扣减、订单创建、余额扣款,如何保证数据一致性?"
核心挑战:
- 单体事务(@Transactional)只能管理单个数据库
- 微服务拆分后,跨服务、跨数据库的事务无法保证 ACID
- CAP 定理:分布式事务只能在 CP 和 AP 间权衡
6.2 Seata 架构与角色
┌─────────────────────────────────────────────────────────────┐
│ TM(Transaction Manager) │
│ 事务管理器(发起方) │
│ @GlobalTransactional │
│ 定义全局事务边界 │
└────────────────────────┬────────────────────────────────────┘
│ 1. begin global transaction
▼
┌─────────────────────────────────────────────────────────────┐
│ TC(Transaction Coordinator) │
│ 事务协调器(Seata Server) │
│ 维护全局事务状态,驱动全局提交/回滚 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Global Session: xid=xxx, status=Begin/Committed/Rollbacked │ │
│ │ Branch Session 1: RM1, status=Registered/Completed │ │
│ │ Branch Session 2: RM2, status=Registered/Completed │ │
│ └─────────────────────────────────────────────────────┘ │
└────────────────────────┬────────────────────────────────────┘
│ 2. register branch
┌────────────┴────────────┐
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ RM1(Resource Manager)│ │ RM2(Resource Manager)│
│ 订单库(order DB) │ │ 库存库(inventory DB) │
│ - 执行业务 SQL │ │ - 执行业务 SQL │
│ - 记录 UndoLog │ │ - 记录 UndoLog │
│ - 注册分支事务 │ │ - 注册分支事务 │
└──────────────────┘ └──────────────────┘
三角色交互流程:
@Service
public class OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private InventoryFeignClient inventoryClient;
@Autowired
private AccountFeignClient accountClient;
@GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
public Order createOrder(Order order) {
// 1. TM 向 TC 申请开启全局事务,获取 XID
// TC 生成 GlobalSession
// 2. 创建订单(RM1)
orderMapper.insert(order); // 记录 UndoLog
// 3. 扣减库存(RM2,远程调用)
inventoryClient.deduct(order.getProductId(), order.getCount());
// 4. 扣减余额(RM3,远程调用)
accountClient.debit(order.getUserId(), order.getAmount());
// 5. 所有分支成功,TM 通知 TC 全局提交
// TC 驱动各 RM 异步删除 UndoLog
// 如果第 4 步失败:
// 5'. TM 通知 TC 全局回滚
// TC 驱动各 RM 根据 UndoLog 执行补偿
return order;
}
}6.3 AT 模式详解
AT 模式是 Seata 的默认模式,对业务零侵入:
执行阶段:
// RM 拦截业务 SQL,自动记录前后镜像
public class ConnectionProxy extends AbstractConnectionProxy {
@Override
public PreparedStatement prepareStatement(String sql) throws SQLException {
// 解析 SQL 类型(INSERT/UPDATE/DELETE)
SQLRecognizer recognizer = SQLVisitorFactory.get(sql, dbType);
// 生成 UndoLog
if (recognizer.getSQLType() == SQLType.UPDATE) {
// 1. 查询更新前数据(Before Image)
TableRecords beforeImage = getBeforeImage();
// 2. 执行业务 SQL
PreparedStatement stmt = targetConnection.prepareStatement(sql);
stmt.executeUpdate();
// 3. 查询更新后数据(After Image)
TableRecords afterImage = getAfterImage();
// 4. 组装 UndoLog
SQLUndoLog undoLog = new SQLUndoLog();
undoLog.setSqlType(SQLType.UPDATE);
undoLog.setTableName(tableName);
undoLog.setBeforeImage(beforeImage);
undoLog.setAfterImage(afterImage);
// 5. 插入 UndoLog 到 UNDO_LOG 表
insertUndoLog(undoLog);
}
}
}回滚阶段:
// TC 通知回滚时,RM 根据 UndoLog 恢复数据
public class UndoLogManager {
public void undo(DataSourceProxy dataSource, String xid, long branchId) {
// 1. 查询 UNDO_LOG
UndoLog log = queryUndoLog(xid, branchId);
// 2. 校验脏写(对比 After Image 与当前数据)
if (checkDirtyWrite(log.getAfterImage())) {
throw new DirtyWriteException("数据被其他事务修改,无法回滚");
}
// 3. 生成回滚 SQL
AbstractUndoExecutor executor = buildUndoExecutor(log);
// 4. 执行回滚
executor.executeOn(targetConnection);
// 5. 删除 UndoLog
deleteUndoLog(xid, branchId);
}
}UndoLog 表结构:
CREATE TABLE `undo_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`branch_id` bigint(20) NOT NULL,
`xid` varchar(100) NOT NULL,
`context` varchar(128) NOT NULL,
`rollback_info` longblob NOT NULL, -- JSON 格式的前后镜像
`log_status` int(11) NOT NULL,
`log_created` datetime NOT NULL,
`log_modified` datetime NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB;6.4 四种模式对比
| 模式 | 一致性 | 侵入性 | 性能 | 适用场景 |
|---|---|---|---|---|
| AT | 最终一致 | 低(自动补偿) | 高 | 80% 场景,简单 CRUD |
| TCC | 最终一致 | 高(需实现 3 个接口) | 高 | 复杂业务,需精细控制 |
| Saga | 最终一致 | 中(状态机配置) | 高 | 长事务、业务流程编排 |
| XA | 强一致 | 低 | 低(两阶段锁定) | 金融核心,要求强一致 |
TCC 模式示例:
@LocalTCC
public interface InventoryTccAction {
@TwoPhaseBusinessAction(name = "inventoryDeduct",
commitMethod = "commit",
rollbackMethod = "rollback")
boolean tryDeduct(@BusinessActionContextParameter(paramName = "productId") String productId,
@BusinessActionContextParameter(paramName = "count") int count);
// 确认:真正扣减库存
boolean commit(BusinessActionContext context);
// 回滚:释放预留库存
boolean rollback(BusinessActionContext context);
}
@Service
public class InventoryTccActionImpl implements InventoryTccAction {
@Autowired
private InventoryMapper inventoryMapper;
@Override
public boolean tryDeduct(String productId, int count) {
// 1. 检查库存
// 2. 预留库存(冻结字段)
return inventoryMapper.freezeStock(productId, count) > 0;
}
@Override
public boolean commit(BusinessActionContext context) {
String productId = context.getActionContext("productId");
int count = Integer.parseInt(context.getActionContext("count"));
// 将冻结库存转为实际扣减
return inventoryMapper.confirmDeduct(productId, count) > 0;
}
@Override
public boolean rollback(BusinessActionContext context) {
String productId = context.getActionContext("productId");
int count = Integer.parseInt(context.getActionContext("count"));
// 释放冻结库存
return inventoryMapper.releaseStock(productId, count) > 0;
}
}6.5 全局锁与脏写问题
AT 模式通过全局锁保证隔离性:
// 全局锁:防止其他事务修改同一行数据
public class ConnectionContext {
public void prepareUndoLog() {
// 1. 获取全局锁(向 TC 申请)
boolean lockSuccess = DefaultResourceManager.get()
.lockQuery(BranchType.AT, dataSourceProxy.getResourceId(),
xid, lockKeys);
if (!lockSuccess) {
throw new LockConflictException("获取全局锁失败,事务冲突");
}
// 2. 执行业务 SQL
// 3. 记录 UndoLog
}
}性能优化:
- 全局锁默认开启,可通过
client.rm.asyncCommitBufferLimit调优 - 读已提交隔离级别下,SELECT 不加锁(默认)
- 可配置
@GlobalTransactional(readOnly = true)优化只读事务
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "Seata AT 模式完全无侵入" | 需要创建 UNDO_LOG 表,且数据源需代理为 DataSourceProxy |
| "分布式事务一定比本地事务慢" | AT 模式提交是 异步删除 UndoLog,正常路径性能损失 < 10% |
| "Seata 能保证强一致性" | AT/TCC/Saga 都是 最终一致性,只有 XA 是强一致 |
| "全局锁会阻塞所有读写" | 全局锁只在 事务提交前 持有,且只锁修改的行;读默认不加锁 |
延伸问题
- Seata TC 高可用怎么部署?(DB 模式 + Raft 模式)
- AT 模式的脏读问题怎么解决?(SELECT FOR UPDATE 会检查全局锁)
- Saga 状态机与 TCC 相比,适用什么场景?(业务流程长、需要可视化编排)
7. Dubbo 与 OpenFeign 服务通信
TL;DR
Dubbo 是高性能 Java RPC 框架,3.x 版本支持 Triple 协议(基于 HTTP/2 + gRPC)实现跨语言互通;OpenFeign 是声明式 HTTP 客户端,与 Spring Cloud 生态无缝集成。选型建议:内部服务用 Dubbo,跨团队/跨语言用 Triple,简单聚合层用 OpenFeign。
7.1 场景与背景
面试问题: "你们微服务之间怎么通信?Dubbo 和 Feign 有什么区别?什么时候选 Dubbo?"
核心需求:
- 服务间调用低延迟、高吞吐
- 支持负载均衡、容错降级
- 跨语言互通(Java + Go + Node.js)
- 可观测性(Tracing、Metrics)
7.2 Dubbo 核心架构
┌──────────────────────────────────────────────┐
│ Consumer(调用方) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Proxy │─►│ Cluster │─►│ Directory│ │
│ │(代理接口) │ │(集群容错) │ │(服务目录) │ │
│ └──────────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │
│ ┌──────────┐ ┌───▼─────┐ ┌───▼─────┐ │
│ │ LoadBalance│◄│ Router │ │Registry │ │
│ │(负载均衡) │ │(路由) │ │(注册中心)│ │
│ └────┬─────┘ └─────────┘ └─────────┘ │
│ │ │
│ ┌────▼─────┐ │
│ │ Protocol │ ──► 网络传输(Netty) │
│ │(协议编码) │ │
│ └──────────┘ │
└──────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────┐
│ Provider(提供方) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Protocol│─►│ Exchange│─►│ Invoker │ │
│ │(协议解码) │ │(数据交换) │ │(调用目标) │ │
│ └──────────┘ └──────────┘ └────┬─────┘ │
│ │ │
│ ┌────▼─────┐ │
│ │ Impl │ │
│ │(业务实现) │ │
│ └──────────┘ │
└──────────────────────────────────────────────┘
7.3 Dubbo 负载均衡策略
// 配置负载均衡策略
@DubboReference(loadbalance = "consistenthash")
private OrderService orderService;
// 或在 XML/YAML 中配置| 策略 | 名称 | 适用场景 |
|---|---|---|
| Random | 随机(默认) | 机器性能均衡时 |
| RoundRobin | 轮询 | 短连接、均匀请求 |
| LeastActive | 最小活跃数 | 处理耗时差异大的场景 |
| ConsistentHash | 一致性哈希 | 有状态服务、缓存亲和性 |
| ShortestResponse | 最短响应时间 | 根据 RT 动态选择 |
一致性哈希源码:
public class ConsistentHashLoadBalance extends AbstractLoadBalance {
@Override
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
// 获取方法名作为哈希 Key
String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
// 根据 Invokers 列表生成一致性哈希环
int identityHashCode = System.identityHashCode(invokers);
ConsistentHashSelector<T> selector = selectors.get(key);
if (selector == null || selector.identityHashCode != identityHashCode) {
selectors.put(key, new ConsistentHashSelector<>(invokers, invocation.getMethodName(), identityHashCode));
selector = selectors.get(key);
}
// 根据参数哈希选择 Invoker
return selector.select(invocation);
}
}7.4 Dubbo 3.x Triple 协议
// Triple 协议:基于 HTTP/2 + gRPC,支持跨语言
@DubboService(protocol = "tri") // tri = Triple
public class OrderServiceImpl implements OrderService {
@Override
public Order getOrder(Long id) {
return orderMapper.selectById(id);
}
}
// 客户端调用(Java)
@DubboReference(protocol = "tri")
private OrderService orderService;
// Go 客户端调用(跨语言)
// 通过 protoc-gen-dubbo 生成 Go Stub协议对比:
| 协议 | 传输层 | 序列化 | 跨语言 | 性能 | 适用场景 |
|---|---|---|---|---|---|
| dubbo | TCP | Hessian2 | 差 | 极高 | Java 内部服务 |
| triple | HTTP/2 | Protobuf | 优 | 高 | 跨语言、云原生 |
| rest | HTTP/1.1 | JSON | 优 | 中 | 简单 REST 调用 |
| grpc | HTTP/2 | Protobuf | 优 | 高 | 标准 gRPC 生态 |
7.5 OpenFeign 声明式调用
// 1. 定义 Feign 接口
@FeignClient(
name = "inventory-service",
fallback = InventoryFeignClientFallback.class,
configuration = FeignConfig.class
)
public interface InventoryFeignClient {
@PostMapping("/inventory/deduct")
Result<Void> deduct(@RequestParam("productId") String productId,
@RequestParam("count") int count);
}
// 2. 降级实现
@Component
public class InventoryFeignClientFallback implements InventoryFeignClient {
@Override
public Result<Void> deduct(String productId, int count) {
return Result.fail("库存服务暂时不可用,请稍后重试");
}
}
// 3. 配置重试与超时
@Configuration
public class FeignConfig {
@Bean
public Retryer feignRetryer() {
// 初始间隔 100ms,最大间隔 1s,最多重试 3 次
return new Retryer.Default(100, 1000, 3);
}
@Bean
public Request.Options feignOptions() {
return new Request.Options(5, TimeUnit.SECONDS, 10, TimeUnit.SECONDS, true);
}
}Feign 与 Ribbon 集成(负载均衡):
# Spring Cloud LoadBalancer 配置(替代 Ribbon)
spring:
cloud:
loadbalancer:
ribbon:
enabled: false # 禁用 Ribbon
configurations: default
retry:
enabled: true
maxRetriesOnNextServiceInstance: 27.6 Dubbo vs OpenFeign 对比
| 特性 | Dubbo | OpenFeign |
|---|---|---|
| 协议 | TCP(dubbo)/ HTTP/2(triple) | HTTP/1.1(REST) |
| 序列化 | Hessian2 / Protobuf / Kryo | JSON(默认) |
| 性能 | 极高(二进制协议) | 中(文本协议) |
| 负载均衡 | 内置多种策略 | 依赖 LoadBalancer |
| 服务发现 | 多注册中心支持 | 依赖 Nacos/Eureka |
| 熔断降级 | 内置 Sentinel | 依赖 Hystrix/Sentinel |
| 跨语言 | Triple 支持 | 需额外适配 |
| 编程模型 | 接口调用 | 声明式注解 |
| 云原生 | Dubbo 3.x 支持 Mesh | 原生集成 Spring Cloud |
7.7 业界案例:美团
美团外卖服务调用:
- 内部 Java 服务:Dubbo 2.7 + Hessian2,日均调用量 1000 亿+
- 跨语言服务(Go 网关调用 Java 服务):Dubbo 3.x Triple 协议
- 外部开放 API:OpenFeign + Spring Cloud Gateway
- 服务分组:按区域(华北、华东)和版本(灰度)隔离
// 美团实践:按区域路由
@DubboReference(group = "beijing", version = "2.0")
private DeliveryService beijingDelivery;
@DubboReference(group = "shanghai", version = "2.0")
private DeliveryService shanghaiDelivery;常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "Dubbo 比 Feign 好,应该全用 Dubbo" | 选型看场景:内部 Java 服务用 Dubbo,跨团队/跨语言用 Triple,快速集成用 Feign |
| "Dubbo 不支持 REST" | Dubbo 3.x 支持 Triple 协议,天然兼容 HTTP/2 和 gRPC |
| "Feign 调用不用考虑超时" | 必须配置 连接超时 和 读取超时,防止级联阻塞 |
| "负载均衡策略选随机就行" | 有状态服务用 一致性哈希,耗时差异大用 最小活跃数 |
延伸问题
- Dubbo 的 SPI 扩展机制与 Java SPI 有什么区别?
- Triple 协议与原生 gRPC 的兼容性如何?
- Feign 的 Retry 机制与 Sentinel 的熔断怎么配合?
8. Spring Cloud Gateway 网关
TL;DR
Spring Cloud Gateway 基于 Spring WebFlux 和 Reactor 构建,通过路由(Route)、断言(Predicate)、过滤器(Filter)三元组实现请求转发,性能比 Zuul 1.x 高 50% 以上,是云原生网关的标准选型。
8.1 场景与背景
面试问题: "为什么需要 API Gateway?Gateway 里一般做什么?怎么保证高性能?"
核心职责:
- 统一入口:前端/移动端只调 Gateway,不用关心后端服务地址
- 路由转发:按路径、Header、参数等规则转发到不同服务
- 横切能力:鉴权、限流、日志、灰度发布
- 协议转换:HTTP 转 gRPC / Dubbo
8.2 核心概念:Route = Predicate + Filter
spring:
cloud:
gateway:
routes:
# 路由 ID
- id: order-service
# 目标 URI(lb:// = LoadBalancer)
uri: lb://order-service
predicates:
# 路径断言
- Path=/api/order/**
# 时间断言
- After=2024-01-01T00:00:00+08:00[Asia/Shanghai]
# Header 断言
- Header=X-Api-Version, v1
filters:
# 路径重写
- RewritePath=/api/order/(?<segment>.*), /order/$\{segment}
# 请求头添加
- AddRequestHeader=X-Gateway-Time, ${now}
# 响应头添加
- AddResponseHeader=X-Response-Gateway, SCG
# 限流(基于 Redis)
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 1000
redis-rate-limiter.burstCapacity: 2000Predicate 断言类型:
| Predicate | 说明 | 示例 |
|---|---|---|
| Path | 路径匹配 | Path=/api/order/** |
| Method | HTTP 方法 | Method=GET,POST |
| Header | Header 匹配 | Header=X-Version, v1 |
| Query | 查询参数 | Query=source, app |
| Cookie | Cookie 匹配 | Cookie=sessionId, abc* |
| After/Before | 时间窗口 | After=2024-01-01T00:00:00+08:00 |
| Weight | 权重分流 | Weight=group1, 8 |
8.3 过滤器链执行机制
请求流程:
Client
│
▼
┌──────────────────────────────────────────────────────┐
│ 1. Global Filter(全局过滤器) │
│ - LoggingGlobalFilter │
│ - AuthGlobalFilter │
│ - RateLimitGlobalFilter │
└──────────────────┬───────────────────────────────────┘
│
┌──────────────┴──────────────┐
▼ ▼
┌──────────────┐ ┌──────────────┐
│ Route Predicate│ 匹配成功 │ 404 Not Found│
│ (路由选择) │──────────►│ │
└──────┬───────┘ └──────────────┘
│
┌──────▼───────────────────────────────────────────────┐
│ 2. Gateway Filter(路由级过滤器) │
│ - StripPrefixFilter │
│ - RewritePathFilter │
│ - AddRequestHeaderFilter │
│ - CircuitBreakerFilter (Resilience4j) │
└──────────────────┬───────────────────────────────────┘
│
▼
┌──────────────┐
│ Netty Client │
│ (转发请求) │
└──────┬───────┘
│
▼
目标服务
自定义全局过滤器(鉴权):
@Component
@Order(-1) // 最高优先级
public class AuthGlobalFilter implements GlobalFilter {
@Autowired
private JwtTokenProvider tokenProvider;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
String path = request.getURI().getPath();
// 白名单跳过
if (isWhiteList(path)) {
return chain.filter(exchange);
}
// 校验 JWT
String token = request.getHeaders().getFirst("Authorization");
if (!tokenProvider.validateToken(token)) {
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.UNAUTHORIZED);
return response.setComplete();
}
// 将用户信息传递给下游服务
ServerHttpRequest mutatedRequest = exchange.getRequest().mutate()
.header("X-User-Id", tokenProvider.getUserId(token))
.header("X-User-Role", tokenProvider.getRole(token))
.build();
return chain.filter(exchange.mutate().request(mutatedRequest).build());
}
}8.4 Sentinel 网关流控
@Configuration
public class GatewaySentinelConfig {
@PostConstruct
public void init() {
// 自定义限流响应
BlockExceptionHandler blockHandler = (exchange, ex) -> {
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
String body = "{\"code\":429,\"message\":\"系统繁忙,请稍后重试\"}";
DataBuffer buffer = response.bufferFactory().wrap(body.getBytes());
return response.writeWith(Mono.just(buffer));
};
GatewayCallbackManager.setBlockHandler(blockHandler);
// 网关流控规则(针对 API 分组)
Set<GatewayFlowRule> rules = new HashSet<>();
rules.add(new GatewayFlowRule("order-service")
.setCount(1000) // QPS 限流 1000
.setIntervalSec(1)
.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT));
// 针对用户 ID 热点限流
rules.add(new GatewayFlowRule("user-service")
.setCount(100)
.setParamItem(new GatewayParamFlowItem()
.setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_HEADER)
.setFieldName("X-User-Id")));
GatewayRuleManager.loadRules(rules);
}
}8.5 性能优化
spring:
cloud:
gateway:
httpclient:
# 连接池配置
pool:
type: elastic # 弹性连接池
max-connections: 1000 # 最大连接数
max-idle-time: 10s # 最大空闲时间
# 超时配置
connect-timeout: 2000 # 连接超时 2s
response-timeout: 10s # 响应超时 10s
# 开启 HTTPS
httpserver:
wiretap: false # 关闭调试(生产)性能对比:
| 网关 | 吞吐量 (QPS) | 延迟 (P99) | 特点 |
|---|---|---|---|
| Zuul 1.x | ~1000 | 50ms | 阻塞 IO,线程池模型 |
| Spring Cloud Gateway | ~3000 | 15ms | 非阻塞 IO,WebFlux |
| Nginx | ~10000 | 5ms | C 语言,纯代理 |
| Envoy | ~8000 | 8ms | C++,Service Mesh 标准 |
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "Gateway 只做路由转发" | Gateway 是 横切逻辑集中地:鉴权、限流、日志、灰度、协议转换 |
| "Gateway 过滤器顺序不重要" | 全局过滤器 → 路由过滤器,顺序错误会导致鉴权前就被限流 |
| "Gateway 性能比 Nginx 好" | Gateway 基于 Java,性能低于 Nginx/Envoy,但功能更强大 |
| "所有请求都走 Gateway" | 内部服务间调用 直接走 Dubbo/Feign,不经过 Gateway |
延伸问题
- Gateway 如何实现灰度发布?(Weight Predicate + Metadata)
- Gateway 与 Nginx 如何配合使用?(Nginx 做 L7,Gateway 做业务网关)
- Gateway 的 WebFlux 编程模型有什么坑?(阻塞操作必须包装为 Mono/Flux)
9. 全链路治理实战
TL;DR
全链路治理涵盖灰度发布(按流量特征路由)、多环境隔离(Namespace/泳道)、服务降级(熔断兜底)、链路追踪(Sleuth+Zipkin)四大能力,是微服务大规模落地的关键工程实践。
9.1 全链路灰度发布
场景: 新版本上线,先让 5% 的流量验证,再逐步扩大。
# Gateway 灰度路由配置
spring:
cloud:
gateway:
routes:
- id: order-service-gray
uri: lb://order-service
predicates:
- Path=/api/order/**
# 按 Header 灰度:灰度用户走新版本
- Header=X-Gray-User, true
metadata:
version: v2
- id: order-service-stable
uri: lb://order-service
predicates:
- Path=/api/order/**
metadata:
version: v1Dubbo 标签路由:
// 提供者打标签
@DubboService(version = "2.0", tag = "gray")
public class OrderServiceV2 implements OrderService {
// 新版本实现
}
// 消费者指定标签
@DubboReference(version = "2.0", tag = "gray")
private OrderService orderService;
// 或动态设置(Gateway 透传 Header 设置)
RpcContext.getContext().setAttachment("dubbo.tag", "gray");全链路灰度传递:
@Component
public class GrayGlobalFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 1. 判断是否为灰度用户(按用户 ID 取模)
String userId = exchange.getRequest().getHeaders().getFirst("X-User-Id");
boolean isGray = isGrayUser(userId);
// 2. 灰度标记传递到所有下游服务
ServerHttpRequest request = exchange.getRequest().mutate()
.header("X-Gray-Route", isGray ? "gray" : "stable")
.build();
// 3. Dubbo/Feign 调用时自动透传(需配置拦截器)
return chain.filter(exchange.mutate().request(request).build());
}
}9.2 多环境隔离(泳道设计)
生产环境(Production Namespace)
├── 主干泳道(Main):承载大部分流量
│ ├── Order-Service v1
│ ├── Payment-Service v1
│ └── Inventory-Service v1
│
├── 灰度泳道(Gray):验证新版本
│ ├── Order-Service v2 ← 只改了这个服务
│ ├── Payment-Service v1 (复用主干)
│ └── Inventory-Service v1 (复用主干)
│
└── 压测泳道(Stress):线上压测隔离
├── Order-Service v1
├── Payment-Service v1
└── Inventory-Service v1
Nacos Namespace 隔离:
spring:
cloud:
nacos:
discovery:
namespace: ${ENV_NAMESPACE} # dev / test / pre / prod
config:
namespace: ${ENV_NAMESPACE}9.3 服务降级与兜底策略
@Service
public class OrderService {
@Autowired
private InventoryFeignClient inventoryClient;
@Autowired
private PaymentFeignClient paymentClient;
@SentinelResource(
value = "createOrder",
blockHandler = "createOrderBlockHandler",
fallback = "createOrderFallback"
)
public Order createOrder(OrderDTO dto) {
// 1. 扣库存
inventoryClient.deduct(dto.getProductId(), dto.getCount());
// 2. 创建订单
Order order = orderMapper.insert(dto);
// 3. 支付
paymentClient.pay(order.getId(), dto.getAmount());
return order;
}
// 限流/熔断时的降级逻辑
public Order createOrderBlockHandler(OrderDTO dto, BlockException ex) {
throw new BizException("系统繁忙,请稍后重试");
}
// 业务异常时的兜底逻辑
public Order createOrderFallback(OrderDTO dto, Throwable ex) {
// 记录失败日志,异步补偿
asyncCompensate(dto);
return Order.builder()
.status(OrderStatus.PENDING)
.message("订单处理中,请查询状态")
.build();
}
}9.4 链路追踪 Sleuth + Zipkin
<!-- 依赖 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>spring:
sleuth:
sampler:
probability: 0.1 # 采样率 10%
zipkin:
base-url: http://zipkin:9411Trace 结构:
Trace: abc123(一次请求全链路)
├── Span: order-service /createOrder [0ms - 200ms]
│ ├── Tag: http.method=POST
│ └── Tag: http.status=200
│
├── Span: inventory-service /deduct [10ms - 50ms] ← 子 Span
│ ├── Tag: db.statement=UPDATE inventory ...
│ └── Tag: sql.execute_time=20ms
│
└── Span: payment-service /pay [60ms - 180ms] ← 子 Span
├── Tag: mq.topic=payment_notify
└── Tag: mq.produce_time=5ms
9.5 业界案例:阿里巴巴
双11 全链路压测:
- 压测流量标记
x-shadow: true,走独立泳道 - 数据库通过 影子库 隔离,写影子表
- MQ 通过 影子 Topic 隔离,消费端识别标记
- 缓存通过 Key 前缀
shadow_隔离
// 影子库路由(MyBatis 插件)
@Intercepts(@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}))
public class ShadowPlugin implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
if (ShadowContext.isShadow()) {
// 替换为影子数据源
DataSource shadowDs = getShadowDataSource();
return executeWithDataSource(invocation, shadowDs);
}
return invocation.proceed();
}
}常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "灰度发布就是蓝绿部署" | 灰度是 流量比例切分,蓝绿是 全量切换,可结合使用 |
| "泳道越多越好" | 泳道增加 运维复杂度,建议主干 + 灰度 + 压测 3 个足矣 |
| "降级就是返回错误" | 降级可以是 返回缓存数据、异步补偿、简化流程 |
| "链路追踪采样率越高越好" | 高采样率带来 存储压力,生产环境通常 1%-10% |
延伸问题
- 如何实现数据库级别的影子表隔离?
- 全链路灰度中,如果下游服务没有灰度版本怎么办?(自动 fallback 到主干)
- Sleuth 与 OpenTelemetry 的关系?(Sleuth 3.x 支持 OTel 格式)
10. 微服务安全与运维
TL;DR
微服务安全需要在网关层统一鉴权(OAuth2/JWT),配合 RBAC 权限模型;运维层面通过 K8s + Helm 实现声明式部署,结合 Prometheus + Grafana 实现可观测性,是微服务稳定运行的基础设施。
10.1 网关统一鉴权
OAuth2 + JWT 架构:
┌──────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────┐
│ Client │─────►│ Auth Server │─────►│ Gateway │─────►│ Service │
│ (App/Web) │ │ (Keycloak/ │ │ (JWT 校验) │ │ (RBAC) │
│ │ │ Auth0/自研) │ │ │ │ │
└──────────┘ └──────────────┘ └──────────────┘ └──────────┘
│ │ │ │
│ 1. 登录获取 Token │ │ │
│────────────────────►│ │ │
│ 2. 返回 JWT │ │ │
│◄────────────────────│ │ │
│ 3. 请求携带 JWT │ │ │
│─────────────────────│────────────────────►│ │
│ │ │ 4. 校验 JWT │
│ │ │ 5. 解析用户角色 │
│ │ │───────────────────►│
│ │ │ │ 6. 校验权限
Gateway JWT 校验:
@Component
public class JwtAuthGlobalFilter implements GlobalFilter {
@Autowired
private JwtTokenProvider tokenProvider;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String token = extractToken(exchange.getRequest());
if (token == null || !tokenProvider.validate(token)) {
return unauthorized(exchange);
}
Claims claims = tokenProvider.parse(token);
// 将用户信息注入请求头,下游服务可直接使用
ServerHttpRequest request = exchange.getRequest().mutate()
.header("X-User-Id", claims.getSubject())
.header("X-User-Roles", claims.get("roles", String.class))
.header("X-Tenant-Id", claims.get("tenantId", String.class))
.build();
return chain.filter(exchange.mutate().request(request).build());
}
}服务内 RBAC 校验:
@RestController
public class OrderController {
@GetMapping("/admin/orders")
@PreAuthorize("hasRole('ADMIN') or hasAuthority('order:read')")
public List<Order> getAllOrders() {
return orderService.list();
}
@DeleteMapping("/admin/orders/{id}")
@PreAuthorize("hasRole('ADMIN')")
public void deleteOrder(@PathVariable Long id) {
orderService.delete(id);
}
}10.2 K8s 集成与 Helm 部署
Helm Chart 结构:
order-service/
├── Chart.yaml
├── values.yaml
├── values-prod.yaml
└── templates/
├── deployment.yaml
├── service.yaml
├── configmap.yaml
└── ingress.yaml
Deployment 模板:
# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .Chart.Name }}
labels:
app: {{ .Chart.Name }}
version: {{ .Values.image.tag }}
spec:
replicas: {{ .Values.replicaCount }}
selector:
matchLabels:
app: {{ .Chart.Name }}
template:
metadata:
labels:
app: {{ .Chart.Name }}
version: {{ .Values.image.tag }}
spec:
containers:
- name: {{ .Chart.Name }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
ports:
- containerPort: 8080
env:
- name: SPRING_PROFILES_ACTIVE
value: "{{ .Values.profile }}"
- name: NACOS_SERVER
value: "{{ .Values.nacos.server }}"
resources:
limits:
cpu: {{ .Values.resources.limits.cpu }}
memory: {{ .Values.resources.limits.memory }}
requests:
cpu: {{ .Values.resources.requests.cpu }}
memory: {{ .Values.resources.requests.memory }}Nacos 服务发现集成 K8s:
# 自动注册 Pod IP 到 Nacos
spring:
cloud:
nacos:
discovery:
server-addr: nacos-headless.default.svc.cluster.local:8848
ip: ${POD_IP} # K8s Downward API 注入
port: 8080
metadata:
pod-name: ${POD_NAME}
namespace: ${POD_NAMESPACE}10.3 可观测性:Prometheus + Grafana
Micrometer 指标暴露:
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
</dependency>@Configuration
public class MetricsConfig {
@Bean
MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
return registry -> registry.config()
.commonTags("application", "order-service")
.commonTags("env", "production");
}
// 自定义业务指标
@Bean
public Counter orderCreateCounter(MeterRegistry registry) {
return Counter.builder("order.create.total")
.description("订单创建总数")
.tags("status", "success")
.register(registry);
}
}Prometheus 抓取配置:
# prometheus.yml
scrape_configs:
- job_name: 'spring-boot-services'
kubernetes_sd_configs:
- role: pod
namespaces:
names:
- default
relabel_configs:
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
action: keep
regex: true
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
action: replace
target_label: __metrics_path__
regex: (.+)关键监控指标:
| 指标类型 | 指标名称 | 告警阈值 |
|---|---|---|
| 流量 | http_server_requests_seconds_count | - |
| 延迟 | http_server_requests_seconds_max | P99 > 500ms |
| 错误 | http_server_requests_seconds_count{status="5xx"} | 错误率 > 1% |
| JVM | jvm_memory_used_bytes / jvm_memory_max_bytes | > 80% |
| GC | jvm_gc_pause_seconds_sum | > 100ms/s |
| 线程 | jvm_threads_live_threads | > 400 |
10.4 压测与容量规划
全链路压测流程:
1. 基线测试:单机性能摸底(QPS、RT、资源使用率)
└── 工具:JMeter、K6、Gatling
2. 容量规划:根据业务目标推算集群规模
└── 公式:目标 QPS / 单机 QPS * 冗余系数(1.5-2x)
3. 影子压测:线上环境 + 影子数据隔离
└── 标记压测流量,走影子库/影子缓存
4. 瓶颈分析:
├── DB 瓶颈 → 连接池、慢查询、索引
├── 缓存瓶颈 → 热 Key、大 Key
├── MQ 瓶颈 → 消费延迟、堆积
└── 服务瓶颈 → GC、线程阻塞、外部依赖
5. 优化验证:
└── 重复 1-4,直到满足目标
常见误区
| ❌ 错误认知 | ✅ 正确理解 |
|---|---|
| "JWT 可以无限期使用" | JWT 应设置 过期时间(如 2h),配合 RefreshToken |
| "K8s 会自动发现 Nacos 服务" | 需要配置 K8s 服务发现 或 Pod IP 注册 |
| "监控指标越多越好" | 聚焦 RED 指标(Rate/Error/Duration),避免噪音 |
| "压测通过就万事大吉" | 压测是 特定场景,实际流量模式可能不同,需持续观察 |
延伸问题
- Gateway 层鉴权后,服务层还需要鉴权吗?(需要,防止绕过 Gateway 的直接调用)
- K8s HPA 如何与 Sentinel 流控配合?(HPA 扩容 + Sentinel 兜底)
- 微服务拆分后日志怎么聚合?(ELK / Loki + TraceID 关联)
附录:面试高频问题速查
Spring Cloud Alibaba 生态
- Spring Cloud Alibaba 与 Netflix 组件的对应关系?
- Nacos 1.x 和 2.x 的核心差异?为什么 2.x 性能更高?
- Nacos 的 AP 和 CP 模式分别适用什么场景?
Nacos
- 服务注册表的数据结构是怎样的?
- 心跳机制怎么实现的?临时实例和持久化实例的区别?
- 配置中心的长轮询原理?延迟多少?
- Namespace、Group、DataId 怎么设计多环境隔离?
Sentinel
- 滑动窗口统计原理?和固定窗口的区别?
- Warm Up 和匀速排队的适用场景?
- 熔断器的三种策略和状态机?
- 热点参数限流怎么实现?
- 集群流控的 Token Server 模式?
Seata
- AT 模式的 UndoLog 机制?回滚时怎么保证脏写?
- TC、TM、RM 分别是什么?交互流程?
- AT、TCC、Saga、XA 四种模式对比?
- 全局锁对性能的影响?
Dubbo
- Dubbo 的 SPI 机制与 Java SPI 的区别?
- 负载均衡策略有哪些?一致性哈希的应用场景?
- Triple 协议与 gRPC 的关系?
- Dubbo 3.x 的 Mesh 架构?
Gateway
- Route、Predicate、Filter 的关系?
- 自定义 GlobalFilter 实现鉴权?
- Sentinel 网关流控怎么配?
- Gateway 性能优化手段?
全链路治理
- 全链路灰度发布怎么实现?
- 泳道设计原则?
- 服务降级的策略有哪些?
- Sleuth Trace 的传播原理?
安全与运维
- JWT 鉴权流程?Token 刷新机制?
- K8s 部署微服务的最佳实践?
- Prometheus 监控哪些指标?
- 全链路压测怎么做?
本文档覆盖 Spring Cloud Alibaba 微服务面试核心知识点,建议结合源码阅读和实际项目经验深入理解。