RequestContextHolder使用指南

原创 已于 2025-02-06 11:35:00 修改 · 1.1k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#SaaS项目 #web项目

于 2025-01-09 15:57:13 首次发布

目录

前言

解决方案

RequestContextHolder静态获取

直接注入httpServletRequest

注意事项

主线程没有提前结束

主线程提前结束

总结

前言

在一个web系统中，可能会经常需要处理一些公共的参数，比如，在一个Saas系统中，需要根据用户选择的租户信息来展示不同的数据，这个时候前端可能就会将这个租户信息放在了header中，后端怎么去解析这个租户信息呢？

方法有很多种，下面就来介绍几种具体的做法。

解决方案

直接通过HttpServletRequest参数，进行方法的传递，毫无疑问，这种方式是最简单的，不过缺点也显而易见，就是很麻烦，显得不够优雅。如果方法嵌套层次比较多，都会要携带这个参数，多少优点累赘感。

参考代码如下

package com.tml.mouseDemo.controller;

import com.tml.mouseDemo.constants.CommonResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

@RestController
@Slf4j
public class TestController {
    @GetMapping("/common")
    public CommonResponse<String> commonHandler(HttpServletRequest request) {
        String tenantId = request.getHeader("tenantId");
        log.info("tenantId: {}", tenantId);
        return CommonResponse.success("common handler");
    }


}

解决这种多层次方法参数的传递一般会使用ThreadLocal，那么我们是不是在web系统增加一个拦截器或者过滤器，拦截http请求，将http请求中的租户信息放进threadLocal中，当然可以，不过这种方案会存在一个问题，就是需要手动清理threadLocal对象中的数据以防止内存泄漏。

HttpServlertRequest对象的作用域是请求作用域（Request Scope）。这意味着每个HTTP请求都会创建一个新的HttpServlertRequest对象，并且该对象仅在当前请求的生命周期内有效。请求结束时，HttpServlertRequest对象会被销毁。

基于HttpServlertRequest的作用域，这里给出两种方案仅供参考

RequestContextHolder静态获取

直接看代码

package com.tml.mouseDemo.controller;

import com.tml.mouseDemo.constants.CommonResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@RestController
@Slf4j
public class TestController {
    @GetMapping("/common")
    public CommonResponse<String> commonHandler() {
        String tenantId = getTenantId();
        log.info("tenantId: {}", tenantId);
        return CommonResponse.success("common handler");
    }


    private static String getTenantId(){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return request.getHeader("tenantId");
    }


}

可以看到，使用RequestContextHolder是直接静态获取，去看源码，发现里面也是使用了ThreadLocal，和预想的一致，使用这种方式的优点就是，可以在任意地方获取租户信息，而不需要传递httpServletRequest对象

直接注入httpServletRequest

直接看代码

package com.tml.mouseDemo.controller;

import com.tml.mouseDemo.constants.CommonResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

@RestController
@Slf4j
public class TestController {

    @Autowired
    private HttpServletRequest request;

    @GetMapping("/common")
    public CommonResponse<String> commonHandler() {
        String tenantId = request.getHeader("tenantId");
        log.info("tenantId: {}", tenantId);
        return CommonResponse.success("common handler");
    }


}

使用这种方式的优点显而易见，就是简单，在被spring容器纳入管理的对象上，就可以随意注入httpServletRequest对象，而这个对象的作用域是Request Scope，使用者根本不用担心不同的请求会造成数据混乱。

注意事项

如果一个http请求逻辑处理过程中，使用了多线程，那么无论是使用RequestContextHolder还是直接注入httpServletRequest，都会存在问题，因为这两种底层的实现，都是基于ThreadLocal的，而threadLocal是没法跨越两个线程来进行数据传递。

先看一个例子

package com.tml.mouseDemo.controller;

import com.tml.mouseDemo.config.AgeContext;
import com.tml.mouseDemo.constants.CommonResponse;
import com.tml.mouseDemo.core.threadLocalDemo.SimpleThreadFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@RestController
@Slf4j
public class TestController {


    private static ExecutorService service = Executors.newFixedThreadPool(4, new SimpleThreadFactory());


