SpringCloud Gateway读取Request Body

我们使用SpringCloud Gateway做微服务网关的时候，经常需要在过滤器Filter中读取到Post请求中的Body内容进行日志记录、签名验证、权限验证等操作。我们知道，Request的Body是只能读取一次的，如果直接通过在Filter中读取，而不封装回去回导致后面的服务无法读取数据。
SpringCloud Gateway 内部提供了一个断言工厂类ReadBodyPredicateFactory，这个类实现了读取Request的Body内容并放入缓存，我们可以通过从缓存中获取body内容来实现我们的目的。

1、分析ReadBodyPredicateFactory

public AsyncPredicate<ServerWebExchange> applyAsync(ReadBodyPredicateFactory.Config config) {
        return (exchange) -> {
            Class inClass = config.getInClass();
            Object cachedBody = exchange.getAttribute("cachedRequestBodyObject");
            if (cachedBody != null) {
                try {
                    boolean test = config.predicate.test(cachedBody);
                    exchange.getAttributes().put("read_body_predicate_test_attribute", test);
                    return Mono.just(test);
                } catch (ClassCastException var7) {
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Predicate test failed because class in predicate does not match the cached body object", var7);
                    }

                    return Mono.just(false);
                }
            } else {
                return DataBufferUtils.join(exchange.getRequest().getBody()).flatMap((dataBuffer) -> {
                    DataBufferUtils.retain(dataBuffer);
                    final Flux<DataBuffer> cachedFlux = Flux.defer(() -> {
                        return Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount()));
                    });
                    ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
                        public Flux<DataBuffer> getBody() {
                            return cachedFlux;
                        }
                    };
                    return ServerRequest.create(exchange.mutate().request(mutatedRequest).build(), messageReaders).bodyToMono(inClass).doOnNext((objectValue) -> {
                        exchange.getAttributes().put("cachedRequestBodyObject", objectValue);
                        exchange.getAttributes().put("cachedRequestBody", cachedFlux);
                    }).map((objectValue) -> {
                        return config.predicate.test(objectValue);
                    });
                });
            }
        };
    }

通过查看ReadBodyPredicateFactory内部实现，我们可以看到，该工厂类将request body内容读取后存放在 exchange的cachedRequestBodyObject中。那么我们可以通过代码：exchange.getAttribute("cachedRequestBodyObject"); //将body内容取出来。
知道如何取body内容后，我们只需将该工厂类注册到yml配置文件中的predicates，然后从Filter中获取即可。

2、配置ReadBodyPredicateFactory
查看ReadBodyPredicateFactory关于配置的代码:

public <T> ReadBodyPredicateFactory.Config setPredicate(Class<T> inClass, Predicate<T> predicate) {
            this.setInClass(inClass);
            this.predicate = predicate;
            return this;
        }

配置该工厂类需要两个参数:
inClass：接收body内容的对象Class，我们用字符串接收，配置String即可。
Predicate：Predicate的接口实现类，我们自定义一个Predicate的实现类即可。

自定义Predicate实现，并注册Bean。

    /**
     * 用于readBody断言，可配置到yml
     * @return
     */
    @Bean
    public Predicate bodyPredicate(){
        return new Predicate() {
            @Override
            public boolean test(Object o) {
                return true;
            }
        };
    }

两个参数都有了，直接在yml中配置：

        predicates:
        - Path=/xx/xx/**
        - name: ReadBodyPredicateFactory #使用ReadBodyPredicateFactory断言，将body读入缓存
          args:
            inClass: '#{T(String)}'
            predicate: '#{@bodyPredicate}' #注入实现predicate接口类

3、编写自定义GatewayFilterFactory
编写自己的过滤器工厂类，读取缓存的body内容，并支持在配置文件中配置。

public class ReadBodyGatewayFilterFactory
        extends AbstractGatewayFilterFactory<ReadBodyGatewayFilterFactory.Config> {

    private Logger logger = LoggerFactory.getLogger(ReadBodyGatewayFilterFactory.class);

    private static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedRequestBodyObject";

    public ReadBodyGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return ((exchange, chain) -> {
            //利用ReadBodyPredicateFactory断言，会将body读入exchange的cachedRequestBodyObject中
            Object requestBody = exchange.getAttribute(CACHE_REQUEST_BODY_OBJECT_KEY);
            logger.info("request body is:{}", requestBody);

            return chain.filter(exchange);
        });
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("withParams");//将参数放入
    }

    public static class Config {
        private boolean withParams;//接收配置的参数值，可以随便写

        public boolean isWithParams() {
            return withParams;
        }

        public void setWithParams(boolean withParams) {
            this.withParams = withParams;
        }
    }
}

将ReadBodyGatewayFilterFactory工程类在容器中注入。

     /**
     * 注入ReadBody过滤器
     * @return
     */
    @Bean
    public ReadBodyGatewayFilterFactory readBodyGatewayFilterFactory() {
        return new ReadBodyGatewayFilterFactory();
    }

到此，我们的Filter类也可以在yml配置文件中直接配置使用了。

4、完整的yml配置

        - id: xx
          predicates:
            - Path=/xx/xx/**
            - name: ReadBodyPredicateFactory #使用ReadBodyPredicateFactory断言，将body读入缓存
              args:
                inClass: '#{T(String)}'
                predicate: '#{@bodyPredicate}' #注入实现predicate接口类
          uri: lb://xx-service  #注册中心服务名
          filters:
            - ReadBody=true #使用自定义的过滤器工厂类，读取request body内容
            - ThirdFilter  #自定义过滤器
            - name: RequestRateLimiter #基于redis的Gateway的自身限流
              args:
                redis-rate-limiter.replenishRate: 1  # 允许用户每秒处理多少个请求
                redis-rate-limiter.burstCapacity: 1  # 令牌桶的容量，允许在一秒钟内完成的最大请求数
                key-resolver: "#{@ipKeyResolver}" #SPEL表达式取的对应的bean

OK，以上是通过ReadBodyPredicateFactory这个类读取到request body内容。
另外springcloud gateway内部还提供了ModifyRequestBodyGatewayFilterFactory类用于修改body内容，既然能修改，自然也能获取body，大家可自行去研究。