Why is Spring Boot not using a @Primary Jackson ObjectMapper for JSON serialization on a rest controller?

Question

I have a class set up to return a customised ObjectMapper. As far as I can find, the correct way to have Spring Boot use this ObjectMapper is to declare it as @Primary, which it is.

    @Configuration
    public class MyJacksonConfiguration {

        @Bean
        @Primary
        public ObjectMapper objectMapper() {
            return Jackson2ObjectMapperBuilder
                .json()
                .findModulesViaServiceLoader(true)
                .mixIn(Throwable.class, ThrowableMixin.class)
                .featuresToDisable(
                        WRITE_DATES_AS_TIMESTAMPS)
                .serializationInclusion(
                        Include.NON_ABSENT)
                .build();
        }
    }

However, when I return an object from a controller method it is serialized with the default Jackson ObjectMapper configuration.

If I add an explicit ObjectMapper to my controller and call writeValueAsString on it, I can see that this ObjectMapper is the customised one that I would like Spring Boot to use.

    @RestController
    public class TestController {

        @Autowired
        private TestService service;

        @Autowired
        private ObjectMapper mapper;

        @GetMapping(value = "/test", produces = "application/json")
        public TestResult getResult() {

            final TestResult ret = service.getResult();

            String test = "";
            try {
                test = mapper.writeValueAsString(ret);
                // test now contains the value I'd like returned by the controller!
            } catch (final JsonProcessingException e) {
                e.printStackTrace();
            }

            return ret;
        }
    }

When I run tests on my controller the test class also uses an autowired ObjectMapper. Again the ObjectMapper supplied to the test is the customised one.

So Spring knows about the customised ObjectMapper to some extent, but it isn't being used by my rest controller classes.

I have tried turning on Debug logging for Spring but can't see anything useful in logs.

Any idea what might be happening, or where else I should be looking to track down the issue?

EDIT: There appear to be multiple ways to do this, however the way I'm trying to do it appears to be a recommended method and I would like to get it to work this way - see 71.3 of https://docs.spring.io/spring-boot/docs/1.4.7.RELEASE/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper - am I misunderstanding something there?

Answer 1

Whilst the other answers show alternative ways of achieving the same result, the actual answer to this question is that I had defined a separate class that extended WebMvcConfigurationSupport. By doing that the WebMvcAutoConfiguration bean had been disabled and so the @Primary ObjectMapper was not picked up by Spring. (Look for @ConditionalOnMissingBean(WebMvcConfigurationSupport.class) in the WebMvcAutoConfiguration source.)

Temporarily removing the class extending WebMvcConfigurationSupport allowed the @Primary ObjectMapper to be picked up and used as expected by Spring.

As I couldn't remove the WebMvcConfigurationSupport extending class permanently, I instead added the following to it:

@Autowired
private ObjectMapper mapper;

@Override
public void configureMessageConverters(final List<HttpMessageConverter<?>> converters) {
    converters.add(new MappingJackson2HttpMessageConverter(mapper));
    addDefaultHttpMessageConverters(converters);
    super.configureMessageConverters(converters);
}

Answer 2

Spring uses HttpMessageConverters to render @ResponseBody (or responses from @RestController). I think you need to override HttpMessageConverter. You can do that by extending WebMvcConfigurerAdapter and override following.

 @Override
public void configureMessageConverters(
  List<HttpMessageConverter<?>> converters) {     
    messageConverters.add(new MappingJackson2HttpMessageConverter());
    super.configureMessageConverters(converters);
}

Spring documentation

Answer 3

Correct way that won't broke string serialization(keep order):

public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    addDefaultHttpMessageConverters(converters);

    HttpMessageConverter<?> jacksonConverter =
        converters.stream()
            .filter(converter -> converter.getClass().equals(MappingJackson2HttpMessageConverter.class))
            .findFirst().orElseThrow(RuntimeException::new);

    converters.add(converters.indexOf(jacksonConverter), new MappingJackson2HttpMessageConverter(objectMapper));
}

Answer 4

Because what you have done is creating a bean that you can Autowired for later usage. (just like that you wrote in the code) Spring boot uses auto-configured Jackson2ObjectMapperBuilder to get default ObjectMapper for serialization.

So if you want to customize an ObjectMapper for serialization on your rest controller, you need to find a way to configure Jackson2ObjectMapperBuilder. There are two ways to do this:

Declare your own Jackson2ObjectMapperBuilder for spring

@Bean
public Jackson2ObjectMapperBuilder jacksonBuilder() {
    Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
    builder.serializationInclusion(JsonInclude.Include.NON_NULL);
    // other settings you want.
    return builder;
}

Setting through properties

You can set it through application.properties. For example, if you want to enable pretty print, set spring.jackson.serialization.indent_output=true.

For more detail information, please check here: Customize the Jackson ObjectMapper