Jaxb2CollectionHttpMessageConverter:explaination+usage?

[H Paul]

I am trying to understand how/when HttpMessageConverter is called to process the request's argument data type.
I try to post List<Computer> with jaxb-annotated Computer.
I expect to be processed by Jaxb2CollectionHttpMessageConverter but it did not happen. Got exception.
My question is am I understanding correctly its usage? (probably no.)
Need some explaination

http://static.springsource.org/spring-framework/docs/3.2.0.M2/reference/html/new-in-3.2.html

In support of this feature, the HttpMessageConverter is extended by GenericHttpMessageConverter adding a method for reading content given a specified parameterized type. The new interface is implemented by the MappingJacksonHttpMessageConverter and also by a new Jaxb2CollectionHttpMessageConverter that can read read a generic Collection where the generic type is a JAXB type annotated with @XmlRootElement or @XmlType.

@Controller
@RequestMapping("computer")
public class ComputerController {
	@RequestMapping(value="list", method = RequestMethod.POST)
	@ResponseBody
	public void addComputers(@RequestBody List<Computer> computers) {
		logger.debug(computers.toString());

	}
		
@XmlRootElement
@XmlAccessorType(value=XmlAccessType.FIELD) 
@XmlAccessorOrder 
public class Computer {
	   private long id;
	   private String brand;

	   private String model;

	   private String reference;

	   private String description

;

TCP/IP MON: request
	   
POST /mvc/computer/list HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:19.0) Gecko/20100101 Firefox/19.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: null
Accept-Encoding: gzip, deflate
Content-Type: application/xml; charset=UTF-8
Content-Length: 161
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

<computers>
<id>1</id>
<brand>setBrand</brand>
<model>setModel</model>
<reference>setReference</reference>
<description>setDescription</description>
</computers>

DEBUG: org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Looking up handler method for path /computer/list
TRACE: org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Found 1 matching mapping(s) for [/computer/list] : [{[/computer/list],methods=[POST],params=[],headers=[],consumes=[],produces=[],custom=[]}]
DEBUG: org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Returning handler method [public void org.concepts.mvc.ComputerController.addComputers(java.util.List<org.concepts.domain.Computer>)]
DEBUG: org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'computerController'
TRACE: org.springframework.web.servlet.DispatcherServlet - Testing handler adapter [org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter@3a44ea]
TRACE: org.springframework.web.method.HandlerMethod - Error resolving argument [0] [type=java.util.List]
HandlerMethod details: 
Controller [org.concepts.mvc.ComputerController]
Method [public void org.concepts.mvc.ComputerController.addComputers(java.util.List<org.concepts.domain.Computer>)]

org.springframework.web.HttpMediaTypeNotSupportedException: Content type 'application/xml;charset=UTF-8' not supported
	at org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters(AbstractMessageConverterMethodArgumentResolver.java:149)
	at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.readWithMessageConverters(RequestResponseBodyMethodProcessor.java:180)
	at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.resolveArgument(RequestResponseBodyMethodProcessor.java:95)
	at org.springframework.web.method.support.HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:77)
	at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:162)
	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:123)

[Bill Gorder]

I have not played with this yet. I know it was added in Spring 3.2 are you using the latest version? Take a look at the format of the XML used in the test case.

public class Jaxb2CollectionHttpMessageConverterTests
{

    private Jaxb2CollectionHttpMessageConverter<?> converter;

    private Type                                   rootElementListType;

    private Type                                   rootElementSetType;

    private Type                                   typeListType;

    private Type                                   typeSetType;


    @Before
    public void setUp()
    {
        converter = new Jaxb2CollectionHttpMessageConverter<Collection<Object>>();
        rootElementListType = new ParameterizedTypeReference<List<RootElement>>()
        {
        }.getType();
        rootElementSetType = new ParameterizedTypeReference<Set<RootElement>>()
        {
        }.getType();
        typeListType = new ParameterizedTypeReference<List<TestType>>()
        {
        }.getType();
        typeSetType = new ParameterizedTypeReference<Set<TestType>>()
        {
        }.getType();
    }

