我需要将 java.lang.String 的自定义 Jackson 反序列化器添加到我的 Spring 4.1.x MVC 应用程序中。但是，所有答案(例如 this )都是指为完整的 Web 应用程序配置 ObjectMapper，并且更改将应用​​于所有 Controller 中所有 @RequestBody 的所有字符串。

我只想将自定义反序列化应用于特定 Controller 中使用的 @RequestBody 参数。请注意，我没有为特定字符串字段使用 @JsonDeserialize 注释的选项。

您能否仅为特定 Controller 配置自定义反序列化？

最佳答案

要具有不同的反序列化配置，您必须具有不同的 ObjectMapper 实例，但开箱即用 Spring 使用 MappingJackson2HttpMessageConverter，它旨在仅使用一个实例。

我在这里至少看到两个选项:

从 MessageConverter 移到 ArgumentResolver

创建一个 @CustomRequestBody 注释和一个参数解析器:

public class CustomRequestBodyArgumentResolver implements HandlerMethodArgumentResolver {

  private final ObjectMapperResolver objectMapperResolver;

  public CustomRequestBodyArgumentResolver(ObjectMapperResolver objectMapperResolver) {
    this.objectMapperResolver = objectMapperResolver;
  }

  @Override
  public boolean supportsParameter(MethodParameter methodParameter) {
    return methodParameter.getParameterAnnotation(CustomRequestBody.class) != null;
  }

  @Override
  public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    if (this.supportsParameter(methodParameter)) {
      ObjectMapper objectMapper = objectMapperResolver.getObjectMapper();
      HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
      return objectMapper.readValue(request.getInputStream(), methodParameter.getParameterType());
    } else {
      return WebArgumentResolver.UNRESOLVED;
    }
  }
}

@CustomRequestBody 注释:

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CustomRequestBody {

  boolean required() default true;

}

ObjectMapperResolver 是一个接口(interface)，我们将使用它来解析实际使用的 ObjectMapper 实例，我将在下面讨论它。当然，如果您只有一个需要自定义映射的用例，您可以在此处简单地初始化您的映射器。

您可以使用此配置添加自定义参数解析器:

@Configuration
public class WebConfiguration extends WebMvcConfigurerAdapter {

  @Bean
  public CustomRequestBodyArgumentResolver customBodyArgumentResolver(ObjectMapperResolver objectMapperResolver) {
    return new CustomRequestBodyArgumentResolver(objectMapperResolver)
  } 

  @Override
  public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {       
    argumentResolvers.add(customBodyArgumentResolver(objectMapperResolver()));
  }
}

注意:不要将@CustomRequestBody与@RequestBody结合，会被忽略。

将 ObjectMapper 包装在隐藏多个实例的代理中

MappingJackson2HttpMessageConverter 设计为仅使用 ObjectMapper 的一个实例。我们可以使该实例成为代理委托(delegate)。这将使多个映射器的工作变得透明。

首先，我们需要一个拦截器，它将所有方法调用转换为底层对象。

public abstract class ObjectMapperInterceptor implements MethodInterceptor {

  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    return ReflectionUtils.invokeMethod(invocation.getMethod(), getObject(), invocation.getArguments());
  } 

  protected abstract ObjectMapper getObject();

}

现在我们的 ObjectMapper 代理 bean 将如下所示:

@Bean
public ObjectMapper objectMapper(ObjectMapperResolver objectMapperResolver) {
  ProxyFactory factory = new ProxyFactory();
  factory.setTargetClass(ObjectMapper.class);
  factory.addAdvice(new ObjectMapperInterceptor() {

      @Override
      protected ObjectMapper getObject() {
        return objectMapperResolver.getObjectMapper();
      }

  });

  return (ObjectMapper) factory.getProxy();
}

注意:由于它的模块化类加载，我在 Wildfly 上遇到了这个代理的类加载问题，所以我不得不扩展 ObjectMapper(不做任何更改)我可以使用模块中的类。

使用此配置将所有内容捆绑在一起:

@Configuration
public class WebConfiguration extends WebMvcConfigurerAdapter {

  @Bean
  public MappingJackson2HttpMessageConverter jackson2HttpMessageConverter() {
    return new MappingJackson2HttpMessageConverter(objectMapper(objectMapperResolver()));
  }

  @Override
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(jackson2HttpMessageConverter());
  }
}

ObjectMapperResolver 实现

最后一 block 是确定应该使用哪个映射器的逻辑，它将包含在 ObjectMapperResolver 接口(interface)中。它只包含一种查找方法:

public interface ObjectMapperResolver {

  ObjectMapper getObjectMapper();

}

如果您没有很多使用自定义映射器的用例，您可以简单地使用 ReqeustMatchers 作为键来制作预配置实例的映射。像这样的:

public class RequestMatcherObjectMapperResolver implements ObjectMapperResolver {

  private final ObjectMapper defaultMapper;
  private final Map<RequestMatcher, ObjectMapper> mapping = new HashMap<>();

  public RequestMatcherObjectMapperResolver(ObjectMapper defaultMapper, Map<RequestMatcher, ObjectMapper> mapping) {
    this.defaultMapper = defaultMapper;
    this.mapping.putAll(mapping);
  }

  public RequestMatcherObjectMapperResolver(ObjectMapper defaultMapper) {
    this.defaultMapper = defaultMapper;
  }

  @Override
  public ObjectMapper getObjectMapper() {
    ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = sra.getRequest();
    for (Map.Entry<RequestMatcher, ObjectMapper> entry : mapping.entrySet()) {
      if (entry.getKey().matches(request)) {
        return entry.getValue();
      }
    }
    return defaultMapper;
  }

}

您还可以使用请求范围的ObjectMapper，然后根据每个请求对其进行配置。使用此配置:

@Bean
public ObjectMapperResolver objectMapperResolver() {
  return new ObjectMapperResolver() {
    @Override
    public ObjectMapper getObjectMapper() {
      return requestScopedObjectMapper();
    }
  };
}


@Bean
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public ObjectMapper requestScopedObjectMapper() {
  return new ObjectMapper();
}

这最适合自定义响应序列化，因为您可以在 Controller 方法中正确配置它。对于自定义反序列化，您还必须使用 Filter/HandlerInterceptor/ControllerAdvice 在触发 Controller 方法之前为当前请求配置 Activity 映射器。

可以创建接口(interface)，类似于ObjectMapperResolver:

public interface ObjectMapperConfigurer {

  void configureObjectMapper(ObjectMapper objectMapper);

}

然后以 RequstMatcher 为键制作此实例的映射，并将其放入 Filter/HandlerInterceptor/ControllerAdvice 类似于 RequestMatcherObjectMapperResolver。

附:如果您想进一步探索动态 ObjectMapper 配置，我可以建议我的旧答案 here .它描述了如何在运行时制作动态 @JsonFilter。它还包含我在评论中建议的扩展 MappingJackson2HttpMessageConverter 的旧方法。

关于java - 你能配置 Spring Controller 特定的 Jackson 反序列化吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37844101/