Spring Cloud GateWay

1
<!-- Gateway 核心依赖 -->
2
<dependency>
3
    <groupId>org.springframework.cloud</groupId>
4
    <artifactId>spring-cloud-starter-gateway</artifactId>
5
</dependency>
6
<!-- Sentinel 适配 Gateway（核心） -->
7
<dependency>
8
    <groupId>com.alibaba.cloud</groupId>
9
    <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
10
    <version>2023.0.1.0</version> <!-- 适配Spring Cloud 2023版本 -->
11
</dependency>
12
<!-- Sentinel 核心依赖 -->
13
<dependency>
14
    <groupId>com.alibaba.csp</groupId>
15
    <artifactId>sentinel-core</artifactId>
16
</dependency>
17
<!-- Sentinel 控制台依赖（可视化配置规则） -->
18
<dependency>
19
    <groupId>com.alibaba.csp</groupId>
20
    <artifactId>sentinel-transport-simple-http</artifactId>
21
</dependency>
22
<!-- 可选：Nacos 持久化规则（避免重启丢失） -->
23
<dependency>
24
    <groupId>com.alibaba.csp</groupId>
25
    <artifactId>sentinel-datasource-nacos</artifactId>
26
</dependency>

1
spring:
2
  cloud:
3
    # Gateway 配置（示例路由）
4
    gateway:
5
      routes:
6
        - id: user-service-route
7
          uri: lb://user-service
8
          predicates: [Path=/user/**]
9
        - id: order-service-route
10
          uri: lb://order-service
11
          predicates: [Path=/order/**]
12
    # Sentinel 配置
13
    alibaba:
14
      sentinel:
15
        # Sentinel 控制台地址
16
        transport:
17
          dashboard: localhost:8080  # 控制台端口（需先启动Sentinel控制台）
18
          port: 8719                  # 与控制台通信的端口
19
        # Gateway 适配配置
20
        gateway:
21
          enabled: true               # 开启Sentinel对Gateway的支持
22
          scg:
23
            fallback:
24
              mode: response          # 降级响应模式（返回自定义JSON）
25
              response-body: "{\"code\":503,\"msg\":\"服务繁忙，请稍后再试\",\"success\":false}"
26
              response-status: 503    # 降级响应状态码
27
              content-type: application/json
28
        # 可选：Nacos 持久化规则（避免重启网关丢失规则）
29
        datasource:
30
          ds1:
31
            nacos:
32
              server-addr: localhost:8848
33
              data-id: gateway-sentinel-rules
34
              group-id: DEFAULT_GROUP
35
              rule-type: gw_flow       # 网关限流规则
36
          ds2:
37
            nacos:
38
              server-addr: localhost:8848
39
              data-id: gateway-sentinel-degrade-rules
40
              group-id: DEFAULT_GROUP
41
              rule-type: gw_degrade    # 网关熔断降级规则

1
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
2
import com.alibaba.csp.sentinel.slots.block.BlockException;
3
import org.springframework.core.io.buffer.DataBuffer;
4
import org.springframework.http.HttpStatus;
5
import org.springframework.http.MediaType;
6
import org.springframework.http.server.reactive.ServerHttpResponse;
7
import org.springframework.stereotype.Component;
8
import org.springframework.web.reactive.function.server.ServerResponse;
9
import org.springframework.web.server.ServerWebExchange;
10
import reactor.core.publisher.Mono;
11

12
import java.nio.charset.StandardCharsets;
13

14
/**
15
 * 自定义Sentinel降级响应处理器
16
 */
17
@Component
18
public class CustomSentinelBlockHandler extends SentinelGatewayBlockExceptionHandler {
19
    @Override
20
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
21
        ServerHttpResponse response = exchange.getResponse();
22
        response.setStatusCode(HttpStatus.SERVICE_UNAVAILABLE);
23
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
24

25
        String msg;
26
        if (ex instanceof BlockException) {
27
            // 限流触发的降级
28
            msg = "{\"code\":429,\"msg\":\"请求过于频繁，请稍后再试\",\"success\":false}";
29
        } else {
30
            // 熔断触发的降级
31
            msg = "{\"code\":503,\"msg\":\"服务暂不可用，请稍后再试\",\"success\":false}";
32
        }
33

34
        DataBuffer buffer = response.bufferFactory().wrap(msg.getBytes(StandardCharsets.UTF_8));
35
        return response.writeWith(Mono.just(buffer));
36
    }
37
}