    @Test
    public void canRead() throws Exception
    {
        assertTrue(converter.canRead(rootElementListType, null, null));
        assertTrue(converter.canRead(rootElementSetType, null, null));
        assertTrue(converter.canRead(typeSetType, null, null));
    }

    @Test
    @SuppressWarnings("unchecked")
    public void readXmlRootElementList() throws Exception
    {
        String content = "<list><rootElement><type s=\"1\"/></rootElement><rootElement><type s=\"2\"/></rootElement></list>";
        MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));

        List<RootElement> result = (List<RootElement>) converter.read(rootElementListType, null,
            inputMessage);

        assertEquals("Invalid result", 2, result.size());
        assertEquals("Invalid result", "1", result.get(0).type.s);
        assertEquals("Invalid result", "2", result.get(1).type.s);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void readXmlRootElementSet() throws Exception
    {
        String content = "<set><rootElement><type s=\"1\"/></rootElement><rootElement><type s=\"2\"/></rootElement></set>";
        MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));

        Set<RootElement> result = (Set<RootElement>) converter.read(rootElementSetType, null,
            inputMessage);

        assertEquals("Invalid result", 2, result.size());
        assertTrue("Invalid result", result.contains(new RootElement("1")));
        assertTrue("Invalid result", result.contains(new RootElement("2")));
    }

    @Test
    @SuppressWarnings("unchecked")
    public void readXmlTypeList() throws Exception
    {
        String content = "<list><foo s=\"1\"/><bar s=\"2\"/></list>";
        MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));

        List<TestType> result = (List<TestType>) converter.read(typeListType, null, inputMessage);

        assertEquals("Invalid result", 2, result.size());
        assertEquals("Invalid result", "1", result.get(0).s);
        assertEquals("Invalid result", "2", result.get(1).s);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void readXmlTypeSet() throws Exception
    {
        String content = "<set><foo s=\"1\"/><bar s=\"2\"/></set>";
        MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));

        Set<TestType> result = (Set<TestType>) converter.read(typeSetType, null, inputMessage);

        assertEquals("Invalid result", 2, result.size());
        assertTrue("Invalid result", result.contains(new TestType("1")));
        assertTrue("Invalid result", result.contains(new TestType("2")));
    }


    @XmlRootElement
    public static class RootElement
    {

        public RootElement()
        {
        }

        public RootElement(String s)
        {
            this.type = new TestType(s);
        }

        @XmlElement
        public TestType type = new TestType();

        @Override
        public boolean equals(Object o)
        {
            if (this == o)
            {
                return true;
            }
            if (o instanceof RootElement)
            {
                RootElement other = (RootElement) o;
                return this.type.equals(other.type);
            }
            return false;
        }

        @Override
        public int hashCode()
        {
            return type.hashCode();
        }
    }

    @XmlType
    public static class TestType
    {

        public TestType()
        {
        }

        public TestType(String s)
        {
            this.s = s;
        }

        @XmlAttribute
        public String s = "Hello World";

        @Override
        public boolean equals(Object o)
        {
            if (this == o)
            {
                return true;
            }
            if (o instanceof TestType)
            {
                TestType other = (TestType) o;
                return this.s.equals(other.s);
            }
            return false;
        }

        @Override
        public int hashCode()
        {
            return s.hashCode();
        }

    }
}

[H Paul]

(0. First thing first: thank-you for your dollars Bill.)

I used the latest spring-framework-3.2.1.RELEASE

1. With DEBUGGER, I traced down the exception and found that
By default <mvc:annotation-driven />
does not have/register Jaxb2CollectionHttpMessageConverter. (Wonder why it was not registered by default by design?)
See code 1.

2. So, I did a quick test by programatically registering Jaxb2CollectionHttpMessageConverter. See code 2.
It worked my POST a List because Jaxb2CollectionHttpMessageConverter get called. See TCP/IP mon for the POST+data

Code 2: programatically registering Jaxb2CollectionHttpMessageConverter

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
	private static final Logger logger = LoggerFactory.getLogger(WebConfig.class);

	@Override
	public void configureMessageConverters(
			List<HttpMessageConverter<?>> converters) {
		logger.debug("configureMessageConverters");
		converters.add(new Jaxb2CollectionHttpMessageConverter<List<Computer>>());
		super.configureMessageConverters(converters);
	}

}