    @GetMapping("/common")
    public CommonResponse<String> commonHandler() throws InterruptedException {

        String tenantId = getTenantId();
        log.info("tenantId: {}", tenantId);

        CountDownLatch countDownLatch = new CountDownLatch(1);


        new Thread(() -> {

            try {
                Thread.sleep(900);
                String tenantId1 = getTenantId();

                log.info("tenantId1: {}", tenantId1);

            } catch (Exception e) {
                log.error(e.getMessage());
            } finally {
                countDownLatch.countDown();
            }
        }, "child thread").start();


        countDownLatch.await();
        return CommonResponse.success("common handler");
    }


    

    private static String getTenantId() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return request.getHeader("tenantId");
    }


}

这里使用了CountDownLatch是为了防止主线程提前结束

运行结果毫无疑问，在子线程中是没法获取到租户信息的。 

2025-01-10 18:12:01 | INFO  | http-nio-9090-exec-1 | com.tml.mouseDemo.controller.TestController | tenantId: 10086
2025-01-10 18:12:02 | ERROR | child thread | com.tml.mouseDemo.controller.TestController | null

针对这种野线程【自己new出来的线程】 ，要解决问题，还有两种场景需要考虑

主线程没有提前结束

上面的案例使用了CountDownLatch就是为了防止主线程提前结束，要解决这种场景的数据传递，代码很简单，就是我们需要使用InheritableThreadLocal来代替ThreadLocal

package com.tml.mouseDemo.controller;

import com.tml.mouseDemo.config.AgeContext;
import com.tml.mouseDemo.constants.CommonResponse;
import com.tml.mouseDemo.core.threadLocalDemo.SimpleThreadFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@RestController
@Slf4j
public class TestController {


    private static ExecutorService service = Executors.newFixedThreadPool(4, new SimpleThreadFactory());


    @GetMapping("/common")
    public CommonResponse<String> commonHandler() throws InterruptedException {

        String tenantId = getTenantId();
        log.info("tenantId: {}", tenantId);

        CountDownLatch countDownLatch = new CountDownLatch(1);

        RequestContextHolder.setRequestAttributes(RequestContextHolder.getRequestAttributes(), true);
        new Thread(() -> {

            try {
                Thread.sleep(900);
                String tenantId1 = getTenantId();

                log.info("tenantId1: {}", tenantId1);

            } catch (Exception e) {
                log.error(e.getMessage());
            } finally {
                countDownLatch.countDown();
            }
        }, "child thread").start();


        countDownLatch.await();
        return CommonResponse.success("common handler");
    }


    

    private static String getTenantId() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return request.getHeader("tenantId");
    }


}

通过这个重新赋值，底层是使用了InheritableThreadLocal，以确保子线程可以获取到主线程中的值

RequestContextHolder.setRequestAttributes(RequestContextHolder.getRequestAttributes(), true);

执行结果如下：

2025-01-10 18:47:49 | INFO  | http-nio-9090-exec-2 | com.tml.mouseDemo.controller.TestController | tenantId: 10086
2025-01-10 18:47:50 | INFO  | child thread | com.tml.mouseDemo.controller.TestController | tenantId1: 10086

主线程提前结束

主线程提前结束了，就是常说的异步处理，针对这种情况，即使使用了InheritableThreadLocal也不能解决，因为httpServletRequest的生命周期结束了，会自动释放http上下文，自然header中的数据也没有了

主线程提前结束，这个场景很好模拟，我们去掉CountDownLatch就行了，可以看下获取不到数据的demo

package com.tml.mouseDemo.controller;

import com.tml.mouseDemo.config.AgeContext;
import com.tml.mouseDemo.constants.CommonResponse;
import com.tml.mouseDemo.core.threadLocalDemo.SimpleThreadFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@RestController
@Slf4j
public class TestController {


    private static ExecutorService service = Executors.newFixedThreadPool(4, new SimpleThreadFactory());


    @GetMapping("/common")
    public CommonResponse<String> commonHandler() throws InterruptedException {

        String tenantId = getTenantId();
        log.info("tenantId: {}", tenantId);


        RequestContextHolder.setRequestAttributes(RequestContextHolder.getRequestAttributes(), true);
        new Thread(() -> {

            try {
                Thread.sleep(900);
                String tenantId1 = getTenantId();

                log.info("tenantId1: {}", tenantId1);

            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }, "child thread").start();


        return CommonResponse.success("common handler");
    }


    
    private static String getTenantId() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return request.getHeader("tenantId");
    }


}

