简单例子gateway网关加密解密子服务分发请求

已于 2024-01-18 10:47:51 修改
阅读量824 收藏 10
点赞数 12
分类专栏： gateway 文章标签： gateway java spring cloud
于 2024-01-17 15:49:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19342829/article/details/135649381
版权

简单例子gateway网关加密解密子服务分发请求

1.需求

编写一个简单的dmz区网关，接收外围加密的请求，并且接收参数后进行请求信息解密，建立新的请求信息，转发到自己业务对应的微服务，再根据请求业务id,分发到自己业务处理的详细serviceImpl

2.具体的执行流程

  1. 使用AES生成随机加密秘钥转换为base64字符串
  2. 生成网关验签的sign信息（md5[系统标识|业务时间|约定md5随机key]）
  3. 使用AES随机秘钥对请求参数Body进行AES对称加密
  4. 将AES随机秘钥byte[]转换为16进制字符串
  5. 将16进制的秘钥串进行RSA非对称加密[提前自己生成需要的私钥和公钥]既signature
  6. 网关接收到信息，进行数据解密，将解密内容按照约定格式发送到微服务集群
  7. 微服务接收到请求信息，按照约定进行hibernate validate参数校验
  8. 校验通过进行业务转发，到各自业务serviceImpl进行执行业务

3. 详情实现

3.1 dmz网关编写

dmz网关编写主要就是接收信息，将数据进行解析，并且需要解析后进行验签操作，在处理过程中，无果报错，则要统一返回对应的错误处理信息，并且格式要提前确定好，然后就是转发到具体对的业务服务了，之后接收服务返回的信息再进行加密操作，将数据返回到调用方即可。此过程需要三个过滤器分别做如下操作，缓存解密请求body中信息数据，dmz网关全局过滤器,进行请求参数解密转发，返回信息加密，具体过程如下。

3.1.1 缓存body请求信息DmzCacheFilter
package cn.git.dmz.filter;

import cn.git.dmz.constants.DmzConstants;
import cn.git.dmz.util.ResponseUtil;
import cn.git.foreign.dmz.DmzResult;
import cn.git.foreign.dmz.DmzResultEnum;
import cn.hutool.core.util.ObjectUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.client.methods.HttpPost;
import org.springframework.beans.factory.annotation.Autowired;
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.DataBufferUtils;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * @description: 缓存解密请求body中信息数据
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 10:06:45
 */
@Slf4j
@Component
public class DmzCacheFilter implements GlobalFilter, Ordered {

    @Autowired
    private ResponseUtil responseUtil;

    /**
     * 执行逻辑
     * @param exchange
     * @param chain
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 判断请求是否为POST请求
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        String uri = request.getPath().pathWithinApplication().value();
        String method = request.getMethod().name();
        // 方法类型校验必须为post
        if (!HttpPost.METHOD_NAME.equals(method)) {
            return responseUtil.responseErrorInfo(response, DmzResult.error(DmzResultEnum.REQUEST_METHOD_ERROR));
        }

        // 将请求信息放入exchange中
        Object cachedRequestBodyObject = exchange.getAttributeOrDefault(DmzConstants.REQUEST_INFO_CACHE_KEY, null);
        // 已经缓存，则不做任何处理
        if (ObjectUtil.isNotNull(cachedRequestBodyObject)) {
            return chain.filter(exchange);
        }
        // 如果没有缓存过，获取字节数组存入exchange中
        return DataBufferUtils
                .join(exchange.getRequest().getBody())
                .map(dataBuffer -> {
                    byte[] bytes = new byte[dataBuffer.readableByteCount()];
                    dataBuffer.read(bytes);
                    DataBufferUtils.release(dataBuffer);
                    return bytes;
                }).defaultIfEmpty(new byte[0])
                .doOnNext(bytes ->
                        exchange.getAttributes().put(DmzConstants.REQUEST_INFO_CACHE_KEY, bytes)
                ).then(chain.filter(exchange));
    }

    /**
     * 过滤器执行顺序 越小越先执行
     * @return
     */
    @Override
    public int getOrder() {
        return DmzConstants.CACHE_FILTER_ORDER_NUM;
    }
}
3.1.2 dmz网关全局过滤器,进行请求参数解密转发
package cn.git.dmz.filter;

import cn.git.dmz.constants.DmzConstants;
import cn.git.dmz.util.AESUtil;
import cn.git.dmz.util.LogUtil;
import cn.git.dmz.util.RSAUtil;
import cn.git.dmz.util.ResponseUtil;
import cn.git.foreign.dmz.DmzResult;
import cn.git.foreign.dmz.DmzResultEnum;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.client.methods.HttpPost;
import org.springframework.beans.factory.annotation.Autowired;
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.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.Base64;

/**
 * dmz网关全局过滤器,进行请求参数解密转发
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2021-09-15
 */
@Slf4j
@Component
public class DmzGlobalFilter implements GlobalFilter, Ordered {

    @Autowired
    private LogUtil logUtil;

    @Autowired
    private AESUtil aesUtil;

    @Autowired
    private RSAUtil rsaUtil;

    @Autowired
    private ResponseUtil responseUtil;

