java如何在过滤器中为http请求加请求头header

前言

先抛一个核心判断：在不少微服务或前后端分离的项目里，给请求统一加上一个token或用户标识，可以说是刚需。传统的做法是，把token存在session里，然后在页面上通过Ajax拿到之后，再塞进隐藏域或者请求头里传递。这种做法应付常规页面接口尚可，但一旦遇到上传、下载这类通过表单提交的场景，你就会发现——请求头里压根就没有token。那问题来了，有没有一种更通用的方式，能彻底绕过前端，直接在服务端把事情办妥？

答案是肯定的。我们可以用过滤器（Filter），或者在Spring MVC体系中用拦截器（Interceptor），在后端强制注入请求头。本文要讲的就是这个思路，核心是把用户的唯一标识加到请求头里，后续接口需要时直接取用就行，省去前端反复传递的麻烦。

1.创建拦截器

先看核心代码。拦截器的核心逻辑集中在addHeader方法里，它利用反射获取Tomcat底层的MimeHeaders对象，然后把指定的键值对强行塞进请求头中。

package com.kaying.luck.interceptor;

import com.kaying.luck.dao.draw.user.UserDao;
import com.kaying.luck.exception.ServiceException;
import com.kaying.luck.pojo.draw.user.dos.UserDO;
import com.kaying.luck.response.enums.ApiResponseCodeEnum;
import com.kaying.luck.utils.applicationContext.MyApplicationContext;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.http.MimeHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import ja vax.servlet.http.HttpServletRequest;
import ja vax.servlet.http.HttpServletResponse;
import ja va.lang.reflect.Field;
import ja va.util.HashMap;
import ja va.util.Map;

/**
 * @author csp
 * @create 2021-11-23 14:54
 * @description
 */
@Component
public class BaseInterceptor implements HandlerInterceptor {

    @Autowired
    private UserDao userDao = MyApplicationContext.getBean(UserDao.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {

        String userId = request.getHeader("userId");
        if (StringUtils.isBlank(userId)){
            throw new ServiceException(ApiResponseCodeEnum.ERROR_USER_ID, "未查询到用户信息");
        }
        UserDO userDO = userDao.getUserByUserId(userId);
        if (userDO == null) {
            userDO = new UserDO();
            userDO.setId(null);
            userDO.setUserId(userId);
            userDO.setUserOrderStatus(0);
            userDao.insert(userDO);
        }
        Map map=new HashMap<>();
        map.put("userId",userId);
        addHeader(request,map);
        return true;
    }

    private void addHeader(HttpServletRequest request, Map headerMap) {
        if (headerMap==null||headerMap.isEmpty()){
            return;
        }

        Class c=request.getClass();
        System.out.println("request实现类="+c.getName());
        try{
            Field requestField=c.getDeclaredField("request");
            requestField.setAccessible(true);

            Object o=requestField.get(request);
            Field coyoteRequest=o.getClass().getDeclaredField("coyoteRequest");
            coyoteRequest.setAccessible(true);

            Object o2=coyoteRequest.get(o);
            System.out.println("coyoteRequest实现类="+o2.getClass().getName());
            Field headers=o2.getClass().getDeclaredField("headers");
            headers.setAccessible(true);

            MimeHeaders mimeHeaders=(MimeHeaders) headers.get(o2);
            for (Map.Entry entry:headerMap.entrySet()){
                mimeHeaders.removeHeader(entry.getKey());
                mimeHeaders.addValue(entry.getKey()).setString(entry.getValue());
            }

        }catch (Exception e){
            e.printStackTrace();
        }

    }


    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse response, Object o, ModelAndView modelAndView) throws Exception {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "*");
        response.setHeader("Access-Control-Allow-Credentials", "true");
    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    }

}

说句实在话，这里用反射访问MimeHeaders是个偏底层的玩法，它绕开了Servlet API的标准限制。业内方案不少。可以做到，但也需要意识到这种做法对容器实现有耦合——目前这段代码针对的是Tomcat的RequestFacade和CoyoteRequest。如果将来换了Jetty或Undertow，就需要调整反射路径。好在大多数Spring Boot项目默认用的是嵌入式Tomcat，所以短期内问题不大。

2.配置拦截器

有了拦截器，当然还需要让Spring Boot知道它的存在。配置起来并不复杂：注册拦截器，指定路径，再排掉一些不需要拦截的公开接口，比如Swagger文档、回调地址、静态资源等。

package com.kaying.luck.config.interceptor;

import com.kaying.luck.interceptor.BaseInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 拦截器需要配置才可以使用，也可以在这里注入其他的类
 *
 * @author yt
 * @create 2022/10/17 14:26
 */
@Configuration
public class BaseInterceptorConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截器
        registry.addInterceptor(new BaseInterceptor())
                //添加拦截路径
                .addPathPatterns("/**")
                //排除的拦截路径（此路径不拦截）
                .excludePathPatterns("/swagger/**","/error","/download/**","/wx/**","/address/**","/management/**","/callback/**",
                        "/fa vicon.ico","/swagger2/**", "/swagger*", "/swagger*/**", "/webjars/**", "/doc.html", "/swagger-ui.html", "/swagger-resources/**", "/v2/api-docs**");

    }

    /**
     * 开启跨域
     */
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        // 设置允许跨域的路由
        registry.addMapping("/**")
                // 设置允许跨域请求的域名
                .allowedOriginPatterns("*")
                // 是否允许证书（cookies）
                .allowCredentials(true)
                // 设置允许的方法
                .allowedMethods("*")
                // 跨域允许时间
                .maxAge(3600);
    }


}

从设计角度看，拦截路径的粒度需要仔细斟酌。示例项目中把/download/**和上传相关的路径排除了，这很合理——因为这些接口通常不走前端Ajax。但如果你希望所有接口，包括上传下载，都带上用户标识，那排除列表里就不应该出现它们。这个需要根据业务场景灵活调整。

4.在要拦截的方法

当然，后端把userId强行塞进请求头之后，业务接口那边也不能闲着。正确的做法是在Controller的入参上使用@RequestHeader注解，直接从请求头里提取出来。

 @ApiOperation(value = "根据用户UserId查询用户信息")
    @GetMapping("get/user")
    public ApiResponse getUserByUserId( @RequestHeader("userId") String userId) {
        System.out.println("userId = " + userId);
        if (StringUtils.isBlank(userId)) {
            throw new ServiceException(ApiResponseCodeEnum.FAIL, "获取用户信息失败");
        }
        UserDO userDO = userLoginService.getUserByUserId(userId);
        return ApiResponse.success(userDO);
    }

这一步既是收尾，也是验证。如果拦截器成功注入了userId，那么Controller中打印出来的值就不应该为空。这正是整个链路生效的证明。

5.测试访问是可以拿到userid的

总结

整体看下来，通过拦截器配合反射机制来动态添加请求头，确实能解决传统前端传参方式覆盖不全的问题。不过也有几点值得留个心眼：一是反射代码对容器类型有依赖，换个中间件就可能翻车；二是这种做法绕过了Servlet标准，后续升级容器版本时可能出兼容性问题。如果项目对稳定性要求极高，也可以考虑在网关层（如Spring Cloud Gateway）统一处理请求头，或者直接使用过滤器（Filter）在Servlet容器层面完成注入，方式更标准一些。但就通用性和落地便捷性而言，本文介绍的方案在大多数Tomcat环境下足够用，而且代码量也不大，属于“小成本解决大痛点”的典型做法。