1
resilience4j:
2
  circuitbreaker:
3
    instances:
4
      user-service:  # 对应路由ID
5
        failureRateThreshold: 50  # 失败率阈值50%
6
        waitDurationInOpenState: 10000  # 熔断时长10秒
7
        minimumNumberOfCalls: 5  # 最小触发请求数
8
        slidingWindowSize: 10    # 统计窗口大小
9
  timelimiter:
10
    instances:
11
      user-service:
12
        timeoutDuration: 1000    # 请求超时时间1秒
13
spring:
14
  cloud:
15
    gateway:
16
      routes:
17
        - id: user-service-route
18
          uri: lb://user-service
19
          predicates: [Path=/user/**]
20
          filters:
21
            # 整合Resilience4j熔断
22
            - name: CircuitBreaker
23
              args:
24
                name: user-service
25
                fallbackUri: forward:/fallback/user  # 降级转发到本地接口

1
<!-- Gateway 核心依赖 -->
2
<dependency>
3
    <groupId>org.springframework.cloud</groupId>
4
    <artifactId>spring-cloud-starter-gateway</artifactId>
5
</dependency>
6
<!-- JWT 工具依赖（用于Token生成/解析） -->
7
<dependency>
8
    <groupId>io.jsonwebtoken</groupId>
9
    <artifactId>jjwt-api</artifactId>
10
    <version>0.11.5</version>
11
</dependency>
12
<dependency>
13
    <groupId>io.jsonwebtoken</groupId>
14
    <artifactId>jjwt-impl</artifactId>
15
    <version>0.11.5</version>
16
    <scope>runtime</scope>
17
</dependency>
18
<dependency>
19
    <groupId>io.jsonwebtoken</groupId>
20
    <artifactId>jjwt-jackson</artifactId>
21
    <version>0.11.5</version>
22
    <scope>runtime</scope>
23
</dependency>
24
<!-- 可选：Redis依赖（存储黑名单Token/用户权限） -->
25
<dependency>
26
    <groupId>org.springframework.boot</groupId>
27
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
28
</dependency>

1
import io.jsonwebtoken.*;
2
import io.jsonwebtoken.security.Keys;
3
import org.springframework.beans.factory.annotation.Value;
4
import org.springframework.stereotype.Component;
5

6
import javax.crypto.SecretKey;
7
import java.util.Date;
8
import java.util.Map;
9

10
/**
11
 * JWT工具类：生成、解析、验证Token
12
 */
13
@Component
14
public class JwtUtil {
15
    // JWT密钥（建议配置在Nacos/配置文件，长度至少256位）
16
    @Value("${jwt.secret:abcdefghijklmnopqrstuvwxyz1234567890abcdef}")
17
    private String secret;
18
    // Token过期时间（单位：毫秒，示例：2小时）
19
    @Value("${jwt.expire:7200000}")
20
    private long expire;
21

22
    // 生成Token
23
    public String generateToken(String userId, Map<String, Object> claims) {
24
        SecretKey key = Keys.hmacShaKeyFor(secret.getBytes());
25
        return Jwts.builder()
26
                .setClaims(claims) // 自定义载荷（如角色、权限）
27
                .setSubject(userId) // 主题（用户ID）
28
                .setIssuedAt(new Date()) // 签发时间
29
                .setExpiration(new Date(System.currentTimeMillis() + expire)) // 过期时间
30
                .signWith(key, SignatureAlgorithm.HS256) // 签名算法
31
                .compact();
32
    }
33

34
    // 解析Token，获取载荷信息
35
    public Claims parseToken(String token) {
36
        SecretKey key = Keys.hmacShaKeyFor(secret.getBytes());
37
        return Jwts.parserBuilder()
38
                .setSigningKey(key)
39
                .build()
40
                .parseClaimsJws(token)
41
                .getBody();
42
    }
43

44
    // 验证Token是否有效（过期/签名错误）
45
    public boolean validateToken(String token) {
46
        try {
47
            parseToken(token);
48
            return true;
49
        } catch (ExpiredJwtException e) {
50
            // Token过期
51
            return false;
52
        } catch (MalformedJwtException | SignatureException | IllegalArgumentException e) {
53
            // 签名错误/Token格式错误/空Token
54
            return false;
55
        }
56
    }
57
}

1
import org.springframework.context.annotation.Configuration;
2
import java.util.HashSet;
3
import java.util.Set;
4

5
/**
6
 * 权限白名单配置：登录、注册、健康检查等接口无需校验
7
 */
8
@Configuration
9
public class AuthWhiteListConfig {
10
    // 白名单路径（支持通配符**）
11
    public static final Set<String> WHITE_LIST = new HashSet<>();
12

13
    static {
14
        // 登录/注册接口
15
        WHITE_LIST.add("/auth/login");
16
        WHITE_LIST.add("/auth/register");
17
        // 健康检查接口
18
        WHITE_LIST.add("/actuator/**");
19
        // 公开接口
20
        WHITE_LIST.add("/public/**");
21
    }
22
}

1
import org.springframework.cloud.gateway.filter.GlobalFilter;
2
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
3
import org.springframework.core.Ordered;
4
import org.springframework.http.HttpStatus;
5
import org.springframework.http.MediaType;
6
import org.springframework.http.server.reactive.ServerHttpRequest;
7
import org.springframework.http.server.reactive.ServerHttpResponse;
8
import org.springframework.stereotype.Component;
9
import org.springframework.util.AntPathMatcher;
10
import org.springframework.web.server.ServerWebExchange;
11
import reactor.core.publisher.Mono;
12

13
import javax.annotation.Resource;
14
import java.nio.charset.StandardCharsets;
15
import java.util.List;
16
import java.util.Map;
17

18
/**
19
 * 全局权限校验过滤器：Token校验 + 接口权限校验
20
 */
21
@Component
22
public class AuthGlobalFilter implements GlobalFilter, Ordered {
23
    @Resource
24
    private JwtUtil jwtUtil;
25
    // 路径匹配器（支持通配符）
26
    private final AntPathMatcher pathMatcher = new AntPathMatcher();
27

28
    @Override
29
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
30
        ServerHttpRequest request = exchange.getRequest();
31
        String path = request.getPath().toString();
32

33
        // 1. 判断是否在白名单，白名单接口直接放行
34
        if (isWhiteList(path)) {
35
            return chain.filter(exchange);
36
        }
37

38
        // 2. 提取Token（从请求头Authorization中获取，格式：Bearer xxx）
39
        List<String> authHeaders = request.getHeaders().get("Authorization");
40
        if (authHeaders == null || authHeaders.isEmpty()) {
41
            // 无Token，返回401
42
            return responseError(exchange, HttpStatus.UNAUTHORIZED, "未登录，请先登录");
43
        }
44

45
        String token = authHeaders.get(0).replace("Bearer ", "");
46
        // 3. 校验Token有效性
47
        if (!jwtUtil.validateToken(token)) {
48
            return responseError(exchange, HttpStatus.UNAUTHORIZED, "Token无效或已过期");
49
        }
50

51
        // 4. 解析Token，获取用户信息和权限
52
        Map<String, Object> claims = jwtUtil.parseToken(token);
53
        String userId = claims.get("sub").toString(); // 用户ID
54
        List<String> userPermissions = (List<String>) claims.get("permissions"); // 用户权限列表
55

56
        // 5. 校验接口访问权限（示例：路径=/user/add 对应权限码user:add）
57
        String requiredPermission = getPermissionByPath(path);
58
        if (requiredPermission != null && !userPermissions.contains(requiredPermission)) {
59
            // 无接口权限，返回403
60
            return responseError(exchange, HttpStatus.FORBIDDEN, "无接口访问权限");
61
        }
62

63
        // 6. 将用户信息放入请求头，供后端服务使用
64
        ServerHttpRequest newRequest = request.mutate()
65
                .header("X-User-Id", userId)
66
                .header("X-User-Permissions", String.join(",", userPermissions))
67
                .build();
68
        ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();
69

70
        // 7. 权限校验通过，放行请求
71
        return chain.filter(newExchange);
72
    }
73

74
    // 判断路径是否在白名单
75
    private boolean isWhiteList(String path) {
76
        return AuthWhiteListConfig.WHITE_LIST.stream()
77
                .anyMatch(whitePath -> pathMatcher.match(whitePath, path));
78
    }
79

80
    // 自定义：路径转换为权限码（根据业务规则调整）
81
    private String getPermissionByPath(String path) {
82
        // 示例规则：/user/add → user:add；/order/list → order:list
83
        if (pathMatcher.match("/user/add", path)) {
84
            return "user:add";
85
        } else if (pathMatcher.match("/user/delete/**", path)) {
86
            return "user:delete";
87
        } else if (pathMatcher.match("/order/list", path)) {
88
            return "order:list";
89
        }
90
        // 无需权限的接口返回null
91
        return null;
92
    }
93

94
    // 统一返回权限错误响应（JSON格式）
95
    private Mono<Void> responseError(ServerWebExchange exchange, HttpStatus status, String msg) {
96
        ServerHttpResponse response = exchange.getResponse();
97
        response.setStatusCode(status);
98
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
99

100
        String errorJson = String.format("{\"code\":%d,\"msg\":\"%s\",\"success\":false}", status.value(), msg);
101
        return response.writeWith(Mono.just(
102
                response.bufferFactory().wrap(errorJson.getBytes(StandardCharsets.UTF_8))
103
        ));
104
    }
105

106
    // 设置过滤器优先级（数值越小越先执行，建议比限流过滤器高）
107
    @Override
108
    public int getOrder() {
109
        return -100;
110
    }
111
}

