@XmlElement name property is ignored for Collection types such as List

Sounds like a bug, will try to reproduce.

Correction.

This behavior is not related to Collection type but related to how getter and setter methods are being used.

Working example:
@XmlElement(name="listelement")
public List<String> getMyList()

produces:
"myList":["list1","list2"]

I'm not sure if this is intended behavior but glancing at the JaxbAnnotationIntrospector class Line: 1265, it does look like we need both read and write methods for this to work.

Actually, I think I know what is happening here: JAXB requires definition of both setter and getter; and when one is missing, no property is considered to exist.
Jackson on the other hand does not add such limitation.

Now: when using both annotation introspectors, some combinations do not work very well: and in this case, JAXBAnnotationIntrospector decides that getter is not part of a property, and thus does not handle @XmlElement annotation.
JacksonAnnotationIntrospector does recognize getter, but it only recognizes its own annotations.

Ideally I think this should work, but it may not be trivial to make things work without breaking JAXB limit (of requiring both setter and getter; or field (which acts as both)) for properties.

Hello,

I am experiencing this problem with Jackson 1.8.5 and JAXB2 generated objects. I am just using the JAXBAnnotationIntrospector and not the JacksonAnnotationIntrospector.

JAXB generates code that looks like this:

    @XmlElement(required = true)
    protected List<Quantity> expectedQuantities;

    public List<Quantity> getExpectedQuantities() {
       .....

No setter is generated.

When I serialize, I get this output:

Expected Quantities: {"expectedQuantities":[

,

]}

Which fails to deserialize correctly because the type names for the polymorphic type hierarchy are not provided.

Joshua, I think what you are experiencing is bit different from the original issue (since you don't use name property) – you may want to enable polymorphic type handling?

I thought @XmlElement was what enabled polymorphic type handling? Perhaps I misunderstood the documentation here:

http://wiki.fasterxml.com/JacksonPolymorphicDeserialization

The way I read the documentation (which is probably wrong), is that you can enable PTH globally, or use the annotations (@JsonTypeInfo or @XmlElement) to do it on a per-class basis.

Almost – JAXB @XmlElements (note the plural) can be used (although Jackson annotations are recommended) for enabling polymorphic type handling, but plain @XmlElement is not enough to trigger that. So try using @XmlElements, with set of @XmlElement annotations inside and that should work.

It looks like @XmlElements is used for an <xsd:choice> definition, (ie, a collection with multiple distinct type possibilities), but I am trying to model an <xsd:complexContent> type hierarchy (a base complexType and extensions on top of that). In this case, I think JAXB uses @XmlSeeAlso annotations.

I guess Jackson won't work for us in this specific case (we use it for plenty else).

That is possible. @XmlSeeAlso is not currently used, although it might be relatively easy to make it be used for declaring subtypes (similar to @JsonSubTypes). But there are limits to how far JAXB annotation compatibility can be taken.

Many fixes have gone in JAXB-annotations module, including use of @XmlSeeAlso.
Because of this I don't know which parts are still not working (if any).

Please file a new issue at:

https://github.com/FasterXML/jackson-module-jaxb-annotations/issues

if there are remaining problems – the Codehaus Jackson Jira is being deprecated, and issues moved to appropriate github project issue trackers.