即便使用了InheritableThreadLocal，子线程依然获取不到数据，执行结果如下

2025-01-10 18:56:58 | INFO  | http-nio-9090-exec-1 | com.tml.mouseDemo.controller.TestController | tenantId: 10086
2025-01-10 18:56:59 | INFO  | child thread | com.tml.mouseDemo.controller.TestController | tenantId1: null

针对这种异步，最简单的方式就是在主线程中先提取租户信息，然后直接传参给子线程。

总结

上面的两个demo可以发现，使用RequestContextHolder更加的通用，可以在任意地方调用静态方法获取header中的数据，不过，在spring项目中，被spring管理的对象中，我们也可以通过直接注入的方式使用httpServletRequest对象，这种方式是最简洁的。

不过，这两种方式获取header中的参数一定是要在当前线程中的，如果使用了多线程，是获取不到数据的，千万注意。

另外，在多线程环境下【主动创建线程】，使用RequestContextHolder会更加灵活，不过生产环境也很少会直接创建线程，一般都是使用线程池。

综合权衡，直接使用RequestContextHolder静态获取http中的属性会更加灵活。

线程池中中获取主线程的ThreadLocal变量，工业实践中会有更好的解决方案，那就是阿里巴巴开源的TransmittableThreadLocal，下一章会介绍。

