快捷導(dǎo)航

如何使用攔截器獲取請求的入?yún)⒉⑵滢D(zhuǎn)化為Java對象詳解

更新時間：2025年02月11日 08:52:57 作者：m0_69893292

這篇文章主要介紹了如何使用攔截器獲取請求的入?yún)⒉⑵滢D(zhuǎn)化為Java對象的相關(guān)資料,文中介紹了兩種實現(xiàn)的方法,并給出了詳細(xì)的代碼示例,需要的朋友可以參考下

方式一：攔截器配合過濾器

1. 設(shè)計思路

在 Web 開發(fā)中，當(dāng) HTTP 請求發(fā)送到服務(wù)器時，Spring 會通過一個鏈條處理這個請求，這個鏈條包括很多組件，比如：攔截器（HandlerInterceptor）、過濾器（Filter）、控制器（Controller）、參數(shù)解析器（比如 Spring MVC 的 @RequestParam 或 @RequestBody 等注解）等。

輸入流的問題

當(dāng)客戶端通過 POST 請求發(fā)送數(shù)據(jù)時，數(shù)據(jù)通常是包含在請求體中的（比如表單數(shù)據(jù)或者 JSON 數(shù)據(jù)）。Spring 的 HttpServletRequest 提供了 getInputStream() 方法來讀取請求體中的數(shù)據(jù)。

問題： HttpServletRequest.getInputStream() 只能讀取一次。也就是說，當(dāng)你在攔截器中調(diào)用了 getInputStream() 讀取數(shù)據(jù)時，流就被消費掉了，后續(xù)的組件（例如，Spring 的參數(shù)解析器）再調(diào)用 getInputStream() 就無法讀取到數(shù)據(jù)了，因為流已經(jīng)被關(guān)閉了。

解決方案

解決這個問題的思路是：在攔截器中讀取請求體的數(shù)據(jù)時，不直接從 HttpServletRequest 中讀取，而是通過包裝（HttpServletRequestWrapper）的方式，重新實現(xiàn) getInputStream()，將讀取的數(shù)據(jù)緩存下來，確保后續(xù)的處理鏈依然能夠訪問到請求體的內(nèi)容。

2. 如何實現(xiàn)

創(chuàng)建一個 HttpServletRequestWrapper 類：它將重寫 getInputStream() 方法，讓流的數(shù)據(jù)可以多次讀取。通過這個類緩存請求體的內(nèi)容。
創(chuàng)建一個 Filter：用于包裝請求，將 HttpServletRequest 包裝成我們自己的 HttpServletRequestWrapper。
在攔截器中獲取請求體：在 HandlerInterceptor 中獲取請求體并進(jìn)行解析。

3. 實現(xiàn)步驟

3.1 創(chuàng)建 HttpServletRequestWrapper

這個類主要作用是緩存請求體內(nèi)容，并且重寫 getInputStream()，讓它能夠多次讀取。

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

public class CachedBodyHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private byte[] requestBody;

    public CachedBodyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        // 從 InputStream 讀取數(shù)據(jù)，緩存請求體內(nèi)容
        InputStream inputStream = request.getInputStream();
        this.requestBody = inputStream.readAllBytes();  // 將流中的數(shù)據(jù)讀取到字節(jié)數(shù)組中
    }

    @Override
    public InputStream getInputStream() throws IOException {
        // 返回緩存的數(shù)據(jù)
        return new ByteArrayInputStream(requestBody);
    }

    public byte[] getRequestBody() {
        return requestBody;
    }
}

3.2 創(chuàng)建 Filter 以包裝 HttpServletRequest

這個過濾器的作用是將原始的 HttpServletRequest 替換為我們自定義的 CachedBodyHttpServletRequestWrapper。

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.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter("/*")  // 這個過濾器會攔截所有請求
public class RequestWrapperFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 僅對 HttpServletRequest 進(jìn)行包裝
        if (request instanceof HttpServletRequest) {
            CachedBodyHttpServletRequestWrapper wrappedRequest =
                    new CachedBodyHttpServletRequestWrapper((HttpServletRequest) request);
            // 將包裝后的請求傳遞給下一個過濾器
            chain.doFilter(wrappedRequest, response);
        } else {
            // 對非 HttpServletRequest 請求不做任何處理
            chain.doFilter(request, response);
        }
    }

    @Override
    public void destroy() {
        // 銷毀操作
    }
}

3.3 創(chuàng)建攔截器 HandlerInterceptor 以處理請求參數(shù)

接下來，在 Spring 的攔截器中獲取請求體并解析成 Java 對象。這個攔截器將會在請求進(jìn)入控制器之前進(jìn)行攔截。

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestBodyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws IOException {
        if (request instanceof CachedBodyHttpServletRequestWrapper) {
            // 獲取包裝后的請求體
            CachedBodyHttpServletRequestWrapper wrappedRequest = (CachedBodyHttpServletRequestWrapper) request;
            String requestBody = new String(wrappedRequest.getRequestBody(), "UTF-8");
            // 打印或處理請求體內(nèi)容
            System.out.println("Request Body: " + requestBody);

            // 將請求體轉(zhuǎn)換成 Java 對象
            MyRequestObject myRequestObject = new ObjectMapper().readValue(requestBody, MyRequestObject.class);
            System.out.println("Parsed Java Object: " + myRequestObject);
        }

        return true; // 返回 true，表示繼續(xù)處理請求
    }
}

3.4 注冊攔截器和過濾器

在 Spring Boot 中注冊 Filter：
提示：在Spring Boot項目中，Filter會自動注冊到應(yīng)用上下文中，可以不手動注冊。

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<RequestWrapperFilter> loggingFilter() {
        FilterRegistrationBean<RequestWrapperFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new RequestWrapperFilter());
        registrationBean.addUrlPatterns("/api/*");  // 這里根據(jù)需要配置攔截的 URL
        return registrationBean;
    }
}

在 Spring Boot 中注冊 HandlerInterceptor：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private RequestBodyInterceptor requestBodyInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(requestBodyInterceptor).addPathPatterns("/api/*");  // 根據(jù)需要配置路徑
    }
}

4. 總結(jié)

通過以上步驟，你可以實現(xiàn)一個能夠多次讀取 HttpServletRequest.getInputStream() 數(shù)據(jù)的機(jī)制?；舅悸肥牵?/p>

創(chuàng)建一個 HttpServletRequestWrapper 類來緩存請求體內(nèi)容；
通過 Filter 來包裝 HttpServletRequest；
在 HandlerInterceptor 中獲取請求體并進(jìn)行處理。

這樣，無論在攔截器還是后續(xù)的參數(shù)解析過程中，都會能夠多次訪問請求體數(shù)據(jù)。

方式二：攔截器中使用包裝類ContentCachingRequestWrapper

在 HTTP 請求中，HttpServletRequest 的請求體（POST 請求中的 JSON 數(shù)據(jù)）是一次性的流，讀取完一次之后，如果沒有特殊處理，就不能再次讀取它。

ContentCachingRequestWrapper 是 Spring 框架提供的一個包裝類，它的作用是“包裝”原始的 HttpServletRequest 對象，使得請求體內(nèi)容可以被多次讀取。

使用ContentCachingRequestWrapper ，省去方法一中創(chuàng)建的 HttpServletRequestWrapper和RequestWrapperFilter。

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class RequestBodyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws IOException {
		if (HttpMethod.POST.matches(request.getMethod())) {
 			// 包裝請求，使其可以多次讀取請求體
            ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(request);

			// 讀取請求體，明確指定字符編碼為 UTF-8
			String requestBody = new String(wrappedRequest.getContentAsByteArray(), "UTF-8");

            // 打印或處理請求體內(nèi)容
            System.out.println("Request Body: " + requestBody);

            // 將請求體轉(zhuǎn)換成 Java 對象
            MyRequestObject myRequestObject = new ObjectMapper().readValue(requestBody, MyRequestObject.class);
            System.out.println("Parsed Java Object: " + myRequestObject);
        }

        return true; // 返回 true，表示繼續(xù)處理請求
    }
}

總結(jié)

ContentCachingRequestWrapper 是一種非常有用的工具，允許緩存并多次讀取請求體內(nèi)容，尤其需要在攔截器中處理請求體數(shù)據(jù)時，它非常有效。

到此這篇關(guān)于如何使用攔截器獲取請求的入?yún)⒉⑵滢D(zhuǎn)化為Java對象的文章就介紹到這了,更多相關(guān)攔截器獲取請求入?yún)⒉⑥D(zhuǎn)化Java對象內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: