成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

如何優雅的實現 Spring Boot 接口參數加密解密？

作者：江南一點雨
安全 應用安全
加密解密本身并不是難事，問題是在何時去處理?定義一個過濾器，將請求和響應分別攔截下來進行處理也是一個辦法，這種方式雖然粗暴，但是靈活，因為可以拿到一手的請求參數和響應數據。

因為有小伙伴剛好問到這個問題，松哥就抽空擼一篇文章和大家聊聊這個話題。

加密解密本身并不是難事，問題是在何時去處理?定義一個過濾器，將請求和響應分別攔截下來進行處理也是一個辦法，這種方式雖然粗暴，但是靈活，因為可以拿到一手的請求參數和響應數據。不過 SpringMVC 中給我們提供了 ResponseBodyAdvice 和 RequestBodyAdvice，利用這兩個工具可以對請求和響應進行預處理，非常方便。

所以今天這篇文章有兩個目的：

  • 分享參數/響應加解密的思路。
  • 分享 ResponseBodyAdvice 和 RequestBodyAdvice 的用法。

好了，那么接下來就不廢話了，我們一起來看下。

1.開發加解密 starter

為了讓我們開發的這個工具更加通用，也為了復習一下自定義 Spring Boot Starter，這里我們就將這個工具做成一個 stater，以后在 Spring Boot 項目中直接引用就可以。

首先我們創建一個 Spring Boot 項目，引入 spring-boot-starter-web 依賴：

  1. <dependency> 
  2.     <groupId>org.springframework.boot</groupId> 
  3.     <artifactId>spring-boot-starter-web</artifactId> 
  4.     <scope>provided</scope> 
  5.     <version>2.4.3</version> 
  6. </dependency> 

因為我們這個工具是為 Web 項目開發的，以后必然使用在 Web 環境中，所以這里添加依賴時 scope 設置為 provided。

依賴添加完成后，我們先來定義一個加密工具類備用，加密這塊有多種方案可以選擇，對稱加密、非對稱加密，其中對稱加密又可以使用 AES、DES、3DES 等不同算法，這里我們使用 Java 自帶的 Cipher 來實現對稱加密，使用 AES 算法：

  1. public class AESUtils { 
  2.  
  3.     private static final String AES_ALGORITHM = "AES/ECB/PKCS5Padding"; 
  4.  
  5.     // 獲取 cipher 
  6.     private static Cipher getCipher(byte[] key, int model) throws Exception { 
  7.         SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES"); 
  8.         Cipher cipher = Cipher.getInstance(AES_ALGORITHM); 
  9.         cipher.init(model, secretKeySpec); 
  10.         return cipher; 
  11.     } 
  12.  
  13.     // AES加密 
  14.     public static String encrypt(byte[] data, byte[] key) throws Exception { 
  15.         Cipher cipher = getCipher(key, Cipher.ENCRYPT_MODE); 
  16.         return Base64.getEncoder().encodeToString(cipher.doFinal(data)); 
  17.     } 
  18.  
  19.     // AES解密 
  20.     public static byte[] decrypt(byte[] data, byte[] key) throws Exception { 
  21.         Cipher cipher = getCipher(key, Cipher.DECRYPT_MODE); 
  22.         return cipher.doFinal(Base64.getDecoder().decode(data)); 
  23.     } 
  24. } 

這個工具類比較簡單，不需要多解釋。需要說明的是，加密后的數據可能不具備可讀性，因此我們一般需要對加密后的數據再使用 Base64 算法進行編碼，獲取可讀字符串。換言之，上面的 AES 加密方法的返回值是一個 Base64 編碼之后的字符串，AES 解密方法的參數也是一個 Base64 編碼之后的字符串，先對該字符串進行解碼，然后再解密。