林犀居士
关注
SpringMVC全栈开发：AOP编程实战指南
AI天才研究院
06-09 988
在SpringMVC开发中，我们常遇到“重复代码”问题：比如每个业务方法都要写日志记录、每个接口都要做权限校验、每个服务都需要事务管理……这些“非核心业务逻辑”像一张网，把核心业务代码缠得乱七八糟。本文将聚焦“面向切面编程（AOP）”这一Spring核心技术，教你如何用AOP把这些“重复的网”抽离成独立模块，让业务代码回归纯粹。内容覆盖AOP核心概念、底层原理、SpringMVC实战案例（日志/权限/性能监控），以及常见问题解决。用“餐厅服务员”案例类比AOP核心概念。
SpringBoot学习指南
北执南念的博客
09-21 1719
SpringBoot学习指南
RequestContextHolder 类简介
Go_ahead_forever的博客
11-28 3281
是Spring Framework中的一个类，用于在多线程环境中存储和访问HTTP请求的上下文信息。它允许在Spring应用程序中从任何位置访问当前请求的相关信息，如HTTP头部、会话数据等，而无需将请求对象传递到每个方法中。通常与拦截器、过滤器、AOP等结合使用，以在整个请求处理周期中访问和管理请求的上下文信息。请注意，对于某些异步操作或者在非Web请求的线程中，获取当前请求的上下文信息，并尝试从会话属性中获取。然后，它可以使用这些信息执行相应的操作。，分别用于请求级别和会话级别的属性存储。
SpringMVC--02--上下文工具类（RequestContextHolder）
时光里的博客
04-12 1883
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
深入理解 RequestContextHolder、ThreadLocal 与 RequestContextFilter
最新发布
技术交流，一起进步
09-06 563
是 Java 提供的一个线程级别的变量隔离机制。它为每个使用该变量的线程提供独立的变量副本，不同线程之间不会相互干扰。// 线程1// 输出: Thread1: User1}).start();// 线程2// 输出: Thread2: User2}).start();return ip;= null?Spring 通过和的组合，为我们提供了一种优雅的方式来在应用的任何地方访问当前请求的信息。基于。
RequestContextHolder 获取 request
weixin_38982591的博客
08-31 1766
前言： 我们平常开发想要获取HttpServletRequest getRequest，大部份都是从controller层声明之后直接传到service层使用，了SpringMVC提供的RequestContextHolder遂去分析一番,并借此对SpringMVC的结构深入了解一下。 1.RequestContextHolder RequestContextHolder顾名思义,持有上下文的Request容器.使用是很简单的,具体使用如下: 源码： @Nullable publ..
SpringBoot异步任务获取HttpServletRequest
欢迎来到我的博客
07-12 1987
通过自定义过滤器对Request的内容进行备份保存，主线程结束时Request清除结束不会影响到子线程的相应参数的获取，也适用于增加拦截器/过滤器后body参数无法重复获取的问题。在使用框架日常开发中需要在controller中进行一些异步操作减少请求时间，但是发现在使用@Anysc注解后会出现Request对象无法获取的情况，本文就此情况给出完整的解决方案。用于拦截异步任务执行，在任务执前统一进行Request共享操作，且可以定义多个，不影响原有的异步任务代码。自定义request过滤器。
RequestContextHolder详解
fengbin2005的专栏
11-15 3259
最近遇到的问题是在service获取request和response,正常来说在service层是没有request的,然而直接从controlller传过来的话解决方法太粗暴,后来发现了SpringMVC提供的RequestContextHolder遂去分析一番,并借此对SpringMVC的结构深入了解一下,后面会再发文章详细分析源码1.RequestContextHolder的使用RequestContextHolder顾名思义,持有上下文的Request容器.使用是很简单的,具体使用如下:
keycloak中文使用文档_doc/keycloak-learn/Spring Cloud Keycloak搭建手把手操作指南.md · 周立/spring-cloud-yes - 码云 Gitee...
weixin_34718952的博客
12-24 1666
Keycloak安装&初始化下载 笔者下载的是“Standalone server distribution” 。安装&启动安装Keycloak非常简单，步骤如下： 解压下载下来的安装包将目录切换到 KEYCLOAK_PATH/bin，其中KEYCLOAK_PATH是您Keycloak的根目录执行 ./standalone.sh，即可启动Ke...
RocketMQ 分布式事务消息实战指南：确保数据一致性的关键设计
vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计
11-16 6773
该篇博文主要是通过实际的业务代码来进行 RocketMQ 事务消息实战，上一篇博文从 RocketMQ 事务消息的整体设计以及相关的源码的讲解，这篇通过订单生成、库存预扣减的简单例子来对事务消息的这块流程进行细粒化的业务设计，事务消息生产者的本地事务消息与补偿事务消息结合起来保证订单创建成功以后，库存才进行预扣减，希望这篇简单的 RocketMQ 事务消息实战博文能够帮助到您理解事务消息的实际应用
接口重试方案，使用网络工具的内置重试机制，并发框架异步重试，Spring Retry，消息队列重试，Feign调用重试，监控与报警，避坑指南
殇的不悔
08-04 75
接口重试方案，使用网络工具的内置重试机制，并发框架异步重试，Spring Retry，消息队列重试，Feign调用重试，监控与报警，避坑指南
RequestContextHolder源码、理解、使用
RocZhang的博客
09-22 2288
首先看这个类的变量： private static final boolean jsfPresent = ClassUtils.isPresent("javax.faces.context.FacesContext", RequestContextHolder.class.getClassLoader()); private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new Name
关于RequestContextHolder（请求上下文持有者）
qq_39419082的博客
06-25 254
简书博客👇。
RequestContextHolder简析
hnhygkx的博客
11-27 2236
在Web开发中，service层或者某个工具类中需要获取到HttpServletRequest对象还是比较常见的。一种方式是将HttpServletRequest作为方法的参数从controller层一直放下传递，不过这种有点费劲，且做起来不是优雅；还有另一种则是RequestContextHolder，直接在需要用的地方使用如下方式取HttpServletRequest即可，使用代码如下： ...
RequestContextHolder使用
m0_59465624的博客
10-11 139
不通过controller层传递request和response，在service层直接获取requst和response。
RequestContextHolder获取request
热门推荐
weixin_44251024的博客
01-18 1万+
SpringMvc之RequestContextHolder
jiangshubian的博客
04-21 1990
项目中除了Controller能够接收到请求对象HttpServletRequest和HttpServletResponse外，如果需要在service层使用以上请求和/或响应对象，如果直接从Controller传递过service层感觉太麻烦，而且耦合度太高；那么有什么方式可以优雅的解决该问题么？ SpringMvc提供了RequestContextHolder对象!一、初识RequestCon...
RequestContextHolder
qq_25775675的博客
06-05 3257
顾名思义，持有上下文的Request容器。从中我们可以获取到、、等对象。 三、实现原理 1、存储变量 首先分析这个类,里面有两个保存当前线程下的。 2、获取 3、存入 request和response等是什么时候设置进去的?参考：.........
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值