侧边栏壁纸
博主头像
再见理想博主等级

只争朝夕，不负韶华

  • 累计撰写 112 篇文章
  • 累计创建 64 个标签
  • 累计收到 4 条评论
标签搜索

目 录CONTENT

文章目录
Spring

SpringMVC之RequestBodyAdvice源码解析

再见理想
再见理想
2023-07-03 / 0 评论 / 0 点赞 / 1,388 阅读 / 2,582 字

一，前言

在项目中，有时候我们需要在请求之前或之后做一些操作，比如：对参数进行解密，对所有的返回值进行加密、或需要对参数进行加工处理等，这些与业务无关的操作，我们没有必要在每个 controller 方法中都写一遍，这里我们就可以使用 springmvc 中的 @ControllerAdvice 和 RequestBodyAdvice、ResponseBodyAdvice 来对请求前后进行处理，本质上就是 aop 的思想。
RequestBodyAdvice：对 @RquestBody 参数进行增强处理。比如所有请求的数据都加密之后放在 body 中，在到达 controller 的方法之前，需要先进行解密，那么就可以通过 RequestBodyAdvice 来进行统一的解密处理，无需在 controller 方法中去做这些通用的操作。
ResponseBodyAdvice：对 Controller 中@ResponseBody 类型返回值进行增强处理。也就是说可以拦截 @ResponseBody 类型的返回值，进行再次处理，比如加密、包装等操作。

二，关于RequestBodyAdvice概述

RequestBodyAdvice 源码：

/**
 * Allows customizing the request before its body is read and converted into an
 * Object and also allows for processing of the resulting Object before it is
 * passed into a controller method as an {@code @RequestBody} or an
 * {@code HttpEntity} method argument.
 *
 * <p>Implementations of this contract may be registered directly with the
 * {@code RequestMappingHandlerAdapter} or more likely annotated with
 * {@code @ControllerAdvice} in which case they are auto-detected.
 *
 * @author Rossen Stoyanchev
 * @since 4.2
 */
public interface RequestBodyAdvice {
	boolean supports(MethodParameter methodParameter, Type targetType,
			Class<? extends HttpMessageConverter<?>> converterType);

	Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType, Class<? extends HttpMessageConverter<?>> converterType);

	HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException;

	Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType, Class<? extends HttpMessageConverter<?>> converterType); 
}

该接口是 Spring4.2 版本新增的接口，主要用于给请求体参数做前后增强处理，如果supports方法返回true，调用beforeBodyRead方法进行参数增强处理。

查看一下源码中的 beforeBodyRead 方法，看到 RequestResponseBodyAdviceChain 类有实现该接口，并调用该方法。继续向下查看，发现AbstractMessageConverterMethodArgumentResolver抽象类中 readWithMessageConverters 方法中调用该方法，该抽象类实现了 RequestResponseBodyMethodProcessor（下文有介绍）的HandlerMethodArgumentResolver 处理方法参数接口，当重写 supports 方法返回true 时，通过 beforeBodyRead和afterBodyRead 进行参数处理。

AbstractMessageConverterMethodArgumentResolver 抽象类用于对不同类型的请求参数作不同的处理。实现子类有：

  • HttpEntityMethodProcessor：处理方法参数是 HttpEntity 或 RequestEntity；
  • RequestPartMethodArgumentResolver：处理方法参数是 @RequestPart 和 MultipartFile 和Part；
  • RequestResponseBodyMethodProcessor：处理方法参数是 RequestBody；

三，HttpMessageConverter 消息转换器

在 Spring MVC 中，可以使用 @RequestBody 和 @ResponseBody 两个注解，分别完成请求报文到对象和对象到响应报文的转换，底层这种灵活的消息转换机制，就是Spring 3.x 中新引入的 HttpMessageConverter ，即消息转换器机制。我们先来看 HttpInputMessage 和 HttpOutputMessage 两个接口。

3.1，HttpInputMessage

