spring的Controller的方法總的來說返回方式有兩種：一種是view, 另一種是converter,通過@ResponseBody來註解方法，

這裡主要講述註解方式，@RequestMapping的 headers 和produces引數設定不同，返回處理略有不同，這裡主要講述下accept和produces的各種配置及優先順序型別。

一. @ResponseBody 註解是如何處理訊息的

首先找到ResponseBody的處理類：

org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor，

繼承了 org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor

方法writeWithMessageConverters 處理返回結果：

/**
	 * Writes the given return type to the given output message.
	 *
	 * @param returnValue the value to write to the output message
	 * @param returnType the type of the value
	 * @param inputMessage the input messages. Used to inspect the {@code Accept} header.
	 * @param outputMessage the output message to write to
	 * @throws IOException thrown in case of I/O errors
	 * @throws HttpMediaTypeNotAcceptableException thrown when the conditions indicated by {@code Accept} header on
	 * the request cannot be met by the message converters
	 */
	@SuppressWarnings("unchecked")
	protected <T> void writeWithMessageConverters(T returnValue,
												MethodParameter returnType,
												ServletServerHttpRequest inputMessage,
												ServletServerHttpResponse outputMessage)
			throws IOException, HttpMediaTypeNotAcceptableException {

		Class<?> returnValueClass = returnValue.getClass();

		HttpServletRequest servletRequest = inputMessage.getServletRequest();
                // 取請求中accept的型別，無值為*/*
                List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(servletRequest);
//  見下面程式碼片段
                List<MediaType> producibleMediaTypes = getProducibleMediaTypes(servletRequest, returnValueClass);
// 匹配相容的型別
		Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
		for (MediaType r : requestedMediaTypes) {
			for (MediaType p : producibleMediaTypes) {
				if (r.isCompatibleWith(p)) {
					compatibleMediaTypes.add(getMostSpecificMediaType(r, p));
				}
			}
		}
              // 匹配不到就拋返回型別不支援
                if (compatibleMediaTypes.isEmpty()) {
			throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
		}

		List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);

// 按quality 排序
		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 : messageConverters) {
				 if (messageConverter.canWrite(returnValueClass, selectedMediaType)) {
					  ((HttpMessageConverter<T>) messageConverter).write(returnValue, selectedMediaType, outputMessage);
					if (logger.isDebugEnabled()) {
						 logger.debug("Written [" + returnValue + "] as \"" + selectedMediaType + "\" using [" +
 								messageConverter + "]");
					}
  					return;
 				}
 			}
 		}
 		throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
	}
 

獲取可生產的型別

/**
	 * Returns the media types that can be produced:
	 * <ul>
	 * 	<li>The producible media types specified in the request mappings, or
	 * 	<li>Media types of configured converters that can write the specific return value, or
	 * 	<li>{@link MediaType#ALL}
	 * </ul>
	 */
	@SuppressWarnings("unchecked")
	protected List<MediaType> getProducibleMediaTypes(HttpServletRequest request, Class<?> returnValueClass) {
		Set<MediaType> mediaTypes = (Set<MediaType>) request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
		if (!CollectionUtils.isEmpty(mediaTypes)) {
			return new ArrayList<MediaType>(mediaTypes);
		}//當請求中accept沒有設定，或者@RequestMapping註解中沒有配置header的accept和produces,
		else if (!allSupportedMediaTypes.isEmpty()) {
			List<MediaType> result = new ArrayList<MediaType>();
			for (HttpMessageConverter<?> converter : messageConverters) { 
         //取spring配置中所有converter支援的MediaType
				 if (converter.canWrite(returnValueClass, null)) {
 					result.addAll(converter.getSupportedMediaTypes());
				}
 			}
 			return result;
 		}
                else {
                      return Collections.singletonList(MediaType.ALL);
   	        }
	}
 

二. 示例程式碼：

controller 片段：

@Controller
@RequestMapping(URIConstant.SERVICE_CONFIG)
public class ConfigController {

