SpringMVC系列第18篇：RequestBodyAdvice：对@ReuqestBody进行增强

star2017 1年前 ⋅ 578 阅读

大家好，我是路人，这是SpringMVC系列第18篇。

1、前言

在实际项目中，有时候我们需要在请求之前或之后做一些操作，比如：对参数进行解密，对所有的返回值进行加密等。这些与业务无关的操作，我们没有必要在每个 controller 方法中都写一遍，这里我们就可以使用 springmvc 中的@ControllerAdvice 和 RequestBodyAdvice、ResponseBodyAdvice 来对请求前后进行处理，本质上就是 aop 的思想。

RequestBodyAdvice：对@RquestBody进行增强处理，比如所有请求的数据都加密之后放在body中，在到达controller的方法之前，需要先进行解密，那么就可以通过RequestBodyAdvice来进行统一的解密处理，无需在 controller 方法中去做这些通用的操作。

ResponseBodyAdvice：通过名称就可以知道，这玩意是对@ResponseBody进行增强处理的，可以对Controller中@ResponseBody类型返回值进行增强处理，也就是说可以拦截@ResponseBody类型的返回值，进行再次处理，比如加密、包装等操作。

本文主要介绍RequestBodyAdvice的用法，下一篇介绍RequestBodyAdvice的用法。

2、这个需求如何实现？

比如咱们的项目中对数据的安全性要求比较高，那么可以对所有请求的数据进行加密，后端需要解密之后再进行处理。

怎么实现呢？可以在controller中的每个方法中先进行解密，然后在进行处理，这也太low了吧，需要修改的代码太多了。

这个需求可以通过@ControllerAdvice和RequestBodyAdvice来实现，特别的简单，两三下的功夫就搞定了，下面上代码。

3、案例代码

3.1、git代码位置

  1. https://gitee.com/javacode2018/springmvc-series

3.2、自定义一个RequestBodyAdvice

  1. package com.javacode2018.springmvc.chat13.config;
  3. import com.javacode2018.springmvc.chat13.util.EncryptionUtils;
  4. import org.apache.commons.io.IOUtils;
  5. import org.springframework.core.MethodParameter;
  6. import org.springframework.http.HttpHeaders;
  7. import org.springframework.http.HttpInputMessage;
  8. import org.springframework.http.converter.HttpMessageConverter;
  9. import org.springframework.web.bind.annotation.ControllerAdvice;
  10. import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdviceAdapter;
  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.lang.reflect.Type;
  16. @ControllerAdvice
  17. public class DecryptRequestBodyAdvice extends RequestBodyAdviceAdapter {
  18.     @Override
  19.     public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
  20.         return true;
  21.     }
  23.     @Override
  24.     public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
  25.         String encoding = "UTF-8";
  26.         //①：获取http请求中原始的body
  27.         String body = IOUtils.toString(inputMessage.getBody(), encoding);
  28.         //②：解密body，EncryptionUtils源码在后面
  29.         String decryptBody = EncryptionUtils.desEncrypt(body);
  30.         //将解密之后的body数据重新封装为HttpInputMessage作为当前方法的返回值
  31.         InputStream inputStream = IOUtils.toInputStream(decryptBody, encoding);
  32.         return new HttpInputMessage() {
  33.             @Override
  34.             public InputStream getBody() throws IOException {
  35.                 return inputStream;
  36.             }
  38.             @Override
  39.             public HttpHeaders getHeaders() {
  40.                 return inputMessage.getHeaders();
  41.             }
  42.         };
  43.     }
  45. }
  • 自定义的类需要实现RequestBodyAdvice接口，这个接口有个默认的实现类RequestBodyAdviceAdapter，相当于一个适配器，方法体都是空的，所以我们自定义的类可以直接继承这个类，更方便一些
  • 这个类上面一定要加上@ControllerAdvice注解，有了这个注解，springmvc才能够识别这个类是对controller的增强类
  • supports方法：返回一个boolean值，若为true，则表示参数需要这个类处理，否则，跳过这个类的处理
  • beforeBodyRead：在body中的数据读取之前可以做一些处理，我们在这个方法中来做解密的操作。

3.3、来个controller测试效果

