gateway对参数解密，返回值加密统一处理方法，可用版

最新推荐文章于 2024-05-05 20:31:31 发布
最新推荐文章于 2024-05-05 20:31:31 发布
阅读量5.4k 收藏 14
点赞数 2
文章标签： gateway java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34117294/article/details/121167738
版权

加密解密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.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSAEncrypt {
    private static Map<Integer, String> keyMap = new HashMap<Integer, String>();  //用于封装随机产生的公钥与私钥

    public static String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDPaJOEpH+TYNrYoHhVdfxwr5JomM9OTAbC4OuPDEVCGpY9J0OTi2yG8Q2M37c6fm+4+E6vGsfZcimszKNWut/wUQ1YirSCnE7OIilwFuCnwRj+ELvwkG3CYVz9cRAUh8ospdvVwroq56AF04j2r1MgMzB/sJWV5XBWlx9So3xNOwIDAQAB";
    public static String PRIVATE_KEY= "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAM9ok4Skf5Ng2tigeFV1/HCvkmiYz05MBsLg648MRUIalj0nQ5OLbIbxDYzftzp+b7j4Tq8ax9lyKazMo1a63/BRDViKtIKcTs4iKXAW4KfBGP4Qu/CQbcJhXP1xEBSHyiyl29XCuirnoAXTiPavUyAzMH+wlZXlcFaXH1KjfE07AgMBAAECgYB1UHRoSVczuEvwzctio2rXHifU6+IOKmiEoA39Cna+LiWej2/kq68GIKCGdx+/gTaWTDTNTHuP3cf+ynz1GJyC33J6BtWXp4GCv21k/ivGyFdjfX/d89OPn5n1LbImRqh9SgSc5SlvU66K7y5AqBBnI19nrh2XDaENSqHoEU22qQJBAPOYF8ZxwETI21Ntmr0Gz+e9vMP13kRduEA1U/B02LEgYjY8iqT41+4DEmQA1FNqe13GuIdI0P/RgB7zMceWlk0CQQDZ+LTJNUg2/NygMyjzm854Ru6IIrS6s2YaYEeD1Ejka/RWn4BO4CR0hVIzx4hkwUcusNOy+EzZBer5w0oyc8WnAkEAuviPryraeDFvXz7umY5kAC07eXH7s5/375i/H/6f4HzJxXV8uZmjK7ZB5G5aithdbqI8OuKiQOkOHTNvjxG/tQJBAMgNKDfHDDlTiFYLvlkfNbdUOpZ9a+wyvNIWbWyDyEbFAeMCzusVcr/yoMhfKEJ41ZD3v8RxeW5xrQCAiTeW498CQQC3gCZwMzG/laJwVnCQtychXg82r+93Lz4SxsMBQ7ygWMrqQN8WB0JtAt1f2DwoDDPR8PDDrv5KiAGxjMrzgA1O";

    private static final String ALGORITHM = "RSA";
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    public static void main(String[] args) throws Exception {
        //生成公钥和私钥
//        genKeyPair();
//        //加密字符串
//        //String message = "df723820";
        Map<String, Object> map = new HashMap<String, Object>();
        //map.put("username", "13019352001");
        //map.put("password", MD5Utils.md5Hex("123456".getBytes()));
        map.put("userId", 1);
        JSONObject json = new JSONObject(map);
        String messageEn = encrypt(JSONObject.toJSONString(json),PUBLIC_KEY);
        System.out.println(messageEn + "\t加密后的字符串为:" + messageEn);
        String messageDe = decrypt(messageEn,PRIVATE_KEY);
        System.out.println("还原后的字符串为:" + messageDe);


//        User user = new User();
//        user.setUserName("13019352002");
//        user.setPassword("123456");
//        user.setSex("1");
//        JSONObject.toJSONString(user);

//        Map<String, Object> map = new HashMap<String, Object>();
//        map.put("pageNum", 1);
//        map.put("pageSize", 10);
//        JSONObject json = new JSONObject(map);

//        String messageEn = encrypt(JSONObject.toJSONString(json),PUBLIC_KEY);
//        System.out.println(messageEn + "\t加密后的字符串为:" + messageEn);

//        String messageEn = "yS/8tswgmAXuPoW0jtzjVvQXuou+PZ7FSQ+nm/LYd3ExNKngcaDLLiCqUl4kETlAGBWcDyNaMbL0FP4IxwwmyizHCgt0Kp5ldkj3SVkOKora1PSA88LKPxXwpFJPm/z/4MTVM+0TfmeTdIXacK21DSXLfbzblqvoDuETBSDZNQVVhQKOmL62Ou1Jepakoc2pstsJq1AoSVmOPOmiKNWUGxj8UzLkR/blX71QVhA/k348zISYK+2X7Q3hyfkYL9xuDk5OfrdWi62BfOLp3hO2RbGW7Yd8TLjx/gfXfLHAMKlytsuR/ePt5s/bsl96eeKgmB9Ba/B4zI0MB0nb7Rf/naEJkEAUENu3vbNbnYjNdUhUxygzyn5T9GhHom0gvhEu/XTlUAlwQba3OL8ZInlbGoZhu5Pc1rP+OTJOGt3gYRIathT54MLbxBSm7JSAZkvfABe2cc8+AH/scJzOkUhpSbs3VJdFxcgWIKdjveDrvGA8u0bzNz/KNd1ARcOYZJrCx/SMiu8XoW0ilbc+0HfoYmSqhhYzbnYkYCH8uberwi7pA7RzNp46UNEBnqUpDZ2thQ9Xk8Z6/FiYglggIbpV6Szp/fOHsENEgrv3gfmAjltMTnoNdTXZSrirg5GXyn14koZW52tg/Zty0NO4xuD6aLLiXX42mhhiPniz5axrxCA=";
//        String messageDe = decrypt(messageEn,PRIVATE_KEY);
//        System.out.println("还原后的字符串为:" + messageDe);
    }

    /**
     * 随机生成密钥对
     * @throws NoSuchAlgorithmException
     */
    public static void genKeyPair() throws NoSuchAlgorithmException {
        // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        // 初始化密钥对生成器，密钥大小为96-1024位
        keyPairGen.initialize(1024,new SecureRandom());
        // 生成一个密钥对，保存在keyPair中
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公钥
        String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
        // 得到私钥字符串
        String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));
        // 将公钥和私钥保存到Map
        keyMap.put(0,publicKeyString);  //0表示公钥
        keyMap.put(1,privateKeyString);  //1表示私钥
    }
    /**
     * RSA公钥加密
     *
     * @param input
     *            加密字符串
     * @param rsaPublicKey
     *            公钥
     * @return 密文
     * @throws Exception
     *             加密过程中的异常信息
     */
    public static String encrypt( String input, String rsaPublicKey ) throws Exception{
        byte[] decoded = Base64.decodeBase64(rsaPublicKey);
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
        //RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        byte[] data = input.getBytes();

        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(decoded);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        Key key = keyFactory.generatePublic(x509EncodedKeySpec);
        // 加密数据，分段加密
        int inputLength = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offset = 0;
        byte[] cache;
        int i = 0;
        while (inputLength - offset > 0) {
            if (inputLength - offset > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offset, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offset, inputLength - offset);
            }
            out.write(cache, 0, cache.length);
            i++;
            offset = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return Base64.encodeBase64String(encryptedData);
    }

    /**
     * RSA私钥解密
     *
     * @param str
     *            加密字符串
     * @param privateKey
     *            私钥
     * @return 铭文
     * @throws Exception
     *             解密过程中的异常信息
     */
    public static String decrypt(String str, String privateKey) throws Exception{
        // 得到私钥
        byte[] data = Base64.decodeBase64(str.getBytes("UTF-8"));
        byte[] decoded = Base64.decodeBase64(privateKey);
        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));

        // 解密数据，分段解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        int inputLength = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offset = 0;
        byte[] cache;
        int i = 0;
        byte[] tmp;
        Integer MAX_DECRYPT_BLOCK = 128;
        while (inputLength - offset > 0) {
            if (inputLength - offset > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(data, offset, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offset, inputLength - offset);
            }
            out.write(cache);
            i++;
            offset = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        String result = new String(decryptedData);
        return result;
    }
}

