Spring Cloud Alibaba微服务实战二十九 - SpringCloud Gateway 请求响应日志

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

请求响应日志是日常开发调试定位问题的重要手段，在微服务中引入SpringCloud Gateway后我们希望在网关层统一进行日志的收集。

本节内容将实现以下两个功能：

1. 获取请求的输入输出参数，封装成自定义日志
2. 将日志发送到MongoDB进行存储

获取输入输出参数

• 首先我们先定义一个日志体

    @Data
    public class GatewayLog {
        /**访问实例*/
        private String targetServer;
        /**请求路径*/
        private String requestPath;
        /**请求方法*/
        private String requestMethod;
        /**协议 */
        private String schema;
        /**请求体*/
        private String requestBody;
        /**响应体*/
        private String responseData;
        /**请求ip*/
        private String ip;
     /**请求时间*/
        private Date requestTime;
     /**响应时间*/
        private Date responseTime;
        /**执行时间*/
        private long executeTime;
    }

• 【关键】在网关定义日志过滤器，获取输入输出参数

    /**
     * 日志过滤器，用于记录日志
     * @author mx
     * @date 2024/3/24 17:17
     */
    @Slf4j
    @Component
    public class AccessLogFilter implements GlobalFilter, Ordered {
        @Autowired
        private AccessLogService accessLogService;
    
        private final List<HttpMessageReader<?>> messageReaders = HandlerStrategies.withDefaults().messageReaders();
    
        @Override
        public int getOrder() {
            return -100;
        }
    
        @Override
        @SuppressWarnings("unchecked")
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    
            ServerHttpRequest request = exchange.getRequest();
    
            // 请求路径
            String requestPath = request.getPath().pathWithinApplication().value();
    
            Route route = getGatewayRoute(exchange);
    
    
            String ipAddress = WebUtils.getServerHttpRequestIpAddress(request);
    
            GatewayLog gatewayLog = new GatewayLog();
            gatewayLog.setSchema(request.getURI().getScheme());
            gatewayLog.setRequestMethod(request.getMethodValue());
            gatewayLog.setRequestPath(requestPath);
            gatewayLog.setTargetServer(route.getId());
            gatewayLog.setRequestTime(new Date());
            gatewayLog.setIp(ipAddress);
    
            MediaType mediaType = request.getHeaders().getContentType();
    
            if(MediaType.APPLICATION_FORM_URLENCODED.isCompatibleWith(mediaType) || MediaType.APPLICATION_JSON.isCompatibleWith(mediaType)){
                return writeBodyLog(exchange, chain, gatewayLog);
            }else{
                return writeBasicLog(exchange, chain, gatewayLog);
            }
        }
    
        private Mono<Void> writeBasicLog(ServerWebExchange exchange, GatewayFilterChain chain, GatewayLog accessLog) {
            StringBuilder builder = new StringBuilder();
            MultiValueMap<String, String> queryParams = exchange.getRequest().getQueryParams();
            for (Map.Entry<String, List<String>> entry : queryParams.entrySet()) {
                builder.append(entry.getKey()).append("=").append(StringUtils.join(entry.getValue(), ","));
            }
            accessLog.setRequestBody(builder.toString());
    
            //获取响应体
            ServerHttpResponseDecorator decoratedResponse = recordResponseLog(exchange, accessLog);
    
            return chain.filter(exchange.mutate().response(decoratedResponse).build())
                    .then(Mono.fromRunnable(() -> {
                        // 打印日志
                        writeAccessLog(accessLog);
                    }));
        }
    
    
        /**
         * 解决 request body 只能读取一次问题，
         * 参考: org.springframework.cloud.gateway.filter.factory.rewrite.ModifyRequestBodyGatewayFilterFactory
         * @param exchange
         * @param chain
         * @param gatewayLog
         * @return
         */
        @SuppressWarnings("unchecked")
        private Mono writeBodyLog(ServerWebExchange exchange, GatewayFilterChain chain, GatewayLog gatewayLog) {
            ServerRequest serverRequest = ServerRequest.create(exchange,messageReaders);
    
            Mono<String> modifiedBody = serverRequest.bodyToMono(String.class)
                    .flatMap(body ->{
                        gatewayLog.setRequestBody(body);
                        return Mono.just(body);
                    });
    
            // 通过 BodyInserter 插入 body(支持修改body), 避免 request body 只能获取一次
            BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
            HttpHeaders headers = new HttpHeaders();
            headers.putAll(exchange.getRequest().getHeaders());
            // the new content type will be computed by bodyInserter
            // and then set in the request decorator
            headers.remove(HttpHeaders.CONTENT_LENGTH);
    
            CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
    
            return bodyInserter.insert(outputMessage,new BodyInserterContext())
                    .then(Mono.defer(() -> {
                        // 重新封装请求
                        ServerHttpRequest decoratedRequest = requestDecorate(exchange, headers, outputMessage);
    
                        // 记录响应日志
                        ServerHttpResponseDecorator decoratedResponse = recordResponseLog(exchange, gatewayLog);
    
                        // 记录普通的
                        return chain.filter(exchange.mutate().request(decoratedRequest).response(decoratedResponse).build())
                                .then(Mono.fromRunnable(() -> {
                                    // 打印日志
                                    writeAccessLog(gatewayLog);
                                }));
                    }));
        }
    
        /**
         * 打印日志
         * @author mx
         * @date 2024/3/24 14:53
         * @param gatewayLog 网关日志
         */
        private void writeAccessLog(GatewayLog gatewayLog) {
            log.info(gatewayLog.toString());  
        }
    
    
    
        private Route getGatewayRoute(ServerWebExchange exchange) {
            return exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
        }
    
    
        /**
         * 请求装饰器，重新计算 headers
         * @param exchange
         * @param headers
         * @param outputMessage
         * @return
         */
        private ServerHttpRequestDecorator requestDecorate(ServerWebExchange exchange, HttpHeaders headers,
                                                           CachedBodyOutputMessage outputMessage) {
            return new ServerHttpRequestDecorator(exchange.getRequest()) {
                @Override
                public HttpHeaders getHeaders() {
                    long contentLength = headers.getContentLength();
                    HttpHeaders httpHeaders = new HttpHeaders();
                    httpHeaders.putAll(super.getHeaders());
                    if (contentLength > 0) {
                        httpHeaders.setContentLength(contentLength);
                    } else {
                        // TODO: this causes a 'HTTP/1.1 411 Length Required' // on
                        // httpbin.org
                        httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                    }
                    return httpHeaders;
                }
    
                @Override
                public Flux<DataBuffer> getBody() {
                    return outputMessage.getBody();
                }
            };
        }
    
    
        /**
         * 记录响应日志
         * 通过 DataBufferFactory 解决响应体分段传输问题。
         */
        private ServerHttpResponseDecorator recordResponseLog(ServerWebExchange exchange, GatewayLog gatewayLog) {
            ServerHttpResponse response = exchange.getResponse();
            DataBufferFactory bufferFactory = response.bufferFactory();
    
            return new ServerHttpResponseDecorator(response) {
                @Override
                public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                    if (body instanceof Flux) {
                        Date responseTime = new Date();
                        gatewayLog.setResponseTime(responseTime);
                        // 计算执行时间
                        long executeTime = (responseTime.getTime() - gatewayLog.getRequestTime().getTime());
    
                        gatewayLog.setExecuteTime(executeTime);
    
                        // 获取响应类型，如果是 json 就打印
                        String originalResponseContentType = exchange.getAttribute(ServerWebExchangeUtils.ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR);
    
    
                        if (ObjectUtil.equal(this.getStatusCode(), HttpStatus.OK)
                                && StringUtil.isNotBlank(originalResponseContentType)
                                && originalResponseContentType.contains("application/json")) {
    
                            Flux<? extends DataBuffer> fluxBody = Flux.from(body);
                            return super.writeWith(fluxBody.buffer().map(dataBuffers -> {
    
                                // 合并多个流集合，解决返回体分段传输
                                DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
                                DataBuffer join = dataBufferFactory.join(dataBuffers);
                                byte[] content = new byte[join.readableByteCount()];
                                join.read(content);
    
                                // 释放掉内存
                                DataBufferUtils.release(join);
                                String responseResult = new String(content, StandardCharsets.UTF_8);
    
    
    
                                gatewayLog.setResponseData(responseResult);
    
                                return bufferFactory.wrap(content);
                            }));
                        }
                    }
                    // if body is not a flux. never got there.
                    return super.writeWith(body);
                }
            };
        }
    }

