This article is about fixing `InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime...` when calling `mapper.createObjectNode().putPOJO` in fasterxml jackson-databind
  • 31-Jan-2023
Lightrun Team
Author Lightrun Team
This article is about fixing `InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime...` when calling `mapper.createObjectNode().putPOJO` in fasterxml jackson-databind

`InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime…` when calling `mapper.createObjectNode().putPOJO` in fasterxml jackson-databind

Lightrun Team
Lightrun Team

Explanation of the problem

The code throws a “java.lang.RuntimeException: com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime not supported by default: add Module ‘com.fasterxml.jackson.datatype:jackson-datatype-jsr310’ to enable handling” exception when run. The exception originates from the “com.fasterxml.jackson.databind.node.InternalNodeMapper.nodeToPrettyString” method and is caused by an “com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime not supported by default”.

The code imports the “com.fasterxml.jackson.datatype.jsr310.JavaTimeModule” module and creates an “ObjectMapper” with the “JsonMapper.builder().addModule(new JavaTimeModule()).build()” statement. The code then creates an “ObjectNode” and attempts to add a “LocalDateTime” object to it with the “putPOJO” method.

The build.gradle file specifies a dependency on “com.fasterxml.jackson:jackson-bom:2.12.5” with other unspecified dependencies. The code fails with the exception using version 2.13.0-rc2 but works as expected with version 2.11.4.

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for`InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime…` when calling `mapper.createObjectNode().putPOJO`

The error message “InvalidDefinitionException: Java 8 date/time type java.time.LocalDateTime…” when calling mapper.createObjectNode().putPOJO indicates that the java.time.LocalDateTime type is not supported by the ObjectMapper class. To solve this issue, you can use a custom serializer to convert the LocalDateTime object to a string representation before serializing it to a JSON string.

Here’s an example of how you can implement a custom serializer in Jackson, a popular Java library for JSON processing:

public class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
    public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {

To use this custom serializer, you need to annotate the LocalDateTime field with @JsonSerialize and specify the custom serializer class. For example:

class MyPojo {
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    private LocalDateTime dateTime;

    // other fields, constructors, getters, setters

With these changes, you should be able to successfully serialize the LocalDateTime object to a JSON string using the mapper.createObjectNode().putPOJO method.

Other popular problems with fasterxml jackson-databind

Problem: Deserialization Vulnerability

Jackson-databinding is popular for its easy to use and fast deserialization process. However, this feature can be a source of vulnerability if the incoming JSON data is malicious. This vulnerability can lead to Remote Code Execution (RCE) attack and other security risks.


To prevent this vulnerability, Jackson-databinding provides a number of ways to secure deserialization process. The most common way is to use the @JsonCreator annotation which restricts the deserialization to a single constructor. Another way is to use JsonDeserializer class to validate the incoming data before deserializing it. The JsonDeserializer class provides a flexible and extensible way to control the deserialization process.

Problem: Serialization Loop

Another common problem with Jackson-databinding is the serialization loop. This occurs when an object references another object in its definition. The serialization process will keep repeating itself and eventually lead to a stack overflow error.


To avoid serialization loop, Jackson-databinding provides the @JsonIgnore annotation. By using this annotation, the developer can specify which properties of the object should not be serialized. This can be done on a per-property basis or on the entire object. Another solution is to use the @JsonBackReference and @JsonManagedReference annotations to define the relationship between objects. This allows the serialization process to avoid the loop and keep the object relationship intact.

Problem: Custom Serialization

Another challenge with Jackson-databinding is custom serialization. The default serialization process provided by Jackson-databinding may not be suitable for all use cases. For example, the developer may need to serialize an object in a different format or change the property names during serialization.


Jackson-databinding provides a number of ways to handle custom serialization. The most common way is to use the @JsonSerialize annotation. This annotation allows the developer to specify a custom serializer class which will handle the serialization process. Another way is to implement the JsonSerializer interface and register it with the ObjectMapper. This allows the developer to have full control over the serialization process and customize it as needed.

A brief introduction to fasterxml jackson-databind

Jackson-databinding is a popular library for Java developers that provides fast and easy-to-use data binding between JSON and Java objects. The library is based on the Jackson JSON processor and uses annotations and interfaces to control the serialization and deserialization process. This technical style allows developers to focus on the business logic of their applications, rather than worrying about the data binding process.

Jackson-databinding offers a number of features and customization options to meet the needs of different applications. For example, the library provides annotations to control the serialization of individual properties or entire objects, as well as the ability to write custom serialization and deserialization logic. It also supports a number of data formats such as JSON, XML, and YAML, making it easy for developers to switch between formats as needed. Additionally, Jackson-databinding offers flexible configuration options that allow developers to fine-tune the behavior of the library to meet the specific needs of their applications.

Most popular use cases for fasterxml jackson-databind

  1. Jackson-databind is a Java library used for data-binding, which means converting Java objects to JSON and vice-versa. It is a part of the Jackson library and works seamlessly with other Jackson components.
  2. Jackson-databind provides a rich set of annotations that can be used to control the serialization and deserialization process, including specifying the names of properties, ignoring properties, and handling complex data structures such as nested objects and collections.
  3. To use Jackson-databind, one can simply create an instance of the ObjectMapper class and use its readValue and writeValueAsString methods to convert Java objects to JSON and vice-versa. For example, consider the following code block:
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        Person person = new Person("John", "Doe", 30);
        String json = mapper.writeValueAsString(person);

class Person {
    private String firstName;
    private String lastName;
    private int age;
    // constructor, getters, and setters

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.