SpringBoot如何使用RequestBodyAdvice进行统一参数处理

SpringBoot如何使用RequestBodyAdvice进行统一参数处理

SpringBoot RequestBodyAdvice参数处理

在实际项目中 , 往往需要对请求参数做一些统一的操作 , 例如参数的过滤 , 字符的编码 , 第三方的解密等等 , Spring提供了RequestBodyAdvice一个全局的解决方案 , 免去了我们在Controller处理的繁琐 .

RequestBodyAdvice仅对使用了@RqestBody注解的生效 , 因为它原理上还是AOP , 所以GET方法是不会操作的.

package com.xbz.common.web;

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.IOException;

import java.io.InputStream;

import java.lang.reflect.Type;

/**

* @title 全局请求参数处理类

* @author Xingbz

* @createDate 2019-8-2

*/

@ControllerAdvice(basePackages = "com.xbz.controller")//此处设置需要当前Advice执行的域 , 省略默认全局生效

public class GlobalRequestBodyAdvice implements RequestBodyAdvice {

/** 此处如果返回false , 则不执行当前Advice的业务 */

@Override

public boolean supports(MethodParameter methodParameter, Type targetType, Class extends HttpMessageConverter>> converterType) {

// return methodParameter.getMethod().isAnnotationPresent(XXApiReq.class);

return false;

}

/**

* @title 读取参数前执行

* @description 在此做些编码 / 解密 / 封装参数为对象的操作

*

* */

@Override

public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class extends HttpMessageConverter>> converterType) throws IOException {

return new XHttpInputMessage(inputMessage, "UTF-8");

}

/**

* @title 读取参数后执行

* @author Xingbz

*/

@Override

public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class extends HttpMessageConverter>> converterType) {

return inputMessage;

}

/**

* @title 无请求时的处理

*/

@Override

public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class extends HttpMessageConverter>> converterType) {

return body;

}

}

//这里实现了HttpInputMessage 封装一个自己的HttpInputMessage

class XHttpInputMessage implements HttpInputMessage {

private HttpHeaders headers;

private InputStream body;

public XHttpInputMessage(HttpInputMessage httpInputMessage, String encode) throws IOException {

this.headers = httpInputMessage.getHeaders();

this.body = encode(httpInputMessage.getBody(), encode);

}

private InputStream encode(InputStream body, String encode) {

//省略对流进行编码的操作

return body;

}

@Override

public InputStream getBody() {

return body;

}

@Override

public HttpHeaders getHeaders() {

return null;

}

}

Spring默认提供了接口的抽象实现类RequestBodyAdviceAdapter , 我们可以继承这个类按需实现 , 让代码更简洁一点

package org.springframework.web.servlet.mvc.method.annotation;

import java.io.IOException;

import java.lang.reflect.Type;

import org.springframework.core.MethodParameter;

import org.springframework.http.HttpInputMessage;

import org.springframework.http.converter.HttpMessageConverter;

import org.springframework.lang.Nullable;

public abstract class RequestBodyAdviceAdapter implements RequestBodyAdvice {

@Override

public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter,

Type targetType, Class extends HttpMessageConverter>> converterType)

throws IOException {

return inputMessage;

}

@Override

public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter,

Type targetType, Class extends HttpMessageConverter>> converterType) {

return body;

}

@Override

@Nullable

public Object handleEmptyBody(@Nullable Object body, HttpInputMessage inputMessage,

MethodParameter parameter, Type targetType,

Class extends HttpMessageConverter>> converterType) {

return body;

}

}

Springboot 对RequestBody的值进行统一修改的几种方式

背景

最近在项目中遇到需要统一对Request请求中的某一个自定义对象的属性进行统一修改的需求。

考虑了几种实现方式，现在记录一下。由于原项目过于复杂，自己写几个demo进行记录。

解决方式

方式一：利用filter进行处理

大坑：

​ 如果你想要改变加了RequestBody注解的数据，无论如何你都要通过getInputStream()方法来获取流来拿到对应的参数，然后更改。在不经过拿取流的情况下，spring的RequestBody注解也是通过getInputStream()方法来获取流来映射为request对象。