Worked:
TRACE: org.springframework.web.method.support.HandlerMethodArgumentResolverComposite - Testing if argument resolver [org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor@192aed7] supports [java.util.List<org.concepts.domain.Computer>]
DEBUG: org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor - Reading [java.util.List<org.concepts.domain.Computer>] as "application/xml;charset=UTF-8" using [org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter@19e51d9]
TRACE: org.springframework.web.method.HandlerMethod - Invoking [addComputers] method with arguments [[Computer [id=1, brand=setBrand, model=setModel, reference=setReference, description=setDescription], Computer [id=2, brand=setBrand 2, model=setModel 2, reference=setReference 2, description=setDescription 2]]]
DEBUG: org.concepts.controller.ComputerController - addComputers
DEBUG: org.concepts.controller.ComputerController - Computer [id=1, brand=setBrand, model=setModel, reference=setReference, description=setDescription]
DEBUG: org.concepts.controller.ComputerController - Computer [id=2, brand=setBrand 2, model=setModel 2, reference=setReference 2, description=setDescription 2]

Code 1: Place where exception is raised.

package org.springframework.web.servlet.mvc.method.annotation;

public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {

	protected final Log logger = LogFactory.getLog(getClass());

	protected final List<HttpMessageConverter<?>> messageConverters;


	/**
	 * Creates the method argument value of the expected parameter type by reading
	 * from the given HttpInputMessage.
	 *
	 * @param <T> the expected type of the argument value to be created
	 * @param inputMessage the HTTP input message representing the current request
	 * @param methodParam the method argument
	 * @param targetType the type of object to create, not necessarily the same as
	 * the method parameter type (e.g. for {@code HttpEntity<String>} method
	 * parameter the target type is String)
	 * @return the created method argument value
	 * @throws IOException if the reading from the request fails
	 * @throws HttpMediaTypeNotSupportedException if no suitable message converter is found
	 */
	@SuppressWarnings("unchecked")
	protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage,
			MethodParameter methodParam, Type targetType) throws IOException, HttpMediaTypeNotSupportedException {

				MediaType contentType = inputMessage.getHeaders().getContentType();
				if (contentType == null) {
					contentType = MediaType.APPLICATION_OCTET_STREAM;
				}

				Class<?> contextClass = methodParam.getDeclaringClass();
				Map<TypeVariable, Type> map = GenericTypeResolver.getTypeVariableMap(contextClass);
				Class<T> targetClass = (Class<T>) GenericTypeResolver.resolveType(targetType, map);

				for (HttpMessageConverter<?> converter : this.messageConverters) {
					if (converter instanceof GenericHttpMessageConverter) {
						GenericHttpMessageConverter genericConverter = (GenericHttpMessageConverter) converter;
						if (genericConverter.canRead(targetType, contextClass, contentType)) {
							if (logger.isDebugEnabled()) {
								logger.debug("Reading [" + targetType + "] as \"" +
										contentType + "\" using [" + converter + "]");
							}
							return genericConverter.read(targetType, contextClass, inputMessage);
						}
					}
					if (targetClass != null) {
						if (converter.canRead(targetClass, contentType)) {
							if (logger.isDebugEnabled()) {
								logger.debug("Reading [" + targetClass.getName() + "] as \"" +
										contentType + "\" using [" + converter + "]");
							}
							return ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
						}
					}
				}

				throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
			}
			
			
this.messageConverters is a List. It has only 7 converters.
It does not have Jaxb2CollectionHttpMessageConverter.

TCP/IP mon.

POST /mvc/computer/list HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:19.0) Gecko/20100101 Firefox/19.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: null
Accept-Encoding: gzip, deflate
Content-Type: application/xml; charset=UTF-8
Content-Length: 392
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

<Computers>
<computer>
    <id>1</id>
    <brand>setBrand</brand>
    <model>setModel</model>
    <reference>setReference</reference>
    <description>setDescription</description>
</computer>
<computer>
    <id>2</id>
    <brand>setBrand 2</brand>
    <model>setModel 2</model>
    <reference>setReference 2</reference>
    <description>setDescription 2</description>
</computer>
</Computers>

[Bill Gorder]

Glad you got it working and thanks for posting back with what you figured out!