Spring Boot如何基于StrategyProp统一处理Header与QueryParam的自定义反序列化？

针对你遇到的问题，这里提供三种无需手动逐个转换、能统一处理的可行方案：

方案1：自定义Converter注册到ConversionService #

Spring原生的ConversionService可以处理字符串到自定义类型的转换，是处理Header/QueryParam参数最简洁的方式，不需要触碰复杂的HandlerMethodArgumentResolver扩展逻辑。

实现步骤 #

1. 实现Converter<String, PropInterface>，在转换方法中从当前请求上下文获取StrategyProp参数，再根据策略值解析字符串为对应实现类：

@Component
public class PropInterfaceConverter implements Converter<String, PropInterface> {

    @Override
    public PropInterface convert(String source) {
        // 从当前请求中提取StrategyProp（同时兼容QueryParam和Header）
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String strategyStr = request.getParameter("strategyProp");
        if (strategyStr == null) {
            strategyStr = request.getHeader("strategyProp");
        }
        StrategyProp strategyProp = StrategyProp.valueOf(strategyStr);
        
        // 根据策略调用对应反序列化逻辑
        return switch (strategyProp) {
            case STRATEGY_A -> new PropADeserializer().parse(source);
            case STRATEGY_B -> new PropBDeserializer().parse(source);
            default -> throw new IllegalArgumentException("不支持的策略类型：" + strategyProp);
        };
    }
}

2. 将Converter注册到Spring的转换体系（Spring Boot中添加@Component会自动注册，也可手动配置）：

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new PropInterfaceConverter());
    }
}

3. 控制器直接使用目标类型参数：

@GetMapping("/demo")
public ResponseEntity<Void> demo(
        @RequestParam PropInterface prop,
        @RequestParam StrategyProp strategyProp) {
    // prop已自动转换为对应策略的实现类，可直接使用
    return ResponseEntity.ok().build();
}

方案2：自定义注解+独立HandlerMethodArgumentResolver #

不扩展Spring默认的Resolver，而是编写优先级更高的自定义Resolver，专门处理你的策略接口类型参数。

实现步骤 #

1. 定义标记注解，用来标识需要自动解析的参数：

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface StrategyResolved {
    // 可选：指定参数对应的Header/QueryParam名称，默认用参数名
    String value() default "";
}

2. 实现HandlerMethodArgumentResolver：

@Component
public class StrategyArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        // 只处理标记了@StrategyResolved的PropInterface类型参数
        return parameter.getParameterType().isAssignableFrom(PropInterface.class)
                && parameter.hasParameterAnnotation(StrategyResolved.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        StrategyResolved annotation = parameter.getParameterAnnotation(StrategyResolved.class);
        String paramName = StringUtils.hasText(annotation.value()) ? annotation.value() : parameter.getParameterName();
        
        // 获取参数值（先查QueryParam，再查Header）
        String paramValue = webRequest.getParameter(paramName);
        if (paramValue == null) {
            paramValue = webRequest.getHeader(paramName);
        }
        if (paramValue == null) {
            throw new MissingServletRequestParameterException(paramName, parameter.getParameterType().getName());
        }

        // 获取StrategyProp参数
        String strategyStr = webRequest.getParameter("strategyProp");
        if (strategyStr == null) {
            strategyStr = webRequest.getHeader("strategyProp");
        }
        StrategyProp strategyProp = StrategyProp.valueOf(strategyStr);

        // 实例化对应实现类
        return switch (strategyProp) {
            case STRATEGY_A -> new PropADeserializer().parse(paramValue);
            case STRATEGY_B -> new PropBDeserializer().parse(paramValue);
            default -> throw new IllegalArgumentException("不支持的策略类型：" + strategyProp);
        };
    }
}

3. 注册Resolver并设置优先级：

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private StrategyArgumentResolver strategyArgumentResolver;

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        // 放在列表最前面，优先于Spring默认Resolver处理
        resolvers.add(0, strategyArgumentResolver);
    }
}

4. 控制器使用注解标记参数：

@GetMapping("/demo")
public ResponseEntity<Void> demo(
        @StrategyResolved("prop") PropInterface prop,
        @RequestParam StrategyProp strategyProp) {
    // prop已自动转换为对应策略的实现类
    return ResponseEntity.ok().build();
}

方案3：@InitBinder全局绑定属性编辑器 #

如果参数是封装在DTO类中的，可以通过@ControllerAdvice结合@InitBinder注册全局属性编辑器，处理DTO内的PropInterface类型参数。

实现步骤 #

1. 编写全局Binder配置：

@ControllerAdvice
public class GlobalBinderConfig {

    @InitBinder
    public void initPropInterfaceBinder(WebDataBinder binder) {
        binder.registerCustomEditor(PropInterface.class, new PropertyEditorSupport() {
            @Override
            public void setAsText(String text) throws IllegalArgumentException {
                // 从请求上下文获取StrategyProp
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                String strategyStr = request.getParameter("strategyProp");
                if (strategyStr == null) {
                    strategyStr = request.getHeader("strategyProp");
                }
                StrategyProp strategyProp = StrategyProp.valueOf(strategyStr);
                
                // 解析字符串为对应实现类
                switch (strategyProp) {
                    case STRATEGY_A -> setValue(new PropADeserializer().parse(text));
                    case STRATEGY_B -> setValue(new PropBDeserializer().parse(text));
                    default -> throw new IllegalArgumentException("不支持的策略类型：" + strategyProp);
                }
            }
        });
    }
}

2. 控制器直接使用DTO参数：

public class DemoRequest {
    private PropInterface prop;
    private StrategyProp strategyProp;
    // getter/setter
}

@GetMapping("/demo")
public ResponseEntity<Void> demo(DemoRequest request) {
    // request.getProp()已自动转换为对应策略的实现类
    return ResponseEntity.ok().build();
}

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