• SpringCloud-Gateway网关实现入参统一解密

    1.添加依赖

    剩下的依赖自行添加...

    1.     <dependency>
    2.             <groupId>org.springframework.cloud</groupId>
    3.             <artifactId>spring-cloud-starter-gateway</artifactId>
    4.         </dependency>

    2.创建配置文件

    这里我使用了Nacos，使用时需要添加Nacos依赖 及配置gateway路由配置

    1. server:
    2.   port: 8080
    3.  
    4. spring:
    5.   application:
    6.     name: gateway-service
    7.   cloud:
    8.     nacos:
    9.       discovery:
    10.         server-addr: 127.0.0.1:8848
    11.       config:
    12.         server-addr: 127.0.0.1:8848
    13.         file-extension: yaml
    14.     gateway:
    15.       discovery:
    16.         locator:
    17.           enabled: true
    18.       routes:
    19.         - id: testservice
    20.           uri: lb://testservice
    21.           predicates:
    22.             - Path=/test/**
    23.           filters:
    24.            - RequestSign

    3.过滤器

    直接看代码

    1. import com.alibaba.fastjson.JSONObject;
    2. import com.example.itvcommoncore.commonUtils.AESCoder;
    3. import io.netty.buffer.ByteBufAllocator;
    4. import org.springframework.core.io.buffer.NettyDataBufferFactory;
    5. import org.springframework.http.HttpHeaders;
    6. import org.springframework.http.MediaType;
    7. import org.springframework.http.server.reactive.ServerHttpRequest;
    8. import lombok.SneakyThrows;
    9. import org.slf4j.Logger;
    10. import org.slf4j.LoggerFactory;
    11. import org.springframework.cloud.gateway.filter.GatewayFilter;
    12. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    13. import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
    14. import org.springframework.core.Ordered;
    15. import org.springframework.core.io.buffer.DataBuffer;
    16. import org.springframework.http.HttpMethod;
    17. import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
    18. import org.springframework.stereotype.Component;
    19. import org.springframework.util.MultiValueMap;
    20. import org.springframework.web.server.ServerWebExchange;
    21. import org.springframework.web.util.UriComponentsBuilder;
    22. import reactor.core.publisher.Flux;
    23. import reactor.core.publisher.Mono;
    24.  
    25. import java.net.URI;
    26. import java.net.URLDecoder;
    27. import java.net.URLEncoder;
    28. import java.nio.CharBuffer;
    29. import java.nio.charset.StandardCharsets;
    30. import java.util.ArrayList;
    31. import java.util.List;
    32. import java.util.concurrent.atomic.AtomicReference;
    33.  
    34.  
    35. @Component
    36. public class RequestSignGatewayFilterFactory extends AbstractGatewayFilterFactory {
    37.  
    38.     private static final Logger log = LoggerFactory.getLogger(RequestSignGatewayFilterFactory.class);
    39.  
    40.     @Override
    41.     public GatewayFilter apply(Object config) {
    42.         return  new RequestSignGatewayFilter();
    43.     }
    44.  
    45.  
    46.     public class RequestSignGatewayFilter implements GatewayFilter, Ordered {
    47.         @SneakyThrows
    48.         @Override
    49.         public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    50.             ServerHttpRequest request = exchange.getRequest();
    51.             String decryptedParam ="";
    52.             if( exchange.getRequest().getMethod().matches(String.valueOf(HttpMethod.GET))){
    53.                 MultiValueMap queryParams = exchange.getRequest().getQueryParams();
    54.                 log.warn("request GET param :{}", queryParams.toString());
    55.                 decryptedParam=queryParams.getFirst("REQUEST");
    56.                 String decryptedValue = decrypt(decryptedParam);
    57.                 // 编码参数值
    58.                 String encodedDecryptedParam = URLEncoder.encode(decryptedValue, StandardCharsets.UTF_8);
    59.                 // 构建修改后的URI
    60.                 URI modifiedUri = UriComponentsBuilder.fromUri(exchange.getRequest().getURI())
    61.                         .replaceQueryParam("REQUEST", encodedDecryptedParam)
    62.                         .build(true)
    63.                         .toUri();
    64.                 // 修改请求，设置新的URI
    65.                 ServerHttpRequest modifiedRequest = exchange.getRequest().mutate()
    66.                         .uri(modifiedUri)
    67.                         .build();
    68.                 // 用修改后的请求继续处理请求链
    69.                 return chain.filter(exchange.mutate().request(modifiedRequest).build());
    70.             }else {
    71.                 //获取请求体数据
    72.                 AtomicReference requestBody = new AtomicReference<>("");
    73.                 RecorderServerHttpRequestDecorator requestDecorator = new RecorderServerHttpRequestDecorator(request);
    74.                 Flux body = requestDecorator.getBody();
    75.                 body.subscribe(buffer -> {
    76.                     CharBuffer charBuffer = StandardCharsets.UTF_8.decode(buffer.asByteBuffer());
    77.                     requestBody.set(charBuffer.toString());
    78.                 });
    79.                 //我这里是用request=参数  格式
    80.                 String decode = URLDecoder.decode(requestBody.get());
    81.                 String param = decode.replace("REQUEST=", "");
    82.                 log.warn("request POST param :{}",decode);
    83.                 decryptedParam=param;
    84.                 //解密的方法
    85.                 String decryptedValue = decrypt(decryptedParam);
    86.                 //编码参数值
    87.                 String encodedDecryptedParam = URLEncoder.encode(decryptedValue, StandardCharsets.UTF_8);
    88.                 //拼接新的请求体
    89.                 String str="REQUEST="+encodedDecryptedParam;
    90.                 DataBuffer bodyDataBuffer = stringBuffer(str);
    91.                 //添加到请求体
    92.                 Flux bodyFlux = Flux.just(bodyDataBuffer);
    93.                 MediaType contentType = request.getHeaders().getContentType();
    94.                 ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(
    95.                         exchange.getRequest()) {
    96.                     @Override
    97.                     public HttpHeaders getHeaders() {
    98.                         //重新设置请求头
    99.                         HttpHeaders httpHeaders = new HttpHeaders();
    100.                         int length = str.getBytes().length;
    101.                         httpHeaders.putAll(super.getHeaders());
    102.                         httpHeaders.remove(HttpHeaders.CONTENT_TYPE);
    103.                         httpHeaders.remove(HttpHeaders.CONTENT_LENGTH);
    104.                         httpHeaders.setContentLength(length);
    105.                         httpHeaders.set(HttpHeaders.CONTENT_TYPE, contentType.toString());
    106.                         // 设置CONTENT_TYPE
    107.                         return httpHeaders;
    108.                     }
    109.                     @Override
    110.                     public Flux getBody() {
    111.                         return bodyFlux;
    112.                     }
    113.                 };
    114.                 return chain.filter(exchange.mutate().request(mutatedRequest).build());
    115.  
    116.             }
    117.         }
    118.  
    119.         @Override
    120.         public int getOrder() {
    121.             return 2;
    122.         }
    123.     }
    124.  
    125.     /**
    126.      * 转换参数的方法
    127.      * @param value
    128.      * @return
    129.      */
    130.     protected DataBuffer stringBuffer(String value) {
    131.         byte[] bytes = value.getBytes(StandardCharsets.UTF_8);
    132.         NettyDataBufferFactory nettyDataBufferFactory = new NettyDataBufferFactory(ByteBufAllocator.DEFAULT);
    133.         DataBuffer buffer = nettyDataBufferFactory.allocateBuffer(bytes.length);
    134.         buffer.write(bytes);
    135.         return buffer;
    136.     }
    137.  
    138.     /**
    139.      * 解密方法
    140.      * @param encryptedParam
    141.      * @return
    142.      */
    143.     private String decrypt(String encryptedParam) {
    144.         String returnResult = "";
    145.         JSONObject json = JSONObject.parseObject(encryptedParam);
    146.         //我的参数在data里
    147.         String encrypt = json.getString("data");
    148.         try {
    149.         //解密
    150.             returnResult = AESCoder.decryptAES(encrypt, "test");
    151.             return returnResult;
    152.         } catch (Exception e) {
    153.             e.printStackTrace();
    154.         }
    155.         return returnResult;
    156.     }
    157.  
    158.     public class RecorderServerHttpRequestDecorator  extends ServerHttpRequestDecorator {
    159.         private final List dataBuffers = new ArrayList<>();
    160.         public RecorderServerHttpRequestDecorator(ServerHttpRequest delegate) {
    161.             super(delegate);
    162.             super.getBody().map(dataBuffer -> {
    163.                 dataBuffers.add(dataBuffer);
    164.                 return dataBuffer;
    165.             }).subscribe();
    166.         }
    167.  
    168.         @Override
    169.         public Flux getBody() {
    170.             return copy();
    171.         }
    172.  
    173.         private Flux copy() {
    174.             return Flux.fromIterable(dataBuffers)
    175.                     .map(buf -> buf.factory().wrap(buf.asByteBuffer()));
    176.         }
    177.     }
    178. }
      179.  

      4.接口层
       

      这里要新建一个testservice服务，在testservice工程里写这个接口
       

      1. @RestController
      2. public class Test{
      3.  
      4.     @GetMapping("hello") //这里根据需要更换get、post请求
      5.     public String test(@RequestParam("REQUEST")String result){
      6.         System.out.println(result);
      7.         return result;
      8.         
      9.         }
      10.  
      11. }
       

      配置文件：
       

      1. spring:
      2.   application:
      3.     name: testservice
      4.   cloud:
      5.     nacos:
      6.       discovery:
      7.         server-addr: 127.0.0.1:8848
      8.       config:
      9.         server-addr: 127.0.0.1:8848
      10.         file-extension: yaml
      11.         group: test
      12.         prefix: test
      13. server:
      14.   servlet:
      15.     context-path: /test
       

      5. 测试
       

      我这里是编写了一个测试类
       

      1.  public static void main(String[] args) throws Exception {
      2.         try {
      3.             JSONObject jo = new JSONObject();
      4.             jo.put("param1", "测试啊");
      5.             jo.put("param2", "1");
      6.             JSONObject reqjo = new JSONObject();
      7.             String params = "";
      8.             //加密请求参数
      9.             encrypt = AESCoder.encrypt(jo.toString(), "test");
      10.             reqjo.put("data", params );
      11.             String responseBody = "";
      12.             // 请求参数
      13.                 String sendparam= "REQUEST="
      14.                         + URLEncoder.encode(reqjo.toString(), "UTF-8");
      15.             String localUrl="htp://localhost:8081/test/hello"
      16.  
      17.                 HttpClientCommon hc = new HttpClientCommon();
      18.                 responseBody = hc.responseBody(localUrl + "?" + sendparam, sendparam);
      19.             } catch (Exception e) {
      20.                 e.printStackTrace();
      21.             }
      22.             System.out.println(responseBody);
      23.             JSONObject json = JSONObject.fromObject(responseBody);
      24.             String res = (String) json.get("RESPONSE=");
      25.             res = URLDecoder.decode(res, "UTF-8");
      26.             byte[] bytes = AESCoder.decrypt(res, "test");
      27.             String returnResult = new String(bytes, "UTF-8");
      28.             System.out.println("返回参数：" + returnResult);
      29.         }
       

      
                
                    
                

                
    179. 

                    相关阅读:
      
                    
【Go语言】切片的扩容                            
      
面试官：介绍一下 Redis 三种集群模式                            
      
G1回收器参数设置                            
      
玩一玩 Ubuntu 下的 VSCode 编程                            
      
【回归预测】基于萤火虫算法优化模糊实现数据回归预测附matlab代码                            
      
Java职业发展                            
      
说说教育机构教学课程视频加密是如何实现的？                            
      
Oracle Schema Only账户                            
      
leetcode 15. 三数之和                            
      
深度学习之使用Milvus向量数据库实战图搜图                            
      
                          
                
      180. 
                
    180. 
                    原文地址：https://blog.csdn.net/RHHcainiao/article/details/132868757
                
      181.