接下來我們封裝一個響應工具類備用，這個大家如果經常看松哥視頻已經很了解了：

  1. public class RespBean { 
  2.     private Integer status; 
  3.     private String msg; 
  4.     private Object obj; 
  5.  
  6.     public static RespBean build() { 
  7.         return new RespBean(); 
  8.     } 
  9.  
  10.     public static RespBean ok(String msg) { 
  11.         return new RespBean(200, msg, null); 
  12.     } 
  13.  
  14.     public static RespBean ok(String msg, Object obj) { 
  15.         return new RespBean(200, msg, obj); 
  16.     } 
  17.  
  18.     public static RespBean error(String msg) { 
  19.         return new RespBean(500, msg, null); 
  20.     } 
  21.  
  22.     public static RespBean error(String msg, Object obj) { 
  23.         return new RespBean(500, msg, obj); 
  24.     } 
  25.  
  26.     private RespBean() { 
  27.     } 
  28.  
  29.     private RespBean(Integer status, String msg, Object obj) { 
  30.         this.status = status; 
  31.         this.msg = msg; 
  32.         this.obj = obj; 
  33.     } 
  34.  
  35.     public Integer getStatus() { 
  36.         return status; 
  37.     } 
  38.  
  39.     public RespBean setStatus(Integer status) { 
  40.         this.status = status; 
  41.         return this; 
  42.     } 
  43.  
  44.     public String getMsg() { 
  45.         return msg; 
  46.     } 
  47.  
  48.     public RespBean setMsg(String msg) { 
  49.         this.msg = msg; 
  50.         return this; 
  51.     } 
  52.  
  53.     public Object getObj() { 
  54.         return obj; 
  55.     } 
  56.  
  57.     public RespBean setObj(Object obj) { 
  58.         this.obj = obj; 
  59.         return this; 
  60.     } 
  61. } 

接下來我們定義兩個注解 @Decrypt 和 @Encrypt：

  1. @Retention(RetentionPolicy.RUNTIME) 
  2. @Target({ElementType.METHOD,ElementType.PARAMETER}) 
  3. public @interface Decrypt { 
  4. } 
  5. @Retention(RetentionPolicy.RUNTIME) 
  6. @Target(ElementType.METHOD) 
  7. public @interface Encrypt { 
  8. } 

這兩個注解就是兩個標記，在以后使用的過程中，哪個接口方法添加了 @Encrypt 注解就對哪個接口的數據加密返回，哪個接口/參數添加了 @Decrypt 注解就對哪個接口/參數進行解密。這個定義也比較簡單，沒啥好說的，需要注意的是 @Decrypt比 @Encrypt 多了一個使用場景就是 @Decrypt 可以用在參數上。

考慮到用戶可能會自己配置加密的 key，因此我們再來定義一個 EncryptProperties 類來讀取用戶配置的 key：

  1. @ConfigurationProperties(prefix = "spring.encrypt") 
  2. public class EncryptProperties { 
  3.     private final static String DEFAULT_KEY = "www.itboyhub.com"; 
  4.     private String key = DEFAULT_KEY; 
  5.  
  6.     public String getKey() { 
  7.         return key; 
  8.     } 
  9.  
  10.     public void setKey(String key) { 
  11.         this.key = key; 
  12.     } 
  13. } 

這里我設置了默認的 key 是 www.itboyhub.com，key 是 16 位字符串，松哥這個網站地址剛好滿足。以后如果用戶想自己配置 key，只需要在 application.properties 中配置 spring.encrypt.key=xxx 即可。

所有準備工作做完了，接下來就該正式加解密了。

因為松哥這篇文章一個很重要的目的是想和大家分享 ResponseBodyAdvice 和 RequestBodyAdvice 的用法，RequestBodyAdvice 在做解密的時候倒是沒啥問題，而 ResponseBodyAdvice 在做加密的時候則會有一些局限，不過影響不大，還是我前面說的，如果想非常靈活的掌控一切，那還是自定義過濾器吧。這里我就先用這兩個工具來實現了。

另外還有一點需要注意，ResponseBodyAdvice 在你使用了 @ResponseBody 注解的時候才會生效，RequestBodyAdvice 在你使用了 @RequestBody 注解的時候才會生效，換言之，前后端都是 JSON 交互的時候，這兩個才有用。不過一般來說接口加解密的場景也都是前后端分離的時候才可能有的事。

