如何创建REST请求级全局可用的临时变量以存储JWT中的UserId？

你之前用静态类存储UserId的问题本质是静态类属于应用级全局共享，所有请求会共用同一个实例，必然导致串值。下面针对主流技术栈给出符合需求的实现方案：

.NET 环境下的实现 #

方案1：使用HttpContext.Items存储（推荐） #

这是.NET中最直接的方式，HttpContext.Items是专门用于存储当前请求生命周期内数据的集合：

• 在JWT授权过滤器中解码令牌并存储UserId：

public class JwtAuthFilter : IAuthorizationFilter
{
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        // 从请求头获取并解析JWT令牌
        var authHeader = context.HttpContext.Request.Headers["Authorization"].ToString();
        if (!string.IsNullOrEmpty(authHeader) && authHeader.StartsWith("Bearer "))
        {
            var jwtToken = authHeader.Substring(7);
            var tokenHandler = new JwtSecurityTokenHandler();
            var jwtSecurityToken = tokenHandler.ReadJwtToken(jwtToken);
            var userId = jwtSecurityToken.Claims.FirstOrDefault(c => c.Type == "UserId")?.Value;
            
            // 将UserId存入当前请求的上下文集合
            if (!string.IsNullOrEmpty(userId))
            {
                context.HttpContext.Items["UserId"] = userId;
            }
        }
    }
}

• 在业务服务或接口中，通过IHttpContextAccessor访问：

public class UserService
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly AppDbContext _dbContext;

    public UserService(IHttpContextAccessor httpContextAccessor, AppDbContext dbContext)
    {
        _httpContextAccessor = httpContextAccessor;
        _dbContext = dbContext;
    }

    public async Task<User> GetCurrentUserInfo()
    {
        var userId = _httpContextAccessor.HttpContext?.Items["UserId"]?.ToString();
        if (string.IsNullOrEmpty(userId))
        {
            throw new UnauthorizedAccessException("无法获取当前用户ID");
        }
        // 执行数据库查询
        return await _dbContext.Users.FirstOrDefaultAsync(u => u.Id == userId);
    }
}

• 必须先在Program.cs中注册IHttpContextAccessor：

builder.Services.AddHttpContextAccessor();

方案2：自定义请求作用域服务 #

如果你需要更结构化的存储，可以创建一个请求作用域的上下文类：

• 定义请求上下文类：

public class RequestContext
{
    public string UserId { get; set; }
}

• 在Program.cs中注册为作用域服务（每个请求创建一个实例）：

builder.Services.AddScoped<RequestContext>();

• 在过滤器中注入并赋值：

public class JwtAuthFilter : IAuthorizationFilter
{
    private readonly RequestContext _requestContext;

    public JwtAuthFilter(RequestContext requestContext)
    {
        _requestContext = requestContext;
    }

    public void OnAuthorization(AuthorizationFilterContext context)
    {
        // 解析JWT获取UserId逻辑同上
        _requestContext.UserId = userId;
    }
}

• 业务代码中直接注入RequestContext即可使用，每个请求的实例完全独立。

Java/Spring 环境下的实现 #

方案1：利用RequestContextHolder存储 #

Spring的RequestContextHolder会维护当前请求的上下文，数据仅在请求周期内有效：

• 创建自定义请求上下文类：

public class RequestContext {
    private String userId;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }
}

• 在JWT拦截器中存入数据：

public class JwtAuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String authHeader = request.getHeader("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String jwtToken = authHeader.substring(7);
            // 解码JWT获取UserId，这里假设JwtUtil是你的工具类
            String userId = JwtUtil.extractUserId(jwtToken);
            
            RequestContext requestContext = new RequestContext();
            requestContext.setUserId(userId);
            // 将上下文存入请求作用域
            RequestContextHolder.getRequestAttributes().setAttribute("RequestContext", requestContext, RequestAttributes.SCOPE_REQUEST);
        }
        return true;
    }
}

• 业务类中获取数据：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getCurrentUser() {
        RequestContext requestContext = (RequestContext) RequestContextHolder.getRequestAttributes()
                .getAttribute("RequestContext", RequestAttributes.SCOPE_REQUEST);
        if (requestContext == null || requestContext.getUserId() == null) {
            throw new UnauthorizedException("无法获取当前用户信息");
        }
        // 数据库查询
        return userRepository.findById(requestContext.getUserId()).orElse(null);
    }
}

方案2：使用@RequestScope Bean #

更简洁的方式是定义一个请求作用域的Bean：

• 创建作用域Bean：

@RequestScope
@Component
public class RequestContext {
    private String userId;

    // getter和setter方法
    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }
}

• 在拦截器中注入并赋值：

@Component
public class JwtAuthInterceptor implements HandlerInterceptor {
    @Autowired
    private RequestContext requestContext;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 解析JWT获取UserId逻辑同上
        requestContext.setUserId(userId);
        return true;
    }
}

• 业务类直接注入RequestContext使用即可，Spring会自动为每个请求创建独立实例。

核心逻辑总结 #

所有方案的核心都是利用请求作用域的隔离性：每个HTTP请求会拥有独立的存储区域或实例，请求结束后自动销毁，既保证了当前请求内全局可访问，又完全避免了多请求间的数据串值问题，从根源解决了静态类的线程安全隐患。

内容的提问来源于stack exchange，提问作者Craig Armstrong