下面这个controller中搞了2个方法，稍后我们传递密文进来，最后这两个方法会将结果返回，返回的结果是经过DecryptRequestBodyAdvice类处理之后的明文，稍后验证。

  1. package com.javacode2018.springmvc.chat13.controller;
  3. import org.springframework.web.bind.annotation.RequestBody;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  7. import java.util.List;
  9. @RestController
  10. public class UserController {
  11.     @RequestMapping("/user/add")
  12.     public User add(@RequestBody User user) {
  13.         System.out.println("user:" + user);
  14.         return user;
  15.     }
  17.     @RequestMapping("/user/adds")
  18.     public List<User> adds(@RequestBody List<User> userList) {
  19.         System.out.println("userList:" + userList);
  20.         return userList;
  21.     }
  23.     public static class User {
  24.         private String name;
  25.         private Integer age;
  27.         public String getName() {
  28.             return name;
  29.         }
  31.         public void setName(String name) {
  32.             this.name = name;
  33.         }
  35.         public Integer getAge() {
  36.             return age;
  37.         }
  39.         public void setAge(Integer age) {
  40.             this.age = age;
  41.         }
  43.         @Override
  44.         public String toString() {
  45.             return "User{" +
  46.                     "name='" + name + '\'' +
  47.                     ", age=" + age +
  48.                     '}';
  49.         }
  50.     }
  51. }

3.4、加密工具类EncryptionUtils

可以运行main方法，得到2个测试的密文。

  1. package com.javacode2018.springmvc.chat13.util;
  4. import javax.crypto.Cipher;
  5. import javax.crypto.spec.IvParameterSpec;
  6. import javax.crypto.spec.SecretKeySpec;
  7. import java.util.Base64;
  9. /**
  10.  * 加密工具类
  11.  */
  12. public class EncryptionUtils {
  14.     private static String key = "abcdef0123456789";
  16.     public static void main(String[] args) throws Exception {
  17.         m1();
  18.         m2();
  19.     }
  21.     private static void m1(){
  22.         String body = "{\"name\":\"路人\",\"age\":30}";
  23.         String encryptBody = EncryptionUtils.encrypt(body);
  24.         System.out.println(encryptBody);
  25.         String desEncryptBody = EncryptionUtils.desEncrypt(encryptBody);
  26.         System.out.println(desEncryptBody);
  27.     }
  28.     private static void m2(){
  29.         String body = "[{\"name\":\"路人\",\"age\":30},{\"name\":\"springmvc高手系列\",\"age\":30}]";
  30.         String encryptBody = EncryptionUtils.encrypt(body);
  31.         System.out.println(encryptBody);
  32.         String desEncryptBody = EncryptionUtils.desEncrypt(encryptBody);
  33.         System.out.println(desEncryptBody);
  34.     }
  36.     private static String AESTYPE = "AES/CBC/PKCS5Padding";
  38.     /**
  39.      * 加密明文
  40.      *
  41.      * @param plainText 明文
  42.      * @return
  43.      * @throws Exception
  44.      */
  45.     public static String encrypt(String plainText) {
  46.         try {
  47.             Cipher cipher = Cipher.getInstance(AESTYPE);
  48.             byte[] dataBytes = plainText.getBytes("utf-8");
  49.             byte[] plaintext = new byte[dataBytes.length];
  50.             System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
  51.             SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
  52.             IvParameterSpec ivspec = new IvParameterSpec(key.getBytes());
  53.             cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
  54.             byte[] encrypted = cipher.doFinal(plaintext);
  55.             return new String(Base64.getEncoder().encode(encrypted), "UTF-8");
  56.         } catch (Exception e) {
  57.             throw new RuntimeException(e);
  58.         }
  59.     }
  61.     /**
  62.      * 解密密文
  63.      *
  64.      * @param encryptData 密文
  65.      * @return
  66.      * @throws Exception
  67.      */
  68.     public static String desEncrypt(String encryptData) {
  69.         try {
  70.             Cipher cipher = Cipher.getInstance(AESTYPE);
  71.             SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
  72.             IvParameterSpec ivspec = new IvParameterSpec(key.getBytes());
  73.             cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
  74.             byte[] original = cipher.doFinal(Base64.getDecoder().decode(encryptData.getBytes("UTF-8")));
  75.             return new String(original, "utf-8");
  76.         } catch (Exception e) {
  77.             throw new RuntimeException(e);
  78.         }
  80.     }
  82. }

3.5、验证效果

验证效果

接口 明文 密文
/user/add {“name”:”路人”,”age”:30} 0A10mig46aZI76jwpgmeeuqDHc7h4Zq/adoY6d5r2mY=
/user/adds [{“name”:”路人”,”age”:30},{“name”:”springmvc高手系列”,”age”:30}] UzWvCsrqt7ljXVI18XBXU3B9S4P2bMB72vH0HNst1GhMt5HTAiodbJwr7r8PuWWs1gM5iAYY4DZWfLgsTbizAEwEtqw8VuCuk2hYBjoCtCc=

将项目发布到tomcat，然后使用idea中的HTTP client跑下这2个测试用例

  1. POST http://localhost:8080/chat13/user/add
  2. Content-Type: application/json
  4. 0A10mig46aZI76jwpgmeeuqDHc7h4Zq/adoY6d5r2mY=
  6. ###
  7. POST http://localhost:8080/chat13/user/adds
  8. Content-Type: application/json
  10. UzWvCsrqt7ljXVI18XBXU3B9S4P2bMB72vH0HNst1GhMt5HTAiodbJwr7r8PuWWs1gM5iAYY4DZWfLgsTbizAEwEtqw8VuCuk2hYBjoCtCc=