先來看接口加密：

  1. @EnableConfigurationProperties(EncryptProperties.class) 
  2. @ControllerAdvice 
  3. public class EncryptResponse implements ResponseBodyAdvice<RespBean> { 
  4.     private ObjectMapper om = new ObjectMapper(); 
  5.     @Autowired 
  6.     EncryptProperties encryptProperties; 
  7.     @Override 
  8.     public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) { 
  9.         return returnType.hasMethodAnnotation(Encrypt.class); 
  10.     } 
  11.  
  12.     @Override 
  13.     public RespBean beforeBodyWrite(RespBean body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) { 
  14.         byte[] keyBytes = encryptProperties.getKey().getBytes(); 
  15.         try { 
  16.             if (body.getMsg()!=null) { 
  17.                 body.setMsg(AESUtils.encrypt(body.getMsg().getBytes(),keyBytes)); 
  18.             } 
  19.             if (body.getObj() != null) { 
  20.                 body.setObj(AESUtils.encrypt(om.writeValueAsBytes(body.getObj()), keyBytes)); 
  21.             } 
  22.         } catch (Exception e) { 
  23.             e.printStackTrace(); 
  24.         } 
  25.         return body; 
  26.     } 
  27. } 

我們自定義 EncryptResponse 類實現 ResponseBodyAdvice接口，泛型表示接口的返回類型，這里一共要實現兩個方法：

  1. supports：這個方法用來判斷什么樣的接口需要加密，參數 returnType 表示返回類型，我們這里的判斷邏輯就是方法是否含有 @Encrypt 注解，如果有，表示該接口需要加密處理，如果沒有，表示該接口不需要加密處理。
  2. beforeBodyWrite：這個方法會在數據響應之前執行，也就是我們先對響應數據進行二次處理，處理完成后，才會轉成 json 返回。我們這里的處理方式很簡單，RespBean 中的 status 是狀態碼就不用加密了，另外兩個字段重新加密后重新設置值即可。
  3. 另外需要注意，自定義的 ResponseBodyAdvice 需要用 @ControllerAdvice 注解來標記。

再來看接口解密：

  1. @EnableConfigurationProperties(EncryptProperties.class) 
  2. @ControllerAdvice 
  3. public class DecryptRequest extends RequestBodyAdviceAdapter { 
  4.     @Autowired 
  5.     EncryptProperties encryptProperties; 
  6.     @Override 
  7.     public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) { 
  8.         return methodParameter.hasMethodAnnotation(Decrypt.class) || methodParameter.hasParameterAnnotation(Decrypt.class); 
  9.     } 
  10.  
  11.     @Override 
  12.     public HttpInputMessage beforeBodyRead(final HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException { 
  13.         byte[] body = new byte[inputMessage.getBody().available()]; 
  14.         inputMessage.getBody().read(body); 
  15.         try { 
  16.             byte[] decrypt = AESUtils.decrypt(body, encryptProperties.getKey().getBytes()); 
  17.             final ByteArrayInputStream bais = new ByteArrayInputStream(decrypt); 
  18.             return new HttpInputMessage() { 
  19.                 @Override 
  20.                 public InputStream getBody() throws IOException { 
  21.                     return bais; 
  22.                 } 
  23.  
  24.                 @Override 
  25.                 public HttpHeaders getHeaders() { 
  26.                     return inputMessage.getHeaders(); 
  27.                 } 
  28.             }; 
  29.         } catch (Exception e) { 
  30.             e.printStackTrace(); 
  31.         } 
  32.         return super.beforeBodyRead(inputMessage, parameter, targetType, converterType); 
  33.     } 
  34. } 
  1. 首先大家注意，DecryptRequest 類我們沒有直接實現 RequestBodyAdvice 接口，而是繼承自 RequestBodyAdviceAdapter 類，該類是 RequestBodyAdvice 接口的子類，并且實現了接口中的一些方法，這樣當我們繼承自 RequestBodyAdviceAdapter 時，就只需要根據自己實際需求實現某幾個方法即可。
  2. supports：該方法用來判斷哪些接口需要處理接口解密，我們這里的判斷邏輯是方法上或者參數上含有 @Decrypt 注解的接口，處理解密問題。
  3. beforeBodyRead：這個方法會在參數轉換成具體的對象之前執行，我們先從流中加載到數據，然后對數據進行解密，解密完成后再重新構造 HttpInputMessage 對象返回。