1
# JWT配置
2
jwt:
3
  secret: abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz123456
4
  expire: 7200000 # Token有效期2小时
5

6
# Gateway路由配置（示例）
7
spring:
8
  cloud:
9
    gateway:
10
      routes:
11
        - id: user-service-route
12
          uri: lb://user-service
13
          predicates:
14
            - Path=/user/**
15
        - id: auth-service-route
16
          uri: lb://auth-service
17
          predicates:
18
            - Path=/auth/**

1
import org.springframework.cloud.client.ServiceInstance;
2
import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
3
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
4
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
5
import org.springframework.core.env.Environment;
6
import reactor.core.publisher.Mono;
7

8
import java.util.List;
9
import java.util.Random;
10
import java.util.stream.Collectors;
11

12
/**
13
 * 自定义权重负载均衡策略
14
 * 要求后端实例的metadata中配置weight（如：10、20、30）
15
 */
16
public class WeightedLoadBalancer implements ReactorServiceInstanceLoadBalancer {
17
    // 服务名称
18
    private final String serviceId;
19
    // 实例列表供应商
20
    private ServiceInstanceListSupplier serviceInstanceListSupplier;
21
    // 随机数生成器
22
    private final Random random = new Random();
23

24
    public WeightedLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
25
        // 获取当前服务ID
26
        this.serviceId = loadBalancerClientFactory.getName(environment);
27
        // 获取实例列表供应商
28
        this.serviceInstanceListSupplier = loadBalancerClientFactory.getLazyProvider(serviceId, ServiceInstanceListSupplier.class);
29
    }
