如何在 Spring 引导中为 Camel 配置 Jackson ObjectMapper

Question

I am trying to serialize and deserialize POJOs to and from JSON on Camel routes using Jackson. Some of these have Java 8 LocalDate fields, and I want them to be serialised as YYYY-MM-DD string, not as an array of integers.

We only use Java configuration for our Spring Boot application, so no XML Camel configuration.

I have successfully created an ObjectMapper that does what I want, which is being used by other parts of our system by adding this to our dependencies:

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

and this to our application configuration:

@Bean
public ObjectMapper objectMapper(Jackson2ObjectMapperBuilder builder) {
    return builder
            .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .build();
}

Example outgoing REST route:

@Component
public class MyRouteBuilder extends RouteBuilder {

    @Override
    public void configure() throws Exception {

        restConfiguration().component("servlet").contextPath("/mycontext")
                .port(8080).bindingMode(RestBindingMode.json);

        rest("/myendpoint)
                .get()
                .route()
                .to("bean:myService?method=myMethod()");
    }
}

Example incoming message route:

@Component
public class MyRouteBuilder extends RouteBuilder {

    @Autowired
    private MyBean myBean;

    @Override
    public void configure() {
        from(uri)
                .unmarshal().json(JsonLibrary.Jackson)
                .bean(myBean);
    }
}

However, by default Camel creates its own ObjectMapper instances so does not pick up on either the JSR310 serializers/deserializers that Jackson2ObjectMapperBuilder adds automatically, or the disabled WRITE_DATES_AS_TIMESTAMPS feature. I have read the Camel JSON documentation, but it does not show how to add a custom DataFormat using Spring configuration, or how to apply a global customisation for all types.

So how can I tell Camel to use my ObjectMapper, using only Spring Boot Java configuration?

Answer 1

I have found a solution by stepping through the Camel code. So while it does what I want, it might not work with future versions of Camel since it appears to be undocumented and potentially unsupported.

All I do is add the following bean to my Spring config, in additional to my ObjectMapper bean in the question:

@Bean(name = "json-jackson")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public JacksonDataFormat jacksonDataFormat(ObjectMapper objectMapper) {
    return new JacksonDataFormat(objectMapper, HashMap.class);
}

The crucial points to note:

• There is no constructor for JacksonDataFormat that takes an ObjectMapper without an unmarshal type. However, in the default constructor a HashMap.class is used when no unmarshal type is provided, so I use that. By some magic, this appears to then get used to unmarshal all POJO types. If you also need more specific data formats for other classes, you will need to set the ObjectMapper in them too.
• Camel appears to search the bean registry for a bean called "json-jackson", so setting the Spring bean to use that name tricks Camel into not creating a new one and using mine instead.
• The bean scope must be set to SCOPE_PROTOTYPE because the REST DSL expects to get a new instance of the DataFormat . See CAMEL-7880 .

Answer 2

在 Java 代码中创建JacksonDataFormat并启用/禁用您想要的功能，然后在 Camel 路由中使用该实例。

 .unmarshal(myInstanceGoesHere).

Answer 3

Using Spring and Camel 2.18.1, I was able to achieve the same by adding the following dependencies:

<dependency>
    <groupId>com.fasterxml.jackson.module</groupId>
    <artifactId>jackson-module-parameter-names</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jdk8</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
    <version>2.6.1</version>
</dependency>

and in a CamelContextConfiguration class, autowiring the JacksonDataFormat in order to configure the discovery of classpath modules and the configuration of the serialization options:

@Configuration
public class CamelContextConfig implements CamelContextConfiguration {

    @Autowired
    public JacksonDataFormat jacksonDataFormat;

    @Override
    public void beforeApplicationStart(CamelContext camelContext) {
    }

    @Override
    public void afterApplicationStart(CamelContext camelContext) {
        jacksonDataFormat
            .getObjectMapper()
            .findAndRegisterModules()
            .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    }
}

Answer 4

Good news everyone, object mapper autodiscovery is supported now for Spring Boot! Simply set this property:

camel.dataformat.json-jackson.auto-discover-object-mapper=true

If set to true then Jackson will lookup for an objectMapper into the registry

Docs: https://camel.apache.org/components/latest/dataformats/json-jackson-dataformat.html#_spring_boot_auto_configuration

Logs:

INFO o.a.c.impl.engine.AbstractCamelContext   : Apache Camel 3.3.0 (CamelContext: camel-1) is starting
INFO o.a.c.c.jackson.JacksonDataFormat        : Found single ObjectMapper in Registry to use: com.fasterxml.jackson.databind.ObjectMapper@20a1b3ae
WARN o.a.c.c.jackson.JacksonDataFormat        : The objectMapper was already found in the registry, no customizations will be applied

(the warning just denotes, that all your other properties under camel.dataformat.json-jackson.* are ignored)

Answer 5

So far only the suggestion of @david-edwards has worked for me. I first defined a data format bean with the id: "json-jackson"

<bean id="json-jackson" class="com.mydomain.JacksonDataFormatExt" />

Then the format class:

public class JacksonDataFormatExt extends JacksonDataFormat{

