SpringBoot如何使用RequestBodyAdvice進行統(tǒng)一參數(shù)處理

更新時間：2021年06月29日 10:01:11 作者：BlueKitty1210

這篇文章主要介紹了SpringBoot使用RequestBodyAdvice進行統(tǒng)一參數(shù)處理方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

SpringBoot RequestBodyAdvice參數(shù)處理

在實際項目中 , 往往需要對請求參數(shù)做一些統(tǒng)一的操作 , 例如參數(shù)的過濾 , 字符的編碼 , 第三方的解密等等 , 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 全局請求參數(shù)處理類
 * @author Xingbz
 * @createDate 2019-8-2
 */
@ControllerAdvice(basePackages = "com.xbz.controller")//此處設置需要當前Advice執(zhí)行的域 , 省略默認全局生效
public class GlobalRequestBodyAdvice implements RequestBodyAdvice {
 
 
    /** 此處如果返回false , 則不執(zhí)行當前Advice的業(yè)務 */
    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
//        return methodParameter.getMethod().isAnnotationPresent(XXApiReq.class);
        return false;
    }
 
    /**
     * @title 讀取參數(shù)前執(zhí)行
     * @description 在此做些編碼 / 解密 / 封裝參數(shù)為對象的操作
     *
     *  */
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        return new XHttpInputMessage(inputMessage, "UTF-8");
    }
 
    /**
     * @title 讀取參數(shù)后執(zhí)行
     * @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;
    }
}
 
//這里實現(xiàn)了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默認提供了接口的抽象實現(xiàn)類RequestBodyAdviceAdapter , 我們可以繼承這個類按需實現(xiàn) , 讓代碼更簡潔一點

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的值進行統(tǒng)一修改的幾種方式

背景

最近在項目中遇到需要統(tǒng)一對Request請求中的某一個自定義對象的屬性進行統(tǒng)一修改的需求。

考慮了幾種實現(xiàn)方式，現(xiàn)在記錄一下。由于原項目過于復雜，自己寫幾個demo進行記錄。

解決方式

在這里插入圖片描述

方式一：利用filter進行處理

大坑：

如果你想要改變加了RequestBody注解的數(shù)據(jù)，無論如何你都要通過getInputStream()方法來獲取流來拿到對應的參數(shù)，然后更改。在不經過拿取流的情況下，spring的RequestBody注解也是通過getInputStream()方法來獲取流來映射為request對象。

但是如果你想要的統(tǒng)一的進行修改，也必須經過getInputStream()來首先拿到stream然后才能進行修改。但此時stream被消費之后，就會關閉。

然后你的controller中的參數(shù)就拿不到對象，報錯如下。

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

可以通過創(chuàng)建并使用自定義的的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數(shù)據(jù)的容器
     */
    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里的數(shù)據(jù)讀取出來并轉換成字符串
     *
     * @param inputStream inputStream
     * @return String
     */
    private String inputStream2String(InputStream inputStream) {
        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 {
        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<Filter> 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請求中的參數(shù)的修改已經完畢。

方式二：使用攔截器進行處理

當我自以為可以使用攔截器前置通知進行處理時才發(fā)現(xiàn)，事情并不簡單。

步驟一：自定義一個攔截器

如下圖實現(xiàn)一個攔截器，preHandle中有HttpServletRequest request參數(shù)，雖然可以通過它的流獲取到body中數(shù)據(jù)，但是如果將body中數(shù)據(jù)進行修改的話，其并不能傳遞給controller。因為request只有兩個set方法。如果將要統(tǒng)一修改的值攝入Attribute，則還仍需從controller中拿到

步驟二：在controller中獲取值

雖然用這種方式可以在request中添加統(tǒng)一的參數(shù)，也可以從每一個controller中獲取值，但仍需要對每一個controller進行代碼修改，顯然這種方式并不是我們需要的。

方式三：使用切面處理

步驟一：引入aspect所需要使用的maven依賴

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>

步驟二：編寫自定義的前置通知以及表達

@Component
@Aspect
public class ChangeStudentNameAdvice {
    @Before("execution(* com.example.testlhf.service.impl.*.*(..))&&args(addStudentRequset)")
    public void aroundPoints(AddStudentRequset addStudentRequset) {
        addStudentRequset.getStudent().setName("amd");
    }
}

注意此處的形參需要和args括號內的字符串保持一致，否則報錯。

步驟三：開啟注解@EnableAspectJAutoProxy

在這里插入圖片描述

總結：

首先說下filter和interceptor的區(qū)別：兩者之間的所依賴的環(huán)境不一致，filter作為javaWeb三大組件之一，其作用為：攔截請求，以及過濾相應。其依賴于servlet容器。但interceptor依賴于web框架，例如springmvc框架。最常見的面向切面編程AOP所使用的動態(tài)代理模式，即是使用攔截器在service方法執(zhí)行前或者執(zhí)行后進行一些操作。他們都可以適用于如下的場景：權限檢查，日志記錄，事務管理等等。當然包括，對所有的請求某些參數(shù)進行統(tǒng)一的修改。

比較三種方式，方式一和方式二所謂的攔截基本都是基于對http請求的攔截，filter執(zhí)行在interceptor之前。雖然filter和interceptor都有類似鏈這種概念，但filter可以將request請求修改之后傳遞給后面的filter，就像電路中的串聯(lián)，而interceptor的鏈是獨立的，修改其中一個request并不會影響其他的interceptor，類似并聯(lián)，不能做到只修改一處其他不用修改的方式。

簡單來說方式一和方式二針對進入controller進行攔截，而后做一些操作。方式三使用的攔截的理念是針對業(yè)務方法的，在執(zhí)行業(yè)務方法的前面對參數(shù)進行修改，和spring中對事務控制的實現(xiàn)方式類似。