Jackson XML doesn't use my Serializer - json works

[benneq]

I've written a small Serializer for MongoDB's ObjectId:

public class ObjectIdSerializer extends StdSerializer<ObjectId> {
    public static final ObjectIdSerializer INSTANCE = new ObjectIdSerializer();
    private ObjectIdSerializer() { super(ObjectId.class); }
    @Override public void serialize(ObjectId value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
        jgen.writeString(value.toHexString());
    }
}

And a SimpleModule:

@Component
public class CommonJacksonModule extends SimpleModule {
    public CommonJacksonModule() {
        super(new Version(1, 0, 0, null, null, null));
        addSerializer(ObjectId.class, ObjectIdSerializer.INSTANCE);
    }
}

When using Accept=application/json it works as expected and I get something like "5498374f44ae6f110dd0abcd". But using Accept=application/xml I get something like:

<new>false</new>
<timeSecond>1419261775</timeSecond>
<inc>231792298</inc>
<machine>1152282385</machine>
<time>1419261775000</time>
<date>2014-12-22T15:22:55.000+0000</date>
<timestamp>1419261775</timestamp>

What's the problem here?

[philwebb]

Are you able to put together a small sample application to demonstrate the issue?

[benneq]

Here it is as zipped Maven Project: http://we.tl/9DLe8BxQZD
If you don't want to download the zip file. Here is the complete code:
Application.java: http://pastebin.com/tvSv7ne7
pom.xml: http://pastebin.com/3GKatnwB

Start via: mvn package && java -jar target/app-0.0.1-SNAPSHOT.war
Call JSON: http://localhost:8080/test.json
Call XML: http://localhost:8080/test.xml

JSON:

{"a":"test1","b":"REPLACE IT!"}

XML:

<Pojo xmlns="">
<a>test1</a>
<b>
<c>42</c>
</b>
</Pojo>

[philwebb]

Great. Thanks, that's very helpful.

[wilkinsona]

JacksonAutoConfiguration adds Module beans to any ObjectMapper beans in the context. Crucially, the ObjectMapper used by the MappingJackson2XmlHttpMessageConverter created in HttpMessageConvertersAutoConfiguration isn't exposed as a bean (and nor should it be). This means that any Module beans aren't registered with it, causing the lack of custom serialisation for XML responses described above.

The current behaviour means that Module registration is performed against any ObjectMapper, not just those that have been created by Boot's auto-configuration. Arguably, this is wrong as it makes it difficult to create your own ObjectMapper bean and not have a Module bean registered with it.

I propose that, rather than registering Module beans with every ObjectMapper bean, we register the Module beans with the auto-configured Jackson2ObjectMapperBuilder. This will mean that the modules are registered with every ObjectMapper that's created via auto-configuration (including the one used by MappingJackson2XmlHttpMessageConverter) while leaving any user-created ObjectMapper beans alone. Note that this would be a breaking change for anyone relying on their own ObjectMapper bean having Module beans registered with it. The alternative is to register the modules with the auto-configured Jackson2ObjectMapperBuilder and with any ObjectMapper beans. @philwebb, what's your preference?

[wilkinsona]

Jackson2ObjectMapperBuilder doesn't support my proposed solution – there's no way to configure additional Module instances. Calling modules(List<Module>) will replace any existing module instance configuration and also disable the registration of well-known modules such as Jackson's JodaTime module.

/cc @sdeleuze

[sdeleuze]

@wilkinsona Indeed. In order to provide you a solution while avoiding breaking existing applications, maybe we could add a Jackson2ObjectMapperBuilder#alwaysRegisterWellKnownModules boolean property (a shorter name would be better if possible). If this fit your need, I could discuss about that with the team this afternoon during our Spring weekly meeting?

[wilkinsona]

@sdeleuze Thanks. That would certainly help. If we go with my proposed solution, it would save us from having to duplicate the logic in registerWellKnownModulesIfAvailable.

[philwebb]

@wilkinsona I think I prefer the first option (but I don't think I've totally got a handle on the issue). If we make the change and someone wanted to create a ObjectMapper and have Module beans applied to it what would they need to do?

[wilkinsona]

I see declaring your own ObjectMapper as saying that you don't want Boot to automatically apply any configuration to it. With that in mind, there's a couple of options (at least) for applying Module beans to an ObjectMapper:

1. They could use Jackson2ObjectMapperBuilder to configure their ObjectMapper. That'll apply any Module beans (and all the other Jackson configuration). They can then customise the ObjectMapper as appropriate to deviate from the "global" Jackson configuration.
2. They could add the modules themselves using objectMapper.registerModules() having retrieved them using an autowired List, for example.

[odrotbohm]

Be aware that this is a breaking change as the mechanism to auto-register all Module beans to all ObjectMapper beans was introduced by purpose. The rational basically was that by exposing an ObjectMapper as Spring bean you expose it to this auto-configuration while not doing so would allow you the keep dedicated control of what gets registered with it.

Also note that e.g. @EnableHypermediaSupport explicitly post-processes well-known Spring components that carry HttpMessageConverters to auto register additional converters whose ObjectMapper is only exposed as Spring bean to benefit from the auto-population behavior. Using Jackson2ObjectMapperBuilder is a non-option here as said class is only available in Spring 4.1.1 and we even got a bit of push back to upgrade to 4.x.