这个类是 SpringMVC 内部对一次 Http 请求报文的抽象，在 HttpMessageConverter 的 read(…) 方法中，有一个 HttpInputMessage 的形参，它正是 SpringMVC 的消息转换器所作用的受体“请求消息”的内部抽象，消息转换器从“请求消息”中按照规则提取消息，转换为方法形参中声明的对象。

3.2，HttpOutputMessage

这个类是 Spring MVC 内部对一次 Http 响应报文的抽象，在 HttpMessageConverter 的 write(…) 方法中，有一个 HttpOutputMessage 的形参，它正是 Spring MVC 的消息转换器所作用的受体“响应消息”的内部抽象，消息转换器将“响应消息”按照一定的规则写到响应报文中。

3.3，HttpMessageConverter

对消息转换器最高层次的接口抽象，描述了一个消息转换器的一般特征，我们可以从这个接口中定义的方法，来领悟Spring3.x的设计者对这一机制的思考过程。

package org.springframework.http.converter;

import java.io.IOException;
import java.util.List;

import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;

public interface HttpMessageConverter<T> {

	boolean canRead(Class<?> clazz, MediaType mediaType);

	boolean canWrite(Class<?> clazz, MediaType mediaType);

	List<MediaType> getSupportedMediaTypes();

	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;

}

HttpMessageConverter接口的定义出现了成对的 canRead(…) + read(…) 和 canWrite(…) + write(…) 方法，SpringMVC之所以能将http请求消息映射成我们controller接口的方法参数的实体，以及将响应结果转换成http消息，是因为框架Spring框架定义了很多的消息转换器，流程如下：

3.4，RequestResponseBodyMethodProcessor

将上述过程集中描述的一个类是 org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor，这个类同时实现了 HandlerMethodArgumentResolver 和 HandlerMethodReturnValueHandler 两个接口。前者是将请求报文绑定到处理方法形参的策略接口，后者则是对处理方法返回值进行处理的策略接口。

对 HandlerMethodArgumentResolver 接口的实现：

// RequestResponseBodyMethodProcessor.java
public boolean supportsParameter(MethodParameter parameter) {
	return parameter.hasParameterAnnotation(RequestBody.class);
}

public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
		NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

	Object argument = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType());

	String name = Conventions.getVariableNameForParameter(parameter);
	WebDataBinder binder = binderFactory.createBinder(webRequest, argument, name);

	if (argument != null) {
		validate(binder, parameter);
	}

	mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());

	return argument;
}

对 HandlerMethodReturnValueHandler 接口的实现：

// RequestResponseBodyMethodProcessor.java
public boolean supportsReturnType(MethodParameter returnType) {
	return returnType.getMethodAnnotation(ResponseBody.class) != null;
}

public void handleReturnValue(Object returnValue, MethodParameter returnType,
		ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
		throws IOException, HttpMediaTypeNotAcceptableException {

	mavContainer.setRequestHandled(true);
	if (returnValue != null) {
		writeWithMessageConverters(returnValue, returnType, webRequest);
	}
}

看完上面的代码，整个 HttpMessageConverter 消息转换的脉络已经非常清晰。因为两个接口的实现，分别是以是否有 @RequestBody 和 @ResponseBody 为条件，然后分别调用 HttpMessageConverter 来进行消息的读写。

3.5，思考

在我们对 Spring MVC 源码分析的过程中，我们可以从 HttpMessageConverter 机制中领悟到类似的道理。在Spring MVC 的设计者眼中，一次请求报文和一次响应报文，分别被抽象为一个请求消息HttpInputMessage 和一个响应消息 HttpOutputMessage 。
处理请求时，由合适的消息转换器将请求报文绑定为方法中的形参对象，在这里，同一个对象就有可能出现多种不同的消息形式，比如 json 和 xml 。同样，当响应请求时，方法的返回值也同样可能被返回为不同的消息形式，比如 json 和 xml 。
在 Spring MVC 中，针对不同的消息形式，我们有不同的 HttpMessageConverter 实现类来处理各种消息形式。但是，只要这些消息所蕴含的“有效信息”是一致的，那么各种不同的消息转换器，都会生成同样的转换结果。至于各种消息间解析细节的不同，就被屏蔽在不同的 HttpMessageConverter 实现类中了。

四，应用一：全局加解密

使用RequestBodyAdvice加解密可以参考以下文章：基于RequestBodyAdvice与ResponseBodyAdvice实现统一加解密

五，应用二：获取并处理类型转换异常的body参数

应用场景：需要对重要接口的参数转换异常情况保存到数据库，以便发现问题及数据修复。
当body参数中出现类型不一致，还没到达接口层，在HttpMessageConverter转换时会报 HttpMessageNotReadableException 异常。
需要在全局异常类中捕获HttpMessageConverter并进行处理，但因为HttpServletRequest读流只能一次，在HttpMessageConverter中已经被读取，在全局异常中不能被读取到。

5.1，解决一：使用 HttpServletRequest 包装类

使用 ContentCachingRequestWrapper 替代 HttpServletRequest，在过滤器filter中传递该类，即可对输入流重复读取。在全局异常类中读取流，进行处理。
自定义过滤器配置类：

@Configuration
public class FilterConfig extends GenericFilterBean {
    // 只处理json数据
    private static final String CONTENT_TYPE_JSON = "application/json";
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String requestURI = request.getRequestURI();
        ContentCachingRequestWrapper wrapper = new ContentCachingRequestWrapper(request);
        filterChain.doFilter(wrapper, servletResponse);
    }
}