gateway请求参数统一处理

postman

Content-Type:application/x-www-form-urlencoded

参数例如：

请求参数解密拦截器

import com.ruoyi.common.core.constant.CacheConstants;
import com.ruoyi.gateway.Utils.GatewayContext;
import com.ruoyi.gateway.Utils.RSAEncrypt;
import io.netty.buffer.ByteBufAllocator;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.cloud.gateway.support.DefaultServerRequest;
import org.springframework.core.Ordered;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.core.io.buffer.NettyDataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;

/**
 * 网关鉴权
 * 
 * @author ruoyi
 */
@Component
public class ReqEncryptRequestFilter implements GlobalFilter, Ordered
{
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();

        // TODO 如果请求的后台管理系统，则直接放行，不做加解密处理

        if (request.getMethod() != HttpMethod.POST && request.getMethod() != HttpMethod.PUT && request.getMethod() != HttpMethod.PATCH) {
            // 如果不是post（新增）、put（全量修改）、patch（部分字段修改）操作，则直接放行
            return chain.filter(exchange);
        }
        // 对增/改操作，实现入参解密操作
        return operationExchange(exchange, chain);
    }

    @Override
    public int getOrder() {
        return Integer.MIN_VALUE;
    }

    private Mono<Void> operationExchange(ServerWebExchange exchange, GatewayFilterChain chain) {

        // 缓存请求路径
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getPath().pathWithinApplication().value();
        GatewayContext gatewayContext = new GatewayContext();
        gatewayContext.setPath(path);
        // 保存网关上下文到exchange中
        exchange.getAttributes().put(GatewayContext.CACHE_GATEWAY_CONTEXT, gatewayContext);

        HttpHeaders headers = request.getHeaders();
        MediaType contentType = headers.getContentType();

        Mono<Void> voidMono = null;
        if (MediaType.APPLICATION_JSON.equals(contentType) || MediaType.APPLICATION_JSON_UTF8.equals(contentType)) {
            // 对applicationjson类型数据做解密操作
            voidMono = readBody(exchange, chain);
        }
        if (MediaType.APPLICATION_FORM_URLENCODED.equals(contentType)
                || (contentType != null && contentType.toString().startsWith(MediaType.MULTIPART_FORM_DATA_VALUE)) ) {
            // form data
            voidMono = readFormData(exchange, chain, gatewayContext);
        }
        if(voidMono == null){
            voidMono = chain.filter(exchange);
        }
        return voidMono;
    }

    private Mono<Void> readFormData(
            ServerWebExchange exchange,
            GatewayFilterChain chain,
            GatewayContext gatewayContext) {
        final ServerHttpRequest request = exchange.getRequest();
        HttpHeaders headers = request.getHeaders();
        String userid = headers.getFirst("token");

        return exchange.getFormData()
                .doOnNext(multiValueMap -> {
                    gatewayContext.setFormData(multiValueMap);
                })
                .then(Mono.defer(() -> {
                    Charset charset = headers.getContentType().getCharset();
                    charset = charset == null ? StandardCharsets.UTF_8 : charset;
                    String charsetName = charset.name();
                    MultiValueMap<String, String> formData =
                            gatewayContext.getFormData();
                    /** formData is empty just return */
                    if (null == formData || formData.isEmpty()) {
                        return chain.filter(exchange);
                    }
                    StringBuilder formDataBodyBuilder = new StringBuilder();
                    String entryKey;
                    List<String> entryValue;
                    try {
                        /* repackage form data */
                        for (Map.Entry<String, List<String>> entry : formData
                                .entrySet()) {
                            entryKey = entry.getKey();
                            entryValue = entry.getValue();
                            if (entryValue.size() > 1) {
                                for (String value : entryValue) {
                                    formDataBodyBuilder.append(entryKey).append("=")
                                            .append(
                                                    URLEncoder.encode(value, charsetName))
                                            .append("&");
                                }
                            } else {
                                formDataBodyBuilder
                                        .append(entryKey).append("=").append(URLEncoder
                                        .encode(decodeBody(entryValue.get(0)), charsetName))
                                        .append("&");
                            }
                        }
                    } catch (UnsupportedEncodingException e) {
                        // ignore URLEncode Exception
                    }
                    /* substring with the last char '&' */
                    String formDataBodyString = "";
                    if (formDataBodyBuilder.length() > 0) {
                        formDataBodyString = formDataBodyBuilder.substring(0,
                                formDataBodyBuilder.length() - 1);
                    }

                    // date data bytes
                    byte[] bodyBytes = formDataBodyString.getBytes(charset);
                    int contentLength = bodyBytes.length;
                    ServerHttpRequestDecorator decorator =
                            new ServerHttpRequestDecorator(
                                    request) {

                                @Override
                                public HttpHeaders getHeaders() {
                                    HttpHeaders httpHeaders = new HttpHeaders();
                                    httpHeaders.putAll(super.getHeaders());
                                    httpHeaders.set(CacheConstants.DETAILS_USER_ID, userid);
                                    if (contentLength > 0) {
                                        httpHeaders.setContentLength(contentLength);
                                    } else {
                                        httpHeaders.set(HttpHeaders.TRANSFER_ENCODING,
                                                "chunked");
                                    }
                                    return httpHeaders;
                                }

                                @Override
                                public Flux<DataBuffer> getBody() {
                                    return DataBufferUtils
                                            .read(new ByteArrayResource(bodyBytes),
                                                    new NettyDataBufferFactory(
                                                            ByteBufAllocator.DEFAULT),
                                                    contentLength);
                                }
                            };
                    ServerWebExchange mutateExchange =
                            exchange.mutate().request(decorator).build();
                    return chain.filter(mutateExchange);
                }));
    }

    private Mono<Void> readBody(ServerWebExchange exchange, GatewayFilterChain chain) {
        final ServerHttpRequest request = exchange.getRequest();
        MediaType mediaType = request.getHeaders().getContentType();
        // 修改响应体
        ServerRequest serverRequest = new DefaultServerRequest(exchange);
        Mono<String> modifiedBody = serverRequest.bodyToMono(String.class)
                .flatMap(body -> {
//				if (MediaType.APPLICATION_JSON.isCompatibleWith(mediaType)) {
//					// 拿到公钥加密后的数据
//					return Mono.just(decodeBody(body));
//				}
//				return Mono.empty();
                    // TODO 加解密暂未联调，先屏蔽掉
                    return Mono.just(body);
                });
        BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
        HttpHeaders headers = new HttpHeaders();
        headers.putAll(request.getHeaders());
        headers.remove(HttpHeaders.CONTENT_LENGTH);
        CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
        return bodyInserter.insert(outputMessage, new BodyInserterContext())
                .then(Mono.defer(() -> {
                    ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(
                            request) {
                        @Override
                        public HttpHeaders getHeaders() {
                            long contentLength = headers.getContentLength();
                            HttpHeaders httpHeaders = new HttpHeaders();
                            httpHeaders.putAll(super.getHeaders());
                            if (contentLength > 0) {
                                httpHeaders.setContentLength(contentLength);
                            } else {
                                httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                            }
                            return httpHeaders;
                        }

                        @Override
                        public Flux<DataBuffer> getBody() {
                            return outputMessage.getBody();
                        }
                    };
                    return chain.filter(exchange.mutate().request(decorator).build());
                }));
    }

    private String decodeBody(String body){
        // 拿到公钥加密后的数据
        String newBoday = null;
        try {
            newBoday = RSAEncrypt.decrypt(body,RSAEncrypt.PRIVATE_KEY);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return newBoday;
    }

}