    /**
     * 处理过滤逻辑信息
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取请求request以及response信息
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        String uri = request.getPath().pathWithinApplication().value();
        String method = request.getMethod().name();
        log.info("DMZ请求uri为[{}]，请求method为[{}]", uri, method);

        // 方法类型校验必须为 post
        if (!HttpPost.METHOD_NAME.equals(method)) {
            return responseUtil.responseErrorInfo(response, DmzResult.error(DmzResultEnum.REQUEST_METHOD_ERROR));
        }

        // 从exchange中获取body信息
        String normalMessage;
        Object cacheBody = exchange.getAttributeOrDefault(DmzConstants.REQUEST_INFO_CACHE_KEY, null);
        // 删除exchange保存的自定义信息
        exchange.getAttributes().remove(DmzConstants.REQUEST_INFO_CACHE_KEY);
        if (ObjectUtil.isNotNull(cacheBody)) {
            // 解密byte数组
            try {
                byte[] body = (byte[]) cacheBody;
                // 传输数据转字符串
                String bodyInfoStr = new String(body);
                // 请求信息转换为JSON对象,并且获取加密key,以及加密message信息
                JSONObject requestJSON = JSONObject.parseObject(bodyInfoStr);
                String encryptSignature = requestJSON.getString(DmzConstants.REQ_SIGNATURE_KEY);
                String encryptMessage = requestJSON.getString(DmzConstants.REQ_MESSAGE);

                // 对encryptSignature进行RSA解密获取16进制的aesKey
                String decodeHexPassKey = rsaUtil.decryptRSA(encryptSignature, DmzConstants.RSA_PRI_KEY);
                // 将16进制的decodeHexPassKey还原为2进制的aesKey
                byte[] aesBytes = aesUtil.parseHexStrToBytes(decodeHexPassKey);
                log.info("signature解析后为[{}]", Base64.getEncoder().encodeToString(aesBytes));

                // 将message信息进行aes解密
                normalMessage = aesUtil.aesDecrypt(encryptMessage, Base64.getEncoder().encodeToString(aesBytes));
                log.info("AES解密信息为[{}]",normalMessage);
            } catch (Exception e) {
                String errorMessage = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
                log.error("客户端发送数据解析失败,具体信息为: [{}]", errorMessage);
                return responseUtil.responseErrorInfo(response, DmzResult.error(DmzResultEnum.DECRYPT_ERROR));
            }

            // 进行sign验签操作
            JSONObject jsonReqInfo = JSONObject.parseObject(normalMessage);
            if (ObjectUtil.isNotNull(jsonReqInfo)) {
                String dealTime = jsonReqInfo.getString(DmzConstants.DEAL_TIME);
                String sign = jsonReqInfo.getString(DmzConstants.SIGN);
                String sysId = jsonReqInfo.getString(DmzConstants.SYS_ID);

                // 验签标识合法完整性校验
                if (StrUtil.isBlank(dealTime) || StrUtil.isBlank(sign) || StrUtil.isBlank(sysId)) {
                    return responseUtil.responseErrorInfo(response, DmzResult.error(DmzResultEnum.SIGN_VALID_FORMAT_ERROR));
                }

                // 验签校验
                String checkMD5Key = SecureUtil.md5(sysId
                        .concat(DmzConstants.SIGN_SEPARATOR)
                        .concat(dealTime)
                        .concat(DmzConstants.SIGN_SEPARATOR)
                        .concat(DmzConstants.MD5_KEY));
                if (!checkMD5Key.equals(sign)) {
                    return responseUtil.responseErrorInfo(response, DmzResult.error(DmzResultEnum.SIGN_VALID_ERROR));
                }
            }

            // 重新构建新的请求信息
            DataBufferFactory dataBufferFactory = exchange.getResponse().bufferFactory();
            Flux<DataBuffer> bodyFlux = Flux.just(dataBufferFactory.wrap(normalMessage.getBytes()));
            ServerHttpRequest newRequest = request.mutate().uri(request.getURI()).build();
            newRequest = new ServerHttpRequestDecorator(newRequest) {
                @Override
                public Flux<DataBuffer> getBody() {
                    return bodyFlux;
                }
            };

            // 请求头信息优化
            HttpHeaders headers = new HttpHeaders();
            headers.putAll(exchange.getRequest().getHeaders());
            // 由于修改了传递参数，需要重新设置CONTENT_LENGTH，长度是字节长度，不是字符串长度
            int length = normalMessage.getBytes().length;
            headers.remove(HttpHeaders.CONTENT_LENGTH);
            headers.setContentLength(length);
            headers.set(HttpHeaders.CONTENT_TYPE, DmzConstants.APPLICATION_TYPE_JSON);
            newRequest = new ServerHttpRequestDecorator(newRequest) {
                @Override
                public HttpHeaders getHeaders() {
                    return headers;
                }
            };

            return chain.filter(exchange.mutate().request(newRequest).build());
        } else {
            // 无请求信息体返回错误
            return responseUtil.responseErrorInfo(response, DmzResult.error(DmzResultEnum.REQUEST_NO_BODY_ERROR));
        }
    }

    /**
     * 过滤器执行顺序数字小的优先执行
     */
    @Override
    public int getOrder() {
        return DmzConstants.GLOBAL_FILTER_ORDER_NUM;
    }
}
3.1.3 响应filter,没时间写意思意思，看看得了
package cn.git.dmz.filter;

import cn.git.common.constant.CommonConstant;
import cn.git.dmz.constants.DmzConstants;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import cn.hutool.crypto.symmetric.AES;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
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.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpStatus;
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.nio.charset.StandardCharsets;

/**
 * 返回信息加密filter
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2021-09-15
 */
@Component
@Slf4j
public class RespEncryptFilter implements GatewayFilter, Ordered {

    /**
     * AES信息加密解密处理
     */
    private static final AES AES = new
            AES(Mode.ECB, Padding.PKCS5Padding, CommonConstant.DMZ_LOCK_KEY.getBytes(StandardCharsets.UTF_8));

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取响应信息
        ServerHttpResponse dmzResponse = exchange.getResponse();
        DataBufferFactory bufferFactory = dmzResponse.bufferFactory();
        ServerHttpResponseDecorator responseDecorator = new ServerHttpResponseDecorator(dmzResponse) {
            @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(dataBuffer -> {
                        DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
                        DataBuffer join = dataBufferFactory.join(dataBuffer);
                        // 获取数据
                        byte[] content = new byte[join.readableByteCount()];
                        join.read(content);
                        // 释放掉内存
                        DataBufferUtils.release(join);
                        // 获取正常返回的数据,并且进行数据data加密 AES(base64)
                        String rootData = new String(content, StandardCharsets.UTF_8);
                        JSONObject responseJSON = JSONObject.parseObject(rootData);
                        JSONObject data = responseJSON.getJSONObject(CommonConstant.DMZ_DATA_FLAG);

                        if (ObjectUtil.isNotNull(data)) {
                            String encryptBase64 = AES.encryptBase64(data.toString());
                            responseJSON.put(CommonConstant.DMZ_DATA_FLAG, encryptBase64);
                        }
                        byte[] respData = responseJSON.toJSONString().getBytes();
                        // 加密后的数据返回给客户端
                        byte[] uppedContent = new String(respData, StandardCharsets.UTF_8).getBytes();
                        dmzResponse.getHeaders().setContentLength(uppedContent.length);
                        return bufferFactory.wrap(uppedContent);
                    }));
                }
                return super.writeWith(body);
            }
        };
        return chain.filter(exchange.mutate().response(responseDecorator).build());
    }

    @Override
    public int getOrder() {
        return DmzConstants.RESP_ORDER_NUM;
    }

}
3.1.4 网关转发配置

此处dmz网关就简单点，不用像业务模块的业务网关，直接转发，不设置数据库获取，转存redis这种动态路由了，具体代码如下

package cn.git.dmz.config;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 路由信息自动配置类
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2021-09-15
 */
@Configuration
public class DmzGatewayConfig {

    /**
     * 匹配业务网关path信息
     */
    private static final String FOREIGN_PATH = "/dmz/**";

    /**
     * 业务网关注册服务器上名称
     */
    private static final String FOREIGN_SERVER = "lb://foreign-server";

    /**
     * 路径截取长度
     */
    private static final Integer STRIP_PREFIX = 1;

    /**
     * 通用过滤器
     */
    @Autowired
    private RespEncryptFilter respEncryptFilter;

    /**
     * response返回信息加密filter加入到路由中
     * @param builder builder
     * @return RouteLocator
     */
    @Bean
    public RouteLocator appRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route(r -> r.path(FOREIGN_PATH)
                        .filters(f ->
                                // f.filter(respEncryptFilter)
                                f.stripPrefix(STRIP_PREFIX)
                        )
                        .uri(FOREIGN_SERVER)
                ).build();
    }
}
3.1.5 过程中的工具类

AES加密工具

package cn.git.dmz.util;

import cn.git.common.exception.ServiceException;
import cn.git.dmz.constants.DmzConstants;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * @description: AES加解密工具类
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 08:52:41
 */
@Component
@Slf4j
public class AESUtil {

    @Autowired
    private LogUtil logUtil;

    /**
     * 获取随机AES密钥
     * @return 返回加密秘钥
     */
    public SecretKey getRandomKey() {
        // 使用种子生成种子随机秘钥，如果想每一次都生成不同秘钥，则去掉种子即可
        SecureRandom secureRandom = new SecureRandom(DmzConstants.DMZ_LOCK_KEY.getBytes(StandardCharsets.UTF_8));
        // 实例
        KeyGenerator kg = null;
        try {
            kg = KeyGenerator.getInstance(DmzConstants.AES_TYPE);
            // AES
            kg.init(DmzConstants.KEY_SIZE, secureRandom);
            // 生成密钥
            SecretKey secretKey = kg.generateKey();
            return secretKey;
        } catch (NoSuchAlgorithmException e) {
            String errorMsg = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
            log.error(errorMsg);
            throw new ServiceException("获取随机AES密钥失败");
        }
    }

