踩坑实录:GET 请求参数偶发丢失,"再点一下就好"?我是怎么把它复现成必现的

GET /api/public-key?userId=10001&channel=app

Required request parameter 'userId' for method parameter type String is not present

HTTP 请求 → Tomcat Connector → DispatcherServlet
  → RequestParamMethodArgumentResolver.resolveName()
    → request.getParameter() → Parameters.handleQueryParameters()
      → didQueryParameters 标志位
→ 绑定到 Controller 方法参数

// 最小化复现:模拟"异步线程晚于请求回收后调用 getParameter"
@RestController
public class ReproController {

    private final ExecutorService pool = Executors.newFixedThreadPool(1);

    @GetMapping("/repro")
    public String repro(@RequestParam("userId") String userId, HttpServletRequest request) {
        pool.submit(() -> {
            sleep(500);                        // 模拟慢任务,等请求回收
            request.getParameter("userId");    // ⚠️ 在已回收的 request 上触发解析
        });
        return "ok";
    }

    private static void sleep(long ms) {
        try { Thread.sleep(ms); } catch (InterruptedException ignored) { }
    }
}

# application.yml:临时缩小 Tomcat 线程数,加速连接器复用,放大问题
server:
  tomcat:
    threads:
      max: 8          # 默认 200,调小后连接器复用频率大幅上升
      min-spare: 2

grep -rn "HttpServletRequest\|getParameter\|request" --include="*.java" | grep -i "async\|thread\|task\|submit\|executor"

线程组:线程数 100,循环次数持续运行
请求:GET /api/export?bizId=xxx
断言:检查是否出现 "Required request parameter" 错误

HTTP 请求
  → Tomcat Connector (接收)
  → Processor (受理请求)
  → DispatcherServlet (SpringMVC 分发)
  → RequestParamMethodArgumentResolver (参数解析)
  → Controller 方法参数

Request.getParameterValues()
  → Parameters.handleQueryParameters()   // 解析 queryString 封装为 parameter

public String getParameter(String name) {
    // 伪代码,省略细节
    if (!parameters.isDidQueryParameters()) {
        handleQueryParameters();  // 仅首次解析
        parameters.setDidQueryParameters(true);
    }
    return parameters.getParameter(name);
}

// ❌ 问题代码:子线程中引用了 request
@RestController
public class PublicKeyController {

    @Autowired
    private HttpServletRequest request;

    @GetMapping("/api/public-key")
    public String getPublicKey(@RequestParam("userId") String userId) {
        // 起了个异步任务,直接引用 request
        CompletableFuture.runAsync(() -> {
            // 子线程里再次调用 getParameter(),污染 didQueryParameters
            String uid = request.getParameter("userId");
            doSomethingSlow(uid);
        });
        return "ok";
    }
}

// ❌ 同样危险:request 被"传递"给异步组件
@GetMapping("/api/public-key")
public String getPublicKey(@RequestParam("userId") String userId) {
    AsyncTaskExecutor.submit(() -> {
        return someService.handle(request);  // request 逃离请求线程
    });
    return "ok";
}

// ❌ 导出接口:接口立即返回,异步线程里继续操作 request
@GetMapping("/api/export")
public String export(@RequestParam("bizId") String bizId) {
    // 异步导出任务,request 被一并传入
    exportTaskExecutor.submit(() -> exportService.doExport(request));
    return "ok";  // 接口已返回,但异步线程还握着 request
}

// ✅ 正确做法:请求线程内取值,子线程只拿值
@GetMapping("/api/export")
public String export(@RequestParam("bizId") String bizId) {
    // 参数在请求线程内已绑定好,直接传值,不再传 request
    exportTaskExecutor.submit(() -> exportService.doExport(bizId));
    return "ok";
}

// ✅ 推荐:构建不可变上下文,子线程只消费值
@GetMapping("/api/public-key")
public String getPublicKey(@RequestParam("userId") String userId,
                           @RequestParam(value = "channel", required = false) String channel) {
    PublicKeyContext ctx = new PublicKeyContext(userId, channel); // 请求线程内构建
    CompletableFuture.runAsync(() -> someService.handle(ctx));     // 子线程只消费值
    return "ok";
}

// ✅ 兜底方案:请求包装类,手动重新解析 queryString
public class ReparsedRequestWrapper extends HttpServletRequestWrapper {

    private final Map<String, String[]> reparsedParams = new HashMap<>();

    public ReparsedRequestWrapper(HttpServletRequest request) {
        super(request);
        parseQueryString(request.getQueryString());
    }

    private void parseQueryString(String queryString) {
        if (StringUtils.hasText(queryString)) {
            for (String pair : queryString.split("&")) {
                int idx = pair.indexOf('=');
                if (idx > 0) {
                    String key = URLDecoder.decode(pair.substring(0, idx), StandardCharsets.UTF_8);
                    String value = URLDecoder.decode(pair.substring(idx + 1), StandardCharsets.UTF_8);
                    reparsedParams.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
                }
            }
        }
    }

    @Override
    public String getParameter(String name) {
        String[] values = reparsedParams.get(name);
        return (values != null && values.length > 0) ? values[0] : null;
    }

    @Override
    public String[] getParameterValues(String name) {
        return reparsedParams.get(name);
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return Collections.unmodifiableMap(reparsedParams);
    }

    @Override
    public Enumeration<String> getParameterNames() {
        return Collections.enumeration(reparsedParams.keySet());
    }
}

// ✅ 兜底方案:拦截器检测参数是否被跳过解析,已跳过则包装重解析 + 告警
@Slf4j
@Component
public class ParameterReparseInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String queryString = request.getQueryString();
        // 判定:queryString 有值,但参数表为空 → 说明解析被提前置位跳过
        if (StringUtils.hasText(queryString) && request.getParameterMap().isEmpty()) {
            log.warn("[参数兜底] 检测到 request 参数解析被跳过, queryString='{}' 但参数为空, 包装重解析", queryString);
            // 将包装类放入 request attribute, 供后续读取; 此处按需选择替换方式
            ReparsedRequestWrapper wrapper = new ReparsedRequestWrapper(request);
            // 实际替换 request 需结合 Spring 机制(如 RequestContextHolder / 自定义解析器),
            // 以下给出核心思路, 具体接入方式按项目实际配置
            request.setAttribute(ReparsedRequestWrapper.class.getName(), wrapper);
        }
        return true;
    }
}