30

31
    @Override
32
    public Mono<ServiceInstance> choose(Request request) {
33
        // 1. 获取所有可用实例列表
34
        return serviceInstanceListSupplier.get()
35
                .filter(instances -> !instances.isEmpty())
36
                .flatMap(instances -> {
37
                    // 2. 解析每个实例的权重，计算总权重
38
                    List<WeightedInstance> weightedInstances = instances.stream()
39
                            .map(instance -> {
40
                                // 从实例metadata中获取权重（默认1）
41
                                String weightStr = instance.getMetadata().getOrDefault("weight", "1");
42
                                int weight = Integer.parseInt(weightStr);
43
                                return new WeightedInstance(instance, weight);
44
                            })
45
                            .collect(Collectors.toList());
46

47
                    // 3. 计算总权重
48
                    int totalWeight = weightedInstances.stream().mapToInt(WeightedInstance::getWeight).sum();
49
                    if (totalWeight <= 0) {
50
                        return Mono.empty();
51
                    }
52

53
                    // 4. 随机生成一个0~totalWeight-1的数，按权重区间选择实例
54
                    int randomWeight = random.nextInt(totalWeight);
55
                    int currentWeight = 0;
56
                    for (WeightedInstance weightedInstance : weightedInstances) {
57
                        currentWeight += weightedInstance.getWeight();
58
                        if (randomWeight < currentWeight) {
59
                            return Mono.just(weightedInstance.getInstance());
60
                        }
61
                    }
62

63
                    // 兜底：返回第一个实例
64
                    return Mono.just(weightedInstances.get(0).getInstance());
65
                });
66
    }