代码较长建议直接拷贝到编辑器，只要注意下面一个关键点：

getOrder()方法返回的值必须要<-1， 「否则标准的NettyWriteResponseFilter将在您的过滤器被调用的机会之前发送响应，即不会执行获取后端响应参数的方法」

通过上面的两步我们已经可以获取到请求的输入输出参数了，在 writeAccessLog()中将其输出到了日志文件，大家可以在Postman发送请求观察日志。

存储日志

如果需要将日志持久化方便后期检索的话可以考虑将日志存储在MongoDB中，实现过程很简单。（安装MongoDB可以参考这篇文章：实战|MongoDB的安装配置）

• 引入MongoDB

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
    </dependency>

由于gateway是基于webflux，所以我们需要选择reactive版本。

• 在GatewayLog上添加对应的注解

    @Data
    @Document
    public class GatewayLog {
        @Id
        private String id;
     ...
    }

• 建立AccessLogRepository

    @Repository
    public interface AccessLogRepository extends ReactiveMongoRepository<GatewayLog,String> {
      
    }

• 建立Service

    public interface AccessLogService {
    
        /**
         * 保存AccessLog
         * @param gatewayLog 请求响应日志
         * @return 响应日志
         */
        Mono<GatewayLog> saveAccessLog(GatewayLog gatewayLog);
    
    }

• 建立实现类

    @Service
    public class AccessLogServiceImpl implements AccessLogService {
        @Autowired
        private AccessLogRepository accessLogRepository;
    
        @Override
        public Mono<GatewayLog> saveAccessLog(GatewayLog gatewayLog) {
            return accessLogRepository.insert(gatewayLog);
        }
    }

• 在Nacos配置中心添加MongoDB对应配置

    spring:
      data:
        mongodb:
          host: xxx.xx.x.xx
          port: 27017
          database: accesslog
          username: accesslog
          password: xxxxxx

• 执行请求，打开MongoDB客户端，查看日志结果