通过SpringGateway对接口请求进行加解密

public class EncryptGatewayFilter implements GlobalFilter, Ordered {

    private static final String BODY_ENCRYPT_HEADER = "X-ENCRYPTED";
    private static final String ENCRYPT_VERSION_1 = "1.0";

    @Override
    public int getOrder() {
        return -99;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 请求头中标识了该请求是加密过的
        HttpHeaders httpHeaders = exchange.getRequest().getHeaders();
        String bodyEncryptHeader = httpHeaders.getFirst(BODY_ENCRYPT_HEADER);

        if (bodyEncryptHeader != null && bodyEncryptHeader.equals(ENCRYPT_VERSION_1)) {
            // 这里可以处理一些自定义的逻辑，并且将参数传到后续的方法中
            CustomParam step1Param = this.prepareCustomParam();

            // 处理加密的请求
            return processEncryptRequest(exchange, chain, step1Param);
        }

        // 处理未加密的请求
        return chain.filter(exchange);
    }

    private Mono<Void> processEncryptRequest(ServerWebExchange exchange, GatewayFilterChain chain, CustomParam step1Param) {
        // 这里可以做一些前置校验，确定是否需要对请求解密
        boolean needProcess = checkIfNeedProcess(step1Param);

        if (needProcess) {
            try {
                // 这里可以处理 step1Param，并且将生成下个阶段需要用的参数 step2Param, 传到后续的方法中
                CustomParam step2Param = this.handleCustomParam(step1Param);

                // 修改请求内容
                return new ModifiedRequestDecorator(new Config()
                        // 可以移除表示加密的请求头
                        .addHeaderToRemove(BODY_ENCRYPT_HEADER)
                        // 设置 request 重写方法，解密请求
                        .setRewriteFunction(String.class, String.class, (ex, requestData)
                                ->  Mono.just(decryptRequestBody(requestData, step2Param))
                        )).filter(exchange.mutate().response(
                                // 修改响应内容
                                new ModifiedResponseDecorator(exchange, new Config()
                                        // 添加响应头，告知调用者该响应已加密
                                        .addHeaderToAdd(BODY_ENCRYPT_HEADER, ENCRYPT_VERSION_1)
                                        // 设置 response 重写方法，加密响应
                                        .setRewriteFunction(String.class, String.class, (ex, responseData)
                                        ->  Mono.just(encryptResponseBody(responseData, step2Param))
                                ))).build(), chain);

            } catch (Exception e) {
                log.error("Failed to process the request body", e);

                // 处理失败，返回错误的响应
                return buildFailResult(exchange.getResponse(), HttpStatus.BAD_REQUEST);
            }

        }

        // 验证未通过，则不处理，直接将原始请求传到链条中的下一个处理器
        return chain.filter(exchange);
    }

    private String decryptRequestBody(Object originalRequest, CustomParam step2Param) {
        try {
            // 这里需要实现解密的方法
            ...

            return decryptedRequest;
        } catch (Exception e) {
            log.warn("Error when decrypting request.", e);
            return null;
        }
    }

    private String encryptResponseBody(String originalResponse, CustomParam step2Param) {
        try {
            // 这里需要实现加密的方法
            ...

            return oencryptedResponse;
        } catch (Exception e) {
            log.warn("Error when encrypting response.", e);
            return null;
        }
    }
}