Spring Cloud中如何根据请求体（RequestBody）修改路由URL

方案一：自定义Gateway RoutePredicateFactory（推荐） #

Spring Cloud Gateway默认没有提供基于请求体字段的路由匹配规则，我们可以自定义RoutePredicateFactory来实现这个逻辑。

1. 定义配置类 #

用来接收路由配置中的匹配参数：

public class RequestBodyFieldRoutePredicateConfig {
    private String fieldName;
    private String fieldValue;

    // Getter和Setter省略
}

2. 实现自定义Predicate工厂 #

继承AbstractRoutePredicateFactory，解析请求体并匹配字段：

@Component
public class RequestBodyFieldRoutePredicateFactory extends AbstractRoutePredicateFactory<RequestBodyFieldRoutePredicateConfig> {

    public RequestBodyFieldRoutePredicateFactory() {
        super(RequestBodyFieldRoutePredicateConfig.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("fieldName", "fieldValue");
    }

    @Override
    public Predicate<ServerWebExchange> apply(RequestBodyFieldRoutePredicateConfig config) {
        return exchange -> {
            ServerHttpRequest request = exchange.getRequest();
            // 读取请求体（注意：请求体是流，需缓存后重复读取）
            String requestBody = null;
            try {
                requestBody = StreamUtils.copyToString(request.getBody(), StandardCharsets.UTF_8);
                // 解析JSON请求体，这里假设是JSON格式，用Jackson
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode jsonNode = objectMapper.readTree(requestBody);
                String fieldValue = jsonNode.get(config.getFieldName()).asText();
                // 匹配字段值
                return config.getFieldValue().equals(fieldValue);
            } catch (IOException e) {
                return false;
            } finally {
                // 将读取后的请求体重写回exchange，避免后续组件无法读取
                byte[] bodyBytes = requestBody != null ? requestBody.getBytes(StandardCharsets.UTF_8) : new byte[0];
                DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(bodyBytes);
                ServerHttpRequest decoratedRequest = new ServerHttpRequestDecorator(request) {
                    @Override
                    public Flux<DataBuffer> getBody() {
                        return Flux.just(buffer);
                    }
                };
                exchange.mutate().request(decoratedRequest).build();
            }
        };
    }
}

3. 在Gateway配置中使用 #

在application.yml里配置路由规则：

spring:
  cloud:
    gateway:
      routes:
        - id: chagre_route
          uri: lb://YOUR-SERVICE-NAME # 目标服务地址，用负载均衡或直接http地址
          predicates:
            - Path=/api/v1/common # 统一入口路径
            - RequestBodyField=firstField,chagre
          filters:
            - RewritePath=/api/v1/common,/chagre # 重写路径到目标接口

        - id: package_route
          uri: lb://YOUR-SERVICE-NAME
          predicates:
            - Path=/api/v1/common
            - RequestBodyField=firstField,package
          filters:
            - RewritePath=/api/v1/common,/package

方案二：使用GlobalFilter手动转发 #

如果不想自定义Predicate，也可以通过全局过滤器直接处理请求转发：

@Component
public class RequestBodyRouteFilter implements GlobalFilter, Ordered {

    private final ObjectMapper objectMapper;
    private final WebClient webClient;

    public RequestBodyRouteFilter(ObjectMapper objectMapper, WebClient.Builder webClientBuilder) {
        this.objectMapper = objectMapper;
        this.webClient = webClientBuilder.build();
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        // 只处理指定入口路径的请求
        if (!request.getPath().toString().equals("/api/v1/common")) {
            return chain.filter(exchange);
        }

        return request.getBody().aggregate().asByteArray()
                .flatMap(bodyBytes -> {
                    try {
                        String requestBody = new String(bodyBytes, StandardCharsets.UTF_8);
                        JsonNode jsonNode = objectMapper.readTree(requestBody);
                        String firstField = jsonNode.get("firstField").asText();

                        // 构造目标路径
                        String targetPath;
                        if ("chagre".equals(firstField)) {
                            targetPath = "/chagre";
                        } else if ("package".equals(firstField)) {
                            targetPath = "/package";
                        } else {
                            // 不匹配时返回错误或转发到默认路径
                            exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
                            return exchange.getResponse().setComplete();
                        }

                        // 转发请求到目标接口
                        String targetUri = "http://YOUR-SERVICE-ADDRESS" + targetPath;
                        return webClient.method(request.getMethod())
                                .uri(targetUri)
                                .headers(headers -> headers.addAll(request.getHeaders()))
                                .bodyValue(requestBody)
                                .exchangeToMono(clientResponse -> {
                                    // 将响应写回原请求
                                    ServerHttpResponse response = exchange.getResponse();
                                    response.setStatusCode(clientResponse.statusCode());
                                    response.getHeaders().putAll(clientResponse.headers().asHttpHeaders());
                                    return response.writeWith(clientResponse.bodyToFlux(DataBuffer.class));
                                });
                    } catch (IOException e) {
                        exchange.getResponse().setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
                        return exchange.getResponse().setComplete();
                    }
                });
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE; // 确保过滤器优先执行
    }
}

注意事项 #

• 请求体重读问题：无论是Predicate还是Filter，读取请求体后都需要将流重新包装，避免后续组件无法读取请求体。
• 请求格式：以上示例假设请求体是JSON格式，如果是表单格式，需要改用MultiValueMap解析。
• 性能考虑：解析请求体会增加网关的性能开销，建议只在必要的路由规则中使用。

内容的提问来源于stack exchange，提问作者Milad Bahmanabadi