    public JacksonDataFormatExt(){
        super();
        setPrettyPrint(true);
        setEnableFeatures(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS.name());
        SimpleModule s = new SimpleModule();
        s.addSerializer(CustomEnum.class, new CustomEnumSerializer());
        addModule(s);
    }
}

And the CustomEnumSerializer class:

public class CustomEnumSerializer extends JsonSerializer<CustomEnum> {

    @Override
    public void serialize(CustomEnumvalue, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
        String stringValue = value.getNlsText();
        if(stringValue != null && !stringValue.isEmpty() && !stringValue.equals("null")) {
            jgen.writeString(stringValue);
        } else {
            jgen.writeNull();
        }
    }
}

Answer 6

I managed to configure ObjectMapper for Camel quite conveniently using org.apache.camel:camel-jackson-starter:2.20.0

It exposes some of the useful ObjectMapper properties for configuration via Spring application properties. WRITE_DATES_AS_TIMESTAMPS for example can be set straight from application.yaml or application.properties file.

Look for JacksonDataFormatConfiguration class for more details.

I also needed to use some Mixins so I still needed to configure Camel to use a Spring's ObjectMapper. I ended up with this:

Configuration bean:

@Bean
public Jackson2ObjectMapperBuilderCustomizer customizer() {
    return new Jackson2ObjectMapperBuilderCustomizer() {
        @Override
        public void customize(Jackson2ObjectMapperBuilder builder) {
            builder.mixIn(Person.class, PersonMixin.class);
        }
    }
}

application.yaml:

camel:
  dataformat:
    json-jackson:
      disable-features: WRITE_DATES_AS_TIMESTAMPS
      object-mapper: jacksonObjectMapper

Where jacksonObjectMapper is the name of the ObjectMapper bean built by the configured Jackson2ObjectMapperBuilder

Answer 7

If anyone else was wondering how to use the fix put in the ver. 2.17.. I got it working using this xml configuration:

 <camel:camelContext id="defaultCamelContext">
       .....
        <camel:dataFormats>
            <camel:json id="json" library="Jackson"  objectMapper="myObjectMapper"/>
        </camel:dataFormats>

 </camel:camelContext>

..where myObjectMapper is a name of a spring bean of type ObjectMapper

Answer 8

I solved by including jackson dependency in pom

<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-jackson-starter</artifactId>
  <version>${camel.version}</version>
</dependency>

Now, simply adding JacksonDataFormat in route configuration

public void configure() throws Exception {
    JacksonDataFormat jsonDf = new JacksonDataFormat(Card.class);
    jsonDf.setPrettyPrint(true);

    from("direct:endpoint")
    .marshal(jsonDf)
    .convertBodyTo(String.class)
    .....
}

Answer 9

If Camel gives you trouble there, I would revert to using beans directly:

1. Simply create a small Json utility that can do marshalling and unmarshalling and autowire your preconfigured ObjectMapper into it.

2. Harness Camels awesome Spring bean integration to call your utility and transform the Message in the route, eg:

    from(uri) .unmarshal().json(JsonLibrary.Jackson) .beanRef("jsonUtil", "unmarshal") .bean(myBean);

Answer 10

I could not get any of the examples to work. A little disappointed that this is quite complicated from reading workarounds.

In my opinion camel should make it easy to use the Spring default object mapper by using the same Jackson bean that comes with the application.

I forgone the use of .json() and swapped it for a processor.

like the following, this used the objectMapper provided by Spring.

Route

from(CONSUME_TAG)
 .process("jsonProcessor")
 .to("direct:anotherRoute")
 .end();

Generic Processor notice how this Autowires the spring boot objectMapper bean.

@Component
public class JsonProcessor implements Processor {

    @Autowired
    ObjectMapper objectMapper;

    @Override
    public void process(Exchange exchange) throws Exception {
        exchange.getOut().setBody(objectMapper.writeValueAsString(exchange.getIn().getBody()));
    }

}

Answer 11

Here is what works for me (Camel 2.2.0)

    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jsr310</artifactId>
        <version>2.12.5</version>
    </dependency>

REST configuration

            restConfiguration().dataFormatProperty("moduleClassNames", "com.fasterxml.jackson.datatype.jsr310.JavaTimeModule")
                               .dataFormatProperty("disableFeatures", "WRITE_DATES_AS_TIMESTAMPS")

Answer 12

Spring Boot configures ObjectMapper with required jackson-datatype-jsr310 module during start up and puts it to the Spring Context.

New versions of Camel don't use ObjectMapper form Spring Context by default and create own ObjectMapper without jackson-datatype-jsr310 .

1. For new versions of Camel add this to the application.yaml

camel.dataformat.jackson.auto-discover-object-mapper: true

2. Use to unmarshall

from("some").unmarshal().json(SomeClass.class)

And don't use

from("some").unmarshal(new JacksonDataFormat(SomeClass.class))

It will not get ObjectMapper from Spring Context.

To check what happens debug AbstractJacksonDataFormat.doStart() method. It is called during Camel start up and gets ObjectMapper from the Spring Context or creates a new one. When new ObjectMapper is created, it doesn't have required Jackson jackson-datatype-jsr310 module and an error happens.