67

68
    // 内部类：封装实例和权重
69
    private static class WeightedInstance {
70
        private final ServiceInstance instance;
71
        private final int weight;
72

73
        public WeightedInstance(ServiceInstance instance, int weight) {
74
            this.instance = instance;
75
            this.weight = weight;
76
        }
77

78
        public ServiceInstance getInstance() {
79
            return instance;
80
        }
81

82
        public int getWeight() {
83
            return weight;
84
        }
85
    }
86
}

1
import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
2
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
3
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
4
import org.springframework.context.annotation.Bean;
5
import org.springframework.context.annotation.Configuration;
6
import org.springframework.core.env.Environment;
7

8
/**
9
 * 负载均衡策略配置类
10
 */
11
@Configuration
12
public class CustomLoadBalancerConfig {
13
    /**
14
     * 注册自定义权重策略
15
     */
16
    @Bean
17
    public ReactorServiceInstanceLoadBalancer weightedLoadBalancer(Environment environment,
18
                                                                   LoadBalancerClientFactory loadBalancerClientFactory) {
19
        return new WeightedLoadBalancer(environment, loadBalancerClientFactory);
20
    }
21

22
    /**
23
     * 配置实例列表供应商（默认即可，无需修改）
24
     */
25
    @Bean
26
    public ServiceInstanceListSupplier serviceInstanceListSupplier(LoadBalancerClientFactory factory) {
27
        return factory.getLazyProvider(factory.getName(environment), ServiceInstanceListSupplier.class);
28
    }
29
}

1
<!-- Gateway 核心依赖 -->
2
<dependency>
3
    <groupId>org.springframework.cloud</groupId>
4
    <artifactId>spring-cloud-starter-gateway</artifactId>
5
</dependency>
6
<!-- Nacos 配置中心依赖（支持配置动态推送） -->
7
<dependency>
8
    <groupId>com.alibaba.cloud</groupId>
9
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
10
</dependency>
11
<!-- Nacos 服务发现（可选，配合负载均衡） -->
12
<dependency>
13
    <groupId>com.alibaba.cloud</groupId>
14
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
15
</dependency>