    /**
     * 加密
     *
     * @param content 内容
     * @param randomPassKey     秘钥
     * @return 加密后的数据
     */
    public String aesEncrypt(String content, String randomPassKey) {
        try {
            // 新建Cipher 类
            Cipher cipher = Cipher.getInstance(DmzConstants.AES_MODE);
            // 初始化秘钥
            SecretKeySpec sks = new SecretKeySpec(Base64.getDecoder().decode(randomPassKey), DmzConstants.AES_TYPE);
            // 初始化加密类
            cipher.init(Cipher.ENCRYPT_MODE, sks);
            // 进行加密
            byte[] encrypt = cipher.doFinal(content.getBytes());
            // 进行base64编码
            encrypt = Base64.getEncoder().encode(encrypt);
            // 转成字符串返回
            return new String(encrypt, StandardCharsets.UTF_8);
        } catch (Exception e) {
            String errorMsg = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
            log.error(errorMsg);
            throw new ServiceException("AES加密失败");
        }
    }

    /**
     * AES进行解密数据
     *
     * @param content 解密内容
     * @param randomPassKey aes随机秘钥
     * @return 解密后数据
     */
    public String aesDecrypt(String content, String randomPassKey) {
        try {
            // base64里会携带换行符导致解码失败,替换base64里的换行
            content = content.replaceAll("[\\n\\r]", StrUtil.EMPTY);
            // base64 解码，跟上面的编码对称
            byte[] data = Base64.getDecoder().decode(content.getBytes(StandardCharsets.UTF_8));
            // 新建Cipher 类
            Cipher cipher = Cipher.getInstance(DmzConstants.AES_MODE);
            // 初始化秘钥
            SecretKeySpec keySpec = new SecretKeySpec(Base64.getDecoder().decode(randomPassKey), DmzConstants.AES_TYPE);
            // 初始化类
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
            // 进行AES
            byte[] result = cipher.doFinal(data);
            // 返回解密后内容信息
            return new String(result);
        } catch (Exception e) {
            String errorMsg = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
            log.error(errorMsg);
            throw new ServiceException("AES解密失败");
        }
    }

    /**
     * 将byte数组转换成16进制String
     * @param bytes 转换的byte数组
     * @return 16进制字符串
     */
    public String parseBytesToHexStr(byte[] bytes) {
        StringBuilder stringBuilder = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(b & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            stringBuilder.append(hex.toUpperCase());
        }
        return stringBuilder.toString();
    }


    /**
     * 将16进制String转换为byte数组
     * @param hexStr 16进制字符串
     * @return 2进制byte数组
     */
    public byte[] parseHexStrToBytes(String hexStr) {
        // 空值判断
        if (hexStr.length() < 1) {
            return null;
        }
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / DmzConstants.NUM_2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }
}

RSA加解密工具类

package cn.git.dmz.util;

import cn.git.common.exception.ServiceException;
import cn.git.dmz.constants.DmzConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * @description: RSA加解密工具类
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 08:58:58
 */
@Component
@Slf4j
public class RSAUtil {

    @Autowired
    private LogUtil logUtil;

    /**
     * RSA初始化key pair,初始化公钥私钥方法
     * @return KeyPair
     */
    public KeyPair getRSAKeyPair() {
        try {
            // 生成RSA密钥对
            KeyPairGenerator keyGen = KeyPairGenerator.getInstance(DmzConstants.RSA_TYPE);
            // 根据种子生成秘钥对
            SecureRandom secureRandom = new SecureRandom(DmzConstants.DMZ_LOCK_KEY.getBytes(StandardCharsets.UTF_8));
            keyGen.initialize(DmzConstants.NUM_1024, secureRandom);
            return keyGen.generateKeyPair();
        } catch (Exception e) {
            String errorMsg = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
            log.error(errorMsg);
            throw new ServiceException("RSA初始化keyPairs失败");
        }
    }

    /**
     * RSA加密
     * @param data 待加密数据
     * @param publicKeyStr 公钥
     * @return 加密后的数据
     */
    public String encryptRSA(String data, String publicKeyStr) {
        try {
            byte[] keyBytes = Base64.getDecoder().decode(publicKeyStr);
            // 初始化公钥key
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(DmzConstants.RSA_TYPE);
            PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

            // 使用公钥进行加密
            Cipher encryptCipher = Cipher.getInstance(DmzConstants.RSA_MODE);
            encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] encryptedBytes = encryptCipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            String errorMsg = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
            log.error(errorMsg);
            throw new ServiceException("RSA加密失败");
        }
    }

    /**
     * 进行RSA解密
     * @param content 解密文本
     * @param privateKeyStr 私钥字符串
     * @return
     */
    public String decryptRSA(String content, String privateKeyStr) {
        try {
            byte[] keyBytes = Base64.getDecoder().decode(privateKeyStr);
            // 初始化私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(DmzConstants.RSA_TYPE);
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

            // 使用私钥进行解密
            Cipher decryptCipher = Cipher.getInstance(DmzConstants.RSA_MODE);
            decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] decryptedBytes = decryptCipher.doFinal(Base64.getDecoder().decode(content));
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            String errorMsg = logUtil.getStackTraceInfo(e, DmzConstants.NUM_2000);
            log.error(errorMsg);
            throw new ServiceException("RSA解密失败");
        }
    }

}

日志工具类

package cn.git.dmz.util;

import cn.git.dmz.constants.DmzConstants;
import cn.hutool.core.util.StrUtil;
import org.springframework.stereotype.Component;
import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * @description: 日志通用方法
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 04:21:12
 */
@Component
public class LogUtil {