输出如下，变成明文了

  1. 用例1输出
  2. {
  3.   "name": "路人",
  4.   "age": 30
  5. }
  7. 用例2输出
  8. [
  9.   {
  10.     "name": "路人",
  11.     "age": 30
  12.   },
  13.   {
  14.     "name": "springmvc高手系列",
  15.     "age": 30
  16.   }
  17. ]

是不是特别的爽，无需在controller中进行解密，将解密统一放在RequestBodyAdvice中做了。

4、多个RequestBodyAdvice指定顺序

当程序中定义了多个RequestBodyAdvice，可以通过下面2种方式来指定顺序。

方式1：使用@org.springframework.core.annotation.Order注解指定顺序，顺序按照value的值从小到大，如：

  1. @Order(2)
  2. @ControllerAdvice
  3. public class RequestBodyAdvice1 extends RequestBodyAdviceAdapter{}
  5. @Order(1)
  6. @ControllerAdvice
  7. public class RequestBodyAdvice2 extends RequestBodyAdviceAdapter{}

方式1：实现org.springframework.core.Ordered接口，顺序从小到大，如：

  1. @ControllerAdvice
  2. public class RequestBodyAdvice1 extends RequestBodyAdviceAdapter implements Ordered{
  3.     int getOrder(){
  4.         return 1;
  5.     }
  6. }
  8. @Order(1)
  9. @ControllerAdvice
  10. public class RequestBodyAdvice2 extends RequestBodyAdviceAdapter implements Ordered{
  11.     int getOrder(){
  12.         return 2;
  13.     }
  14. }

5、@ControllerAdvice指定增强的范围

@ControllerAdvice注解相当于对Controller的功能进行了增强，目前来看，对所有的controller方法都增强了。

那么，能否控制一下增强的范围呢？比如对某些包中的controller进行增强，或者通过其他更细的条件来控制呢？

确实可以，可以通过@ControllerAdvice中的属性来指定增强的范围，需要满足这些条件的才会被@ControllerAdvice注解标注的bean增强，每个属性都是数组类型的，所有的条件是或者的关系，满足一个即可。

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Component
  5. public @interface ControllerAdvice {
  7.     /**
  8.      * 用来指定controller所在的包，满足一个就可以
  9.      */
  10.     @AliasFor("basePackages")
  11.     String[] value() default {};
  13.     /**
  14.      * 用来指定controller所在的包，满足一个就可以
  15.      */
  16.     @AliasFor("value")
  17.     String[] basePackages() default {};
  19.     /**
  20.      * controller所在的包必须为basePackageClasses中同等级或者子包中，满足一个就可以
  21.      */
  22.     Class<?>[] basePackageClasses() default {};
  24.     /**
  25.      * 用来指定Controller需要满足的类型，满足assignableTypes中指定的任意一个就可以
  26.      */
  27.     Class<?>[] assignableTypes() default {};
  29.     /**
  30.      * 用来指定Controller上需要有的注解，满足annotations中指定的任意一个就可以
  31.      */
  32.     Class<? extends Annotation>[] annotations() default {};
  34. }

扩展知识：这块的判断对应的源码如下，有兴趣的可以看看。

  1. org.springframework.web.method.HandlerTypePredicate#test

6、RequestBodyAdvice原理

有些朋友可能对@ControllerAdvice和RequestBodyAdvice的原理比较感兴趣，想研究一下他们的源码，关键代码在下面这个方法中，比较简单，有兴趣的可以去翻阅一下，这里就不展开说了。

  1. org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#afterPropertiesSet
  2. org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#initControllerAdviceCache

7、总结

  • @ControllerAdvice和RequestBodyAdvice一起使用可以拦截@RequestBody标注的参数，对参数进行增强处理
  • 建议：案例中RequestBodyAdvice#supports方法咱们直接返回的是true，会对所有@RequestBody标注的参数进行处理，有些参数可能不需要处理，对于这种情况的，supports方法需要返回false，这种问题留给大家自己试试了，挺简单的，比如可以自定义一个注解标注在无需处理的参数上，检测到参数上有这个注解的时候（supprts方法中的methodParameter参数可以获取参数的所有信息），supports返回false。

8、留个问题

若body中是xml格式的数据，后端接口通过java对象接收，怎么实现呢？欢迎留言讨论。

有问题欢迎加我微信：itsoku，交流。

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#SpringMVC教程
阅读全部
相关文章推荐
  • 1

全部评论: 0 条

    我有话说: