SpringBoot如何使用RequestBodyAdvice進行統一參數處理

Posted on 2021-06-29 by WalkonNet

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 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請求中的參數的修改已經完畢。

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

當我自以為可以使用攔截器前置通知進行處理時才發現，事情並不簡單。

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

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

步驟二：在controller中獲取值

雖然用這種方式可以在request中添加統一的參數，也可以從每一個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的區別：兩者之間的所依賴的環境不一致，filter作為javaWeb三大組件之一，其作用為：攔截請求，以及過濾相應。其依賴於servlet容器。但interceptor依賴於web框架，例如springmvc框架。最常見的面向切面編程AOP所使用的動態代理模式，即是使用攔截器在service方法執行前或者執行後進行一些操作。他們都可以適用於如下的場景：權限檢查，日志記錄，事務管理等等。當然包括，對所有的請求某些參數進行統一的修改。

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

簡單來說方式一和方式二針對進入controller進行攔截，而後做一些操作。方式三使用的攔截的理念是針對業務方法的，在執行業務方法的前面對參數進行修改，和spring中對事務控制的實現方式類似。

思考：

雖然第一，第三種方式都可以在技術上實現針對某些方法進行統一的參數修改。但是如果將項目當做一個工程來思考的話，不同於日志打印或者事務控制這種非業務邏輯的處理，這種統一修改某些參數來完成一些操作，已嚴重入侵瞭業務邏輯。

真正的解決方式要麼在請求的源頭就做好參數設置，要麼通過配置文件在需要使用的地方來進行某些參數的賦值。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

SpringBoot如何使用RequestBodyAdvice進行統一參數處理

SpringBoot RequestBodyAdvice參數處理

Springboot 對RequestBody的值進行統一修改的幾種方式

背景

解決方式

方式一：利用filter進行處理

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

方式三：使用切面處理

總結：

思考：

推薦閱讀：

發佈留言取消回覆

近期文章

SpringBoot RequestBodyAdvice參數處理

Springboot 對RequestBody的值進行統一修改的幾種方式

背景

解決方式

方式一：利用filter進行處理

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

方式三：使用切面處理

總結：

思考：

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