springmvc中反序列化与序列化的原理

说明

• 在千变化万的需求面前，使用 springmvc原生的api进行开发，多数情况是可以满足的，但对于某些特定的场景是无法满足的，这时候就需要对框架进行扩展了或是重写源码组件了。但前提是需要对框架原理流程等掌握透彻，知己知彼，方能动手重构。
• 本文主要研究下 springmvc如何对http协议中的请求报文，进行反序列化输入和序列化输出的。简单的说，研究下消息转换的输入与输出。
• 环境说明
  • 操作系统： windows
  • 开发IDE： STS 3.8.release
  • spring&springmvc版本： 4.3.0.RELEASE
  部分源码调试 反序列化(http body--java对象)

  先从以下这个实验入手： 发送一个post类型的http请求， content-type:application/json

  

  查看下springmvc控制器中

  

在modifyUserInfo方法里面，入参前面加了个注解@RequestBody，就能将http body中的json报文，反序列化成UserRequest对象了，究竟是如何做到的呢，看下调用栈： InvocableHandlerMethod.doInvoke()

依次从上往下看下调用栈，看看方法 InvocableHandlerMethod.doInvoke()

InvocableHandlerMethod.doInvoke()方法里，getBean()返回就是被代理的类UserController，这里使用到了jdk反射，调用UserController里的modifyUserInfo方法，到目前为止，看不到什么反序列化有关的线索，继续看上一个调用栈： InvocableHandlerMethod.invokeForRequest

可以看到Object类型的变量args已经被反序列化过了。很好，快接近目标了，我们继续往上看，可以看到

1. Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

继续看方法 getMethodArgumentValues里的实现：

可以看到，这个数组argumentResolvers里面，装载了26个 HandlerMethodArgumentResolver接口实现类（先不用关心HandlerMethodArgumentResolver接口干什么的）

真正使用到了哪个类呢，在 methodArgumentResolvers.supportParameter方法里面加个断点继续调试

可以看到methodArgumentResolver是类 RequestResponseBodyMethodProcessor的实例，那么这个supportsParameter方法里面如何实现的呢

好，我们看到了这个Boolean型的方法，判断方法参数级别上，有没有 RequestBody注解，在一开始的 UserController方法里，确实加入过@RequestBody注解；

继续回到

现在可以知道resolver变量是 RequestResponseBodyMethodProcessor类的实例，继续看resolveArgument方法里实现

越来越接近目标了

再看的 readWithMessageConverters(inputMessage,methodParam,paramType)实现

关键的代码就是这行 body=genericConverter.read(targetType,contextClass,inputMessage)，这行代码就是将http body中的字符串反序列成targeType=UserRequest对象的;

看到这个for循环messageConverters数组没有，这个messageConver时什么东西？继续看下messageConverters数组里加载的内容：

看下这个messageConverters数组是怎么定义的，原来这个messageConverters是个全局的容器，

1. protected final List<HttpMessageConverter<?>> messageConverters;

所以，这个messageConverters数组，可以在容器配置文件中配置，有关 HttpMessageConverter的内容，这里略； 至此，大体就能明白,http body反序列化成UserRequest的原理流程；

到目前为止，对于序列化流程，可能还是有点模糊，我们来画个时序图，帮助理清类与方法调用顺序与关系：

序列化(java对象--http json response)

接着再看UserController，我们打算在方法modifyUserInfo中，返回一个GeneralResponse类型的对象，可以看到postman中，返回的body报文：

那么这序列化，又是如何做到的呢，继续跟踪源码来发现答案

可以看到,在调用完毕 ServletInvocableHandlerMethod里的方法invokeForRequest(反序列化)之后，又调用了 returnValueHandlers.handleReturnValue方法，从方法的取名上看，处理返回值的，进去看看实现

同样的，一开始选择合适的 HandlerMethodReturnValueHandler类返回实例，然后调用具体实例里的handlerReturnValue方法， 我们先看看方法selectHandler，是如何适配到合适的 HandlerMethodReturnValueHandler具体实现类的

和刚才类似的，这里也是通过遍历returnValueHandlers 数组，不断的去判断返回方法是否满足方法 supportsReturnType ,打上断点继续调试

可以发现，满足supportsReturnType方法的实现类，是 RequestResponseBodyMethodProcessor，我们进到该类中，查看下supportsReturnType方法的具体实现

