美文网首页微服务网关Spring-Cloud-GatewayIT干货
Spring-Cloud-Gateway之请求响应日志打印过滤器

Spring-Cloud-Gateway之请求响应日志打印过滤器

作者: Mr_1214 | 来源:发表于2018-12-06 16:42 被阅读682次

Gateway网关开发中我们的大部分时间都是在开发各种各样功能的过滤器,下面为网关,请求,响应日志打印的过滤器,以及涉及到的类

  • DefaultLogFilter
public class DefaultLogFilter implements GlobalFilter, Ordered {
    /**
     * 日志信息
     */
    private static final Logger logger = LoggerFactory.getLogger(DefaultLogFilter.class);

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        long startTime = System.currentTimeMillis();
        String trace = exchange.getRequest().getHeaders().getFirst("trace");
        ServerRequest serverRequest = new DefaultServerRequest(exchange);
        return serverRequest.bodyToMono(String.class).flatMap(reqBody -> {
            //重写原始请求
            ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(exchange.getRequest()) {
                @Override
                public HttpHeaders getHeaders() {
                    HttpHeaders httpHeaders = new HttpHeaders();
                    httpHeaders.putAll(super.getHeaders());
                    return httpHeaders;
                }

                @Override
                public Flux<DataBuffer> getBody() {
                    //打印原始请求日志
                    logger.info("[Trace:{}]-gateway request:headers=[{}],body=[{}]", trace, getHeaders(), reqBody);
                    return Flux.just(reqBody).map(bx -> exchange.getResponse().bufferFactory().wrap(bx.getBytes()));
                }
            };
            //重写原始响应
            BodyHandlerServerHttpResponseDecorator responseDecorator = new BodyHandlerServerHttpResponseDecorator(
                    initBodyHandler(exchange, startTime), exchange.getResponse());

            return chain.filter(exchange.mutate().request(decorator).response(responseDecorator).build());
        });
    }

    @Override
    public int getOrder() {
        //在NettyWriteResponseFilter之前
        return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER - 20;
    }

    /**
     * 响应body处理,添加响应的打印
     *
     * @param exchange
     * @param startTime
     * @return
     */
    protected BodyHandlerFunction initBodyHandler(ServerWebExchange exchange, long startTime) {
        return (resp, body) -> {
            //拦截
            String trace = exchange.getRequest().getHeaders().getFirst("trace");
            MediaType originalResponseContentType = exchange.getAttribute(ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR);
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setContentType(originalResponseContentType);
            DefaultClientResponseAdapter clientResponseAdapter = new DefaultClientResponseAdapter(body, httpHeaders);
            Mono<String> bodyMono = clientResponseAdapter.bodyToMono(String.class);
            return bodyMono.flatMap((respBody) -> {
                //打印返回响应日志
                logger.info("[Trace:{}]-gateway response:ct=[{}], status=[{}],headers=[{}],body=[{}]", trace,
                        System.currentTimeMillis() - startTime, resp.getStatusCode(), resp.getHeaders(), respBody);
                return resp.writeWith(Flux.just(respBody).map(bx -> resp.bufferFactory().wrap(bx.getBytes())));
            }).then();
        };
    }
}
  • BodyHandlerFunction
/**
 * 响应body拦截处理接口
 */
public interface BodyHandlerFunction
        extends BiFunction<ServerHttpResponse, Publisher<? extends DataBuffer>, Mono<Void>> {
}
  • BodyHandlerServerHttpResponseDecorator
/**
 * ServerHttpResponse包装类,通过ResponseBodyHandlerFunction处理响应body
 */
public class BodyHandlerServerHttpResponseDecorator extends ServerHttpResponseDecorator {

    /**
     * body 处理拦截器
     */
    private BodyHandlerFunction bodyHandler = initDefaultBodyHandler();

    /**
     * 构造函数
     *
     * @param bodyHandler
     * @param delegate
     */
    public BodyHandlerServerHttpResponseDecorator(BodyHandlerFunction bodyHandler, ServerHttpResponse delegate) {
        super(delegate);
        if (bodyHandler != null) {
            this.bodyHandler = bodyHandler;
        }
    }

