你能配置Spring控制器特定的Jackson反序列化吗？

Question

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

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

您是否可以仅为特定控制器配置自定义反序列化？

Answer 1

要具有不同的反序列化配置,您必须具有不同的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;
    }
  }
}

ObjectMapperResolver是我们将用于解析实际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.我们可以将该实例设为代理委托.这将使多个映射器的工作变得透明.

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

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 实现

最后一块是确定应该使用哪个映射器的逻辑,它将包含在ObjectMapperResolver接口中.它只包含一个查找方法:

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();
}

这最适合自定义响应序列化,因为您可以在控制器方法中进行正确配置.对于自定义反序列化,您还必须使用Filter/ HandlerInterceptor/ ControllerAdvice在触发控制器方法之前为当前请求配置活动映射器.

您可以创建界面,类似于ObjectMapperResolver:

public interface ObjectMapperConfigurer {

  void configureObjectMapper(ObjectMapper objectMapper);

}

然后使用RequstMatchers作为键来创建此实例的映射,并将其放在Filter/ HandlerInterceptor/ ControllerAdvice类似于RequestMatcherObjectMapperResolver.

PS如果你想进一步探索动态ObjectMapper配置,我可以在这里建议我的旧答案.它描述了如何@JsonFilter在运行时创建动态s.它还包含我MappingJackson2HttpMessageConverter在评论中建议的扩展的旧方法.

Answer 2

您可以为要反序列化的每种不同类型的请求参数定义一个 POJO。然后，以下代码会将 JSON 中的值提取到您定义的对象中，假设 POJO 中的字段名称与 JSON 请求中的字段名称匹配。

ObjectMapper mapper = new ObjectMapper(); 
YourPojo requestParams = null;

try {
    requestParams = mapper.readValue(JsonBody, YourPOJO.class);

} catch (IOException e) {
    throw new IOException(e);
}