接下來，我們再來定義一個自動化配置類，如下：

  1. @Configuration 
  2. @ComponentScan("org.javaboy.encrypt.starter") 
  3. public class EncryptAutoConfiguration { 
  4.  
  5. } 

這個也沒啥好說的，比較簡單。

最后，resources 目錄下定義 META-INF，然后再定義 spring.factories 文件，內容如下：

  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=org.javaboy.encrypt.starter.autoconfig.EncryptAutoConfiguration 

這樣當項目啟動時，就會自動加載該配置類。

至此，我們的 starter 就開發完成啦。

2.打包發布

我們可以將項目安裝到本地倉庫，也可以發布到線上供他人使用。

2.1 安裝到本地倉庫

安裝到本地倉庫比較簡單，直接 mvn install，或者在 IDEA 中，點擊右邊的 Maven，然后雙擊 install，如下：

 

2.2 發布到線上

發不到線上我們可以使用 JitPack 來做。

首先我們在 GitHub 上創建一個倉庫，將我們的代碼上傳上去，這個過程應該不用我多說吧。

上傳成功后，點擊右邊的 Create a new release 按鈕，發布一個正式版，如下：

 

發布成功后，打開 jitpack，輸入倉庫的完整路徑，點擊 lookup 按鈕，查找到之后，再點擊 Get it 按鈕完成構建，如下：

 

構建成功后，JitPack 上會給出項目引用方式：

 

注意引用時將 tag 改成你具體的版本號。

至此，我們的工具就已經成功發布了!小伙伴們可以通過如下方式引用這個 starter：

  1. <dependencies> 
  2.     <dependency> 
  3.         <groupId>com.github.lenve</groupId> 
  4.         <artifactId>encrypt-spring-boot-starter</artifactId> 
  5.         <version>0.0.3</version> 
  6.     </dependency> 
  7. </dependencies> 
  8. <repositories> 
  9.     <repository> 
  10.         <id>jitpack.io</id> 
  11.         <url>https://jitpack.io</url> 
  12.     </repository> 
  13. </repositories> 

3.應用

我們創建一個普通的 Spring Boot 項目，引入 web 依賴，再引入我們剛剛的 starter 依賴，如下：

  1. <dependencies> 
  2.     <dependency> 
  3.         <groupId>org.springframework.boot</groupId> 
  4.         <artifactId>spring-boot-starter-web</artifactId> 
  5.     </dependency> 
  6.     <dependency> 
  7.         <groupId>com.github.lenve</groupId> 
  8.         <artifactId>encrypt-spring-boot-starter</artifactId> 
  9.         <version>0.0.3</version> 
  10.     </dependency> 
  11.     <dependency> 
  12.         <groupId>org.springframework.boot</groupId> 
  13.         <artifactId>spring-boot-starter-test</artifactId> 
  14.         <scope>test</scope> 
  15.     </dependency> 
  16. </dependencies> 
  17. <repositories> 
  18.     <repository> 
  19.         <id>jitpack.io</id> 
  20.         <url>https://jitpack.io</url> 
  21.     </repository> 
  22. </repositories> 

然后再創建一個實體類備用：

  1. public class User { 
  2.     private Long id; 
  3.     private String username; 
  4.     //省略 getter/setter 
  5. } 