    @Override
    public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
        //body 拦截处理器处理响应
        return bodyHandler.apply(getDelegate(), body);
    }

    @Override
    public Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> body) {
        return writeWith(Flux.from(body).flatMapSequential(p -> p));
    }

    /**
     * 默认body拦截处理器
     *
     * @return
     */
    private BodyHandlerFunction initDefaultBodyHandler() {
        return (resp, body) -> resp.writeWith(body);
    }
}
  • DefaultClientResponseAdapter
/**
 * ClientResponse适配器,用于将body转换为DefaultClientResponse对象进而对body流反序列化
 *
 */
public class DefaultClientResponseAdapter extends DefaultClientResponse {

    /**
     * @param body
     * @param httpHeaders
     */
    public DefaultClientResponseAdapter(Publisher<? extends DataBuffer> body,
            HttpHeaders httpHeaders) {
        this(new ResponseAdapter(body, httpHeaders),
                ExchangeStrategies.withDefaults());
    }

    /**
     * @param response
     * @param strategies
     */
    public DefaultClientResponseAdapter(ClientHttpResponse response,
            ExchangeStrategies strategies) {
        super(response, strategies);
    }

    /**
     * ClientHttpResponse 适配器
     */
    static class ResponseAdapter implements ClientHttpResponse {
        /**
         * 响应数据
         */
        private final Flux<DataBuffer> flux;
        /**
         *
         */
        private final HttpHeaders headers;

        public ResponseAdapter(Publisher<? extends DataBuffer> body,
                HttpHeaders headers) {
            this.headers = headers;
            if (body instanceof Flux) {
                flux = (Flux) body;
            } else {
                flux = ((Mono) body).flux();
            }
        }

        @Override
        public Flux<DataBuffer> getBody() {
            return flux;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }

        @Override
        public HttpStatus getStatusCode() {
            return null;
        }

        @Override
        public int getRawStatusCode() {
            return 0;
        }

        @Override
        public MultiValueMap<String, ResponseCookie> getCookies() {
            return null;
        }
    }
}

相关文章

  • Spring-Cloud-Gateway之请求响应日志打印过滤器

    Gateway网关开发中我们的大部分时间都是在开发各种各样功能的过滤器,下面为网关,请求,响应日志打印的过滤器,以...

  • Spring-Cloud-Gateway之过滤器GatewayF

    在Spring-Cloud-Gateway之请求处理流程文中我们了解最终网关是将请求交给过滤器链表进行处理,接下来...

  • 开源 - 收藏集 - 掘金

    (译)Android 上的网络响应日志技巧 - Android - 掘金介绍如何对 HTTP 请求打印 Log.....

  • JavaWeb Filter

    过滤器,用于执行过滤任务的对象,针对指定请求响应执行,通过doFilter()方法进行过滤。常用于验证过滤、日志记...

  • Xcode 日志打印不全

    突然发现我们Xcode 日志请求响应打印不全了,只打印了一小半。 宏连接符 注意下:__VA_ARGS__代表 C...

  • 过滤器(Filter),拦截器(Interceptor)和AOP

    1.过滤器过滤器可以拦截到方法的请求和响应(ServletRequest request, ServletResp...

  • 过滤器

    过滤器 Filter 用于对用户请求进行预处理,和对请求响应进行后处理的 web 应用组件。 过滤源:请求与响应过...

  • JSP 过滤器+Cookie+Session

    过滤器 过滤器可以动态的拦截请求和相应,以变换或使用包含在请求或响应中的信息。 过滤器是可用于 Servlet 编...

  • Filter、Interceptor、Aspect学习

    简介:过滤器、拦截器、切面 如何选择? Filter过滤器 过滤器可以拦截到方法的请求和响应ServletRequ...

  • 拦截过滤器模式

    拦截过滤器模式 拦截过滤器模式(Intercepting Filter Pattern)用于对应用程序的请求或响应...

网友评论

    本文标题:Spring-Cloud-Gateway之请求响应日志打印过滤器

    本文链接:https://www.haomeiwen.com/subject/ctiocqtx.html