如何基于Spring Bean实现HTTP请求头参数的自定义上下文提供者？

1. 定义RequestContext实体类 #

先创建封装请求头参数的实体类，提供必要的getter方法：

public class RequestContext {
    private final String flowId;
    private final String someAnotherParam;
    private final String customerId;

    public RequestContext(String flowId, String someAnotherParam, String customerId) {
        this.flowId = flowId;
        this.someAnotherParam = someAnotherParam;
        this.customerId = customerId;
    }

    // Getter方法
    public String getFlowId() { return flowId; }
    public String getSomeAnotherParam() { return someAnotherParam; }
    public String getCustomerId() { return customerId; }
}

2. 实现RequestContextProvider服务 #

用ThreadLocal存储请求上下文，保证每个请求线程的上下文独立隔离，避免线程安全问题：

import org.springframework.stereotype.Service;

@Service
public class RequestContextProvider {
    private final ThreadLocal<RequestContext> contextHolder = new ThreadLocal<>();

    public RequestContext getRequestContext() {
        RequestContext context = contextHolder.get();
        if (context == null) {
            throw new IllegalStateException("RequestContext未初始化，请检查拦截器配置");
        }
        return context;
    }

    // 供拦截器调用，设置上下文
    public void setRequestContext(RequestContext context) {
        contextHolder.set(context);
    }

    // 请求结束后清理上下文，防止内存泄漏
    public void clearRequestContext() {
        contextHolder.remove();
    }
}

3. 实现请求拦截器提取请求头 #

创建Spring拦截器，在请求进入控制器前提取请求头参数，封装到RequestContext并交给RequestContextProvider，请求完成后清理上下文：

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

@Component
public class RequestContextInterceptor implements HandlerInterceptor {
    private final RequestContextProvider contextProvider;

    public RequestContextInterceptor(RequestContextProvider contextProvider) {
        this.contextProvider = contextProvider;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从请求头提取参数
        String flowId = request.getHeader("flowId");
        String someAnotherParam = request.getHeader("someAnotherParam");
        String customerId = request.getHeader("customerId");

        // 可选：校验必填参数，若缺失直接返回错误
        if (flowId == null || customerId == null) {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST, "必填请求头参数缺失");
            return false;
        }

        // 封装上下文并设置
        RequestContext context = new RequestContext(flowId, someAnotherParam, customerId);
        contextProvider.setRequestContext(context);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 清理上下文，避免ThreadLocal内存泄漏
        contextProvider.clearRequestContext();
    }
}

4. 配置拦截器生效 #

将拦截器注册到Spring MVC配置中，指定需要拦截的路径（通常是所有接口路径）：

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 WebMvcConfig implements WebMvcConfigurer {
    private final RequestContextInterceptor contextInterceptor;

    public WebMvcConfig(RequestContextInterceptor contextInterceptor) {
        this.contextInterceptor = contextInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(contextInterceptor)
                .addPathPatterns("/**"); // 拦截所有请求路径，可根据需求调整
    }
}

5. 改造控制器与下游服务 #

控制器无需再逐个接收请求头参数，直接注入RequestContextProvider获取上下文即可，下游服务也可同样注入该Provider获取参数，无需逐层传递：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SomeController {
    private final RequestContextProvider contextProvider;
    private final SomeService someService;

    public SomeController(RequestContextProvider contextProvider, SomeService someService) {
        this.contextProvider = contextProvider;
        this.someService = someService;
    }

    @PostMapping("/some-endpoint")
    public void someEndpoint() {
        RequestContext context = contextProvider.getRequestContext();
        // 直接将上下文传递给服务，或按需提取参数
        someService.doBusiness(context.getFlowId(), context.getCustomerId());
    }
}

关键注意事项 #

• ThreadLocal清理：必须在请求结束后调用clearRequestContext()，否则线程池复用线程时会导致上下文泄漏，afterCompletion方法是可靠的清理时机。
• 参数校验：拦截器中可统一处理必填参数的校验，避免在每个控制器重复校验逻辑。
• 兼容性：如果项目使用Spring Boot 2.x，请求对象需用javax.servlet.http.HttpServletRequest；若用Spring Boot 3.x，需使用jakarta.servlet.http.HttpServletRequest。

内容的提问来源于stack exchange，提问作者Tomasz Kowalczyk