如何将AOP @Before修改的HttpServletRequest传递给Spring控制器

你当前的写法无法生效，核心是两个认知误区：

• @Before前置通知的返回值不会被Spring AOP消费，你在方法内创建包装请求对象、给局部变量request重新赋值再返回的操作，完全不会替换掉Spring请求上下文（RequestContextHolder）中存储的原始请求实例，控制器拿到的始终是最开始的原始请求。
• Spring AOP是基于代理的方法级拦截，执行时机在Servlet请求处理链的末端，此时控制器的参数解析流程已经完成，你根本无法在这个阶段替换传入控制器方法的HttpServletRequest对象。

请求头修改属于请求预处理逻辑，标准实现方式是使用Servlet Filter，而不是Spring AOP。Filter在请求进入处理链的最前端执行，支持将包装后的请求对象沿着过滤链向后传递，后续所有组件（拦截器、AOP、控制器、参数解析器）拿到的都是修改后的请求对象，不会出现逻辑不一致的问题。

1. 实现可修改请求头的Request包装类 #

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import java.util.*;

public class MutableHeaderRequestWrapper extends HttpServletRequestWrapper {
    private final Map<String, String> customHeaders = new HashMap<>();

    public MutableHeaderRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    /**
     * 往请求头中添加自定义值
     */
    public void addHeader(String name, String value) {
        customHeaders.put(name, value);
    }

    @Override
    public String getHeader(String name) {
        // 优先返回自定义头
        if (customHeaders.containsKey(name)) {
            return customHeaders.get(name);
        }
        return super.getHeader(name);
    }

    @Override
    public Enumeration<String> getHeaderNames() {
        // 合并自定义头和原始头
        List<String> allHeaderNames = new ArrayList<>(customHeaders.keySet());
        Enumeration<String> originalNames = super.getHeaderNames();
        while (originalNames.hasMoreElements()) {
            allHeaderNames.add(originalNames.nextElement());
        }
        return Collections.enumeration(allHeaderNames);
    }

    @Override
    public Enumeration<String> getHeaders(String name) {
        if (customHeaders.containsKey(name)) {
            return Collections.enumeration(Collections.singletonList(customHeaders.get(name)));
        }
        return super.getHeaders(name);
    }
}

注：如果使用Spring Boot 2.x版本，将代码中jakarta.servlet包路径替换为javax.servlet即可

2. 实现Filter注入默认请求头 #

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.io.IOException;

@Component
@Order(1) // 指定过滤器优先级，数字越小越先执行
public class AppNameHeaderFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpReq = (HttpServletRequest) request;
        String appName = httpReq.getHeader("application-name");
        
        if (appName == null || appName.isBlank()) {
            // 头不存在时创建包装请求，设置默认值
            MutableHeaderRequestWrapper wrappedReq = new MutableHeaderRequestWrapper(httpReq);
            wrappedReq.addHeader("application-name", "unknown");
            // 将包装后的请求传递给后续处理链
            chain.doFilter(wrappedReq, response);
            return;
        }

        // 此处可保留你原有的application-name合法性校验逻辑，校验不通过直接返回400响应即可
        chain.doFilter(request, response);
    }
}

配置完成后，控制器中通过request.getHeader("application-name")就能拿到默认填充的unknown值，不需要修改原有控制器和AOP的其他逻辑。

• AOP拦截控制器方法时，请求已经经过了过滤器、拦截器、参数解析器等多个组件，就算你通过反射强行修改JoinPoint的传入参数，也无法保证前面执行的组件拿到的是修改后的值，很容易出现逻辑漏洞。
• Filter是Servlet规范定义的原生请求扩展点，天生支持请求对象的包装替换，没有Spring框架层面的兼容问题，是这类全局请求预处理需求的最优实现。

内容的提问来源于stack exchange，提问作者Anil Nivargi