SpringCloud Gateway 对返回参数加密

接上篇，spring cloud gateway 对请求参数解密_那年夏天丶的博客-CSDN博客

前言：刚做完请求数据加密，测试反馈说还需要做返回数据加密，那就做呗。

返回数据加密也主要用到 GlobalFilter全局过滤器和 Ordered

1.网关路由请求过后，如果我们希望拦截请求，做自己的业务逻辑则可以使用GlobalFilter 全局过滤器。

public interface GlobalFilter {
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

gateway filter的定义如下，可以看到他们的接口描述基本一致，说明其用途也是相类似的。不一样的地方是GatewayFilter多定义两个属性，暂时没看到它的用途是什么。还有其继承了ShortcutConfigurable，这个应该是方便GatewayFilter做配置化的，因为GatewayFilter没有具体的实现类定义，必须从配置中读取filter信息，然后动态创建GatewayFilter。

/**
 * Contract for interception-style, chained processing of Web requests that may be used to
 * implement cross-cutting, application-agnostic requirements such as security, timeouts,
 * and others. Specific to a Gateway
 * 
 * Copied from WebFilter
 */
public interface GatewayFilter extends ShortcutConfigurable {
	String NAME_KEY = "name";
	String VALUE_KEY = "value";
	Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

代码都贴出来看看，代码都差不多，但是我之前发现，配置GatewayFilter 过滤器后，断点进不来，找了很久发现问题，后面贴出来。

2.利用GlobalFilter进行返回参数加密

 @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("============================Return data encryption============================");
        HttpStatus statusCode = exchange.getResponse().getStatusCode();
        if(Objects.equals(statusCode, HttpStatus.BAD_REQUEST) || Objects.equals(statusCode, HttpStatus.TOO_MANY_REQUESTS)){
            // 如果是特殊的请求，已处理响应内容，这里不再处理
            return chain.filter(exchange);
        }
        // 根据具体业务内容，修改响应体
        ServerHttpResponse originalResponse = exchange.getResponse();
        originalResponse.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        DataBufferFactory bufferFactory = originalResponse.bufferFactory();
        ServerHttpResponseDecorator responseDecorator = new ServerHttpResponseDecorator(originalResponse){
            @Override
            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                if (getStatusCode().equals(HttpStatus.OK) && body instanceof Flux) {
                    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 responseData = new String(content, Charsets.UTF_8);
                        System.out.println(responseData);
                        if(Strings.isNotBlank(responseData)){
                            responseData = AESUtil.encrypt(responseData);
                            log.info("encrypt params {}",responseData);
                        }
                        byte[] uppedContent = responseData.getBytes(Charsets.UTF_8);
                        originalResponse.getHeaders().setContentLength(uppedContent.length);
                        return bufferFactory.wrap(uppedContent);
                    }));
                } else {
                    log.error("获取响应体数据 ："+getStatusCode());
                }
                return super.writeWith(body);
            }

            @Override
            public Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> body) {
                return writeWith(Flux.from(body).flatMapSequential(p -> p));
            }
        };
        return chain.filter(exchange.mutate().response(responseDecorator).build());
    }