前言

在現(xiàn)代 Web 開發(fā)中，使用異步線程處理長時間運行的任務(wù)（如文件導(dǎo)出、大規(guī)模數(shù)據(jù)處理等）已經(jīng)成為一種常見的做法。

Spring 提供了多種方式來實現(xiàn)異步請求，其中 startAsync() 是一個常見的用法。然而，當(dāng)我們需要在異步線程中訪問 HttpServletRequest 時，可能會遇到一些問題，因為 HttpServletRequest 的生命周期與線程綁定，而異步線程通常無法繼承主線程的請求上下文。

本文將從以下幾個方面詳細(xì)分析這個問題，并提供解決方案：

• 為什么異步線程中無法訪問 HttpServletRequest？
• Tomcat 的 request 復(fù)用機制及其影響
• AsyncContext 的作用與局限性
• RequestContextHolder 的正確使用
• 完整的解決方案

一、問題的來源：為什么異步線程中無法訪問 HttpServletRequest？

1. 請求上下文與線程綁定

HttpServletRequest 是與當(dāng)前請求線程綁定的。通常情況下，Servlet 容器會為每個 HTTP 請求分配一個線程，并在該線程內(nèi)處理請求。在這種情況下，HttpServletRequest 是屬于主線程的。當(dāng)請求處理完成后，Servlet 容器會清除請求對象。

然而，在異步請求處理模式下，主線程與異步線程是不同的線程，默認(rèn)情況下，異步線程無法訪問到主線程中的請求對象。原因在于：

• 線程隔離：異步線程和主線程的上下文是隔離的，異步線程不能自動繼承主線程的請求上下文。
• 生命周期問題：HttpServletRequest 的生命周期通常與請求處理線程綁定，當(dāng)請求處理完成時，它會被清除。

2. 異步線程訪問請求對象時的常見問題

• 異步線程初始無法訪問 HttpServletRequest：異步線程在執(zhí)行時，并不自動繼承主線程的請求上下文。因此，直接在異步線程中通過 RequestContextHolder.getRequestAttributes() 獲取請求對象時，返回值為 null，導(dǎo)致無法訪問 HttpServletRequest。
• 短時間內(nèi)可以訪問，隨后無法訪問：在使用 startAsync() 啟動異步線程時，Tomcat 會延遲 HttpServletRequest 對象的清除。這意味著，如果異步線程在 complete() 被調(diào)用之前開始執(zhí)行，可能仍然能訪問到 HttpServletRequest。但一旦 complete() 被調(diào)用，HttpServletRequest 會被清除，此時異步線程就無法再訪問請求對象。
• 請求對象清除后無法訪問：一旦 asyncContext.complete() 被調(diào)用，請求對象將被清除，異步線程就無法再訪問 HttpServletRequest。

二、Tomcat 的 request 復(fù)用機制及其影響

1. Tomcat 請求對象復(fù)用機制

Tomcat 在處理請求時采用了一種請求對象復(fù)用機制。為了提高性能，Tomcat 會復(fù)用請求對象以減少內(nèi)存的創(chuàng)建和銷毀開銷。這個機制通常用于高并發(fā)的環(huán)境中，以提高服務(wù)器的處理效率。在復(fù)用機制下，Tomcat 會緩存一些請求對象，在同一請求的生命周期內(nèi)重新使用這些對象。

然而，這種復(fù)用機制并不會影響請求對象的生命周期。當(dāng)請求在主線程中處理完畢時，HttpServletRequest 對象會被銷毀，并且不能跨線程使用。因此，盡管 Tomcat 可能復(fù)用了某些對象，它不會在請求的生命周期結(jié)束后繼續(xù)提供給異步線程。

2. 請求對象的生命周期與清理機制

Tomcat 中，HttpServletRequest 的生命周期由請求的處理線程管理。當(dāng)一個請求到達(dá)時，Tomcat 會為它分配一個線程來處理，而當(dāng)請求處理完畢后，Tomcat 會清除該請求對象。對于異步請求，Tomcat 會延緩請求對象的銷毀，直到異步任務(wù)完成并調(diào)用 complete()。

在使用 startAsync() 啟動異步線程時，Tomcat 會為請求對象設(shè)置一個“延遲銷毀”的狀態(tài)，直到所有異步任務(wù)完成。這意味著，異步線程可以在 complete() 被調(diào)用之前訪問請求對象，因為請求對象尚未被清除。

3. AsyncContext 的影響