    /**
     * 打印异常信息转字符串
     *
     * @param exception          异常
     * @param errorMessageLength 打印异常信息长度
     * @return 异常信息
     */
    public String getStackTraceInfo(Exception exception, Integer errorMessageLength) {
        StringWriter stringWriter = new StringWriter();
        PrintWriter printWriter = new PrintWriter(stringWriter);
        try {
            exception.printStackTrace(printWriter);
            printWriter.flush();
            stringWriter.flush();
            String errorMessage = stringWriter.toString();
            if (StrUtil.isNotBlank(errorMessage) && errorMessage.length() > DmzConstants.NUM_3000) {
                errorMessage = errorMessage.substring(DmzConstants.NUM_0, errorMessageLength);
            }
            return errorMessage;
        } finally {
            try {
                printWriter.close();
                stringWriter.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

}

响应信息工具类

package cn.git.dmz.util;

import cn.git.foreign.dmz.DmzResult;
import com.alibaba.fastjson.JSON;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

/**
 * @description: 响应工具类
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 10:15:13
 */
@Component
public class ResponseUtil {

    /**
     * 封装错误信息
     * @param response 相应
     * @param dmzResult 结果
     * @return 封装后的结果
     */
    public Mono<Void> responseErrorInfo(ServerHttpResponse response, DmzResult dmzResult) {
        HttpHeaders httpHeaders = response.getHeaders();
        httpHeaders.add("Content-Type", "application/json; charset=UTF-8");
        httpHeaders.add("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");

        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        DataBuffer bodyDataBuffer = response.bufferFactory().wrap(JSON.toJSONBytes(dmzResult));
        return response.writeWith(Mono.just(bodyDataBuffer));
    }
}

3.2 自服务接收数据编写

自服务接收到的数据已经是解密之后的数据，直接对数据接收内容进行业务转发即可，代码如下

3.2.1 自服务接口入口

实现业务的转发，以及使用简单反射，实例化参数信息，方便后续进行validate校验

package cn.git.foreign.controller;

import cn.git.api.util.NewCoreProperties;
import cn.git.common.exception.ServiceException;
import cn.git.common.thread.ThreadPoolUtil;
import cn.git.common.util.LogUtil;
import cn.git.foreign.dmz.DmzResult;
import cn.git.foreign.dmz.DmzResultEnum;
import cn.git.foreign.dmz.dto.base.LRCBRequestDTO;
import cn.git.foreign.dmz.log.LogDealUtil;
import cn.git.foreign.dmz.tran.base.DmzBaseTran;
import cn.git.foreign.entity.TbEsbNewCoreRecords;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.ConstraintViolationException;
import java.util.Date;

/**
 * @description: 业务并入controller
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-04 09:43:09
 */
@Slf4j
@RestController
@RequestMapping("/lrcb")
public class LRCBWebApplyController {

    /**
     * 业务基础包
     */
    public static final String BASE_VALID_PACKAGE = "cn.git.foreign.dmz.dto.";

    /**
     * dto尾缀
     */
    public static final String SUFFIX_DTO = "DTO";

    /**
     * tran尾缀
     */
    public static final String SUFFIX_TRAN = "Tran";

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private LogDealUtil logDealUtil;

    /**
     * 通用并入接口
     * @param sysId 商户编号，此编号由数字信贷运营人员统一提供
     * @param lrcbRequestDTO 参数信息
     * @return
     */
    @RequestMapping("/service/js/{sysId}")
    public DmzResult serviceJS(@PathVariable(value = "sysId") String sysId, @RequestBody LRCBRequestDTO lrcbRequestDTO) {
        log.info("DMZ网关请求来源为[{}],交易类型为[{}],请求流水号为[{}],具体请求信息为[{}]",
                sysId,
                lrcbRequestDTO.getTranscode(),
                lrcbRequestDTO.getTransno(),
                lrcbRequestDTO.getRequestParams().toJSONString());

        // 获取参数信息,并且对参数信息进行校验
        JSONObject jsonParam = lrcbRequestDTO.getRequestParams();
        if (ObjectUtil.isEmpty(jsonParam)) {
            // 具体业务请求参数为空
            return DmzResult.error(DmzResultEnum.REQUEST_NO_BODY_ERROR, "请求参数为空，请确认!");
        }

        // 交易参数校验
        String transcode = lrcbRequestDTO.getTranscode();
        String transno = lrcbRequestDTO.getTransno();
        String dtoSysId = lrcbRequestDTO.getSysid();
        if (StrUtil.isBlank(transcode) || StrUtil.isBlank(transno) || StrUtil.isBlank(dtoSysId)) {
            // 具体业务请求参数为空
            return DmzResult.error(DmzResultEnum.REQUEST_NO_BODY_ERROR, "通用基础请求参数[sysid,transcode,transno]不全，请确认!");
        }

        // 获取请求参数
        String fullClassName = BASE_VALID_PACKAGE.concat(transcode).concat(SUFFIX_DTO);
        Object reqObject;
        try {
            // 设置流水号以及业务类型
            jsonParam.put("transcode", transcode);
            jsonParam.put("transno", transno);

            // 通过类名获取类类型，再获取参数实例信息
            Class reqClazz = Class.forName(fullClassName);
            reqObject = JSONObject.parseObject(jsonParam.toJSONString(), reqClazz);
        } catch (ClassNotFoundException e) {
            return DmzResult.error(DmzResultEnum.REQUEST_PARAM_TRANSCODE_ERROR);
        }

        // 获取业务执行类名称
        String tranName = transcode.concat(SUFFIX_TRAN);

        // 获取业务执行类
        DmzBaseTran dmzBaseTran;
        try {
            dmzBaseTran = applicationContext.getBean(tranName, DmzBaseTran.class);
        } catch (Exception e) {
            String errorMessage = StrUtil.format("通过[{}]获取请求执行类失败，请确认参数是否正确!", tranName);
            return DmzResult.error(DmzResultEnum.REQUEST_GET_TRAIN_ERROR, errorMessage);
        }

        // 封装日志参数信息
        TbEsbNewCoreRecords tbEsbNewCoreRecords = new TbEsbNewCoreRecords();
        tbEsbNewCoreRecords.setSvcNo(transcode);
        tbEsbNewCoreRecords.setScnNo(transcode);
        tbEsbNewCoreRecords.setRecordId(IdUtil.simpleUUID());
        tbEsbNewCoreRecords.setGloSeqNo(transno);
        tbEsbNewCoreRecords.setLocalBusFlag(null);
        tbEsbNewCoreRecords.setMessageInfo(jsonParam.toJSONString());
        tbEsbNewCoreRecords.setMessageTime(new Date());
        tbEsbNewCoreRecords.setCtime(new Date());
        tbEsbNewCoreRecords.setMessageType(NewCoreProperties.ACCEPT);

        // 执行业务逻辑
        DmzResult dmzResult = null;
        try {
            dmzResult = dmzBaseTran.process(reqObject);
        } catch (ConstraintViolationException e) {
            log.error("DMZ请求参数校验异常,异常信息为[{}]", e.getMessage());
            return dmzResult = DmzResult.error(DmzResultEnum.REQUEST_PARAM_VALID_ERROR, e.getMessage());
        } catch (ServiceException e) {
            // 抛出自定义异常信息
            return dmzResult = DmzResult.error(DmzResultEnum.CUSTOM_TRAIN_ERROR, e.getMessage());
        } catch (Exception e) {
            // 其他异常信息
            String errorMessage = LogUtil.getStackTraceInfo(e);
            log.error("DMZ请求执行异常,流水号[{}]，异常信息为[{}]", transno, errorMessage);
            return dmzResult = DmzResult.error(DmzResultEnum.NORMAL_ERROR, errorMessage);
        } finally {
            // 插入业务执行日志
            DmzResult finalDmzResult = dmzResult;
            ThreadPoolUtil.THREAD_POOL.execute(() -> {
                logDealUtil.addLog(tbEsbNewCoreRecords, finalDmzResult);
            });
        }
        return DmzResult.ok(dmzResult);
    }

}
3.2.2 策略类
package cn.git.foreign.dmz.tran.base;

import cn.git.foreign.dmz.DmzResult;
import javax.validation.Valid;

/**
 * @description: base通用tran接口
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-08 10:10:38
 */
public interface DmzBaseTran<T> {

    /**
     * 通用业务执行方法
     * @param requestParam 参数
     * @return
     */
    DmzResult process(@Valid T requestParam);

}
3.2.3 具体业务执行类

此处对应的@Validated以及@Valid ，可以实现hibernate validate对应的参数校验

package cn.git.foreign.dmz.tran;

import cn.git.common.exception.ServiceException;
import cn.git.foreign.dmz.DmzResult;
import cn.git.foreign.dmz.dto.XDTSW000DTO;
import cn.git.foreign.dmz.tran.base.DmzBaseTran;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;

import javax.validation.Valid;

/**
 * @description: 测试业务逻辑
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-08 10:17:11
 */
@Validated
@Component
public class XDTSW000Tran implements DmzBaseTran<XDTSW000DTO> {

    /**
     * 通用业务执行方法
     *
     * @param requestParam 参数
     * @return
     */
    @Override
    public DmzResult process(@Valid XDTSW000DTO requestParam) {
        // 异常测试
        if (1 == 1) {
            // 执行业务代码
            try {
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            }

            // 业务逻辑异常
            double a = 1 / 0;

            // 自定义异常
            throw new ServiceException("异常测试啦，抛出自定义异常!");
        }
        // 失败返回 DmzResult.error("0XXX", "失败了")
        return DmzResult.ok(requestParam);
    }
}
3.2.4 操作流水记录类

通过流水号记录具体的请求响应信息，方便出问题的时候进行查询

package cn.git.foreign.dmz.log;

import cn.git.api.util.NewCoreProperties;
import cn.git.foreign.dmz.DmzResult;
import cn.git.foreign.entity.TbEsbNewCoreRecords;
import cn.git.foreign.mapper.TbEsbNewCoreRecordsMapper;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @description: dmz日志处理
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-08 03:01:40
 */
@Component
@RequiredArgsConstructor
public class LogDealUtil {

    private final TbEsbNewCoreRecordsMapper tbEsbNewCoreRecordsMapper;

    /**
     * 插入日志信息
     * @param tbEsbNewCoreRecords 请求信息
     * @param dmzResult 响应信息
     */
    public void addLog(TbEsbNewCoreRecords tbEsbNewCoreRecords, DmzResult dmzResult) {
        // 插入请求信息
        if (ObjectUtil.isNotNull(tbEsbNewCoreRecords)) {
            tbEsbNewCoreRecordsMapper.insert(tbEsbNewCoreRecords);

            // 插入响应信息
            if (ObjectUtil.isNotEmpty(dmzResult)) {
                tbEsbNewCoreRecords.setRecordId(IdUtil.simpleUUID());
                tbEsbNewCoreRecords.setMessageTime(new Date());
                tbEsbNewCoreRecords.setMessageType(NewCoreProperties.SEND);
                tbEsbNewCoreRecords.setMessageInfo(JSONObject.toJSONString(dmzResult));
                tbEsbNewCoreRecords.setRspDate(DateUtil.format(new Date(), DatePattern.NORM_DATE_PATTERN));
                tbEsbNewCoreRecords.setCtime(new Date());
                tbEsbNewCoreRecords.setMtime(new Date());
                tbEsbNewCoreRecordsMapper.insert(tbEsbNewCoreRecords);
            }
        }
    }

}
3.2.5 请求参数的实体类

这部分实体就是简单的测试对象类，里面有对应的validate注解。具体如下

package cn.git.foreign.dmz.dto;

import cn.git.foreign.dmz.dto.base.DmzBaseDTO;
import cn.git.foreign.dmz.dto.child.XDTSW000ChildDTO;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.util.List;

/**
 * @description: dmz网关base测试dto
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-08 09:01:29
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class XDTSW000DTO extends DmzBaseDTO {

    /**
     * 名称
     */
    @NotBlank(message = "名称不能为空!")
    private String name;

    /**
     * 年龄
     */
    @NotNull(message = "年龄不能为空!")
    private Integer age;

    /**
     * 身高
     */
    @NotNull(message = "身高不能为空!")
    private Integer tall;

    /**
     * 操作时间
     */
    @Pattern(regexp = "^\\d{4}-\\d{2}-\\d{2}$", message = "日期格式不正确!")
    private String date;

    /**
     * 附属信息
     */
    @Valid
    @NotNull(message = "附属信息不能为空")
    @Size(min = 1, message = "至少有一个附属信息")
    List<XDTSW000ChildDTO> childDTOList;
}

此为银行附属子信息，子信息也支持参数信息校验

package cn.git.foreign.dmz.dto.child;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.NotBlank;

/**
 * @description: 银行附属子信息
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-08 09:58:17
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class XDTSW000ChildDTO {

    /**
     * 银行编号
     */
    @NotBlank(message = "银行编号不能为空!")
    private String bankNum;

    /**
     * 银行名称
     */
    @NotBlank(message = "银行名称不能为空!")
    private String bankName;

}

3.3 网关以及子模块微服务通用类

这部分主要就是响应的结构类型，编写了两个类进行实现具体如下

3.3.1 DmzResult
package cn.git.foreign.dmz;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @description: DMZ响应结果集
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 10:18:16
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DmzResult<T> {

    /**
     * 响应结果
     */
    private T result;

    /**
     * 是否成功
     * true/false
     */
    private boolean issuccess;

    /**
     * 响应编码
     * 0000 成功
     */
    private String rtncode;

    /**
     * 响应消息
     * 交易成功/交易失败
     */
    private String rtnmessage;

    /**
     * 支持信息
     * 请联系服务商
     */
    private String solution;

    /**
     * 构造函数
     */
    private DmzResult(DmzResultEnum dmzResultEnum) {
        this.issuccess = dmzResultEnum.isIssuccess();
        this.rtncode = dmzResultEnum.getRtncode();
        this.rtnmessage = dmzResultEnum.getRtnmessage();
        this.solution = dmzResultEnum.getSolution();
    }

    /**
     * 构造函数
     */
    private DmzResult(DmzResultEnum dmzResultEnum, T data) {
        this.result = data;
        this.issuccess = dmzResultEnum.isIssuccess();
        this.rtncode = dmzResultEnum.getRtncode();
        this.rtnmessage = dmzResultEnum.getRtnmessage();
        this.solution = dmzResultEnum.getSolution();
    }

    /**
     * 构造函数
     */
    private DmzResult(DmzResultEnum dmzResultEnum, String message) {
        this.result = null;
        this.issuccess = dmzResultEnum.isIssuccess();
        this.rtncode = dmzResultEnum.getRtncode();
        this.rtnmessage = message;
        this.solution = dmzResultEnum.getSolution();
    }

    /**
     * 构造函数
     */
    private DmzResult(DmzResultEnum dmzResultEnum, String message, String rtncode) {
        this.result = null;
        this.issuccess = dmzResultEnum.isIssuccess();
        this.rtncode = dmzResultEnum.getRtncode();
        this.rtnmessage = message;
        this.solution = dmzResultEnum.getSolution();
    }

    /**
     * 构造函数
     * @param result 响应结果
     * @param issuccess 是否成功
     * @param rtncode 响应编码
     * @param rtnmessage 响应消息
     */
    private DmzResult(T result, boolean issuccess, String rtncode, String rtnmessage) {
        this.result = result;
        this.issuccess = issuccess;
        this.rtncode = rtncode;
        this.rtnmessage = rtnmessage;
    }

    /**
     * 构造函数
     * @param result 响应结果
     * @param rtncode 响应编码
     * @param rtnmessage 响应消息
     */
    private DmzResult(T result, String rtncode, String rtnmessage) {
        this.result = result;
        this.rtncode = rtncode;
        this.rtnmessage = rtnmessage;
    }

    /**
     * 构造函数
     * @param rtncode 响应编码
     * @param rtnmessage 响应消息
     */
    private DmzResult(String rtncode, String rtnmessage) {
        this.rtncode = rtncode;
        this.rtnmessage = rtnmessage;
        this.solution = "请联系服务商!";
    }


    /**
     * 业务请求成功，返回业务代码和描述信息
     */
    public static DmzResult<Void> ok() {
        return new DmzResult<>(DmzResultEnum.SUCCESS, null);
    }

    /**
     * 业务请求成功，返回业务代码和描述信息
     */
    public static DmzResult<Void> ok(DmzResult dmzResult) {
        return dmzResult;
    }

    /**
     * 业务请求成功，返回业务代码和描述信息，数据
     */
    public static <T> DmzResult<T> ok(T data) {
        return new DmzResult<>(DmzResultEnum.SUCCESS, data);
    }

    /**
     * 业务请求失败
     */
    public static <T> DmzResult<T> error() {
        return new DmzResult<>(DmzResultEnum.NORMAL_ERROR, null);
    }

    /**
     * 业务请求失败，返回错误响应码
     */
    public static <T> DmzResult<T> error(DmzResultEnum dmzResultEnum) {
        return new DmzResult<>(dmzResultEnum);
    }

    /**
     * 业务请求失败，返回错误响应码
     */
    public static <T> DmzResult<T> error(DmzResultEnum dmzResultEnum, String message, String rtncode) {
        return new DmzResult<>(dmzResultEnum, message, rtncode);
    }

    /**
     * 业务请求失败
     */
    public static <T> DmzResult<T> error(String message) {
        return new DmzResult<>(DmzResultEnum.NORMAL_ERROR, message);
    }

    /**
     * 业务请求失败
     */
    public static <T> DmzResult<T> error(String rtncode, String rtnmessage) {
        return new DmzResult<>(rtncode, rtnmessage);
    }

    /**
     * 业务请求失败
     */
    public static <T> DmzResult<T> error(DmzResultEnum dmzResultEnum, String rtnmessage) {
        return new DmzResult<>(dmzResultEnum, rtnmessage);
    }
}
3.3.2 DmzResultEnum
package cn.git.foreign.dmz;

import lombok.Getter;

/**
 * @description: DMZ网关响应enum
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 10:20:51
 */
@Getter
public enum DmzResultEnum {