返回参数加密处理：

import com.alibaba.fastjson.JSONObject;
import com.ruoyi.gateway.Utils.RSAEncrypt;
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.core.io.buffer.DefaultDataBufferFactory;
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.Charset;

/**
 * 网关鉴权
 * 
 * @author ruoyi
 */
@Component
public class ReqFilter implements GlobalFilter, Ordered {

    private int order;
    // 设置到 exchange.getAttributes()中的key
    public final static String CACHED_REQUEST_BODY_OBJECT_KEY = "CACHED_REQUEST_BODY_OBJECT_KEY";

    // 设置到 exchange.getAttributes()中的key
    public final static String BG_DEBUG_KEY = "BG_DEBUG";

    // 请求参数，返回参数 加密
    public final static String REQ_RES_ENCRYPT = "0";

    // 请求参出，返回结果 无需加密
    public final static String REQ_RES_NALMORE = "1";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String bgDebug = exchange.getAttributeOrDefault(BG_DEBUG_KEY, REQ_RES_ENCRYPT);

        ServerHttpResponse originalResponse = exchange.getResponse();
        DataBufferFactory bufferFactory = originalResponse.bufferFactory();
        ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) {
            @Override
            public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
                if (body instanceof Flux) {
                    Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) 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);
                        // 正常返回的数据
                        String rootData = new String(content, Charset.forName("UTF-8"));
                        byte[] respData = rootData.getBytes();

                        if(REQ_RES_ENCRYPT.equals(bgDebug)){
                            // 对数据进行加密
                            String randomKey = RSAEncrypt.PUBLIC_KEY;
                            String encryptData = null;
                            try {
                                encryptData = RSAEncrypt.encrypt(rootData, randomKey);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            String encryptRandomKey = "999";
                            JSONObject json = new JSONObject();
                            json.put("k", encryptRandomKey);
                            json.put("v", encryptData);
                            respData = json.toJSONString().getBytes();
                        }

                        // 加密后的数据返回给客户端
                        byte[] uppedContent = new String(respData, Charset.forName("UTF-8")).getBytes();
                        return bufferFactory.wrap(uppedContent);
                    }));
                }
                return super.writeWith(body);
            }
        };
        return chain.filter(exchange.mutate().response(decoratedResponse).build());
    }

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

