SpringCloud的Gateway里拦截所有请求

不念不忘少年蓝@ 2022-09-01 13:49 146阅读 0赞

CacheBodyGatewayFilter类：

package cn.com.yusys.aiops.gateway.filter;
    
    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.DataBufferUtils;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Flux;
    import reactor.core.publisher.Mono;
    
    @Component
    public class CacheBodyGatewayFilter implements  GlobalFilter,Ordered {
    
        public static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedRequestBodyObject";
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            if (exchange.getRequest().getHeaders().getContentType() == null) {
                return chain.filter(exchange);
            } else {
                return DataBufferUtils.join(exchange.getRequest().getBody())
                        .flatMap(dataBuffer -> {
                            DataBufferUtils.retain(dataBuffer);
                            Flux<DataBuffer> cachedFlux = Flux
                                    .defer(() -> Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
                            ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(
                                    exchange.getRequest()) {
                                @Override
                                public Flux<DataBuffer> getBody() {
                                    return cachedFlux;
                                }
                            };
                            exchange.getAttributes().put(CACHE_REQUEST_BODY_OBJECT_KEY, cachedFlux);
                            return chain.filter(exchange.mutate().request(mutatedRequest).build());
                        });
            }
        }
    
        @Override
        public int getOrder() {
            return Ordered.HIGHEST_PRECEDENCE;
        }
    }

CacheBodyGatewayFilter先执行，然后将POST请求的请求体放到String CACHE\_REQUEST\_BODY\_OBJECT\_KEY = "cachedRequestBodyObject 里，然后提供之后的Filter进行提取出来做记录。

HttpRequestLogSaveFilter类：

package cn.com.yusys.aiops.gateway.filter;
    
    import com.alibaba.fastjson.JSON;
    import lombok.RequiredArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.reactivestreams.Publisher;
    import org.springframework.cloud.gateway.filter.GatewayFilter;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.cloud.gateway.filter.GlobalFilter;
    import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
    import org.springframework.cloud.gateway.support.BodyInserterContext;
    import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
    import org.springframework.context.ApplicationContext;
    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.HttpHeaders;
    import org.springframework.http.HttpMethod;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.server.RequestPath;
    import org.springframework.http.server.ServletServerHttpRequest;
    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.util.MultiValueMap;
    import org.springframework.web.reactive.function.BodyInserter;
    import org.springframework.web.reactive.function.BodyInserters;
    import org.springframework.web.reactive.function.client.ClientResponse;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Flux;
    import reactor.core.publisher.Mono;
    
    import javax.annotation.Resource;
    import java.net.URI;
    import java.nio.CharBuffer;
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    import java.util.Map;
    import java.util.Objects;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2021, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2021/7/26 17:15
     * @Version: 1.0
     * @Description:
     */
    @Component
    @Slf4j
    @RequiredArgsConstructor
    public class HttpRequestLogSaveFilter implements GlobalFilter, GatewayFilter, Ordered {
    
        //private final HttpRequestLogOpenFeign httpRequestLogOpenFeign;
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            URI requestFullPath = (URI) Objects.requireNonNull(exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR));
            ServerHttpRequest serverHttpRequest = exchange.getRequest();
            String requestMethod = serverHttpRequest.getMethodValue();
            String remoteIp = Objects.requireNonNull(serverHttpRequest.getRemoteAddress()).getAddress().getHostAddress();
            String hostname = Objects.requireNonNull(serverHttpRequest.getRemoteAddress()).getAddress().getHostName();
            String httpRequestPath = requestFullPath.getPath();
    
            MultiValueMap<String, String> queryParams = serverHttpRequest.getQueryParams();
    
            String contentType = serverHttpRequest.getHeaders().getFirst("Content-Type");
            if ("POST".equalsIgnoreCase(requestMethod)) {
                //post请求并且 content-type 为 application/json 或者  application/x-www-form-urlencoded
                Object object = exchange.getAttribute("cachedRequestBodyObject");
                String jsonString = JSON.toJSONString(object);
    
                System.out.println(jsonString);
    
            }
    
            //构造数据对象
    //        HttpRequestLog httpRequestLog = HttpRequestLog
    //                .builder()
    //                .ip(remoteIp)
    //                .httpRequestPath(httpRequestPath)
    //                .hostname(hostname)
    //                .requestMethod(requestMethod)
    //                .requestFullPath(requestFullPath.toString())
    //                .httpStatus(String.valueOf(exchange.getResponse().getRawStatusCode()))
    //                .build();
            return chain.filter(exchange.mutate().response(decorate(exchange)).build());
        }
    
    
        ServerHttpResponse decorate(ServerWebExchange exchange) {
            return new ServerHttpResponseDecorator(exchange.getResponse()) {
                @Override
                public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                    Class inClass = String.class;
                    Class outClass = String.class;
                    String originalResponseContentType = exchange
                            .getAttribute(ServerWebExchangeUtils.ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR);
                    HttpHeaders httpHeaders = new HttpHeaders();
    
                    httpHeaders.add(HttpHeaders.CONTENT_TYPE,
                            originalResponseContentType);
    
                    ClientResponse clientResponse = ClientResponse
                            .create(exchange.getResponse().getStatusCode())
                            .headers(headers -> headers.putAll(httpHeaders))
                            .body(Flux.from(body)).build();
    
                    Mono modifiedBody = clientResponse.bodyToMono(inClass)
                            .flatMap(originalBody -> {
                                //TODO:此次可以对返回的body进行操作
    //                            httpRequestLog.setResponseBody(String.valueOf(originalBody));
    //                            httpRequestLogOpenFeign.insertHttpRequestLog(httpRequestLog);
                                return Mono.just(originalBody);
                            });
    
                    BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody,
                            outClass);
                    CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(
                            exchange, exchange.getResponse().getHeaders());
                    return bodyInserter.insert(outputMessage, new BodyInserterContext())
                            .then(Mono.defer(() -> {
                                Flux<DataBuffer> messageBody = outputMessage.getBody();
                                HttpHeaders headers = getDelegate().getHeaders();
                                if (!headers.containsKey(HttpHeaders.TRANSFER_ENCODING)) {
                                    messageBody = messageBody.doOnNext(data -> headers
                                            .setContentLength(data.readableByteCount()));
                                }
                                return getDelegate().writeWith(messageBody);
                            }));
                }
    
                @Override
                public Mono<Void> writeAndFlushWith(
                        Publisher<? extends Publisher<? extends DataBuffer>> body) {
                    return writeWith(Flux.from(body).flatMapSequential(p -> p));
                }
            };
        }
    
        @Override
        public int getOrder() {
            return -520;
        }
    }