創建兩個測試接口：

  1. @RestController 
  2. public class HelloController { 
  3.     @GetMapping("/user") 
  4.     @Encrypt 
  5.     public RespBean getUser() { 
  6.         User user = new User(); 
  7.         user.setId((long) 99); 
  8.         user.setUsername("javaboy"); 
  9.         return RespBean.ok("ok", user); 
  10.     } 
  11.  
  12.     @PostMapping("/user") 
  13.     public RespBean addUser(@RequestBody @Decrypt User user) { 
  14.         System.out.println("user = " + user); 
  15.         return RespBean.ok("ok", user); 
  16.     } 
  17. } 

第一個接口使用了 @Encrypt 注解，所以會對該接口的數據進行加密(如果不使用該注解就不加密)，第二個接口使用了 @Decrypt 所以會對上傳的參數進行解密，注意 @Decrypt 注解既可以放在方法上也可以放在參數上。

接下來啟動項目進行測試。

首先測試 get 請求接口：

 

可以看到，返回的數據已經加密。

再來測試 post 請求：

 

可以看到，參數中的加密數據已經被還原了。

如果用戶想要修改加密密鑰，可以在 application.properties 中添加如下配置：

spring.encrypt.key=1234567890123456

加密數據到了前端，前端也有一些 js 工具來處理加密數據，這個松哥后面有空再和大家說說 js 的加解密。

 

4.小結

好啦，今天這篇文章主要是想和大家聊聊 ResponseBodyAdvice 和 RequestBodyAdvice 的用法，一些加密思路，當然 ResponseBodyAdvice 和 RequestBodyAdvice 還有很多其他的使用場景，小伙伴們可以自行探索～本文使用了對稱加密中的 AES 算法，大家也可以嘗試改成非對稱加密。

本文轉載自微信公眾號「江南一點雨」，可以通過以下二維碼關注。轉載本文請聯系江南一點雨公眾號。

 

責任編輯：武曉燕 來源： 江南一點雨
加密解密參數
相關推薦

2022-06-04 12:25:10

解密加密過濾器

2023-11-01 08:58:10

2025-03-11 00:55:00

Spring停機安全

2022-07-27 08:49:34

接口加密解密

2024-12-06 09:27:28

2024-09-27 15:24:15

Spring數據加解密

2023-03-06 08:49:02

加密和解密SpringBoot

2025-05-14 04:00:00

2022-12-14 09:06:58

接口Spring解密

2023-10-16 11:12:29

2024-12-18 12:10:00

2024-10-18 08:00:00

SpringBoot框架開發

2024-08-02 09:15:22

Spring捕捉格式

2020-12-08 08:08:51

Java接口數據

2025-02-07 09:11:04

JSON對象策略

2025-06-04 01:00:00

2023-09-27 08:14:56

2019-04-15 08:32:25

Spring Boot日志門面模式

2023-04-17 23:49:09

開發代碼Java

2024-05-29 08:12:55

接口參數格式
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 日本一区二区影视 | 三级av在线 | 狠狠亚洲| 欧美精品在欧美一区二区少妇 | 日韩精品一区二区三区 | 欧美一区二区三区免费电影 | 中文字幕日韩一区 | 91文字幕巨乱亚洲香蕉 | 国产亚洲一区二区三区在线观看 | 欧美xxxⅹ性欧美大片 | 国产精品成人一区二区三区夜夜夜 | 日韩中文字幕在线播放 | 国产视频福利在线观看 | 毛片软件 | а_天堂中文最新版地址 | 中文字幕免费视频 | 中文字幕在线免费观看 | 久久国产欧美日韩精品 | 男人亚洲天堂 | 欧美日韩精品亚洲 | 日本电影韩国电影免费观看 | 日本中出视频 | 一区二区三区中文字幕 | 成人精品一区二区三区中文字幕 | 亚洲视频在线看 | 国产精品国产精品国产专区不卡 | 欧美日韩综合精品 | 久久新| 中文一区二区 | 欧美成人aaa级毛片在线视频 | 日韩在线播放一区 | 三级成人在线 | 亚洲欧美精品在线 | 中文字幕在线观看av | 日韩av在线免费 | 久久久国产精品入口麻豆 | 99中文字幕 | 久久免费香蕉视频 | 亚洲协和影视 | 国产网站在线 | 亚洲欧洲精品在线 |