无聊散人吃吃吃
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
详解SpringCloud Finchley Gateway 统一异常处理
08-26
主要介绍了详解SpringCloud Finchley Gateway 统一异常处理，非常具有实用价值，需要的朋友可以参考下
edgar615#api-gateway#参数校验1
07-25
检查API的URL查询字符串配置name 表示参数名default_value 表示如果调用方没有指定参数值时使用的默认值rules 用来定义参数的各种校验规则
gateway对参数解密，返回值解密统一处理方法，实际验证可用
qq_30983505的博客
05-21 4372
Gateway全局参数解密返回值加密： 项目中前端传入参数是解密的，所以在网关处要统一对加密参数解密，在转发到对应的微服务 请求参数解密统一处理： Req拦截器中处理方法： 把这个方法里处理解密的Util类改成你自己的，我这里contentType约定是Json，你如果用其他的类型，自己改下MediaType.APPLICATION_JSON.： @Component @Slf4j public class ReqFilter implements GlobalFilter, Ordered {
JAVA开发（通过网关gateway过滤器进行返回结果加密）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
04-17 1148
在对C的网站或者APP后端接口中，参数的传输往往需要加密传输。这时我们 可以通过springcloud的网关过滤器进行统一的控制。
[Spring Cloud] (6)gateway整体加解密
一个喜欢什么都研究一下的小小后端程序员
05-05 831
Spring Cloud Gateway的加解密功能为分布式系统提供了一个安全、高效、灵活的数据传输解决方案，有助于提升系统的安全性和开发效率。像数据接口，发送的参数是加密数据，接收到的都是是加密数据。但是经过前后端的拦截器处理之后，显示出的依然是正常数据。在经历前面6章的铺垫下，终于进入到了最重要的环节——拦截器功能实现，此时我们需要看的东西就比较集中而且简单了。本文网关gateway，微服务，vue已开源到gitee。像不需要加密的接口，请求参数与响应数据都是未加密的。
gateway网关对请求参数解密/加密
zrj00711的博客
06-28 2120
首先我们要知道服务端和客服端交互的时候，数据是尤为重要的。我们要对数据进行加密的处理。利用的spring clould 网关服务来处理该项业务。
简单例子gateway网关加密解密子服务分发请求
qq_19342829的博客
01-17 756
简单例子gateway网关加密解密子服务分发请求，子服务参数校验，以及业务简单分发功能
SpringCloud Gateway API接口加解密
small_to_large的博客
06-02 4008
SpringCloud Gateway API接口报文加解密 GET POST AES/DES/对称/非对称加解密
gateway接口参数加解密
Echo的博客
10-10 847
上篇介绍了多种加解密的使用本篇主要介绍在gateway网关中使用对参数解密和返回数据进行加密的操作。
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全局异常处理的方法详解
08-26
主要给大家介绍了关于Spring Cloud Gateway全局异常处理的相关资料,需要的朋友可以参考下
502 bad gateway是什么意思 502 bad gateway错误解决方法
01-20
成功解决502 Bad Gateway错误 今天登陆博客，显示502 bad gateway，NGINX最烦人的地方就是经常会出现这个错误，由于我并不打算在技术上花费过多的时间，所以一般是遇到了相关问题，通过搜索引擎解决后即可，不会去...
nginx 504 Gateway Time-out错误解决方法
01-10
一般看来, 这种情况可能是由于nginx默认的fastcgi进程响应的缓冲区太小造成的, 这将导致fastcgi进程被挂起, 如果你的fastcgi服务对这个挂起处理的不好, 那么最后就极有可能导致504 Gateway Time-out 现在的网站, ...
SpringCloud-Gateway网关实现入参统一解密
RHHcainiao的博客
09-14 777
SpringCloud-Gateway网关统一解密参数
后端Gateway对接口参数统一加解密基于过滤器
weixin_46196153的博客
10-11 378
首先准备工具类：需要加解密的接口预热工具准备就绪开始编写gateway的全局拦截器：2. 接口入参body数据解密3.因为body只能读取一次，所以需要再写个全局过滤器 解决body流重复获取。
spring cloud gateway 网关路由转发及request、response的加解密处理
K_Men的博客
09-23 1万+
sygateway的介绍和使用原理请自行查阅和学习，本章内容需在对spring cloud gateway的基本的了解和一定的知识基础上进行的。附上一个可供学习的博文：SpringCloud gateway （史上最全） - 疯狂创客圈 - 博客园 需求场景： 前端对post请求的数据进行加密（主流的加密方式），后端需要解密，将接口的响应数据进行加密返回，前端解密并展示或其他操作等。出于安全性的考虑和可扩展性故使用了网关来做。 涉及到的问题： 1、request的body数据流读取只能读取一次，co
SpringCloud-Gateway统一处理返回参数，代码请直接复制粘贴
NameLoadingFailed的博客
12-02 5735
说明： SpringCloud-Gateway是基于webflux框架的(响应式编程WEB框架)，就导致不能用正常的springMVC获取httpServletResponse返回值方法来统一获取返回值，所以本文就针对解决此问题 注意: 1.如果返回不是json的话（一般项目都是JSON），就不要转为json，是什么格式就用什么格式解析 2.代码中"//TODO" 标记的地方，即可对返回值进行统一处理，也可以拿到gatewayContext（gatewayContext可以看我这篇博文） 3.代码形式如此，
SpringCloud Gateway 对返回参数加密
weixin_52466601的博客
08-23 563
刚做完请求数据加密，测试反馈说还需要做返回数据加密，那就做呗。返回数据加密也主要用到 GlobalFilter全局过滤器和 Ordered。
Gateway 接口参数加解密
邪神大人
11-15 2998
Gateway网关加解密接口
springcloudgateway统一处理异常
最新发布
06-14
Spring Cloud Gateway 是一个高性能且轻量级的 API 网关，它是 Spring Cloud 家族的一员，用于路由、过滤和服务发现。在 Gateway 中，异常处理是一个关键功能，它可以帮助你在全局层面上捕获和处理请求过程中可能出现的各种错误。 在 Spring Cloud Gateway 中，你可以使用全局错误处理器（Global Error Handler）来统一处理所有未被路由到其他服务的异常。这样，即使内部微服务发生异常，用户也会看到一致的错误响应，而不是直接暴露服务内部的错误。 以下是实现统一异常处理的基本步骤： 1. 配置全局错误处理器：在 `application.yml` 或 `application.properties` 文件中添加全局异常处理器的配置，例如： ```yaml error: path: /error handler: exception: my.error.handler ``` 2. 创建全局错误处理器类：定义一个实现了 `ReactiveErrorWebExceptionHandler` 或其子类的类，并实现 `handle` 方法处理不同类型的错误。 ```java @Bean public GlobalErrorExceptionHandler myErrorHandler() { return new MyErrorExceptionHandler(); } public class MyErrorExceptionHandler implements ReactiveErrorWebExceptionHandler { @Override public Mono<ServerResponse> handle(ServerRequest request, Throwable ex) { // 这里可以根据异常类型、状态码等返回定制化的错误响应 return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR) .bodyValue("An unexpected error occurred: " + ex.getMessage()); } } ``` 3. 异常处理策略：你可以选择只处理特定类型的异常，或者使用 `@ExceptionHandler` 注解来处理特定的 HTTP 状态码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值