    /**
     * 交易枚举类型
     */
    SUCCESS(true, "0000", "交易成功!", "交易成功!"),
    NORMAL_ERROR(false, "000X", "代码异常!", "请联系供应商!"),
    DECRYPT_ERROR(false, "000X", "解密入参失败!", "请确认请求信息是否正确!"),
    REQUEST_METHOD_ERROR(false, "0001", "请求方法必须为post方法!", "请确认请求方式!"),
    REQUEST_NO_BODY_ERROR(false, "0002", "请求信息没有请求体!", "请确认请求信息是否正确!"),
    SIGN_VALID_FORMAT_ERROR(false, "0003", "验签请求信息补全!", "请确认请验签请求信息是合法!"),
    SIGN_VALID_ERROR(false, "0004", "验签失败!", "验签失败!"),
    REQUEST_PARAM_VALID_ERROR(false, "0005", "请求参数格式校验失败!", "请求参数格式校验失败!"),
    REQUEST_PARAM_TRANSCODE_ERROR(false, "0006", "transcode解析失败!", "请确认请求参数transcode!"),
    REQUEST_GET_TRAIN_ERROR(false, "0007", "获取TRAN执行类失败!", "请联系供应商!"),
    CUSTOM_TRAIN_ERROR(false, "0008", "自定义异常信息!", "请联系供应商!"),
    ;

