Spring Java开发RESTful接口：跨请求复用响应的实现及会话疑问

嘿，这个场景我之前在Spring项目里刚好处理过，给你梳理几个实用的实现思路，完美适配你的需求：

不管用哪种方案，核心都是要把每个用户的第一次接口数据独立存储，避免用户1和用户2的数据互相干扰，同时设置合理的过期时间（比如1分钟）来清理无效数据。

方案一：利用Spring Session维护用户会话（简单直接） #

虽然RESTful提倡无状态，但如果你的系统是单体或者已经用了Session集群，这种方案最省心。每个用户的请求会被Spring自动关联到专属的Session，我们可以把第一次接口的结果存在Session里，第二次调用时直接从Session取。

代码示例： #

// getUserRecord接口：获取数据并存入Session
@GetMapping("/getUserRecord")
public ResponseEntity<UserRecord> getUserRecord(HttpSession session, @RequestParam String userId) {
    // 调用业务逻辑获取用户记录
    UserRecord userRecord = userRecordService.getByUserId(userId);
    
    // 把数据存入当前用户的Session，用userId做前缀避免同Session多用户数据冲突
    session.setAttribute("USER_RECORD_" + userId, userRecord);
    // 可以配置全局Session过期时间为1分钟，刚好匹配你的场景
    return ResponseEntity.ok(userRecord);
}

// checkUserRecord接口：从Session取出数据做校验
@GetMapping("/checkUserRecord")
public ResponseEntity<CheckResult> checkUserRecord(HttpSession session, @RequestParam String userId) {
    // 从当前用户Session中取出数据
    UserRecord userRecord = (UserRecord) session.getAttribute("USER_RECORD_" + userId);
    
    if (userRecord == null) {
        return ResponseEntity.badRequest().body(new CheckResult("请先调用/getUserRecord接口，或数据已过期"));
    }
    
    // 执行业务校验逻辑
    CheckResult checkResult = recordCheckService.validate(userRecord);
    
    // 可选：校验完成后移除Session中的数据，避免冗余
    session.removeAttribute("USER_RECORD_" + userId);
    return ResponseEntity.ok(checkResult);
}

优缺点： #

• 优点：无需额外引入组件，Spring原生支持，代码量少
• 缺点：依赖Session机制，分布式环境下需要配置分布式Session（比如Spring Session + Redis），否则集群节点间Session不共享；Session默认存在内存，用户量大会占用内存资源

方案二：生成唯一Token + 缓存暂存数据（无状态更灵活） #

如果想严格遵循RESTful的无状态设计，或者你的系统是分布式架构，这个方案更合适。用户调用/getUserRecord时，后端生成一个唯一Token（比如UUID），把用户数据存入缓存（Redis最佳）并绑定这个Token，然后把Token返回给前端；用户调用/checkUserRecord时携带这个Token，后端用Token从缓存中取出对应的数据。

代码示例： #

首先确保你已经整合了Spring Data Redis或者Spring Cache，然后：

// 自定义DTO：返回给前端的结果包含用户数据和Token
@Data
public class UserRecordWithToken {
    private UserRecord userRecord;
    private String token;
}

// getUserRecord接口：生成Token并存数据到缓存
@GetMapping("/getUserRecord")
public ResponseEntity<UserRecordWithToken> getUserRecord(@RequestParam String userId) {
    UserRecord userRecord = userRecordService.getByUserId(userId);
    
    // 生成唯一Token
    String token = UUID.randomUUID().toString().replace("-", "");
    // 把数据存入Redis，设置1分钟过期时间，刚好匹配你的场景
    redisTemplate.opsForValue().set("RECORD_TOKEN:" + token, userRecord, 1, TimeUnit.MINUTES);
    
    UserRecordWithToken response = new UserRecordWithToken();
    response.setUserRecord(userRecord);
    response.setToken(token);
    return ResponseEntity.ok(response);
}

// checkUserRecord接口：通过Token从缓存取数据校验
@GetMapping("/checkUserRecord")
public ResponseEntity<CheckResult> checkUserRecord(@RequestParam String token) {
    // 根据Token从缓存取数据
    UserRecord userRecord = (UserRecord) redisTemplate.opsForValue().get("RECORD_TOKEN:" + token);
    
    if (userRecord == null) {
        return ResponseEntity.badRequest().body(new CheckResult("数据已过期或无效，请重新调用/getUserRecord"));
    }
    
    CheckResult checkResult = recordCheckService.validate(userRecord);
    
    // 可选：校验完成后删除缓存数据，避免无效占用
    redisTemplate.delete("RECORD_TOKEN:" + token);
    return ResponseEntity.ok(checkResult);
}

优缺点： #

• 优点：完全无状态，天然支持分布式架构；缓存过期时间精准控制，资源占用更合理
• 缺点：需要引入缓存组件（比如Redis），但Spring整合Redis非常便捷，现在也是分布式系统的标配

关于是否需要维护会话？ #

• 如果用方案一：需要维护会话，Spring会自动帮你处理用户与Session的关联，分布式环境下要配置分布式Session
• 如果用方案二：不需要维护会话，完全基于Token和缓存实现，更符合RESTful的设计理念

多用户并发场景的处理 #

这两个方案都能完美解决用户1和用户2的数据冲突问题：

• 方案一中，每个用户的Session是独立的，用户1的Session里只会存自己的用户记录，用户2调用/getUserRecord时会存入自己的Session，互相不会干扰
• 方案二中，每个用户拿到的Token是唯一的，缓存中的数据是和Token一一绑定的，用户1用自己的Token只能取到自己的数据，用户2同理

额外注意点 #

• 一定要设置合理的过期时间（1分钟），避免无效数据长时间占用资源
• 要处理数据不存在的异常情况（比如用户超过1分钟才调用/checkUserRecord，或者直接调用/checkUserRecord），返回清晰的错误提示
• 如果是分布式系统，方案一记得用分布式Session，方案二的Redis要是共享的

内容的提问来源于stack exchange，提问作者Arpit Singh