AsyncContext 是用于支持異步處理的一個對象，它通過 startAsync() 方法創(chuàng)建。它的作用是延遲請求對象的清除，直到異步任務(wù)完成。調(diào)用 asyncContext.complete() 后，Tomcat 會釋放請求對象，這時候異步線程將無法訪問請求對象中的任何數(shù)據(jù)。

這就是為什么，在異步線程執(zhí)行時，能夠訪問請求參數(shù)的一個限制。如果異步線程在 asyncContext.complete() 被調(diào)用之前訪問請求對象，它可以正常獲取請求數(shù)據(jù)。否則，它將無法訪問這些數(shù)據(jù)。

三、AsyncContext 的作用與局限性

1.startAsync() 的作用

startAsync() 方法用于啟動異步處理，它會創(chuàng)建一個 AsyncContext 實例，并延遲請求對象的銷毀。通過調(diào)用 startAsync()，Tomcat 會將請求對象的清除延緩，直到調(diào)用 asyncContext.complete()。

示例：startAsync() 延遲請求清理

public String handleRequest(HttpServletRequest request, HttpServletResponse response) {
    AsyncContext asyncContext = request.startAsync(request, response);
    new Thread(() -> {
        try {
            String age = request.getParameter("name");
            System.out.println("異步線程中訪問的 name: " + age);
            // 執(zhí)行導(dǎo)出任務(wù)
            // 需要將 request 顯式傳遞給異步線程中的方法
            exportData(request);
            asyncContext.complete(); // 延遲請求清理
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
    return "success";
}
 /**
  *  模擬導(dǎo)出任務(wù)
  */
private void exportData(HttpServletRequest request) {
    // 在 exportTask 內(nèi)部可以繼續(xù)訪問 request
    String userId = request.getParameter("userId");
    System.out.println("在 exportData 方法中獲取到的 userId: " + userId);
}

在這個例子中，startAsync() 延遲了 HttpServletRequest 對象的銷毀，因此異步線程在 complete() 執(zhí)行之前可以訪問請求對象。
關(guān)鍵點：

異步線程中無法直接獲取 request：
異步線程和主線程是不同的線程，默認(rèn)情況下，異步線程無法直接訪問主線程的 HttpServletRequest 對象。因此，我們需要將 request 顯式地傳遞給異步線程，或者使用 RequestContextHolder 將請求上下文傳遞給異步線程。

延遲清理請求：
asyncContext.complete() 使得請求對象不會在異步線程執(zhí)行期間被清理，保證了異步線程可以訪問請求。如果不調(diào)用 complete()，請求對象會在請求結(jié)束時被清理，導(dǎo)致異步線程無法訪問 request。

傳遞 request 到其他方法：
如果 exportTask 需要訪問請求中的數(shù)據(jù)，就需要在 exportTask 內(nèi)部顯式傳遞 request，如在示例中將 request 作為參數(shù)傳遞給 exportData 方法。

2. AsyncContext 的局限性

• 請求清理時間：異步線程可以訪問請求對象，直到調(diào)用 asyncContext.complete()。一旦 complete() 被調(diào)用，Tomcat 會銷毀請求對象，異步線程就無法再訪問 HttpServletRequest 了。
• 無法自動繼承請求上下文：即使 startAsync() 延緩了請求清理，它并不會自動將主線程中的請求上下文傳遞給異步線程。這意味著，在異步線程中直接調(diào)用 RequestContextHolder.getRequestAttributes() 獲取請求上下文時，會返回 null，因為請求上下文沒有被傳遞。

四、RequestContextHolder 的正確使用

為了在異步線程中訪問請求對象，我們需要顯式地將請求上下文傳遞給異步線程。這可以通過 RequestContextHolder.setRequestAttributes() 來實現(xiàn)，并通過 inheritable=true 確保請求上下文能夠傳遞到異步線程中。

1. 傳遞請求上下文

在啟動異步線程時，我們需要手動將請求上下文傳遞到異步線程中，以確保它能夠訪問主線程中的 HttpServletRequest。具體方法是通過 RequestContextHolder.setRequestAttributes() 進(jìn)行上下文傳遞。

示例：正確使用 RequestContextHolder

private void executeExportTask(Runnable exportTask, String errorMessage) {
    HttpServletRequest req = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes().getRequest();
    HttpServletResponse response = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes().getResponse();
    // 手動傳遞請求上下文，設(shè)置 inheritable=true 以確保異步線程繼承主線程的請求上下文
    ServletRequestAttributes attributes = new ServletRequestAttributes(req, response);
    RequestContextHolder.setRequestAttributes(attributes, true);
    taskExecutor.execute(() -> {
        try {
             // 在exportData內(nèi)部可以直接獲取RequestContextHolder
            exportData();
        } catch (Exception e) {
            System.out.println(errorMessage + e);
        } finally {
            // 清理請求上下文，防止內(nèi)存泄漏
            RequestContextHolder.resetRequestAttributes();
        }
    });
}

RequestContextHolder.setRequestAttributes(attributes, true) 的作用

• 手動傳遞請求上下文：RequestContextHolder.setRequestAttributes(attributes, true) 會顯式地將當(dāng)前請求上下文綁定到當(dāng)前線程（在這里是異步線程）。通過這種方式，RequestContextHolder 會把 HttpServletRequest 和 HttpServletResponse 傳遞到異步線程中，使得異步線程能夠訪問這些請求參數(shù)。
• inheritable 設(shè)置為 true 是關(guān)鍵：它允許請求上下文在線程間傳播，確保異步線程能在需要時訪問到主線程的請求信息。

2. 獲取請求上下文

在異步線程中，我們可以通過 RequestContextHolder.getRequestAttributes() 獲取當(dāng)前線程的請求上下文，并從中獲取 HttpServletRequest 對象。假設(shè) exportData 方法實現(xiàn)是這樣的：

 /**
  *  模擬導(dǎo)出任務(wù)
  */
private void exportData() {
    // 在 exportData中直接訪問RequestContextHolder.getRequestAttributes()
    HttpServletRequest request = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes().getRequest();
    String userId = request.getParameter("userId");
    System.out.println("在 exportData 方法中獲取到的 userId: " + userId);
}

解釋：

• 請求上下文傳遞：通過 RequestContextHolder.setRequestAttributes(attributes, true)，將當(dāng)前請求上下文顯式傳遞給異步線程，并確保其可繼承。true 參數(shù)表示上下文會被傳遞給子線程（異步線程）。
• exportData 內(nèi)部訪問：在 exportData 任務(wù)中，通過 RequestContextHolder.getRequestAttributes() 獲取當(dāng)前線程的請求上下文。這時可以安全地訪問 HttpServletRequest，獲取請求參數(shù)。
• 清理上下文：在任務(wù)執(zhí)行完成后，通過 RequestContextHolder.resetRequestAttributes() 清理請求上下文，避免內(nèi)存泄漏。

為什么這樣有效？

• 線程上下文繼承：RequestContextHolder.setRequestAttributes(attributes, true) 確保當(dāng)前請求上下文被傳遞到異步線程中，使得異步線程能夠繼承主線程的請求上下文。這是實現(xiàn)異步線程能夠訪問 HttpServletRequest 的關(guān)鍵。
• 請求參數(shù)獲取：由于請求上下文已經(jīng)成功綁定到異步線程，因此在 exportData 內(nèi)部調(diào)用 RequestContextHolder.getRequestAttributes() 時，能夠正常獲取 HttpServletRequest，并從中讀取請求參數(shù)。
• 內(nèi)存管理：每次異步任務(wù)執(zhí)行完后，調(diào)用 RequestContextHolder.resetRequestAttributes() 可以清理當(dāng)前線程的請求上下文，防止可能的內(nèi)存泄漏問題。

五、完整的解決方案

1. 問題回顧

• 請求上下文與線程的綁定: 在異步線程中，HttpServletRequest 無法自動繼承主線程的請求上下文。
  • startAsync() 延緩請求清理的機制:
  • startAsync() 會延緩請求對象的銷毀，異步線程可以在 complete() 被調(diào)用之前訪問請求對象。，但不會自動傳遞請求上下文。

2. 最佳實踐

• 使用 RequestContextHolder.setRequestAttributes() 手動傳遞請求上下文，并設(shè)置 inheritable=true，確保異步線程能夠訪問請求對象。
• 在異步線程執(zhí)行完后，記得調(diào)用 RequestContextHolder.resetRequestAttributes() 清理請求上下文，避免內(nèi)存泄漏。

通過上述方式，可以確保在異步線程中正確訪問 HttpServletRequest，并避免請求對象的清除對異步線程帶來的影響。

到此這篇關(guān)于Spring Boot 中如何正確地在異步線程中使用 HttpServletRequest的文章就介紹到這了,更多相關(guān)Spring Boot 使用 HttpServletRequest內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論