SpringCloud Gateway 打印请求响应日志、跨域全局配置
本文介绍了 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;
}
}
测试结果:

记录响应日志
如果直接从 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;
}
}
测试结果:

跨域全局配置
下面是示例,可以根据项目具体情况修改配置
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);
}
}