mvc:message-converters简单介绍

private ModelAndView invokeHandleMethod(HttpServletRequest request,  
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {  
  
        ServletWebRequest webRequest = new ServletWebRequest(request, response);  
  
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);  
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);  
        ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);  
  
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();  
        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));  
        modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);  
        mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);  
  
        AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);  
        asyncWebRequest.setTimeout(this.asyncRequestTimeout);  
  
        final WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
        asyncManager.setTaskExecutor(this.taskExecutor);  
        asyncManager.setAsyncWebRequest(asyncWebRequest);  
        asyncManager.registerCallableInterceptors(this.callableInterceptors);  
        asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);  
  
        if (asyncManager.hasConcurrentResult()) {  
            Object result = asyncManager.getConcurrentResult();  
            mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];  
            asyncManager.clearConcurrentResult();  
  
            if (logger.isDebugEnabled()) {  
                logger.debug("Found concurrent result value [" + result + "]");  
            }  
            requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);  
        }  
  
//这里是重点，执行handler的业务逻辑，对于@ResponseBody分支的处理在这里  
        requestMappingMethod.invokeAndHandle(webRequest, mavContainer);  
  
        if (asyncManager.isConcurrentHandlingStarted()) {  
            return null;  
        }  
//这里便是分水岭，要么返回一个ModelAndView，对于@ResponseBody的返回内容已写进response的body中，在这里要返回null。  
        return getModelAndView(mavContainer, modelFactory, webRequest);  
    }  

/** 
     * Invokes the method and handles the return value through a registered 
     * {@link HandlerMethodReturnValueHandler}. 
     * 
     * @param webRequest the current request 
     * @param mavContainer the ModelAndViewContainer for this request 
     * @param providedArgs "given" arguments matched by type, not resolved 
     */  
    public final void invokeAndHandle(ServletWebRequest webRequest,  
            ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {  
//这里执行完方法体，并返回结果内容  
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);  
  
        setResponseStatus(webRequest);  
  
        if (returnValue == null) {  
            if (isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled()) {  
                mavContainer.setRequestHandled(true);  
                return;  
            }  
        }  
        else if (StringUtils.hasText(this.responseReason)) {  
            mavContainer.setRequestHandled(true);  
            return;  
        }  
  
        mavContainer.setRequestHandled(false);  
  
        try {  
//重点在这里  
            this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);  
        }  
        catch (Exception ex) {  
            if (logger.isTraceEnabled()) {  
                logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);  
            }  
            throw ex;  
        }  
    }  

/**这里已经写了，要遍历已经注册的HandlerMethodReturnValueHandler，然后执行那个支持returnValue的那一个HandlerMethodReturnValueHandler 
     * Iterate over registered {@link HandlerMethodReturnValueHandler}s and invoke the one that supports it. 
     * @exception IllegalStateException if no suitable {@link HandlerMethodReturnValueHandler} is found. 
     */  
    @Override  
    public void handleReturnValue(  
            Object returnValue, MethodParameter returnType,  
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest)  
            throws Exception {  
  
        HandlerMethodReturnValueHandler handler = getReturnValueHandler(returnType);  
        Assert.notNull(handler, "Unknown return value type [" + returnType.getParameterType().getName() + "]");  
        handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);  
    }  

继续看下它是如何找到合适的HandlerMethodReturnValueHandler的 

Java代码  收藏代码
/** 
     * Find a registered {@link HandlerMethodReturnValueHandler} that supports the given return type. 
     */  
    private HandlerMethodReturnValueHandler getReturnValueHandler(MethodParameter returnType) {  
        for (HandlerMethodReturnValueHandler returnValueHandler : returnValueHandlers) {  
            if (logger.isTraceEnabled()) {  
                logger.trace("Testing if return value handler [" + returnValueHandler + "] supports [" +  
                        returnType.getGenericParameterType() + "]");  
            }  
            if (returnValueHandler.supportsReturnType(returnType)) {  
                return returnValueHandler;  
            }  
        }  
        return null;  
    }  

protected void writeWithMessageConverters(T returnValue, MethodParameter returnType,  
            ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)  
            throws IOException, HttpMediaTypeNotAcceptableException {  
  
        Class> returnValueClass = returnValue.getClass();  
        HttpServletRequest servletRequest = inputMessage.getServletRequest();  
//获取客户端Accept字段接收的content-type  
        List requestedMediaTypes = getAcceptableMediaTypes(servletRequest);  
//获取服务器端指定的content-type，如果@RequestMapping中的produces配置了content-type，则返回此content-type，若果没有，
则获取所有HttpMessageConverter所支持的content-type，然后通过requestedMediaTypes和producibleMediaTypes 对比，选定一个最合适的content-type作为  
//selectedMediaType  
        List producibleMediaTypes = getProducibleMediaTypes(servletRequest, returnValueClass);  
  
        Set compatibleMediaTypes = new LinkedHashSet();  
        for (MediaType requestedType : requestedMediaTypes) {  
            for (MediaType producibleType : producibleMediaTypes) {  
                if (requestedType.isCompatibleWith(producibleType)) {  
                    compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));  
                }  
            }  
        }  
        if (compatibleMediaTypes.isEmpty()) {  
            throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);  
        }  
  
        List mediaTypes = new ArrayList(compatibleMediaTypes);  
        MediaType.sortBySpecificityAndQuality(mediaTypes);  
  
        MediaType selectedMediaType = null;  
        for (MediaType mediaType : mediaTypes) {  
            if (mediaType.isConcrete()) {  
                selectedMediaType = mediaType;  
                break;  
            }  
            else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {  
                selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;  
                break;  
            }  
        }  
  
        if (selectedMediaType != null) {  
            selectedMediaType = selectedMediaType.removeQualityValue();  
            for (HttpMessageConverter> messageConverter :   
//遍历所有已注册的HttpMessageConverter，选出一个支持返回值类型returnValueClass和  
//selectedMediaType的HttpMessageConverter来进行写入数据到response的body中。  
this.messageConverters) {  
                if (messageConverter.canWrite(returnValueClass, selectedMediaType)) {  
                    ((HttpMessageConverter) messageConverter).write(returnValue, selectedMediaType, outputMessage);  
                    if (logger.isDebugEnabled()) {  
                        logger.debug("Written [" + returnValue + "] as \"" + selectedMediaType + "\" using [" +  
                                messageConverter + "]");  
                    }  
                    return;  
                }  
            }  
        }  
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);  
    }