但是如果你想要的统一的进行修改，也必须经过getInputStream()来首先拿到stream然后才能进行修改。但此时stream被消费之后，就会关闭。

然后你的controller中的参数就拿不到对象，报错如下。

I/O error while reading input message; nested exception is java.io.IOException: Stream closed

可以通过创建并使用自定义的的HttpServletRequestWrapper来避免这种情况。

步骤一：编写自定义HttpServletRequestWrapper

package com.example.testlhf.filter;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import com.example.testlhf.entity.Student;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.ReadListener;

import javax.servlet.ServletInputStream;

import javax.servlet.ServletRequest;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.Charset;

/**

* @Description TODO

* @Author yyf

* @Date 2020/10/29 12:48

* @Version 1.0

**/

@Slf4j

public class ChangeStudentNameRequestWrapper extends HttpServletRequestWrapper {

/**

* 存储body数据的容器

*/

private byte[] body;

public ChangeStudentNameRequestWrapper(HttpServletRequest request) throws IOException {

super(request);

//接下来的request使用这个

String bodyStr = getBodyString(request);

body = bodyStr.getBytes(Charset.defaultCharset());

}

/**

* 获取请求Body

*

* @param request request

* @return String

*/

public String getBodyString(final ServletRequest request) {

try {

return inputStream2String(request.getInputStream());

} catch (IOException e) {

log.error("", e);

throw new RuntimeException(e);

}

}

/**

* 获取请求Body

*

* @return String

*/

public String getBodyString() {

final InputStream inputStream = new ByteArrayInputStream(body);

return inputStream2String(inputStream);

}

/**

* 将inputStream里的数据读取出来并转换成字符串

*

* @param inputStream inputStream

* @return String

*/

private String inputStream2String(InputStream inputStrehttp://am) {

StringBuilder sb = new StringBuilder();

BufferedReader reader = null;

try {

reader = new BufferedReader(new InputStreamReader(inputStream, Charset.defaultCharset()));

String line;

while ((line = reader.readLine()) != null) {

sb.append(line);

}

} catch (IOException e) {

log.error("", e);

throw new RuntimeException(e);

} finally {

if (reader != null) {

try {

reader.close();

} catch (IOException e) {

log.error("", e);

}

}

}

JSONObject jsonObject = JSONObject.parseObject(sb.toString());

if (jsonObject != null && jsonObject.get("student") != null) {

Student student = JSON.toJavaObject((JSON) jsonObject.get("student"), Student.class);

log.info("修改之前的学生名称为：" + student.getName());

student.setName("amd");

jsonObject.put("student", student);

return jsonObject.toJSONString();

}

return sb.toString();

}

@Override

public BufferedReader getReader() throws IOException {

return new BufferedReader(new InputStreamReader(getInputStream()));

}

@Override

public ServletInputStream getInputStream() throws IOException {

http:// final ByteArrayInputStream inputStream = new ByteArrayInputStream(body);

return new ServletInputStream() {

@Override

public int read() throws IOException {

return inputStream.read();

}

@Override

public boolean isFinished() {

return false;

}

@Override

public boolean isReady() {

return false;

}

@Override

public void setReadListener(ReadListener readListener) {

}

};

}

}

步骤二：使用自定义的HttpServletRequestWrapper取代原有的

使用自定义的request取代原有的传递给过滤器链。

package com.example.testlhf.filter;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import java.io.IOException;

/**

* @Description TODO

* @Author yyf

* @Date 2020/10/29 13:20

* @Version 1.0

**/

@Slf4j

public class ReplaceStreamFilter implements Filter {

@Override

public void init(FilterConfig filterConfig) throws ServletException {

log.info("StreamFilter初始化...");

}

@Override

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

ServletRequest requestWrapper = null;

//获取请求中的流，将取出来的字符串，再次转换成流，然后把它放入到新request对象中,

if (request instanceof HttpServletRequest) {

requestWrapper = new ChangeStudentNameRequestWrapper((HttpServletRequest) request);

}

// 在chain.doFiler方法中传递新的request对象

if (requestWrapper == null) {

chain.doFilter(request, response);

} else {

chain.doFilter(requestWrapper, response);

}

}

