SpringCloud Gateway 打印请求响应日志、跨域全局配置

2024-06-02后端6 分钟422 次阅读
AI 摘要salmon-ai

本文介绍了 SpringCloud Gateway 中请求日志、响应日志打印以

前言

今天打算在项目中的 Gateway 处记录请求日志、响应日志信息,但发现 Post 请求的参数只能被读取一次、filter 过滤器是在 return 后才调用接口。

我当前项目版本信息:

xml 复制代码
<spring-boot.version>2.7.6</spring-boot.version>
<spring-cloud.version>2021.0.5</spring-cloud.version>

为了方便之后在其它项目进行配置,就在此做记录下这些常用的配置。

这里我简单先介绍下装饰器模式,下面的配置有用到:

简介:装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。

作用:是在原本的类的基础上对其能力进行增强。

举例:有一个方法,它的作用是调用被代理的接口或者转发到模拟接口。

通过使用装饰者模式,我们可以给这个方法外面再包一层,给它添加额外的功能,就像给一个人穿戴武器一样,增加了特殊的能力。比如给他一把剑,他原本是个手无寸铁的普通人,现在有了剑,就能够砍人了。我们可以在这个装饰层中加入我们自己的逻辑,让这个方法按照我们预期的方式进行处理。

这样哪怕它是异步的,当最后执行这个方法时,装饰器也能做额外的事情。这就是装饰者利用装饰增强原有方法的处理能力。

顺便简单介绍下责任链模式:

定义:为 请求 创建一个接收该 请求对象 的 链,链条中每个元素都是一个对象。

适用场景:一个 请求 的 处理,需要多个对象 中的 一个或若干个对象 协作进行处理;

这里我就以 Gateway 的 filter 举例:
我们的所有过滤器是按照从上到下的顺序依次执行,形成了一个链条。所以这里用了一个 chain,如果当前过滤器对请求进行了过滤后发现可以放行,就要调用责任链中的 next 方法,相当于直接找到下一个过滤器,这里称为 filter。有时候我们需要在责任链中使用 next,而在这里它使用了 filter 来找到下一个过滤器,从而正常地放行请求。

记录请求日志

Gateway中 Post 请求参数只能读取一次。

这是因为Gateway网关默认使用的是SpringWebflux,解决这个问题需要容重新构造一个 request 来替换原先的 request。

解决方法:

CacheBodyGlobalFilter这个全局过滤器把原有的 request 请求中的 body 内容读出来,并且使用ServerHttpRequestDecorator这个请求装饰器对 request 进行包装,重写 getBody 方法,并把包装后的请求放到过滤器链中传递下去。这样后面的过滤器中再使用 exchange.getRequest().getBody() 来获取 body 时,实际上就是调用的重载后的 getBody 方法,获取的最先已经缓存了的 body 数据。这样就能够实现 body 的多次读取了。

过滤器的Ordered.HIGHEST_PRECEDENCE,即最高优先级的过滤器。优先级设置高的原因是某些系统内置的过滤器可能也会去读 body。

下面是代码实现:

java 复制代码
package com.salmon.salmongateway.filter;

import lombok.extern.slf4j.Slf4j;
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.HttpHeaders;
import org.springframework.http.server.RequestPath;
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;

import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.charset.StandardCharsets;

/**
 * 请求日志全局处理
 *
 * @author Salmon
 * @since 2024-06-02
 */
@Component
@Slf4j
public class WrapperRequestGlobalFilter implements GlobalFilter, Ordered {

    /**
     * 处理请求日志
     *
     * @param exchange 路由交换机
     * @param chain    责任链模式
     * @return Mono<Void>
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        try {
            // 记录请求日志
            log.info("***********************************请求信息start**********************************");
            // 可以从中拿到:Cookies、Path(请求路径)、QueryParams(请求参数)、RemoteAddress(远程调用地址)、SslInfo(SSL信息)、Body(请求体)、Headers(请求头)等等
            ServerHttpRequest request = exchange.getRequest();
            String id = request.getId(); // 请求唯一标识
            String method = request.getMethodValue(); // 请求方法
            URI uri = request.getURI(); // uri
            RequestPath path = request.getPath(); // 请求路径
            InetSocketAddress remoteAddress = request.getRemoteAddress(); // 请求来源地址
            HttpHeaders headers = request.getHeaders(); // 请求头
            log.info("request info: id = {}, URI = {}, path = {}, method = {}, remoteAddress = {}, header = {}", id, uri, path, method, remoteAddress, headers);
            // 打印请求参数
            if ("POST".equals(method)) {
                return DataBufferUtils.join(request.getBody())
                        .flatMap(dataBuffer -> {
                                    byte[] bytes = new byte[dataBuffer.readableByteCount()];
                                    dataBuffer.read(bytes);
                                    String bodyString = new String(bytes, StandardCharsets.UTF_8);
                                    log.info("请求参数:{}", bodyString);
                                    exchange.getAttributes().put("POST_BODY", bodyString);
                                    DataBufferUtils.release(dataBuffer); // 释放掉内存
                                    // 准备一个新的DataBuffer,包含请求体字节
                                    Flux<DataBuffer> bufferFlux = Flux.defer(() -> {
                                        DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(bytes);
                                        return Mono.just(buffer);
                                    });
                                    // 创建一个装饰器来包装原始请求,以便我们可以再次读取请求体
                                    ServerHttpRequestDecorator decoratorRequest = new ServerHttpRequestDecorator(request) {
                                        // 重写body方法
                                        @Override
                                        public Flux<DataBuffer> getBody() {
                                            return bufferFlux;
                                        }
                                    };
                                    log.info("***********************************请求信息end**********************************\n");
                                    return chain.filter(exchange.mutate().request(decoratorRequest).build());
                                }
                        );
            } else if ("GET".equals(method)) {
                log.info("请求参数:" + request.getQueryParams());
            }
            log.info("***********************************请求信息end**********************************\n");
            return chain.filter(exchange);
        } catch (Exception e) {
            // 处理异常情况,记录错误日志
            log.error("gateway request log exception.\n" + e);
            return chain.filter(exchange);
        }
    }

    @Override
    public int getOrder() {
        // 最低优先级
        return Ordered.LOWEST_PRECEDENCE;
    }
}

测试结果:
image.png

记录响应日志

如果直接从 response 获取响应数据,是获取不到调用接口后返回的数据的。

java 复制代码
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String sourceAddress = request.getLocalAddress().getHostString();
        // 获取响应对象
        ServerHttpResponse response = exchange.getResponse();
        log.info("{}",response.getStatusCode());
        return chain.filter(exchange);
}

进行 Debug 也可以发现,执行完这个方法后,整体 return 了,才调用接口。

原因是:chain.filter是个异步操作,它的返回值:Mono可以理解为前端的Promise。

解决方法:

我们可以利用 ServerHttpResponseDecorator,通过装饰者模式对原来的 response 重新封装,重写 writeWith 方法,这个方法是只有当我们接口调用完后,等它返回结果,用于处理响应体的数据,我们就能根据这个结果做一些处理。

下面是代码实现:

java 复制代码
package com.salmon.salmongateway.filter;

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.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.RequestPath;
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.net.InetSocketAddress;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

/**
 * 响应日志全局处理
 *
 * @author Salmon
 * @since 2024-06-02
 */
@Component
@Slf4j
public class WrapperResponseGlobalFilter implements GlobalFilter, Ordered {

