Spring MVC：当未指定内容类型时@RequestBody

我有一个 Spring MVC 应用程序，它以 JSON 字符串的形式从外部系统接收 HTTP 请求，其响应的返回方式与 JSON 字符串类似。我的控制器正确注释为@RequestBody and @ResponseBody我有集成测试，它实际上发送请求来验证一切是否按预期工作。

但是，当我针对将使用它的实际外部系统测试我的应用程序时，我发现传入请求未指定内容类型！这完全混淆了 Spring 并导致以下类型的错误：

DEBUG [] 2014-04-17 13:33:13,471 AbstractHandlerExceptionResolver.java:132 resolveException - Resolving exception from handler [com.example.controller.MyController@1d04f0a]: org.springframework.web.HttpMediaTypeNotSupportedException: Cannot extract parameter (ValidationRequest request): no Content-Type found

那么，有没有办法强制Spring通过以下方式路由这样的请求：MappingJacksonHttpMessageConverter，要么通过某种方式强制 Spring 使用自定义处理程序链，要么修改传入请求以显式设置内容类型？

我尝试过一些事情：

• 延伸MappingJacksonHttpMessageConverter以便其canRead() and canWrite()方法总是返回 true。不幸的是，由于缺乏内容类型，Spring 在退出之前甚至没有达到查看消息转换器的程度。
• 使用拦截器或 Servlet 过滤器手动设置内容类型。不幸的是，除了设置新属性之外，我看不到任何一种机制可以实际更改传入请求。

任何想法表示赞赏。

为了解决下面的评论，我的@RequestMapping好像：

@RequestMapping(value="/{service}" )
public @ResponseBody MyResponseObject( @PathVariable String service, @RequestBody MyRequestObject request) {

因此，这里没有任何内容指定 JSON，但是如果没有内容类型，Spring 似乎甚至不会尝试从传入请求构建我的请求对象（这是有道理的，因为它没有足够的信息来确定如何执行此操作） ）。

至于 @geoand 的评论询问“为什么不能在 Servlet 过滤器或 Spring 拦截器中添加内容类型 http 标头”，答案是“因为我很笨，忘记了 servlet 过滤器是如何工作的”。这是我最终用来解决问题的方法，我将立即将其添加为答案。

当我问这个问题时，我有点傻，因为我正在 Spring 中寻找一种方法来直接操作传入的请求，或者明确地告诉处理程序链我希望请求始终被视为 JSON。我想了一下，我意识到这正是 Servlet Filter 的用途。

首先，我创建了一个新的HttpServletRequestWrapper看起来像这样：

public class ForcedContentTypeHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private static final Logger log = Logger.getLogger( ForcedContentTypeHttpServletRequestWrapper.class );

    // this is the header to watch out for and what we should make sure it always resolves to.
    private static final String CONTENT_TYPE_HEADER = "content-type";
    private static final String CONTENT_TYPE = "application/json";


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

    /**
     * If content type is explicitly queried, return our hardcoded value
     */
    @Override
    public String getContentType() {
        log.debug( "Overriding request's content type of " + super.getContentType() );
        return CONTENT_TYPE;
    }

    /**
     * If we are being asked for the content-type header, always return JSON
     */
    @Override
    public String getHeader( String name ) {
        if ( StringUtils.equalsIgnoreCase( name, CONTENT_TYPE_HEADER ) ) {
            if ( super.getHeader( name ) == null ) {
                log.debug( "Content type was not originally included in request" );
            }
            else {
                log.debug( "Overriding original content type from request: " + super.getHeader( name ) );
            }
            log.debug( "Returning hard-coded content type of " + CONTENT_TYPE );
            return CONTENT_TYPE;
        }

        return super.getHeader( name );
    }

    /**
     * When asked for the names of headers in the request, make sure "content-type" is always
     * supplied.
     */
    @SuppressWarnings( { "unchecked", "rawtypes" } )
    @Override
    public Enumeration getHeaderNames() {

        ArrayList headerNames = Collections.list( super.getHeaderNames() );
        if ( headerNames.contains( CONTENT_TYPE_HEADER ) ) {
            log.debug( "content type already specified in request. Returning original request headers" );
            return super.getHeaderNames();
        }

        log.debug( "Request did not specify content type. Adding it to the list of headers" );
        headerNames.add( CONTENT_TYPE_HEADER );
        return Collections.enumeration( headerNames );
    }

    /**
     * If we are being asked for the content-type header, always return JSON
     */
    @SuppressWarnings( { "rawtypes", "unchecked" } )
    @Override
    public Enumeration getHeaders( String name ) {
        if ( StringUtils.equalsIgnoreCase( CONTENT_TYPE_HEADER, name ) ) {
            if ( super.getHeaders( name ) == null ) {
                log.debug( "Content type was not originally included in request" );
            }
            else {
                log.debug( "Overriding original content type from request: " + Collections.list( super.getHeaders( name ) ) );
            }
            log.debug( "Returning hard-coded content type of " + CONTENT_TYPE );
            return Collections.enumeration( Arrays.asList( CONTENT_TYPE ) );
        }

        return super.getHeaders( name );
    }

}

然后我将此包装器用于过滤器，如下所示：

public class ContentTypeFilter implements Filter {

    /**
     * @see Filter#destroy()
     */
    @Override
    public void destroy() {
        // do nothing
    }

    /**
     * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
     */
    @Override
    public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain ) throws IOException, ServletException {
        ForcedContentTypeHttpServletRequestWrapper requestWrapper = new ForcedContentTypeHttpServletRequestWrapper( (HttpServletRequest) request );
        chain.doFilter( requestWrapper, response );
    }

    /**
     * @see Filter#init(FilterConfig)
     */
    @Override
    public void init( FilterConfig fConfig ) throws ServletException {
        // do nothing
    }

}

它并不完全安全，但它可以正确处理来自该应用程序实际关心的单一来源的请求。