这下清楚了，原来判断方法级别是否含有 @ResponseBody注解，在方法modifyUserInfo上，我们的也确实加了注解 @ResponseBody。 好，我们找到了具体的返回类 RequestResponseBodyMethodProcessor之后，看下是如何处理返回值的

看到了方法 writeWithMessageConverters，大概能猜到，这个方法应该就是用于处理输出的

这里，根据返回content-type类型，调用canWrite方法，路由到合适的HttpMessageConverter实现类，本例子，实现类是： MappingJackson2HttpMessageConverter，最终的序列化，是调用write()方法来实现的。

好了，我们借用时序图，辅助理清下序列化流程：

接口研究

• 上面两块较详细的调试跟踪了序列化与反序列化的代码部分，发现最终都会进入RequestResponseBodyMethodProcessor类实例来进行输入与输出，看下这个类的说明：

Resolves method arguments annotated with @RequestBody and handles return values from methods annotated with @ResponseBody by reading and writing to the body of the request or response with an HttpMessageConverter.

• 可以得知这个类，就是专门用于解析处理：方法参数中标注了注解 @RequestBody和方法上标注了 @ResponseBody的解析器，这个解析器使用了 HttpMessageConverter类的实例来进行输入与输出。 我们重点看下这个类 RequestResponseBodyMethodProcessor的层次关系
• 这个类同时实现了 HandlerMethodArgumentResolver和 HandlerMethodReturnValueHandler两个接口。前者是将请求报文绑定到处理方法形参的策略接口，后者则是对处理方法返回值进行处理的策略接口。两个接口的源码如下：

1. package org.springframework.web.method.support;
3. import org.springframework.core.MethodParameter;
4. import org.springframework.web.bind.WebDataBinder;
5. import org.springframework.web.bind.support.WebDataBinderFactory;
6. import org.springframework.web.context.request.NativeWebRequest;
8. public interface HandlerMethodArgumentResolver {
10. boolean supportsParameter(MethodParameter parameter);
12. Object resolveArgument(MethodParameter parameter,
13. ModelAndViewContainer mavContainer,
14. NativeWebRequest webRequest,
15. WebDataBinderFactory binderFactory) throws Exception;
17. }
19. package org.springframework.web.method.support;
21. import org.springframework.core.MethodParameter;
22. import org.springframework.web.context.request.NativeWebRequest;
24. public interface HandlerMethodReturnValueHandler {
26. boolean supportsReturnType(MethodParameter returnType);
28. void handleReturnValue(Object returnValue,
29. MethodParameter returnType,
30. ModelAndViewContainer mavContainer,
31. NativeWebRequest webRequest) throws Exception;
33. }

• RequestResponseBodyMethodProcessor这个类，同时充当了方法参数解析和返回值处理两种角色。我们从它的源码中，可以找到上面两个接口的方法实现。

对 HandlerMethodArgumentResolver接口的实现：

1. public boolean supportsParameter(MethodParameter parameter) {
2. return parameter.hasParameterAnnotation(RequestBody.class);
3. }
5. public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
6. NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
8. Object argument = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType());
10. String name = Conventions.getVariableNameForParameter(parameter);
11. WebDataBinder binder = binderFactory.createBinder(webRequest, argument, name);
13. if (argument != null) {
14. validate(binder, parameter);
15. }
17. mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
19. return argument;
20. }

对 HandlerMethodReturnValueHandler接口的实现