    /**
     * 是否成功
     * true/false
     */
    private boolean issuccess;

    /**
     * 响应编码
     * 0000 成功
     */
    private String rtncode;

    /**
     * 响应消息
     * 交易成功/交易失败
     */
    private String rtnmessage;

    /**
     * 支持信息
     * 请联系服务商
     */
    private String solution;

    /**
     * 构造函数
     *
     * @param issuccess
     * @param rtncode
     * @param rtnmessage
     * @param solution
     */
    DmzResultEnum(boolean issuccess, String rtncode, String rtnmessage, String solution) {
        this.issuccess = issuccess;
        this.rtncode = rtncode;
        this.rtnmessage = rtnmessage;
        this.solution = solution;
    }

}

4. 最后测试类

注意，下面的对应的RSA公钥私钥需要自己生成(generatorKey方法即可)，不要用我提供的，我的是乱搞的。。。。。。

package cn.git.foreign;

import cn.git.api.util.NewCoreProperties;
import cn.git.foreign.dmz.dto.base.LRCBRequestDTO;
import cn.git.foreign.dmz.dto.child.XDTSW000ChildDTO;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSONObject;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;

/**
 * @description: 本地业务测试
 * @program: bank-credit-sy
 * @author: lixuchun
 * @create: 2024-01-05 03:11:20
 */
public class SYNSHTest {

    /**
     * 外部系统请求网关加密密匙
     */
    public static final String DMZ_LOCK_KEY = "DMZ:xfxt:wxts==!";

    /**
     * AES
     * 算法名称/加密模式/数据填充方式
     */
    public static String MODE = "AES/ECB/PKCS5Padding";

    /**
     * RSA
     * 算法名称/加密模式/数据填充方式
     */
    private final static String RSA_MODE = "RSA/ECB/PKCS1Padding";

    /**
     * 加密模式
     */
    public static String KEY_ALGORITHM = "AES";

    /**
     * 加密单位长度
     */
    private static final int KEY_SIZE = 128;

    /**
     * 自定义md5key,正常需要与运营人员沟通获取
     */
    public static final String MD5_KEY = "Md5xKey:%#FOr,xoan>2";

    /**
     * RSA公钥
     */
    private static final String RSA_PUB_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCMZ/Q5CIvZjBTLD4sTwxbWYNNZWd7rImD+sAgwOAf+nH1vWN+Qk63iBGQYHzYK5EhSAFqsqX04lsTiJUH42YRJ9yIXUnvd6Osp2JYOXW8WTGgMtfDJp5WzbYzJRxQ0RmJNcfqMcHPVepgpjs2HNj59aTqNPLdiouRSRlh2E0umGwIDAQAB";

    /**
     * RSA私钥
     */
    private static final String RSA_PRI_KEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIxn9DkIi9mMFMsPixPDFtZg01lZ3usiYP6wCDA4B/6cfW9Y35CTreIEZBgfNgrkSFIAWqypfTiWxOIlQfjZhEn3IhdSe93o6ynYlg5dbxZMaAy18MmnlbNtjMlHFDRGYk1x+oxwc9V6mCmOzYc2Pn1pOo08t2Ki5FJGWHYTS6YbAgMBAAECgYEAiQRNNXccmsDz7bGOZEumtrAor/Je8xFKnGCGrR+Q1aw7UHTnPvyO3JiyYUPcBkb+OF+2HPcNhzLCkXoQZltGlznwOwGvHl4qEheVAMwdgijuYQZpsiGQyVyr4C506ydoPjPXbWD+9GGLuakHtIlRP9FAGvwQe/5fkUYsiAJD8mkCQQDop8hxDCrsH9eBQ7PusaGjmW213zmX0O5yAntwuznX3zsQOo+AgeM00ottF4J5BXWCeyF5ZxKi6WoPjSgTw77fAkEAmn6QNwMSEbcWHbuaC3ofjcYhnOl47aQWNr+56G+Wc7vs4xs8PXdd3sVmlepOFSdJLWCxguUBO60Dg6cpnAFMRQJABZLPaHXkKVfx77TRgKxctPCeAjdgx9RHgg+xKVgy4IsGfTMJ8Qgriz5n/KsNgxywXfnZKXFgrupskgbNqPuNfQJAQlOjxnpi/4gCzrED6Xl8onk1ZRA3Ao83mjmlrsx5YyaDBN1kd18PxdwptqLo8tvy5rBkhTWb2erlX1gc3QURoQJABakHaa+GNmKyc7pasJHQ3HMR39k888TQPKEQiE461oc5//Cyqek7u91rCG0HR7O4Hk+ostH9lkxc4bG+HYgWgg==";