5.2，解决二：使用RequestBodyAdvice处理

处理思路是使用RequestBodyAdvice进行body参数的增强处理，在请求体被读取之前，主动读取流，并将请求的json字符串保存在header中，然后重新生成并返回流对象HttpInputMessage。

import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.CharsetUtil;
import com.bbcc.framework.common.utils.RequestUtil;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;


@ControllerAdvice
public class CustomRequestBodyAdvice implements RequestBodyAdvice {

    // 需要处理的接口，多个以','隔开
    private static final String requestURIList = "/api/xxx";

    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        String uri = RequestUtil.getRequest().getRequestURI();
        return requestURIList.contains(uri);
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        try {
            InputStream body = inputMessage.getBody();
            String originalContent = IoUtil.read(body, CharsetUtil.CHARSET_UTF_8);
            RequestUtil.getRequest().setAttribute("jsonStr", originalContent);
            // 将修改后的内容重新生成输入流
            byte[] originalContentBytes = originalContent.getBytes(CharsetUtil.CHARSET_UTF_8);
            InputStream newBody = new ByteArrayInputStream(originalContentBytes);
            //转换新的对象
            return new CustomHttpInputMessage(inputMessage.getHeaders(), newBody);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return inputMessage;
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return null;
    }

    /**
     * 新消息类
     */
    private static class CustomHttpInputMessage implements HttpInputMessage {
        HttpHeaders headers;
        InputStream body;

        public CustomHttpInputMessage(HttpHeaders headers, InputStream body) {
            this.body = body;
            this.headers = headers;
        }

        @Override
        public InputStream getBody() throws IOException {
            return body;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }
    }
}

当拦截的特定的接口，就会进入beforeBodyRead方法进行处理，将请求参数写入到header中，以便在全局异常类中获取。自定义全局异常类：

@Slf4j
@ControllerAdvice
public class ExceptionHandler {
    @ExceptionHandler(HttpMessageNotReadableException.class)
    @ResponseBody
    public Result<String> handleMessageNotReadableException(HttpMessageNotReadableException e) {
        // 读取body字符串
        HttpServletRequest request= RequestUtil.getRequest();
        String requestBody = request.getAttribute("jsonStr").toString();
        // 业务逻辑...
        
        return Result.fail(Error.INVALID_REQUEST_PARAMETER.getCode(), "参数解析失败");
    }

}

总结

可以使用 SpringMVC 中的 @ControllerAdvice 和 RequestBodyAdvice/ResponseBodyAdvice 来对不同类型的请求参数或返回值进行增强处理。

0
Spring SpringMVC
版权归属： 再见理想
本文链接： https://blog.qiyls.cn/archives/requestbodyadvice
许可协议： 本文使用《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》协议授权

评论区