Spring Boot中间微服务请求头传递问题求助（RestTemplate场景）

问题根源 #

你的拦截器无法获取客户端请求头，是因为拦截器中的HttpRequest是发给目标服务的请求对象，而非客户端发送给你的请求；而目标服务的响应头丢失，是因为你只提取了响应体返回给客户端，没有保留响应头信息。

以下是两种无需会话状态的实现方案：

方案一：显式传递请求头 + ThreadLocal暂存响应头 #

这种方式通过Controller提取请求头，传给Service后添加到RestTemplate请求中；同时用ThreadLocal临时存储目标服务的响应头，最后在Controller中设置到返回给客户端的响应里。

1. 修改Controller，提取并传递请求头 #

public ResponseEntity<EntityResponse> checkValidity(RequestEntity request) {
    // 提取需要转发的客户端请求头，比如"X-Client-Id"
    String clientHeader = request.getHeaders().getFirst("X-Client-Id");
    ResponseDTO response = entityService.checkValidity(request, clientHeader);
    
    // 从ThreadLocal取出目标服务的响应头
    String targetHeader = HeaderHolder.getTargetHeader();
    HeaderHolder.clear(); // 清理ThreadLocal，避免内存泄漏
    
    // 构造返回给客户端的响应，添加目标服务的响应头
    HttpHeaders responseHeaders = new HttpHeaders();
    if (targetHeader != null) {
        responseHeaders.add("X-Target-Trace-Id", targetHeader);
    }
    return ResponseEntity.ok().headers(responseHeaders).body(response);
}

2. 修改Service，添加请求头并暂存响应头 #

public ResponseDTO checkValidity(RequestEntity request, String clientHeader) {
    // 构造RestTemplate请求的头部，添加客户端传来的头
    HttpHeaders headers = new HttpHeaders();
    if (clientHeader != null) {
        headers.add("X-Client-Id", clientHeader);
    }
    // 其他必要的请求头（比如Content-Type）可以在这里补充
    headers.setContentType(MediaType.APPLICATION_JSON);
    
    HttpEntity<?> requestEntity = new HttpEntity<>(request.getBody(), headers);
    // 调用目标服务，获取完整的响应（包含响应头）
    ResponseEntity<ResponseDTO> targetResponse = restTemplate.postForEntity(
        "http://target-service/api/check", 
        requestEntity, 
        ResponseDTO.class
    );
    
    // 将目标服务的响应头存入ThreadLocal
    String targetTraceId = targetResponse.getHeaders().getFirst("X-Target-Trace-Id");
    if (targetTraceId != null) {
        HeaderHolder.setTargetHeader(targetTraceId);
    }
    
    return targetResponse.getBody();
}

3. 实现ThreadLocal工具类 #

public class HeaderHolder {
    private static final ThreadLocal<String> TARGET_HEADER = new ThreadLocal<>();

    public static void setTargetHeader(String value) {
        TARGET_HEADER.set(value);
    }

    public static String getTargetHeader() {
        return TARGET_HEADER.get();
    }

    public static void clear() {
        TARGET_HEADER.remove();
    }
}

4. 统一清理ThreadLocal（可选但推荐） #

用过滤器在请求结束后清理ThreadLocal，防止内存泄漏：

public class ThreadLocalCleanupFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            filterChain.doFilter(request, response);
        } finally {
            HeaderHolder.clear();
        }
    }
}

// 注册过滤器
@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<ThreadLocalCleanupFilter> cleanupFilter() {
        FilterRegistrationBean<ThreadLocalCleanupFilter> bean = new FilterRegistrationBean<>();
        bean.setFilter(new ThreadLocalCleanupFilter());
        bean.addUrlPatterns("/*");
        return bean;
    }
}

方案二：利用RequestContextHolder在拦截器中获取客户端请求头 #

这种方式无需修改Controller和Service的方法签名，通过Spring的RequestContextHolder获取当前请求上下文，直接在拦截器中提取客户端请求头；同时用ThreadLocal暂存目标服务的响应头。

1. 修改拦截器代码 #

public class HeaderModifierInterceptor implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(
            @NonNull HttpRequest request,
            byte @NonNull [] body,
            @NonNull ClientHttpRequestExecution execution) throws IOException {
        
        // 从当前请求上下文获取客户端的请求头
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest clientRequest = attributes.getRequest();
            String clientHeader = clientRequest.getHeader("X-Client-Id");
            if (clientHeader != null) {
                request.getHeaders().add("X-Client-Id", clientHeader);
            }
        }
        
        // 执行请求，获取目标服务的响应
        ClientHttpResponse targetResponse = execution.execute(request, body);
        
        // 将目标服务的响应头存入ThreadLocal
        String targetTraceId = targetResponse.getHeaders().getFirst("X-Target-Trace-Id");
        if (targetTraceId != null) {
            HeaderHolder.setTargetHeader(targetTraceId);
        }
        
        return targetResponse;
    }
}

2. 修改Controller，设置返回响应头 #

public ResponseEntity<EntityResponse> checkValidity(RequestEntity request) {
    ResponseDTO response = entityService.checkValidity(request);
    
    // 从ThreadLocal取出目标服务的响应头
    String targetHeader = HeaderHolder.getTargetHeader();
    HeaderHolder.clear();
    
    HttpHeaders responseHeaders = new HttpHeaders();
    if (targetHeader != null) {
        responseHeaders.add("X-Target-Trace-Id", targetHeader);
    }
    return ResponseEntity.ok().headers(responseHeaders).body(response);
}

3. 复用方案一中的HeaderHolder和ThreadLocal清理过滤器 #

和方案一的工具类、过滤器完全一致，无需额外修改。

方案对比 #

• 方案一：显式传参，逻辑直观，适合仅少数端点需要转发头的场景。
• 方案二：无需修改业务方法签名，扩展性更好，适合多个端点都需要处理头转发的场景。

内容的提问来源于stack exchange，提问作者Naresh Kavala