知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 41 - API 网关设计 > 导读:本文用一问一答的方式,讲清 API 网关"为什么存在、内部怎么流转、每个横切功能怎么实现"。读完你能独立回答"网关设计"这类系统设计面试题,并知道过滤器链、限流、灰度、熔断各自的取舍。适合已了解微服务基本概念、准备系统设计面试的初中级后端工程师。 ## 一、先建立全局认知 ### Q:什么是 API 网关?它到底解决了什么问题? A:结论先行——**API 网关是所有外部流量的统一入口,把鉴权、限流、路由、灰度、熔断这类"每个服务都要做、但谁也不该各做一遍"的横切关注点(cross-cutting concern,指与业务逻辑无关、却散落在各处的通用能力)收敛到一处。** 它要解决的问题来自微服务架构本身。假设系统里有 30+ 个后端服务,客户端(App、Web、小程序)直接调用各个服务,会立刻出现以下矛盾: ``` 1. 客户端需要知道每个服务的地址,耦合严重 2. 每个服务都要自己实现鉴权、限流、日志,重复开发 3. 跨域、协议转换等问题分散在各服务中 4. 无法统一做灰度发布和流量控制 ``` 这四点的共同特征是"横切":它们不属于任何一个业务域,却必须作用于所有业务域。如果没有网关,你只有两个选择——让每个服务各自实现(重复且不一致),或者让客户端自己去拼接(耦合且不安全)。API 网关就是第三种选择:**把这些能力前置到一个统一入口,下游服务只关心自己的业务。** ### Q:一个请求从客户端到后端服务,中间经过哪些组件? A:典型链路是"负载均衡 → 网关 → 各业务服务"。网关自身只做横切逻辑,真正的业务仍在后面的服务里完成:  *图:客户端经 Nginx、网关分发到四个服务* ``` 客户端(App/Web/小程序) │ ▼ ┌──────────┐ │ Nginx │ ← 负载均衡 + SSL 终止 └──────────┘ │ ▼ ┌──────────────────────────────────┐ │ API Gateway │ │ │ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │ │ 路由 │ │ 鉴权 │ │ 限流 │ │ │ └──────┘ └──────┘ └──────┘ │ │ ┌──────┐ ┌──────┐ ┌──────┐ │ │ │ 熔断 │ │ 灰度 │ │ 日志 │ │ │ └──────┘ └──────┘ └──────┘ │ └──────────────────────────────────┘ │ ┌────┼────┬────┐ ▼ ▼ ▼ ▼ 用户 订单 商品 支付 服务 服务 服务 服务 ```  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/41-design-gateway-design-gateway-filter-chain-diagram.excalidraw) 这里有两层前置:Nginx 负责四层/七层的负载均衡与 SSL 终止(SSL termination,指在入口处解密 HTTPS 流量,让后面的服务只处理明文),网关负责业务无关的横切逻辑。**把 SSL 放在 Nginx 而不是网关,是为了让网关专注于业务横切能力。** ## 二、理解核心机制 ### Q:网关怎么做路由转发?`lb://` 是什么意思? A:路由的本质是"请求路径 → 目标服务地址"的映射。注意两个细节:`stripPrefix(1)` 会去掉请求前缀再转发给下游(下游服务不需要感知 `/api` 这层网关前缀);`lb://` 表示 **load balance**,即地址不是写死的 IP,而是从注册中心按服务名动态获取实例列表并做负载均衡。 ```java // Spring Cloud Gateway 路由配置 @Configuration public class GatewayConfig { @Bean public RouteLocator customRoutes(RouteLocatorBuilder builder) { return builder.routes() // 路径匹配路由 .route("user-service", r -> r .path("/api/user/**") .filters(f -> f.stripPrefix(1)) // 去掉 /api 前缀 .uri("lb://user-service")) // lb:// 表示从注册中心获取地址 // 带权重的灰度路由 .route("order-v2", r -> r .path("/api/order/**") .and().weight("order-group", 20) // 20% 流量到 v2 .uri("lb://order-service-v2")) .route("order-v1", r -> r .path("/api/order/**") .and().weight("order-group", 80) // 80% 流量到 v1 .uri("lb://order-service-v1")) .build(); } } ``` **替代方案与代价:**也可以把路由规则放在 Nacos 等配置中心里动态下发(配合 `NacosRouteDefinitionRepository`),好处是改路由不用重启网关,代价是多了一层组件依赖和配置一致性风险。硬编码在代码里的优势是直观、编译期可查。 ### Q:统一鉴权为什么放在网关做?又是怎么透传用户信息的? A:结论——**认证(authentication,你是谁)放在网关,是为了让下游服务只做业务、不重复校验 Token;但授权(authorization,你能做什么)通常仍留给下游服务,因为权限规则是业务相关的。** 下面这个过滤器做了三件事:白名单放行、校验 JWT(JSON Web Token,一种自包含签名的令牌)、把解析出的用户信息通过请求头透传给下游。关键实现细节是 `getOrder()` 返回 `-100`,数值越小优先级越高,保证鉴权在所有业务过滤器之前执行。 ```java @Component public class AuthFilter implements GlobalFilter, Ordered { private static final List<String> WHITE_LIST = List.of( "/api/auth/login", "/api/auth/register", "/api/health" ); @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { String path = exchange.getRequest().getURI().getPath(); // 白名单放行 if (WHITE_LIST.stream().anyMatch(path::startsWith)) { return chain.filter(exchange); } // 校验 Token String token = exchange.getRequest().getHeaders().getFirst("Authorization"); if (token == null || !token.startsWith("Bearer ")) { return unauthorized(exchange); } try { // 解析 JWT,提取用户信息 Claims claims = JwtUtil.parse(token.substring(7)); // 将用户信息放入请求头,传递给下游服务 ServerHttpRequest request = exchange.getRequest().mutate() .header("X-User-Id", claims.getSubject()) .header("X-User-Role", claims.get("role", String.class)) .build(); return chain.filter(exchange.mutate().request(request).build()); } catch (JwtException e) { return unauthorized(exchange); } } private Mono<Void> unauthorized(ServerWebExchange exchange) { exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED); return exchange.getResponse().setComplete(); } @Override public int getOrder() { return -100; // 优先级最高 } } ``` **安全边界要讲清:**下游服务必须信任"网关已经鉴权过"这个前提,因此网关不应对公网暴露、内部服务也不应允许外部直连,否则攻击者可以伪造 `X-User-Id` 头绕过鉴权。这是这套设计成立的前提条件,面试时主动说出来会加分。 ### Q:限流怎么实现?手写 Lua 和用框架内置有什么取舍? A:先讲手写版,理解原理;再讲内置版,理解生产推荐。下面这个过滤器的思路是"每个客户端 IP 一个令牌桶(token bucket,一种允许突发流量的限流算法),1 秒窗口内最多 10 次",用 Lua 脚本保证"判断 + 扣减"的原子性: ```java // 基于 Redis 的分布式限流(令牌桶) @Component public class RateLimitFilter implements GlobalFilter, Ordered { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { String clientIp = getClientIp(exchange); String key = "rate:" + clientIp; // Lua 脚本实现令牌桶 String script = "local tokens = tonumber(redis.call('GET', KEYS[1]) or '10') " + "if tokens > 0 then " + " redis.call('DECR', KEYS[1]) " + " redis.call('EXPIRE', KEYS[1], 1) " + // 1 秒窗口 " return 1 " + "else return 0 end"; Long allowed = redis.execute(new DefaultRedisScript<>(script, Long.class), List.of(key)); if (allowed == 0) { exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS); return exchange.getResponse().setComplete(); } return chain.filter(exchange); } @Override public int getOrder() { return -90; // 鉴权之后,路由之前 } } ``` 上面的实现把"令牌桶"简化成了固定计数,生产里更推荐用 Spring Cloud Gateway 内置的 `RequestRateLimiter`,它基于 Redis 实现了真正可配置的令牌桶: ```yaml spring: cloud: gateway: routes: - id: order-service uri: lb://order-service predicates: - Path=/api/order/** filters: - name: RequestRateLimiter args: redis-rate-limiter.replenishRate: 100 # 每秒 100 个令牌 redis-rate-limiter.burstCapacity: 200 # 桶容量 200 key-resolver: "#{@ipKeyResolver}" ``` **关键取舍:**`replenishRate` 是稳态速率,`burstCapacity` 是允许的瞬时突发上限,两者配合才能既抗突发又限平均。限流键(`key-resolver`)决定限流维度——按 IP、按用户、按接口,选错了会导致"一个用户拖垮所有人"或"限流形同虚设"。把计数放在 Redis 而不是网关内存里,是为了多实例部署时全局生效,代价是每次请求多一次 Redis 往返。 ### Q:熔断降级是怎么配置的?它和限流有什么区别? A:结论——**限流是保护自己(不被流量打垮),熔断是保护链路(下游故障时不让自己被拖死)。** 下面用 Resilience4j 配置:滑动窗口内失败率超过 50% 就打开断路器,10 秒后进入半开状态试探恢复: ```yaml # 集成 Resilience4j 熔断 spring: cloud: gateway: routes: - id: order-service uri: lb://order-service filters: - name: CircuitBreaker args: name: orderCircuitBreaker fallbackUri: forward:/fallback/order # 降级接口 resilience4j: circuitbreaker: instances: orderCircuitBreaker: slidingWindowSize: 10 # 滑动窗口大小 failureRateThreshold: 50 # 失败率 50% 触发熔断 waitDurationInOpenState: 10s # 熔断 10 秒后半开 ``` 降级接口返回兜底响应,避免把错误直接抛给用户: ```java @RestController public class FallbackController { @GetMapping("/fallback/order") public Result<?> orderFallback() { return Result.fail("订单服务暂时不可用,请稍后重试"); } } ``` 熔断的三个状态——关闭(正常放过)、打开(快速失败)、半开(放少量请求试探)——是面试常问点。`fallbackUri` 走的是网关内部转发,不经过业务服务,所以降级逻辑要足够轻。 ### Q:灰度发布有哪几种策略?怎么落地? A:灰度的本质是"按某个维度把一部分流量导向新版本"。最轻量的做法是在过滤器里读一个请求头,命中灰度标记就给请求打上版本标;更复杂的分流规则交给路由层: ```java // 基于请求头的灰度路由 @Component public class GrayFilter implements GlobalFilter, Ordered { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { String grayTag = exchange.getRequest().getHeaders().getFirst("X-Gray"); if ("true".equals(grayTag)) { // 灰度用户路由到新版本 ServerHttpRequest request = exchange.getRequest().mutate() .header("X-Service-Version", "v2") .build(); return chain.filter(exchange.mutate().request(request).build()); } return chain.filter(exchange); } @Override public int getOrder() { return -80; } } ``` 常用的灰度维度: | 策略 | 实现方式 | |------|---------| | 按用户 ID | userId % 100 < 10 → 灰度(10% 用户) | | 按请求头 | App 版本号 ≥ 3.0 → 灰度 | | 按 IP | 内部 IP 段 → 灰度(内测) | | 按权重 | Spring Cloud Gateway weight 路由 | **取舍提示:**按权重分流简单但不保证同一用户稳定命中同一版本(用户可能在刷新间看到两种行为),按用户 ID 取模能保证一致性,代价是需要能拿到稳定的用户标识。前文的 `weight("order-group", 20)` 路由就是"按权重"策略的配置化实现。 ### Q:多个过滤器之间,执行顺序如何确定? A:所有 `GlobalFilter` 按 `Ordered.getOrder()` 返回值从小到大排序,**值越小越先执行;请求(pre)按顺序进,响应(post)按逆序出。** 这就是"过滤器链 vs 拦截器"的关键差异——网关的过滤器链同时包裹请求和响应两个阶段,而 Spring MVC 的 HandlerInterceptor 只在 DispatcherServlet 前后工作,无法覆盖网关这种转发场景。  *图:过滤器按 order 执行,响应经 LogFilter 回传* ``` 请求 → AuthFilter(-100) → RateLimitFilter(-90) → GrayFilter(-80) → 路由转发 │ 响应 ← LogFilter ← ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘ ``` 顺序设计的依据是依赖关系而非随意指定:鉴权必须在最前(未认证的请求没必要消耗限流配额);限流在鉴权之后,才能按真实用户而非匿名 IP 计数;灰度在路由之前,才能影响目标版本选择;日志贯穿全程,所以它能在响应阶段回收全部信息。 ## 三、放进真实场景 ### Q:网关会不会成为性能瓶颈? A:会——它是所有外部流量的必经之路,一旦它变慢或挂掉,整个系统对外不可用。应对方案有四个层次: 1. **网关无状态,水平扩展**:不保存会话状态,多实例部署,加机器就能提升吞吐。 2. **用异步非阻塞框架**:Spring WebFlux / Netty 这类响应式模型(Reactive,基于事件循环而非一请求一线程),在大量等待 I/O 的场景下资源利用率更高。 3. **减少网关中的重逻辑**:网关只做横切关注点,禁止塞业务编排——业务逻辑应该在下游服务。 4. **静态资源走 CDN 不经过网关**:图片、脚本这类无需鉴权的内容由 CDN 直接分发。 ### Q:内部服务之间的调用需要经过网关吗? A:一般不需要。内部服务之间通过注册中心直接调用(Feign / gRPC),网关只处理外部流量。**原因是:内部调用已经在一个受信任的网络边界内,再走一遍外面那层鉴权/限流既浪费性能又增加单点。** 如果内部也希望对调用做鉴权限流,可以用 Service Mesh(服务网格,如 Istio)在 Sidecar(边车代理,与业务容器同生命周期的伴生进程)层统一处理,这样业务代码无侵入,代价是引入了整套 Mesh 的运维复杂度。 ### Q:网关选型上,Spring Cloud Gateway 和 Kong / APISIX 怎么选? A:两条技术路线的取舍: - **Spring Cloud Gateway**:基于 Spring WebFlux,与 Java 生态(注册中心、配置中心、Sentinel 等)无缝集成,用 Java 写自定义过滤器最顺手。适合团队以 Java 为主、希望统一技术栈的场景。 - **Kong / APISIX**:基于 Nginx / OpenResty,在纯转发性能上通常更优,插件生态(限流、鉴权、可观测)成熟。代价是自定义逻辑要用 Lua 或插件机制,和多语言微服务体系的集成成本更高。 选型的关键不是性能数字,而是"你的团队能把哪套维护好"。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:分四点作答,从功能到选型再到高可用,逐层展开: 1. **网关核心功能**:路由转发、统一鉴权(JWT 解析 + 用户信息透传)、限流(Redis 令牌桶)、熔断降级、灰度发布。 2. **技术选型**:Spring Cloud Gateway(响应式,性能好)或 Kong / APISIX(基于 Nginx,更高性能)。 3. **Filter 链**:按 Order 排序,鉴权 → 限流 → 灰度 → 路由,每个关注点独立一个 Filter。 4. **高可用**:网关本身无状态,多实例部署 + Nginx 负载均衡;限流数据存 Redis 实现分布式限流。 ### Q:这套设计的主线可以怎么复述? A:一句话串起来——**网关存在的理由是收敛横切关注点;它的内部是一条按依赖关系排序的过滤器链;每个过滤器独立负责一件事并可以单独替换实现;它的高可用靠无状态多实例,它的分布式能力靠 Redis 这类外部存储。** 记住"为什么前置、为什么排序、为什么无状态"这三条,比记住每个类的名字更重要。 --- ## 自测 1. 为什么鉴权过滤器的 Order 要小于限流过滤器?如果反过来会有什么问题? 2. `lb://user-service` 和直接写 `http://10.0.1.5:8080` 相比,多了哪些能力、代价是什么? 3. 限流的 `replenishRate`(每秒令牌数)和 `burstCapacity`(桶容量)分别控制什么?只调大 `burstCapacity` 会发生什么? 4. 网关把 `X-User-Id` 透传给下游服务,这套机制的安全前提是什么? 5. 熔断器打开、半开、关闭三个状态分别代表什么?半开状态的作用是什么? 6. 为什么静态资源走 CDN 而不经过网关?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入