1. public boolean supportsReturnType(MethodParameter returnType) {
2. return returnType.getMethodAnnotation(ResponseBody.class) != null;
3. }
5. public void handleReturnValue(Object returnValue, MethodParameter returnType,
6. ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
7. throws IOException, HttpMediaTypeNotAcceptableException {
9. mavContainer.setRequestHandled(true);
10. if (returnValue != null) {
11. writeWithMessageConverters(returnValue, returnType, webRequest);
12. }
13. }

框架扩展

看完上面的代码，应该对整个序列化与反序列化流程脉络非常清晰了。因为两个接口的实现，分别以是否有 @RequestBody和 @ResponseBody为条件，然后分别调用 HttpMessageConverter来进行消息的读写。

• 假使有一天，有个需求是这样的：对于某些机要敏感的数据，客户端发送的http请求是加密的密文，服务端接收到了之后，需要解密；然后处理业务逻辑，最后返回的给客户端的数据也是加密后的密文。对于这种场景，代码应该如何设计？一个比较简单但冗余的方案就是，在每个控制器的每个方法里，进行解密操作，得到明文后，处理业务逻辑，最后再加密返回。这种方案显然是不现实的，缺点就是：业务逻辑和加解密逻辑耦合在一起，同时重复代码量又非常的多。比较优雅的，同时又能体现架构思想的方案，就是写一个类似与RequestResponseBodyMethodProcessor类，只要自定义的类继承自抽象类AbstractMessageConverterMethodProcessor，然后重写里面的四个方法即可：
• supportsParameter-判断控制器参数级别是否加上了 @DecryptRequestBody注解；
• resolveArgument-解密http密文，并将相应的信息封装到对象 DecryptRequest<UserRequest>实例中，方便controller中参数接收，这个类中可以灵活的接收http请求中的各种信息，比如http header中的api version、client os、client version等信息，封装到对象实例 DecryptRequest<UserRequest>实例；
• supportsReturnType-判断控制方法级别是否含有 @EncryptResponseBody注解；
• handleReturnValue-对controller返回的对象进行加密输出；
• 比如自定义类： DecryptBodyEncryptReturnValueProcessor，大体实现思路如下:

1. public class DecryptBodyEncryptReturnValueProcessor extends AbstractMessageConverterMethodProcessor {
3. protected DecryptBodyEncryptReturnValueProcessor(List<HttpMessageConverter<?>> converters) {
4. super(converters);
5. }
7. @Override
8. public boolean supportsReturnType(MethodParameter returnType) {
9. return returnType.hasMethodAnnotation(EncryptResponseBody.class)
10. && returnType.getParameterType() == GeneralResponse.class;
11. }
13. @SuppressWarnings("unchecked")
14. @Override
15. public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer,
16. NativeWebRequest webRequest) throws Exception {
17. Assert.isInstanceOf(GeneralResponse.class, returnValue, "Return value object type is:" + returnValue.getClass().getName() + ", must be GeneralResponse.");
19. // 需要设置请求结束标志，否则会走ModelAndView，寻找view流程
20. // 参考自 RequestResponseBodyMethodProcessor.handleReturnValue 方法
21. mavContainer.setRequestHandled(true);
23. HttpServletRequest httpServletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
24. GeneralResponse<Object> returnValueResponse = (GeneralResponse<Object>) returnValue;
25. Object payload = returnValueResponse.getData();
26. // 加密返回对象
27. Object encryptPayload = encryptPayload(payload, httpServletRequest);
28. returnValueResponse.setData(encryptPayload);
30. ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
31. ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
32. // Try even with null return value. ResponseBodyAdvice could get involved.
33. writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
34. }
36. private Object encryptPayload(Object payload, HttpServletRequest httpServletRequest) {
37. // TODO
39. return null;
40. }
42. @Override
43. public boolean supportsParameter(MethodParameter parameter) {
44. // 该类只适用于参数上含有@DecryptRequestBody注解的方法
45. return parameter.hasParameterAnnotation(DecryptRequestBody.class)
46. && parameter.getParameterType() == DecryptRequest.class;
47. }
49. @SuppressWarnings("unchecked")
50. @Override
51. public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
52. NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
53. HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
54. ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
57. Object arg = readWithMessageConverters(inputMessage, parameter, parameter.getNestedGenericParameterType());
58. Assert.isInstanceOf(DecryptRequest.class, arg, "Object instance class name:" + arg.getClass().getName() + ", must be DecryptRequest");
59. DecryptRequest<Object> decryptRequest = (DecryptRequest<Object>) arg;
61. String encryptReqData = decryptRequest.getEncryptData();
62. // 对encryptReqData解密逻辑，略...
63. String decryptReqData = decryptPayload(encryptReqData);
65. // 取到EncryptRequest里的泛型类型
66. ResolvableType resolvableType = ResolvableType.forType(parameter.getNestedGenericParameterType());
67. ResolvableType nestedGenericType = resolvableType.getGenerics()[0];
68. ObjectMapper objectMapper = new ObjectMapper();
69. InputStream iss = new ByteArrayInputStream(decryptReqData.getBytes());
70. TypeFactory tf = objectMapper.getTypeFactory();
71. JavaType javaType = tf.constructType(nestedGenericType.getType());
72. Object body = objectMapper.readValue(iss, javaType);
73. // 最终组装属性
74. decryptRequest.setDecryptData(decryptReqData);
75. decryptRequest.setDecryptRequestBody(body);
76. decryptRequest.setApiVersion(servletRequest.getHeader(SysConstant.API_VERSION));
77. decryptRequest.setClientOS(servletRequest.getHeader(SysConstant.CLIENT_OS));
78. decryptRequest.setClientVersion(servletRequest.getHeader(SysConstant.CLIENT_VERSION));
79. decryptRequest.setChannel(servletRequest.getHeader(SysConstant.CHANNEL));
80. decryptRequest.setSignKey(servletRequest.getHeader(SysConstant.SIGN_KEY));
81. return decryptRequest;
82. }
84. private String decryptPayload(String encryptReqData) {
85. // TODO
87. return null;
88. }
90. }