    public static void main(String[] args) throws Exception {
        testSYNSH();
    }

    public static void testSYNSH() throws Exception {
        // 公共请求信息
        LRCBRequestDTO lrcbRequestDTO = new LRCBRequestDTO();
        lrcbRequestDTO.setSysid("LOAN");
        lrcbRequestDTO.setTranstime("20230101121212");
        lrcbRequestDTO.setTransno("YDTS202203121122");
        lrcbRequestDTO.setDeviceType("WECHAT");
        lrcbRequestDTO.setTranscode("XDTSW000");

        // 验签规则
        String sign = SecureUtil.md5(lrcbRequestDTO.getSysid().concat("|")
                .concat(lrcbRequestDTO.getTranstime()).concat("|")
                .concat(MD5_KEY));
        lrcbRequestDTO.setSign(sign);

        // 请求参数，此处信息如果XDTSW000DTO配置validate注解，则生效
        JSONObject requestJSON = new JSONObject();
        requestJSON.put("name", "jack");
        requestJSON.put("age", 18);
        requestJSON.put("tall", 185);
        requestJSON.put("date", "2023-12-12");

        // 附属信息，附属信息validate注解同样生效
        List<XDTSW000ChildDTO> childDTOList = new ArrayList<>();
        XDTSW000ChildDTO childDTO = new XDTSW000ChildDTO();
        childDTO.setBankNum("123456789");
        childDTO.setBankName("中国银行");
        childDTOList.add(childDTO);
        requestJSON.put("childDTOList", childDTOList);

        // 组装请求参数
        lrcbRequestDTO.setRequestParams(requestJSON);

        // 中间请求参数
        String reqJSONStr = JSONObject.toJSONString(lrcbRequestDTO);

        // 获取AES随机秘钥
        SecretKey secretKey = getRandomKey();
        String randomKeyStr = Base64.getEncoder().encodeToString(secretKey.getEncoded());
        System.out.println("AES随机密钥 -> : " + randomKeyStr);

        // 请求信息AES随机秘钥加密
        String encryptMessage = encrypt(reqJSONStr, randomKeyStr);

        // secretKey 转换为16进制字符串
        String randomKeyStrHex = parseByte2HexStr(secretKey.getEncoded());
        System.out.println("AES十六进制hexPassKey -> : " + randomKeyStrHex);

        // 16进制字符串进行RSA公钥加密
        System.out.println("RSA公钥为 -> : " + RSA_PUB_KEY);
        String encryptRandomKey = encryptRSA(randomKeyStrHex, RSA_PUB_KEY);
        System.out.println("RSA加密signature为 -> : " + encryptRandomKey);

        // 组装最终请求信息
        JSONObject requestJSONFinal = new JSONObject();
        requestJSONFinal.put("message", encryptMessage);
        requestJSONFinal.put("signature", encryptRandomKey);

        // foreign 11110 / dmz 11301
        String serverUrl = "localhost:11110/lrcb/service/js/LOAN";
        String serverUrl = "localhost:11301/dmz/lrcb/service/js/LOAN";
        String rspJsonStr = HttpUtil.post(serverUrl, requestJSONFinal.toJSONString(), NewCoreProperties.REQ_TIME_OUT);
        System.out.println(rspJsonStr);
    }

    /**
     * 获取密钥
     *
     * @return
     * @throws Exception
     */
    private static SecretKey getRandomKey() throws Exception {
        // 随机数
        SecureRandom secureRandom = new SecureRandom(DMZ_LOCK_KEY.getBytes(StandardCharsets.UTF_8));
        // 实例
        KeyGenerator kg = KeyGenerator.getInstance("AES");
        // AES
        kg.init(KEY_SIZE, secureRandom);
        // 生成密钥
        SecretKey secretKey = kg.generateKey();
        return secretKey;
    }