    /**
     * 处理响应日志
     *
     * @param exchange 路由交换机
     * @param chain    责任链模式
     * @return Mono<Void>
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        try {
            // 获取原始的响应对象
            ServerHttpResponse originalResponse = exchange.getResponse();
            // 获取数据缓冲工厂
            DataBufferFactory bufferFactory = originalResponse.bufferFactory();
            // 获取响应的状态码
            HttpStatus statusCode = originalResponse.getStatusCode();
            // 判断状态码是否为200 OK
            if (statusCode == HttpStatus.OK) {
                // 创建一个装饰后的响应对象(开始穿装备,增强能力)
                ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) {
                    // 重写writeWith方法,用于处理响应体的数据
                    // 这段方法就是只要当我们的接口调用完成之后,等它返回结果,
                    // 就会调用writeWith方法,我们就能根据响应结果做一些自己的处理
                    @Override
                    public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                        // 判断响应体是否是Flux类型
                        if (body instanceof Flux) {
                            Flux<? extends DataBuffer> fluxBody = Flux.from(body);
                            // 返回一个处理后的响应体
                            // (这里就理解为它在拼接字符串,它把缓冲区的数据取出来,一点一点拼接好)
                            return super.writeWith(fluxBody.map(dataBuffer -> {
                                // 读取响应体的内容并转换为字节数组
                                byte[] content = new byte[dataBuffer.readableByteCount()];
                                dataBuffer.read(content);
                                DataBufferUtils.release(dataBuffer);// 释放掉内存
                                // 构建日志
                                log.info("***********************************响应信息start**********************************");
                                String requestData = new String(content, StandardCharsets.UTF_8);//data
                                log.info("response code: {}", getStatusCode());
                                log.info("response body: {}", requestData);
                                log.info("***********************************响应信息end**********************************\n");
                                // 将处理后的内容重新包装成DataBuffer并返回
                                return bufferFactory.wrap(content);
                            }));
                        } else {
                            log.error("响应code异常: {}", getStatusCode());
                        }
                        return super.writeWith(body);
                    }
                };
                // 对于200 OK的请求,将装饰后的响应对象传递给下一个过滤器链,并继续处理(设置 response 对象为装饰过的)
                return chain.filter(exchange.mutate().response(decoratedResponse).build());
            }
            // 对于非200 OK的请求,直接返回,进行降级处理
            return chain.filter(exchange);
        } catch (Exception e) {
            // 处理异常情况,记录错误日志
            log.error("gateway log exception.\n" + e);
            return chain.filter(exchange);
        }
    }

    @Override
    public int getOrder() {
        // 最高优先级
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

测试结果:
image.png

跨域全局配置

下面是示例,可以根据项目具体情况修改配置

java 复制代码
package com.salmon.salmongateway.config;

import org.springframework.context.annotation.Bean;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.server.ServerWebExchange;

/**
 * 全局跨域配置
 *
 * @author Salmon
 * @since 2024-06-02
 */
public class CorsWebFilterConfig {
    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfigurationSource corsConfigurationSource = new CorsConfigurationSource() {
            @Override
            public CorsConfiguration getCorsConfiguration(ServerWebExchange serverWebExchange) {
                CorsConfiguration corsConfig = new CorsConfiguration();
                corsConfig.addAllowedHeader("*"); // 允许请求中携带的头信息
                corsConfig.addAllowedMethod("*"); // 允许所有 HTTP 方法(GET, POST, PUT, DELETE 等)
                corsConfig.addAllowedOriginPattern("*"); // 允许所有来源(使用模式匹配)
                corsConfig.setMaxAge(1800L); // 跨域检测的有效期,单位s
                corsConfig.setAllowCredentials(true); // 是否允许携带cookie
                return corsConfig;
            }
        };
        return new CorsWebFilter(corsConfigurationSource);
    }
}
觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句