如何实现从Spring控制器提取所有参数的通用解决方案

嘿，我刚好处理过类似的需求，给你分享几个通用的实现方案，不用针对每个控制器写重复代码，完美适配你想要的Map<String, Object> map = getCallingParameters()效果～

方案一：Spring AOP 全局拦截收集参数 #

这是最通用的方案，能捕获控制器方法里的所有参数（包括@PathVariable、@RequestParam、自定义对象参数甚至Model这类框架参数），步骤如下：

1. 定义AOP切面类 #

这个切面会拦截所有标注了@Controller或@RestController的类的方法，自动收集参数并存储到ThreadLocal中：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.Map;

@Aspect
@Component
public class ControllerParameterCollector {

    // 拦截所有控制器类的方法
    @Around("within(@org.springframework.web.bind.annotation.RestController *) || within(@org.springframework.web.bind.annotation.Controller *)")
    public Object collectParameters(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Parameter[] methodParams = signature.getMethod().getParameters();
        Object[] paramValues = joinPoint.getArgs();

        Map<String, Object> paramMap = new HashMap<>();

        for (int i = 0; i < methodParams.length; i++) {
            Parameter param = methodParams[i];
            Object value = paramValues[i];

            // 处理@PathVariable注解的参数
            PathVariable pathVar = param.getAnnotation(PathVariable.class);
            if (pathVar != null) {
                String paramName = getAnnotationParamName(pathVar.name(), pathVar.value(), param.getName());
                paramMap.put(paramName, value);
                continue;
            }

            // 处理@RequestParam注解的参数
            RequestParam reqParam = param.getAnnotation(RequestParam.class);
            if (reqParam != null) {
                String paramName = getAnnotationParamName(reqParam.name(), reqParam.value(), param.getName());
                paramMap.put(paramName, value);
                continue;
            }

            // 可扩展：处理@RequestBody、@RequestHeader等其他注解
            // 如果没有特殊注解，直接用参数本身的名字（需开启-parameters编译选项）
            paramMap.put(param.getName(), value);
        }

        // 把参数Map存入ThreadLocal，方便控制器内获取
        ParamContext.setParamMap(paramMap);
        try {
            // 执行原控制器方法
            return joinPoint.proceed();
        } finally {
            // 清理ThreadLocal，避免内存泄漏
            ParamContext.clear();
        }
    }

    // 统一处理注解的name/value属性，优先取非空的，最后用参数名
    private String getAnnotationParamName(String name, String value, String defaultName) {
        if (!name.isEmpty()) {
            return name;
        }
        if (!value.isEmpty()) {
            return value;
        }
        return defaultName;
    }
}

2. 定义ThreadLocal上下文类 #

用来存储和获取参数Map，保证线程安全：

public class ParamContext {
    private static final ThreadLocal<Map<String, Object>> PARAM_MAP = new ThreadLocal<>();

    public static void setParamMap(Map<String, Object> map) {
        PARAM_MAP.set(map);
    }

    // 就是你想要的getCallingParameters方法！
    public static Map<String, Object> getCallingParameters() {
        return PARAM_MAP.get();
    }

    public static void clear() {
        PARAM_MAP.remove();
    }
}

3. 控制器内直接使用 #

现在你的控制器方法里可以直接调用getCallingParameters()获取所有参数了：

@GetMapping("/test/{date}")
public String details(@PathVariable LocalDate date, @RequestParam(required = false) SortOptions sort, Model model) {
    Map<String, Object> map = ParamContext.getCallingParameters();
    // map里会包含：{"date": date对象, "sort": sort对象, "model": model对象}
    // 如果你不想包含Model这类框架参数，可以在切面里过滤掉，比如判断参数类型是否是Model
    // ...你的业务逻辑
    return "success";
}

关键注意事项 #

• 开启-parameters编译选项：默认Java编译不会保留参数名，会生成arg0、arg1这类名字，所以需要开启这个选项才能通过param.getName()拿到真实参数名。Maven配置示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <parameters>true</parameters>
                <source>11</source> <!-- 替换成你的Java版本 -->
                <target>11</target>
            </configuration>
        </plugin>
    </plugins>
</build>

• 可扩展性：如果需要处理其他注解（比如@RequestBody、@RequestHeader），只需要在切面里添加对应的判断逻辑即可。
• 参数过滤：如果不想收集Model、HttpServletRequest这类框架参数，可以在遍历参数时判断类型，跳过不需要的参数。

方案二：HandlerInterceptor （适合简单场景） #

如果只需要收集@PathVariable和@RequestParam这类请求参数（不包含自定义对象参数），可以用Spring的拦截器：

import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

public class RequestParamInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Map<String, Object> paramMap = new HashMap<>();
        // 获取@RequestParam参数
        request.getParameterMap().forEach((k, v) -> paramMap.put(k, v.length == 1 ? v[0] : v));
        // 获取@PathVariable参数（需要从HandlerMethod里解析，稍微麻烦）
        // 这里省略解析PathVariable的逻辑，因为需要反射HandlerMethod获取注解信息，不如AOP方便
        ParamContext.setParamMap(paramMap);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        ParamContext.clear();
    }
}

不过这个方案的局限性是无法直接获取Spring已经解析好的自定义对象参数（比如你的SortOptions），所以更推荐AOP方案。

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