ThreadLocal跨API调用无法保留值的问题解决咨询

首先得明确核心原因：Spring Boot（准确说是Tomcat这类Web容器）会为每个HTTP请求分配独立的线程处理，而ThreadLocal的作用范围仅限当前线程——第一个请求的线程设置的值，第二个请求的线程完全访问不到，自然返回null。

先贴出你提供的代码片段，方便大家理解场景：

你的代码示例 #

SignUpController.java #

@GetMapping("validate/mobileNo")
public ResponseEntity<ApiResponse> validateMobileNoForSignUp(@RequestParam("countryCode") String countryCode, @RequestParam("mobileNo") String mobileNo, @RequestParam("accountType") String accountType) {
    System.out.println("Value from /validate/mobileNo = " + LocationContextHolder.holder.get());
    LocationContextHolder.holder.set("random_value_to_be_set_and_read");
    System.out.println("Value from /validate/mobileNo SERVICE = " + LocationContextHolder.holder.get());
    return ResponseEntity.status(HttpStatus.OK).body(new ApiResponse<>(null, null));
}

@ResponseStatus(HttpStatus.CREATED)
@PostMapping("/profile")
public Long postProfile(@Valid @RequestBody SignUpDto signUpDTO) {
    System.out.println("Value from /profile = " + LocationContextHolder.holder.get());
    return null;
}

LocationContextHolder.java #

public class LocationContextHolder {
    public static final ThreadLocal<String> holder = new ThreadLocal<>();
}

客户端调用代码（NewThread.java） #

public class NewThread extends Thread{
    public void callGetEndpoint() throws IOException {
        OkHttpClient client = new OkHttpClient();
        //Http call implementation
        Response response = client.newCall(request).execute();
    }
    public void callPostEndpint() throws IOException {
        OkHttpClient client = new OkHttpClient();
        //Http call implementation
        Response response = client.newCall(request).execute();
    }
    public void run() {
        long startTime = System.currentTimeMillis();
        int i = 0;
        while (i<1) {
            System.out.println(this.getName() + ": Thread is running..." + i++);
            try {
                //Wait for one sec so it doesn't print too fast
                callGetEndpoint();
                Thread.sleep(5000);
                callPostEndpint();
                // Thread.sleep(10000);
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

运行结果正如你所见：

Value from /validate/mobileNo = null
Value from /validate/mobileNo SERVICE = random_value_to_be_set_and_read
Value from /profile = null

解决方案 #

根据你的跨API传值场景，推荐以下几种实用方案：

方案1：无状态REST API首选——请求头传递 #

如果你的服务是无状态的REST接口，这是最标准的做法：让客户端在第二个请求中携带第一个请求返回的值。具体步骤：

1. 第一个API把需要传递的值放在响应头或响应体返回给客户端
2. 客户端拿到值后，在调用第二个API时通过请求头传递
3. 第二个API从请求头读取值

修改第一个API：

@GetMapping("validate/mobileNo")
public ResponseEntity<ApiResponse> validateMobileNoForSignUp(
        @RequestParam("countryCode") String countryCode,
        @RequestParam("mobileNo") String mobileNo,
        @RequestParam("accountType") String accountType) {
    String sharedValue = "random_value_to_be_set_and_read";
    LocationContextHolder.holder.set(sharedValue);
    // 将值放在响应头返回给客户端
    return ResponseEntity.status(HttpStatus.OK)
            .header("X-Shared-Value", sharedValue)
            .body(new ApiResponse<>(null, null));
}

修改客户端NewThread：

public class NewThread extends Thread{
    private String sharedValue; // 存储从第一个请求拿到的值

    public void callGetEndpoint() throws IOException {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("http://localhost:8080/validate/mobileNo?countryCode=xx&mobileNo=xx&accountType=xx")
                .build();
        try (Response response = client.newCall(request).execute()) {
            // 从响应头提取值
            sharedValue = response.header("X-Shared-Value");
        }
    }

    public void callPostEndpint() throws IOException {
        OkHttpClient client = new OkHttpClient();
        // 构造请求体（根据你的SignUpDto调整）
        RequestBody body = RequestBody.create(
                new Gson().toJson(new SignUpDto()),
                MediaType.parse("application/json"));
        Request request = new Request.Builder()
                .url("http://localhost:8080/profile")
                .post(body)
                .addHeader("X-Shared-Value", sharedValue) // 传递值到第二个请求
                .build();
        try (Response response = client.newCall(request).execute()) {
            // 处理响应
        }
    }

    // run方法保持不变
}

修改第二个API获取值：

@PostMapping("/profile")
public Long postProfile(
        @Valid @RequestBody SignUpDto signUpDTO,
        @RequestHeader(value = "X-Shared-Value", required = false) String sharedValue) {
    System.out.println("Value from /profile = " + sharedValue);
    return null;
}

方案2：基于会话（Session）传递（适合有状态服务） #

如果你的服务是有状态的Web应用（用户有会话），可以把值存在HttpSession中，同一个用户的多个请求都能访问到：

第一个API：

@GetMapping("validate/mobileNo")
public ResponseEntity<ApiResponse> validateMobileNoForSignUp(
        @RequestParam("countryCode") String countryCode,
        @RequestParam("mobileNo") String mobileNo,
        @RequestParam("accountType") String accountType,
        HttpSession session) {
    String sharedValue = "random_value_to_be_set_and_read";
    LocationContextHolder.holder.set(sharedValue);
    session.setAttribute("sharedValue", sharedValue);
    return ResponseEntity.status(HttpStatus.OK).body(new ApiResponse<>(null, null));
}

第二个API：

@PostMapping("/profile")
public Long postProfile(
        @Valid @RequestBody SignUpDto signUpDTO,
        HttpSession session) {
    String sharedValue = (String) session.getAttribute("sharedValue");
    System.out.println("Value from /profile = " + sharedValue);
    return null;
}

注意：这个方案依赖用户会话，客户端需要支持Cookie（OkHttpClient默认会自动管理Cookie），前后端分离的无状态服务不推荐使用。

方案3：同请求内传递——Spring RequestContextHolder #

如果是同一个请求内的不同方法调用共享数据（比如Controller调用Service），可以用Spring的RequestContextHolder，它底层基于ThreadLocal，但Spring会帮你处理线程池的清理问题：

// 设置值
RequestContextHolder.getRequestAttributes().setAttribute("sharedValue", "xxx", RequestAttributes.SCOPE_REQUEST);
// 获取值
String value = (String) RequestContextHolder.getRequestAttributes().getAttribute("sharedValue", RequestAttributes.SCOPE_REQUEST);

这个方案仅适合同一个请求内，跨请求无效。

额外提醒：ThreadLocal内存泄漏问题 #

不管你是否继续使用ThreadLocal，都要记得在请求结束时手动清理，避免线程池复用导致的内存泄漏。可以用Spring的@ControllerAdvice做全局清理：

@ControllerAdvice
public class ThreadLocalCleanupAdvice {
    @AfterReturning
    @AfterThrowing
    public void cleanupThreadLocal() {
        LocationContextHolder.holder.remove();
    }
}

内容的提问来源于stack exchange，提问作者Marius Pop