1
import com.alibaba.cloud.nacos.NacosConfigManager;
2
import com.alibaba.fastjson2.JSON;
3
import com.alibaba.fastjson2.TypeReference;
4
import org.springframework.cloud.gateway.route.RouteDefinition;
5
import org.springframework.cloud.gateway.route.RouteDefinitionRepository;
6
import org.springframework.cloud.gateway.support.NotFoundException;
7
import org.springframework.context.ApplicationEventPublisher;
8
import org.springframework.context.ApplicationEventPublisherAware;
9
import org.springframework.stereotype.Component;
10
import reactor.core.publisher.Flux;
11
import reactor.core.publisher.Mono;
12

13
import javax.annotation.PostConstruct;
14
import java.util.List;
15

16
@Component
17
public class NacosRouteDefinitionRepository implements RouteDefinitionRepository, ApplicationEventPublisherAware {
18
    // Nacos 配置管理器（读取配置）
19
    private final NacosConfigManager nacosConfigManager;
20
    // 路由配置的Data ID（格式：${spring.application.name}.${file-extension}）
21
    private final String dataId = "gateway-service.yaml";
22
    // 配置分组
23
    private final String group = "DEFAULT_GROUP";
24
    // 应用事件发布器（发布路由刷新事件）
25
    private ApplicationEventPublisher publisher;
26

27
    public NacosRouteDefinitionRepository(NacosConfigManager nacosConfigManager) {
28
        this.nacosConfigManager = nacosConfigManager;
29
    }
30

31
    // 初始化：监听Nacos配置变更
32
    @PostConstruct
33
    public void init() {
34
        try {
35
            // 监听Nacos配置变更，触发路由刷新
36
            nacosConfigManager.getConfigService().addListener(dataId, group, event -> {
37
                // 发布路由刷新事件，Gateway会重新加载路由
38
                publisher.publishEvent(new org.springframework.cloud.gateway.event.RefreshRoutesEvent(this));
39
            });
40
        } catch (Exception e) {
41
            throw new RuntimeException("Nacos路由配置监听失败", e);
42
        }
43
    }
44

45
    // 读取所有路由规则（Gateway启动/刷新时调用）
46
    @Override
47
    public Flux<RouteDefinition> getRouteDefinitions() {
48
        try {
49
            // 从Nacos读取配置内容
50
            String configContent = nacosConfigManager.getConfigService().getConfig(dataId, group, 5000);
51
            // 将JSON/YAML转为RouteDefinition列表（FastJSON解析）
52
            List<RouteDefinition> routeDefinitions = JSON.parseObject(
53
                configContent,
54
                new TypeReference<List<RouteDefinition>>() {}
55
            );
56
            return Flux.fromIterable(routeDefinitions);
57
        } catch (Exception e) {
58
            return Flux.error(new NotFoundException("从Nacos加载路由规则失败：" + e.getMessage()));
59
        }
60
    }
61

62
    // 新增路由（按需实现，可调用Nacos API写入配置）
63
    @Override
64
    public Mono<Void> save(Mono<RouteDefinition> route) {
65
        // 实际场景可实现：将新增的路由写入Nacos配置
66
        return route.flatMap(r -> {
67
            // 省略：读取现有配置 → 添加新路由 → 调用Nacos API更新配置
68
            return Mono.empty();
69
        });
70
    }
71

72
    // 删除路由（按需实现）
73
    @Override
74
    public Mono<Void> delete(Mono<String> routeId) {
75
        // 实际场景可实现：读取现有配置 → 删除指定路由 → 调用Nacos API更新配置
76
        return routeId.flatMap(id -> Mono.empty());
77
    }
78

79
    // 设置事件发布器
80
    @Override
81
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
82
        this.publisher = applicationEventPublisher;
83
    }
84
}