    /**
     * 将byte数组转换成16进制String
     * @param buf
     * @return
     */
    public static String parseByte2HexStr(byte[] buf) {
        StringBuffer sb = new StringBuffer();
        for (byte b : buf) {
            String hex = Integer.toHexString(b & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制String转换为byte数组
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    /**
     * 加密
     *
     * @param content 内容
     * @param randomPassKey     秘钥
     * @return 加密后的数据
     */
    public static String encrypt(String content, String randomPassKey) throws Exception {
        // 新建Cipher 类
        Cipher cipher = Cipher.getInstance(MODE);
        // 初始化秘钥
        SecretKeySpec sks = new SecretKeySpec(Base64.getDecoder().decode(randomPassKey), KEY_ALGORITHM);
        // 初始化加密类
        cipher.init(Cipher.ENCRYPT_MODE, sks);
        // 进行加密
        byte[] encrypt = cipher.doFinal(content.getBytes());
        // 这一步非必须，是因为二进制数组不方便传输，所以加密的时候才进行base64编码
        encrypt = Base64.getEncoder().encode(encrypt);
        // 转成字符串返回
        return new String(encrypt, StandardCharsets.UTF_8);
    }

    /**
     * 解密数据
     *
     * @param content 内容
     * @param randomPassKey 秘钥
     * @return 数据
     */
    public static String decrypt(String content, String randomPassKey) throws Exception{
        // 替换base64里的换行,这一步也非必须，只是有些情况base64里会携带换行符导致解码失败
        content = content.replaceAll("[\\n\\r]", "");
        // base64 解码，跟上面的编码对称
        byte[] data = Base64.getDecoder().decode(content.getBytes(StandardCharsets.UTF_8));
        // 新建Cipher 类
        Cipher cipher = Cipher.getInstance(MODE);
        // 初始化秘钥
        SecretKeySpec keySpec = new SecretKeySpec(Base64.getDecoder().decode(randomPassKey), KEY_ALGORITHM);
        // 初始化类
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        // 解密
        byte[] result = cipher.doFinal(data);
        // 返回解密后的内容
        return new String(result);
    }


    /**
     * RSA初始化key pair
     * @return KeyPair
     */
    private static KeyPair generatorKey() throws NoSuchAlgorithmException {
        // 生成RSA密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(DMZ_LOCK_KEY.getBytes(StandardCharsets.UTF_8));
        keyGen.initialize(1024, secureRandom);
        KeyPair pair = keyGen.generateKeyPair();
        return pair;
    }

    /**
     * RSA加密
     * @param data 待加密数据
     * @param publicKeyStr 公钥
     * @return 加密后的数据
     */
    private static String encryptRSA(String data, String publicKeyStr) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, UnsupportedEncodingException, BadPaddingException, IllegalBlockSizeException {
        byte[] keyBytes = Base64.getDecoder().decode(publicKeyStr);
        // 初始化公钥key
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

        // 使用公钥进行加密
        Cipher encryptCipher = Cipher.getInstance(RSA_MODE);
        encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedBytes = encryptCipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    /**
     * RSA解密
     * @param data
     * @param privateKeyStr
     * @return
     */
    private static String decryptRSA(String data, String privateKeyStr) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, UnsupportedEncodingException, BadPaddingException, IllegalBlockSizeException {
        byte[] keyBytes = Base64.getDecoder().decode(privateKeyStr);
        // 初始化私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 使用私钥进行解密
        Cipher decryptCipher = Cipher.getInstance(RSA_MODE);
        decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedBytes = decryptCipher.doFinal(Base64.getDecoder().decode(data));
        return new String(decryptedBytes, "UTF-8");
    }

}

参考文章 ：https://blog.csdn.net/zrj00711/article/details/131443408

小大力
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7.Gateway服务网关
01-01
7.Gateway服务网关
Spring Cloud Gateway 服务网关快速实现解析
08-25
Spring Cloud Gateway 服务网关快速实现解析 Spring Cloud Gateway 是 Spring Cloud 微服务平台的一个子项目，属于 Spring 开源社区，依赖名叫：spring-cloud-starter-gateway。它构建于 Spring 5+，基于 Spring ...
SpringCloud-Gateway实现RSA加解密
孟孟的博客
04-08 3266
RSA主要使用大整数分解这个数学难题进行设计，巧妙地利用了数论的概念。给了RSA公钥，首先想到的攻击就是分解模数，给了的因子攻击者可以计算得到，从而也可以计算得到解密指数，我们称这种分解模数的方法为针对RSA的暴力攻击。虽然分解算法已经稳步改进，但是在正确使用RSA情况下，当前的技术水平仍远未对RSA的安全性构成威胁。RSA的公钥和私钥到底哪个才是用来加密和哪个用来解密？- 知乎。
【自研网关系列】数字签名和url动态加密
最新发布
m0_63208096的博客
05-10 589
通过AES对称加密和RSA非对称加密，实现url动态加解密功能
Gateway 接口参数加解密
邪神大人
11-15 3024
Gateway网关加解密接口
gateway网关对请求参数解密/加密
zrj00711的博客
06-28 2199
首先我们要知道服务端和客服端交互的时候，数据是尤为重要的。我们要对数据进行加密的处理。利用的spring clould 网关服务来处理该项业务。
SpringCloud-Gateway网关实现入参统一解密
RHHcainiao的博客
09-14 807
SpringCloud-Gateway网关统一解密参数
gateway接口参数加解密
Echo的博客
10-10 870
上篇介绍了多种加解密的使用本篇主要介绍在gateway网关中使用对参数解密和返回数据进行加密的操作。
第五章Gateway--服务网关
02-24
这样的架构，会存在着诸多的问题：客户端多次请求不同的微服务，增加客户端代码或配置编写的复杂性认证复杂，每个服务都需要独立认证。存在跨域请求，在一定场景下处理相对复杂。上面的这些问题可以借助API网关来...
springboot整合Oauth2,GateWay实现网关登录授权验证
12-14
SpringBoot整合OAuth2和Gateway实现网关登录授权验证是一个复杂而关键的过程，它涉及到现代微服务架构中的安全性设计。OAuth2是一种授权框架，用于保护API并允许第三方应用访问受保护的资源，而Spring Gateway作为...
gateway对参数解密，返回值加密统一处理方法，可用版
qq_34117294的博客
11-05 5494
加密解密Util import com.alibaba.fastjson.JSONObject; import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.io.ByteArrayOutputStream; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.securit.
SpringCloud Gateway API接口加解密
small_to_large的博客
06-02 4055
SpringCloud Gateway API接口报文加解密 GET POST AES/DES/对称/非对称加解密
spring cloud gateway 网关路由转发及request、response的加解密处理
K_Men的博客
09-23 1万+
sygateway的介绍和使用原理请自行查阅和学习，本章内容需在对spring cloud gateway的基本的了解和一定的知识基础上进行的。附上一个可供学习的博文：SpringCloud gateway （史上最全） - 疯狂创客圈 - 博客园 需求场景： 前端对post请求的数据进行加密（主流的加密方式），后端需要解密，将接口的响应数据进行加密返回，前端解密并展示或其他操作等。出于安全性的考虑和可扩展性故使用了网关来做。 涉及到的问题： 1、request的body数据流读取只能读取一次，co
SpringCloud Gateway API接口安全设计（加密 、签名）
程序员高级码农的博客
12-29 466
RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。1973年，在英国政府通讯总部工作的数学家克利福德·柯克斯（Clifford Cocks）在一个内部文件中提出了一个相同的算法，但他的发现被列入机密，一直到1997年才被发表。
springcloud gateway api实现全信道加解密
HY_____YH的博客
08-17 159
get 请求 post请求 put请求 delete请求 白名单除外请求头增加一个加密版本字段，标识当前的加密算法版本：crypto-version: 1.0.0考虑到全局加密，使用AES加密方式性能更高加密字符串：原始数据 > AES加密后的字节数组 > Base64编码处理解密字符串：Base64密文 > AES密文 -> 原始字符串GET url：/app/xx/xx?xx=1 加密处理 秘钥：xxxxxxxxxxxxxxxx 加密文本：{“xx”:1} 密文：xq4YR89LgUs4V5N5
spring gateway 实现全信道加解密
天行健，君子以自强不息；地势坤，君子以厚德载物。
08-21 366
前言：近期在项目中需要对指定请求整个信道进行加解密（防篡改，反拦截），实现整个信道通讯安全，由于不确定后期那些接口可能需要类似处理，最后决定放在网关实现该功能（虽然稍微占用网关的性能，但是能够全局统一处理十分方便，性能方面可以增加配置来解决）。此过程中也踩了些坑，在此记录下来，以便后来人参考；首先我们采用的是GlobalFilter，GlobalFilter是应用于所有路由的特殊过滤器。Globa...
SpringCloudGateway请求/响应拦截，加/解密
热门推荐
灼烧的疯狂
12-22 1万+
前言： 目前就是对请求的request body ，url param 在网关进行拦截、做解密操作，对 response body 做加密操作 这边初期就打算先用非对称加密对请求响应进行处理，后续如果项目开展顺利，再改成HTTPS通信（节约钱、先看项目起得来不了）。翻阅了一些博文，抄袭了一下，自己稍作修改。下面直接上代码了，自己做个记录吧 请求体（request body）拦截 import com.ruoyi.gateway.util.RSACoderUtil; import org.apache.co
spring cloud gateway 对请求参数解密
weixin_52466601的博客
08-23 812
在一些针对数据比较敏感的项目中会对客户端与服务端之间交互的数据进行加密处理。在gateway网关服务中处理此项业务需要如何实现呢？gateway中自定义的filter，可以实现对请求前的处理以及返回后的处理。请求顺序可以这样理解：请求-> 自定义的filter-A -> 自定义的filter-B -> 业务处理 -> 自定义的filter-B -> 自定义的filter-A -> 返回，利用这一特性，我们可以在处理业务代码之前添加对参数的统一解密处理，到达下游服务中的请求则为以及解密后的正常参数了。
spring gateway & 响应加密
jsjqjy的博客
01-17 559
一般情况是，Filter Order 的问题。因为你这个Filter执行的优先级比较低导致被截断。不生效，请看这里，比较详细。
SpringCloud微服务架构笔记（三）
03-18
SpringCloud微服务架构笔记（三）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值