    //設定produces
    @RequestMapping(value = "/queryConfig", method = RequestMethod.GET,<strong> produces = { "application/xml",
            "application/json" }</strong>)
    @ResponseBody
    public ResultVo<Config> queryConfig(
            @ModelAttribute CommonParameterVo commonParameterVo,
            @RequestParam(value = "key", required = true) String key)
            throws Exception {
        ResultVo<Config> resultVo = new ConfigVo();
        
        Config config = new Config();
        config.setConfigKey(key);
        config.setConfigValue("test");
        resultVo.setData(config);

        setLogParameters(resultVo, "{key:" + key + "}");
        return resultVo;
    }
    //設定headers的Accept
    @SuppressWarnings("rawtypes")
    @RequestMapping(value = "/queryConfigs", method = RequestMethod.GET, <strong>headers = "Accept=<span style="color:#FF9966;">application/json</span>,application/xml"</strong>)
    @ResponseBody
    public ResultVo queryConfigs(@ModelAttribute CommonParameterVo commonParameterVo) throws Exception {
        ResultVo<ListVo> resultVo = new ResultVo<ListVo>();
        ListVo<Config> configs = new ListVo<>();
        Config config = new Config();
        config.setConfigValue("test");
        config.setConfigKey("test");
        configs.add(config);
        
        resultVo.setData(configs);

        setLogParameters(resultVo, configs);
        return resultVo;
    }
// 沒有設定 header accept 或者produces
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @RequestMapping(value = "/addConfig", method = RequestMethod.POST)
    @ResponseBody
    public ResultVo addConfig(@ModelAttribute CommonParameterVo commonParameterVo, @RequestBody Config config)
            throws Exception {
        ResultVo resultVo = new ConfigVo();

        // TODO 呼叫業務處理。 省略

        resultVo.setData(config);

        // 記錄日誌
        setLogParameters(resultVo, config);
        return resultVo;
    }

 ｝

當設定 accept 或者produces 優先按設定的處理，

當沒有設定 ，按所有converter支援的MediaType來選擇處理，

MediaType.sortBySpecificityAndQuality(mediaTypes);
按Quality來排序，由於預設都是1，優先順序都是一樣， 所以

<strong>produces = { "application/xml", "application/json" }
</strong><pre name="code" class="java"><strong>或者 headers = "Accept=application/xml, application/json"</strong>

都會預設按寫前面的來轉換返回結果 或者加上q，q值越大的優先處理，比如：

 @RequestMapping(value = "/queryConfig", method = RequestMethod.GET, produces = { "application/xml;q=0.4",
            "application/json;q=0.5" })

測試類方法：

設定headers的accept和不設定處理是不同的，

 @Test
    public void testByGetJson() throws Exception {
        UrlBuilder urlBuilder = UrlBuilder.url(URIConstantTest.TEST_URL).append(false, configUrl)
                .append(false, "/queryConfig").queryparam(URIConstantTest.USER_PARAM)
                .queryparam("&key=test&language=en_US");
        System.out.println(urlBuilder.build());
        String result = Request.Get(urlBuilder.build())
//                .addHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
                .execute().returnContent().asString();
        System.out.println(result);
    }
 @Test
    public void testByGetsJson() throws Exception {
        UrlBuilder urlBuilder = UrlBuilder.url(URIConstantTest.TEST_URL).append(false, configUrl)
                .append(false, "/queryConfigs").queryparam(URIConstantTest.USER_PARAM)
                .queryparam("&key=test&language=en_US");
        System.out.println(urlBuilder.build());
        String result = Request.Get(urlBuilder.build())
//                .addHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
                .execute().returnContent().asString();
        System.out.println(result);
    }

    @Test
    public void testAddConfigJson() throws Exception {
        String strReq = "{\"configValue\":\"testValu測試\",\"configKey\":\"test\"}";

        UrlBuilder urlBuilder = UrlBuilder.url(URIConstantTest.TEST_URL).append(false, configUrl)
                .append(false, "/addConfig").queryparam(URIConstantTest.USER_PARAM)
                .queryparam("&key=test&language=en_US");
        System.out.println(urlBuilder.build());
        String result = Request.Post(urlBuilder.build())
//                .addHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
                .bodyString(strReq, ContentType.APPLICATION_JSON).execute().returnContent().asString();
        System.out.println(result);
    } 

spring mvc 配置檔案：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <context:property-placeholder location="classpath:app.properties" />

    <context:spring-configured />
    <context:annotation-config />

    <!-- 定義控制器註解掃描包路徑，控制器註解為 @Controller TODO -->
    <context:component-scan base-package="com.api.**.controller.**"
        use-default-filters="false">
        <context:include-filter expression="org.springframework.stereotype.Controller"
            type="annotation" />
    </context:component-scan>

    <!-- Turns on support for mapping requests to Spring MVC @Controller methods
        Also registers default Formatters and Validators for use across all @Controllers -->
    <mvc:annotation-driven validator="validator">
        <mvc:message-converters>
            <ref bean="stringHttpMessageConverter" />
            <ref bean="jsonHttpMessageConverter" />
            <ref bean="marshallingHttpMessageConverter" />
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- XML view using a JAXB marshaller -->
    <bean id="jaxb2Marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
        <property name="marshallerProperties">
            <map>
                <entry key="jaxb.formatted.output">
                    <value type="boolean">true</value>
                </entry>
                <entry key="jaxb.encoding" value="UTF-8" />
            </map>
        </property>
        <property name="packagesToScan">
            <list>
                <value>com.api.domain</value>
                <value>com.api.web.controller.vo</value>
            </list>
        </property>
    </bean>

    <bean id="stringHttpMessageConverter"
        class="org.springframework.http.converter.StringHttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/plain;charset=UTF-8</value>
                <value>text/html;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <bean id="jsonHttpMessageConverter"
        class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
    <bean id="marshallingHttpMessageConverter"
        class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter">
        <constructor-arg ref="jaxb2Marshaller" />
        <!-- <property name="supportedMediaTypes" value="application/xml"></property> -->
        <property name="supportedMediaTypes">
            <util:list>
                <bean class="org.springframework.http.MediaType" c:type="application" c:subtype="xml" c:qualityValue="0.5"/>
            </util:list>
        </property>
    </bean>

</beans>