SpringCloudGateway过滤器获取request和response的body

深蓝AD

已于 2022-02-17 00:06:22 修改

阅读量2.1k

点赞数 1

文章标签： gateway spring cloud

于 2022-02-16 23:17:35 首次发布

本文链接：https://blog.youkuaiyun.com/u014160286/article/details/122973745

版权

该博客主要介绍了一个实现于Spring Cloud Gateway的全局过滤器，用于在POST请求中捕获并记录请求和响应体。过滤器通过订阅请求体，缓存数据，然后在响应时读取并处理数据，释放内存，并将响应体转换为大写。同时，它还展示了如何设置过滤器的执行顺序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpMethod;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.atomic.AtomicReference;

@Component
@Slf4j
public class MyLogGateWayFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("当前过滤器order：{}", getOrder());

        return HttpMethod.POST.equals(exchange.getRequest().getMethod()) ?
                DataBufferUtils.join(exchange.getRequest().getBody()).flatMap(dataBuffer -> {
                    DataBufferUtils.retain(dataBuffer);
                    Flux<DataBuffer> cachedFlux = Flux.defer(() -> Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
                    ServerHttpRequest decoratedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
                        @Override
                        public Flux<DataBuffer> getBody() {
                            return cachedFlux;
                        }
                    };
                    String requestBody = resolveBodyFromRequest(decoratedRequest.getBody());
                    ServerHttpResponse originalResponse = exchange.getResponse();
                    DataBufferFactory bufferFactory = originalResponse.bufferFactory();
                    ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) {
                        @Override
                        public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                            if (body instanceof Flux) {
                                Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body;
                                return super.writeWith(fluxBody.map(dataBuffer -> {
                                    // probably should reuse buffers
                                    byte[] content = new byte[dataBuffer.readableByteCount()];
                                    dataBuffer.read(content);
                                    //释放掉内存
                                    DataBufferUtils.release(dataBuffer);
                                    String responseBody = new String(content, Charset.forName("UTF-8"));
                                    log.info("requestBody:{}", requestBody);
                                    log.info("responseBody:{}", responseBody);
                                    byte[] uppedContent = new String(content, Charset.forName("UTF-8")).getBytes();
                                    return bufferFactory.wrap(uppedContent);
                                }));
                            }
                            // if body is not a flux. never got there.
                            return super.writeWith(body);
                        }
                    };
                    return chain.filter(exchange.mutate().request(decoratedRequest).response(decoratedResponse).build());
                }) : chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -10;
    }

    /**
     * spring cloud gateway 获取post请求的body体
     *
     * @param body
     * @return
     */
    private String resolveBodyFromRequest(Flux<DataBuffer> body) {
        AtomicReference<String> bodyRef = new AtomicReference<>();
        // 缓存读取的request body信息
        body.subscribe(dataBuffer -> {
            CharBuffer charBuffer = StandardCharsets.UTF_8.decode(dataBuffer.asByteBuffer());
            DataBufferUtils.release(dataBuffer);
            bodyRef.set(charBuffer.toString());
        });
        return bodyRef.get();

    }

}

仅限POST请求，且order<-1

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>