JaxbAnnotationIntrospector does not honor JsonInclude.Include.NON_EMPTY set on ObjectMapper

[jdmichal]

I am configuring a Jackson JSON provider with a JAX-RS application's getSingletons() method. Note setting of NON_EMPTY:

final ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new JaxbAnnotationModule());
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
final JacksonJaxbJsonProvider jsonProvider = new JacksonJaxbJsonProvider(
    objectMapper, JacksonJaxbJsonProvider.DEFAULT_ANNOTATIONS);

Let's also define a piece of dummy data:

@XmlType
public class Data {
    private final List<Object> stuff = new java.util.ArrayList<Object>();

    @XmlElement
    public List<Object> getStuff() {
        return this.stuff;
    }
}

Given that stuff is empty, I would expect this to output an empty object. However, it instead outputs:

{
    "stuff": [ ]
}

I have isolated this behavior to JaxbAnnotationIntrospector.findSerializationInclusion. (This is the 2.4.4 version, but this function is currently unmodified on master.) This function receives the default value of NON_EMPTY, but will return NON_NULL as long as the XmlElement annotation is present.

Given that this behavior is unexpected given the configuration, and also conflicts with the JAXB behavior of not serializing the list, I believe this function should return NON_EMPTY instead of NON_NULL if:

• XmlElementWrapper is not present. (JAXB would output an empty element with the wrapper's name.)
• XmlElement is present.
• The given default is NON_EMPTY.

[jdmichal]

Also, I did attempt to set the JaxbAnnotationModule's priority to SECONDARY. That allowed me to effectively annotate the individual fields with @JsonInclude. However, it also broke my JAXB enumeration mappings. (Enumerations began outputting with their toString value, rather than the assigned @XmlEnumValue.) So I did not investigate this solution any further, as it is not comprehensive (every such field must be annotated) and had undesired side-effects.

[cowtowncoder]

Sounds like a bug yes. Thank you for reporting this.

[cowtowncoder]

Hmmh. I can not reproduce this with a stand-alone test, only using JAXB annotation introspector.
Will next use combination; may well be due to delegation problems.

[cowtowncoder]

... and can't reproduce with a pair either.

[cowtowncoder]

Ok. I am unable to reproduce this with any combination of pieces, not including JAX-RS. I used version from master (2.5.1-SNAPSHOT), but I don't think this should matter as there are no changes in this area.
You may want to check with 2.5.0 just to make sure, but it seems unlikely to help.

So it does not look like a bug in JAXB annotation handling.
But I can't think of an obvious reason for problems via JAX-RS either.

[cowtowncoder]

... hmmh. Except, one more thought. @XmlElement (and @XmlElementWrapper) do have nillable element, which may be relevant here. This setting is used.

But this, then, goes to question of semantics. Global setting has lower precedence (by design -- this will not be changed). But with annotations, it is impossible to know if false is from default settings (it is the default), or explicit choice. It is possible to change false to mean same as "not defined".

For what it is worth, you can probably work around this, on short term, by simply removing @XmlElement (or, if you prefer, setting nillable=true).

[cowtowncoder]

Ok. Yes, it's that nillable thing.

After thinking this through, I think it is safe to assume that nillable=false can be ignored wrt serialization includion setting. None of the tests assumes semantics for that, and interpretation seems to be that nillability simply enforces inclusion (since null is an explicitly allowed choice).
So, I will fix this for 2.5.1.

[jdmichal]

... Interpretation seems to be that nillability simply enforces inclusion (since null is an explicitly allowed choice).

This is my understanding of it. Setting nillable to true indicates that the element should be output with xsi:nil="true" in XML. A false value indicates that the element may be excluded if it is null, and this was exactly the behavior that was implemented when I wrote this ticket. The real issue is that JAXB treats collection types differently, and this was not being taken into account.

Collection types ignore the value of XmlElement.nillable(). null and empty collections are excluded from output entirely. However, the value of XmlElementWrapper.nillable() does matter. Specifically:

• null lists will be excluded from output, unless XmlElementWrapper.nillable() is true. In that case, the wrapper element will be output with xsi:nil="true".
• Empty lists will result a wrapper element with no contents, regardless.

So, that said, I believe that the translated behavior would be something like:

if (isCollectionType(a)) {
    final XmlElementWrapper wrapper = a.getAnnotation(XmlElementWrapper.class);
    if (wrapper != null) {
        // Emulate the fact that wrapper is output when list is empty, but not null.
        return (wrapper.nillable()) ? ALWAYS : NON_NULL;
    } else {
        // No wrapper, so empty or null list is always excluded.
        return NON_EMPTY;
    }
} else {
    final XmlElement element = a.getAnnotation(XmlElement.class);
    if (element != null) {
        return (element.nillable()) ? ALWAYS : NON_NULL;
    }
}

However, there are two confounding factors here. The first is that the above still ignores the default value set on ObjectMapper. The second is that the whole thing is suspect anyway because XmlElementWrapper has no real JSON equivalent. And I believe that, once you take these factors into account, the implemented fix is an acceptable solution. The only improvement I would consider is to determine whether to examine XmlElementWrapper or XmlElement (but not both) depending on whether the element is a collection type or not.

So, this was really just a long-winded thank you.

[cowtowncoder]

Thank you for a very detailed explanation -- this helps a lot. One other confounding factor is that in case of not finding an annotation, no explicit choice should be returned even for collection types.
Although guess this depends on one's view of role of JAXB annotations module: whether it should also try to apply JAXB defaults, or simply JAXB as overrides.
Could even be worth a feature to determine that aspect I guess.

But one thing, if I could ask; would it be possible to add just couple of test cases to ensure proper working of for various combinations (up to 8?) of @XmlElement/@XmlElementWraper, nillable=true/false, collection/non-collection types? I think I know how to choose values properly, but it is surprisingly easy to get wrong results without tests. :)