@Override

public void destroy() {

log.info("StreamFilter销毁...");

}

}

步骤三：将过滤器注册进spring容器

package com.example.testlhf.filter;

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;

/**

* @Description TODO

* @Author yyf

* @Date 2020/10/29 14:20

* @Version 1.0

**/

@Configuration

public class MyFilterConfig {

/**

* 注册过滤器

*

* @return FilterRegistrationBean

*/

@Bean

public FilterRegistrationBean someFilterRegistration() {

FilterRegistrationBean registration = new FilterRegistrationBean<>();

registration.setFilter(replaceStreamFilter());

registration.addUrlPatterns("/*");

registration.setName("replaceStreamFilter");

return registration;

}

/**

* 实例化StreamFilter

*

* @return Filter

*/

@Bean(name = "replaceStreamFilter")

public Filter replaceStreamFilter() {

return new ReplaceStreamFilter();

}

}

看下效果：

到此使用过滤器对post请求中的参数的修改已经完毕。

方式二：使用拦截器进行处理

当我自以为可以使用拦截器前置通知进行处理时才发现，事情并不简单。

步骤一：自定义一个拦截器

如下图实现一个拦截器，preHandle中有HttpServletRequest request参数，虽然可以通过它的流获取到body中数据，但是如果将body中数据进行修改的话，其并不能传递给controller。因为request只有两个set方法。如果将要统一修改的值摄入Attribute，则还仍需从controller中拿到

步骤二：在controller中获取值

虽然用这种方式可以在request中添加统一的参数，也可以从每一个controller中获取值，但仍需要对每一个controller进行代码修改，显然这种方式并不是我们需要的。

方式三：使用切面处理

步骤一：引入aspect所需要使用的maven依赖

org.springframework

spring-aspects

5.1.3.RELEASE

步骤二：编写自定义的前置通知以及表达

@Component

@Aspect

public class ChangeStudentNameAdvice {

@Before("execution(* com.example.testlhf.service.impl.*.*(..))&&args(addStudentRequset)")

public void aroundPoints(AddStudentRequset addStudentRequset) {

addStudentRequset.getStudent().setName("amd");

}

}

注意此处的形参需要和args括号内的字符串保持一致，否则报错。

注意此处的形参需要和args括号内的字符串保持一致，否则报错。

步骤三：开启注解@EnableAspectJAutoProxy

总结：

首先说下filter和interceptor的区别：两者之间的所依赖的环境不一致，filter作为javaWeb三大组件之一，其作用为：拦截请求，以及过滤相应。其依赖于servlet容器。但interceptor依赖于web框架，例如springmvc框架。最常见的面向切面编程AOP所使用的动态代理模式，即是使用拦截器在service方法执行前或者执行后进行一些操作。他们都可以适用于如下的场景：权限检查，日志记录，事务管理等等。当然包括，对所有的请求某些参数进行统一的修改。

比较三种方式，方式一和方式二所谓的拦截基本都是基于对http请求的拦截，filter执行在interceptor之前。虽然filter和interceptor都有类似链这种概念，但filter可以将request请求修改之后传递给后面的filter，就像电路中的串联，而interceptor的链是独立的，修改其中一个request并不会影响其他的interceptor，类似并联，不能做到只修改一处其他不用修改的方式。

简单来说方式一和方式二针对进入controller进行拦截，而后做一些操作。方式三使用的拦截的理念是针对业务方法的，在执行业务方法的前面对参数进行修改，和spring中对事务控制的实现方式类似。

思考：

虽然第一，第三种方式都可以在技术上实现针对某些方法进行统一的参数修改。但是如果将项目当做一个工程来思考的话，不同于日志打印或者事务控制这种非业务逻辑的处理，这种统一修改某些参数来完成一些操作，已严重入侵了业务逻辑。

真正的解决方式要么在请求的源头就做好参数设置，要么通过配置文件在需要使用的地方来进行某些参数的赋值。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。