1
[
2
  {
3
    "id": "user-service-route",
4
    "uri": "lb://user-service",
5
    "predicates": [
6
      {
7
        "name": "Path",
8
        "args": {
9
          "_genkey_0": "/user/**"
10
        }
11
      },
12
      {
13
        "name": "Method",
14
        "args": {
15
          "_genkey_0": "GET"
16
        }
17
      }
18
    ],
19
    "filters": [
20
      {
21
        "name": "AddRequestHeader",
22
        "args": {
23
          "_genkey_0": "X-From-Gateway",
24
          "_genkey_1": "Nacos-Dynamic-Route"
25
        }
26
      }
27
    ]
28
  },
29
  {
30
    "id": "order-service-route",
31
    "uri": "lb://order-service",
32
    "predicates": [
33
      {
34
        "name": "Path",
35
        "args": {
36
          "_genkey_0": "/order/**"
37
        }
38
      }
39
    ]
40
  }
41
]

1
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
2
import org.springframework.context.annotation.Bean;
3
import org.springframework.context.annotation.Configuration;
4
import org.springframework.web.server.ServerWebExchange;
5
import reactor.core.publisher.Mono;
6

7
@Configuration
8
public class RateLimitConfig {
9
    // 1. 按客户端IP限流（最常用）
10
    @Bean
11
    public KeyResolver ipKeyResolver() {
12
        return exchange -> {
13
            // 获取客户端IP地址
14
            String clientIp = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
15
            return Mono.just(clientIp);
16
        };
17
    }
18

19
    // 2. 按用户ID限流（需用户登录，从请求头/参数取userId）
20
    /*
21
    @Bean
22
    public KeyResolver userIdKeyResolver() {
23
        return exchange -> Mono.just(
24
            exchange.getRequest().getHeaders().getFirst("X-User-Id")
25
        );
26
    }
27
    */
28

29
    // 3. 按接口路径限流
30
    /*
31
    @Bean
32
    public KeyResolver apiKeyResolver() {
33
        return exchange -> Mono.just(
34
            exchange.getRequest().getPath().toString()
35
        );
36
    }
37
    */
38
}

1
spring:
2
  # Redis 连接配置
3
  redis:
4
    host: localhost  # Redis 服务地址
5
    port: 6379       # Redis 端口
6
    database: 0      # 数据库索引（默认0）
7
  # Gateway 限流配置
8
  cloud:
9
    gateway:
10
      routes:
11
        - id: user-service-route  # 路由ID
12
          uri: lb://user-service  # 目标服务（负载均衡）
13
          predicates:
14
            - Path=/user/**       # 匹配/user开头的请求
15
          filters:
16
            # 限流过滤器配置
17
            - name: RequestRateLimiter
18
              args:
19
                # 指定限流维度（对应上面定义的 KeyResolver bean 名称）
20
                key-resolver: "#{@ipKeyResolver}"
21
                # 令牌桶每秒填充速率（允许的平均QPS）
22
                redis-rate-limiter.replenishRate: 10
23
                # 令牌桶最大容量（允许的突发QPS）
24
                redis-rate-limiter.burstCapacity: 20
25
                # 每次请求消耗的令牌数（默认1）
26
                redis-rate-limiter.requestedTokens: 1

1
import org.springframework.core.io.buffer.DataBuffer;
2
import org.springframework.http.HttpStatus;
3
import org.springframework.http.MediaType;
4
import org.springframework.http.server.reactive.ServerHttpResponse;
5
import org.springframework.stereotype.Component;
6
import org.springframework.web.server.ServerWebExchange;
7
import reactor.core.publisher.Mono;
8
import java.nio.charset.StandardCharsets;
9

10
@Component
11
public class CustomRateLimitHandler {
12
    public Mono<Void> handle(ServerWebExchange exchange) {
13
        ServerHttpResponse response = exchange.getResponse();
14
        response.setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
15
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
16

17
        String msg = "{\"code\":429,\"msg\":\"请求过于频繁，请稍后再试\"}";
18
        DataBuffer buffer = response.bufferFactory().wrap(msg.getBytes(StandardCharsets.UTF_8));
19
        return response.writeWith(Mono.just(buffer));
20
    }
21
}