面试题集锦:Spring Cloud Alibaba 问答大全

面试题集锦:Spring Cloud Alibaba 问答大全

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


Generated by kimi-k2.6 model

Spring Cloud Alibaba 微服务面试

目录

  1. Spring Cloud Alibaba 生态全景与版本演进
  2. Nacos 服务注册与发现
  3. Nacos 配置中心
  4. Sentinel 流量治理
  5. Sentinel 热点参数与系统保护
  6. Seata 分布式事务
  7. Dubbo 与 OpenFeign 服务通信
  8. Spring Cloud Gateway 网关
  9. 全链路治理实战
  10. 微服务安全与运维

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 替代优势
EurekaNacos同时支持注册中心和配置中心,AP+CP 可选
HystrixSentinel流量控制更丰富,支持热点、系统保护
ZuulSpring Cloud Gateway基于 WebFlux,性能更高
RibbonDubbo / Spring Cloud LoadBalancerDubbo 支持 Triple 协议,性能更优
ConfigNacos 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 BootSpring CloudSpring Cloud AlibabaNacosSentinel
2.3.xHoxton.SR122.2.9.RELEASE1.4.x1.8.6
2.4.x2020.0.x2021.11.4.x / 2.0.x1.8.6
2.6.x2021.0.x2021.0.5.02.1.x1.8.6
3.0.x2022.0.x2022.0.0.02.2.x1.8.6
3.2.x2023.0.x2023.0.1.02.3.x1.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-hangzhou

2.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.xNacos 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: true

3.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 对比

特性SentinelHystrix
隔离策略信号量(并发线程)线程池/信号量
流控粒度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));

保护优先级:

  1. CPU 使用率 > 阈值:拒绝所有入口流量
  2. Load > 阈值:拒绝所有入口流量
  3. RT 持续升高:逐步拒绝请求
  4. 线程数 > 阈值:拒绝新请求
  5. 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

协议对比:

协议传输层序列化跨语言性能适用场景
dubboTCPHessian2差极高Java 内部服务
tripleHTTP/2Protobuf优高跨语言、云原生
restHTTP/1.1JSON优中简单 REST 调用
grpcHTTP/2Protobuf优高标准 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: 2

7.6 Dubbo vs OpenFeign 对比

特性DubboOpenFeign
协议TCP(dubbo)/ HTTP/2(triple)HTTP/1.1(REST)
序列化Hessian2 / Protobuf / KryoJSON(默认)
性能极高(二进制协议)中(文本协议)
负载均衡内置多种策略依赖 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: 2000

Predicate 断言类型:

Predicate说明示例
Path路径匹配Path=/api/order/**
MethodHTTP 方法Method=GET,POST
HeaderHeader 匹配Header=X-Version, v1
Query查询参数Query=source, app
CookieCookie 匹配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~100050ms阻塞 IO,线程池模型
Spring Cloud Gateway~300015ms非阻塞 IO,WebFlux
Nginx~100005msC 语言,纯代理
Envoy~80008msC++,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: v1

Dubbo 标签路由:

// 提供者打标签
@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:9411

Trace 结构:

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_maxP99 > 500ms
错误http_server_requests_seconds_count{status="5xx"}错误率 > 1%
JVMjvm_memory_used_bytes / jvm_memory_max_bytes> 80%
GCjvm_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 微服务面试核心知识点,建议结合源码阅读和实际项目经验深入理解。