[jdmichal]

I wrote the below for my own use in testing the different scenarios for my previous post. It should be fairly easy to adapt it into unit test cases.

import javax.xml.bind.*;
import javax.xml.bind.annotation.*;
import java.util.*;

public class XMLListTest {
    public static interface Lister {
        List<String> getList();
    }

    @XmlRootElement(name = "a")
    public static class NullList implements Lister {
        @XmlElement
        public List<String> getList() {
            return null;
        }
    }

    @XmlRootElement(name = "a")
    public static class EmptyList implements Lister {
        @XmlElement
        public List<String> getList() {
            return Collections.emptyList();
        }
    }

    @XmlRootElement(name = "a")
    public static class NillableNullList implements Lister {
        @XmlElement(nillable = true)
        public List<String> getList() {
            return null;
        }
    }

    @XmlRootElement(name = "a")
    public static class NillableEmptyList implements Lister {
        @XmlElement(nillable = true)
        public List<String> getList() {
            return Collections.emptyList();
        }
    }

    @XmlRootElement(name = "a")
    public static class WrappedNullList implements Lister {
        @XmlElement
        @XmlElementWrapper(name = "wrap")
        public List<String> getList() {
            return null;
        }
    }

    @XmlRootElement(name = "a")
    public static class WrappedEmptyList implements Lister {
        @XmlElement
        @XmlElementWrapper(name = "wrap")
        public List<String> getList() {
            return Collections.emptyList();
        }
    }

    @XmlRootElement(name = "a")
    public static class WrappedNillableNullList implements Lister {
        @XmlElement(nillable = true)
        @XmlElementWrapper(name = "wrap")
        public List<String> getList() {
            return null;
        }
    }

    @XmlRootElement(name = "a")
    public static class WrappedNillableEmptyList implements Lister {
        @XmlElement(nillable = true)
        @XmlElementWrapper(name = "wrap")
        public List<String> getList() {
            return Collections.emptyList();
        }
    }

    @XmlRootElement(name = "a")
    public static class NillableWrappedNullList implements Lister {
        @XmlElement
        @XmlElementWrapper(name = "wrap", nillable = true)
        public List<String> getList() {
            return null;
        }
    }

    @XmlRootElement(name = "a")
    public static class NillableWrappedEmptyList implements Lister {
        @XmlElement
        @XmlElementWrapper(name = "wrap", nillable = true)
        public List<String> getList() {
            return Collections.emptyList();
        }
    }

    @XmlRootElement(name = "a")
    public static class NillableWrappedNillableNullList implements Lister {
        @XmlElement(nillable = true)
        @XmlElementWrapper(name = "wrap", nillable = true)
        public List<String> getList() {
            return null;
        }
    }

    @XmlRootElement(name = "a")
    public static class NillableWrappedNillableEmptyList implements Lister {
        @XmlElement(nillable = true)
        @XmlElementWrapper(name = "wrap", nillable = true)
        public List<String> getList() {
            return Collections.emptyList();
        }
    }

    public static void main(String[] args) throws Exception {
        final List<Class<? extends Lister>> classes = Arrays.asList(
            NullList.class,
            NillableNullList.class,
            WrappedNullList.class,
            WrappedNillableNullList.class,
            NillableWrappedNullList.class,
            NillableWrappedNillableNullList.class,
            EmptyList.class,
            NillableEmptyList.class,
            WrappedEmptyList.class,
            WrappedNillableEmptyList.class,
            NillableWrappedEmptyList.class,
            NillableWrappedNillableEmptyList.class
        );

        final JAXBContext jaxbContext = JAXBContext.newInstance(classes.toArray(new Class<?>[0]));

        final Marshaller marshaller = jaxbContext.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);

        System.out.println(String.format("Value  @XmlElementWrapper  @XmlElement"));
        for(final Class<? extends Lister> cls : classes) {
            final Lister instance = cls.newInstance();
            final java.lang.reflect.Method getList = cls.getMethod("getList");
            final XmlElement xmlElement = getList.getAnnotation(XmlElement.class);
            final XmlElementWrapper xmlElementWrapper = getList.getAnnotation(XmlElementWrapper.class);

            final java.io.StringWriter stringWriter = new java.io.StringWriter();
            marshaller.marshal(instance, stringWriter);

            System.out.println(String.format("%5s  %18s  %11s  %s",
                (instance.getList() == null) ? "null" : "empty",
                (xmlElementWrapper == null) ? "N/A" : xmlElementWrapper.nillable(),
                xmlElement.nillable(),
                stringWriter.toString().replaceAll("xmlns:xsi=\".*\"", "")));
        }
    }
}

Output is:

Value  @XmlElementWrapper  @XmlElement
 null                 N/A        false  <a/>
 null                 N/A         true  <a/>
 null               false        false  <a/>
 null               false         true  <a/>
 null                true        false  <a><wrap xsi:nil="true" /></a>
 null                true         true  <a><wrap xsi:nil="true" /></a>
empty                 N/A        false  <a/>
empty                 N/A         true  <a/>
empty               false        false  <a><wrap/></a>
empty               false         true  <a><wrap/></a>
empty                true        false  <a><wrap/></a>
empty                true         true  <a><wrap/></a>

You can directly see the irrelevance of XmlElement.nillable() in the case of collections, so that axis could be entirely removed.