Jackson’s Deserialization With Lombok

1. Overview

More often than not, when working with Project Lombok, we’ll want to combine our data-related classes with a JSON framework like Jackson. This is particularly true given that JSON is widespread in most modern APIs and data services.

In this quick tutorial, we’ll take a look at how we can configure our Lombok builder classes to work seamlessly with Jackson.

2. Dependencies

All we’ll need to get started with is the org.projectlombok added to our pom.xml:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
</dependency>

And of course, we’ll need the jackson-databind dependency as well:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.14.1</version>
</dependency>

3. A Simple Fruit Domain

Let’s go ahead and define a Lombok-enabled class with an id and a name to represent a fruit:

@Data
@Builder
@Jacksonized
public class Fruit {
    private String name;
    private int id;
}

Let’s walk through the key annotations of our POJO:

• First things first, we start by adding the @Data annotation to our class – this generates all the boilerplate normally associated with a simple POJO, such as getters and setters
• Then, we add the @Builder annotation –  a helpful mechanism for object creation using the Builder pattern
• Finally and most importantly, we add the @Jacksonized annotation

To expand briefly, the @Jacksonized annotation is an add-on annotation for @Builder. Using this annotation lets us automatically configure the generated builder class to work with Jackson’s deserialization.

It is important to note that this annotation only works when there is also a @Builder or a @SuperBuilder annotation present.

Finally, we should mention that although @Jacksonized was introduced in Lombok v1.18.14. It is still considered an experimental feature.

4. Deserializing and Serializing

With our domain model now defined, let’s go ahead and write a unit test to deserialize a fruit using Jackson:

@Test
public void withFruitJSON_thenDeserializeSucessfully() throws IOException {
    String json = "{\"name\":\"Apple\",\"id\":101}";
        
    Fruit fruit = newObjectMapper().readValue(json, Fruit.class);
    assertEquals(new Fruit("Apple", 101), fruit);
}

The simple readValue() API of the ObjectMapper is good enough. We can use it to deserialize a JSON fruit string into a Fruit Java object.

Likewise, we can use the writeValue() API to serialize a Fruit object as JSON output:

@Test
void withFruitObject_thenSerializeSucessfully() throws IOException {
    Fruit fruit = Fruit.builder()
      .id(101)
      .name("Apple")
      .build();

    String json = newObjectMapper().writeValueAsString(fruit);
    assertEquals("{\"name\":\"Apple\",\"id\":101}", json);
}

The test shows how we can build a Fruit using the Lombok builder API and that the serialized Java object matches the expected JSON string.

5. Working With a Customized Builder

Sometimes we might need to work with a customized builder implementation rather than the one Lombok generates for us. For example, when the names of our bean’s properties are different from those of the fields in the JSON string.

Let’s imagine we want to deserialize the following JSON string:

{
    "id": 5,
    "name": "Bob"
}

But the properties on our POJO do not match:

@Data
@Builder(builderClassName = "EmployeeBuilder")
@JsonDeserialize(builder = Employee.EmployeeBuilder.class)
@AllArgsConstructor
public class Employee {

    private int identity;
    private String firstName;

}

In this scenario, we can use the @JsonDeserialize annotation with the @JsonPOJOBuilder annotation, which we can insert on the generated builder class to override Jackson’s defaults:

@JsonPOJOBuilder(buildMethodName = "createEmployee", withPrefix = "construct")
public static class EmployeeBuilder {

    private int idValue;
    private String nameValue;

    public EmployeeBuilder constructId(int id) {
        idValue = id;
        return this;
    }
            
    public EmployeeBuilder constructName(String name) {
        nameValue = name;
        return this;
    }

    public Employee createEmployee() {
        return new Employee(idValue, nameValue);
    }
}

Then we can go ahead and write a test as before:

@Test
public void withEmployeeJSON_thenDeserializeSucessfully() throws IOException {
    String json = "{\"id\":5,\"name\":\"Bob\"}";
    Employee employee = newObjectMapper().readValue(json, Employee.class);

    assertEquals(5, employee.getIdentity());
    assertEquals("Bob", employee.getFirstName());
}

The result shows that a new Employee data object has been successfully re-created from a JSON source despite a mismatch in properties’ names.

6. Conclusion

In this short article, we’ve seen two simple approaches to configure our Lombok builder classes to work seamlessly with Jackson.

Without the @Jacksonized annotation, we’d have to specifically customize our builder class(es). However, using @Jacksonized lets us use the Lombok-generated builder class.