然后可以在控制器中这么用：

1. @RequestMapping(value = "/decrypt/body/encrypt/return", method = RequestMethod.POST)
2. @EncryptResponseBody //表示要对返回报文加密
3. public GeneralResponse<?> decryptBodeAndEncryptReturn(
4. @DecryptRequestBody DecryptRequest<UserRequest> decryptRequest) { //表示要对http body解密
5. UserRequest bizRequest = decryptRequest.getDecryptRequestBody();
6. log.info("解密后的报文:{}", bizRequest);
7. Map<String, Object> data = new HashMap<String, Object>();
8. data.put("key1", "value1");
9. data.put("key2", 2);
10. return GeneralResponse.createSuccessRes(data);
11. }

• 定义了类 DecryptBodyEncryptReturnValueProcessor，那么如何加入spring消息转换组件当中去呢？针对传统xml配置和springboot注解配置，分别如下： xml配置

1. <bean id="jackson_mc" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
3. <mvc:annotation-driven>
4. <mvc:argument-resolvers>
5. <bean class="org.spm.handler.DecryptBodyEncryptReturnValueProcessor">
6. <constructor-arg name="converters">
7. <list>
8. <ref bean="jackson_mc" />
9. </list>
10. </constructor-arg>
11. </bean>
12. </mvc:argument-resolvers>
14. <mvc:message-converters>
15. <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
16. <property name="supportedMediaTypes">
17. <list>
18. <value>application/json</value>
19. </list>
20. </property>
21. <property name="objectMapper" ref="fasterxmlObjectMapper"></property>
22. </bean>
23. </mvc:message-converters>
25. <mvc:return-value-handlers />
26. </mvc:annotation-driven>
28. <bean id="fasterxmlObjectMapper" class="com.fasterxml.jackson.databind.ObjectMapper">
29. <property name="serializationInclusion">
30. <util:constant
31. static-field="com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL" />
32. </property>
33. </bean>

springboot注解配置返回搜狐，查看更多

1. import java.util.List;
3. import org.assertj.core.util.Lists;
4. import org.spm.handler.DecryptBodyEncryptReturnValueProcessor;
5. import org.springframework.context.annotation.Bean;
6. import org.springframework.context.annotation.Configuration;
7. import org.springframework.http.MediaType;
8. import org.springframework.http.converter.HttpMessageConverter;
9. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
10. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
11. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
13. import com.fasterxml.jackson.annotation.JsonInclude;
14. import com.fasterxml.jackson.databind.ObjectMapper;
16. @Configuration
17. public class CustomWebMvcConfig extends WebMvcConfigurerAdapter {
19. @Bean
20. public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
21. return new MappingJackson2HttpMessageConverter();
22. }
24. @Bean
25. public ObjectMapper objectMapper() {
26. ObjectMapper mapper = new ObjectMapper();
27. mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
28. return mapper;
29. }
31. @Bean
32. public List<HttpMessageConverter<?>> messageConverters() {
33. List<HttpMessageConverter<?>> messageConverters = Lists.newArrayList();
34. MappingJackson2HttpMessageConverter jacksonMessageConverters = mappingJackson2HttpMessageConverter();
35. jacksonMessageConverters.setSupportedMediaTypes(Lists.newArrayList(MediaType.APPLICATION_JSON_UTF8));
36. jacksonMessageConverters.setObjectMapper(objectMapper());
37. return messageConverters;
38. }
40. @Override
41. public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
42. super.addArgumentResolvers(argumentResolvers);
43. argumentResolvers.add(new DecryptBodyEncryptReturnValueProcessor(messageConverters()));
45. }
47. }

最后说明

• 以上展示了在实际开发过程中，在使用级别上，思考框架如何实现序列化与反序列化，并带着这个问题，一步一步的跟踪调试源码。希望对读者有所启示。

转载至

    https://www.sohu.com/a/245048777_575744