Immutable Lombok annotated class with Jackson

Question

What is the preferred way to create class that is

Immutable
Can be serialized/deserialized with Jackson
Human-readable and with low level of boilerplate

Preferably, I would have liked something like this to work:

@Data(onConstructor = @__(@JsonCreator))

and then have all fields to be private final. However, this does not even compile (and I'm not sure why). Using

@AllArgsConstructor(onConstructor = @__(@JsonCreator))

will compile but only yields

InvalidDefinitionException: No serializer found for class

robSE13 · Accepted Answer · 2021-08-19T03:47:58.063

add ConstructorProperties:

Create a lombok.config file in an appropriate location with the line: lombok.anyConstructor.addConstructorProperties = true
Add lombok @Value annotation to your class to make it immutable

Then serialization and deserialization by Jackson works as expected.

This method:

meets the criteria
has less boilerplace than the previous top answer
works on v1.16.20 (January 9th, 2018) and later

Edit: 2020-08-16

Note: Using @Builder with @Value causes this solution to fail. (Thanks to comment from @guilherme-blanco below.) However, if you also add e.g. @AllArgsConstructor it does still work as expected.

Edit: 2021-08-19

Note: When you add or change a lombok.config file the change is not picked up unless you do a rebuild (clean then build). I have been caught out by this a few times.
@Jacksonized annotation solution is another method to achieve the desired outcome for the specific classes annotated. However, I personally prefer not to need to remember to annotate every class used for deserialization. Using lombok.config removes this overhead.

BEWARE: This approach does not work in conjunction with @Builder. — Guilherme Blanco, May 12 '20 at 15:21

jr. · Answer 2 · 2021-02-01T08:59:06.217

As of 15 October 2020 (Lombok v1.18.16), you should simply be able to use the @Jacksonized annotation.

@Jacksonized @Builder
@JsonIgnoreProperties(ignoreUnknown = true)
public class JacksonExample {
  private List<Foo> foos;
}

As described in the linked documentation, this annotation:

configures Jackson to use the builder for deserialisation,
copies field-specific configuration down from the annotated class to the generated builder (e.g. @JsonIgnoreProperties), and
aligns the Jackson prefix used on builder methods (e.g. builder().withField(field) vs builder.field(field) to the one configured in Lombok.

Can we upvote this answer to the first place? It works like a charm :) — Pawel Dobierski, Jan 29 '21 at 01:08

Thomas Fritsch · Answer 3 · 2018-04-26T06:18:06.067

You can use Lombok's @Builder annotation to generate a builder for your immutable POJO class. But making the Lombok-generated builder usable by Jackson's deserialization is somewhat tricky.

You need to annotate your POJO class with @JsonDeserialize(builder = ...) to tell Jackson which is the builder class to use.
You need to annotate the builder class with @JsonPOJOBuilder(withPrefix = "") to tell Jackson that its setter-methods do not start with with.

Example:

An immutable POJO class:

@Data
@Builder(builderClassName = "PointBuilder")
@JsonDeserialize(builder = Point.PointBuilder.class)
public class Point {

    private final int x;

    private final int y;

    @JsonPOJOBuilder(withPrefix = "")
    public static class PointBuilder {
        // Lombok will add constructor, setters, build method
    }
}

Here is a JUnit test to verify the serialization/deserialization:

public class PointTest extends Assert {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Test
    public void testSerialize() throws IOException {
        Point point = new Point(10, 20);
        String json = objectMapper.writeValueAsString(point);
        assertEquals("{\"x\":10,\"y\":20}", json);
    }

    @Test
    public void testDeserialize() throws IOException {
        String json = "{\"x\":10,\"y\":20}";
        Point point = objectMapper.readValue(json, Point.class);
        assertEquals(new Point(10, 20), point);
    }
}

I've been using this approach for awhile now, and it is very, very effective. One very small improvement is that I always name my builder classes _Builder. That way when I copy paste to create a new class, etc... I'm not having to remember to change the string in the builderClassName. I used to call the classes Builder (without the underscore), but that has weird conflicts with the @Builder annotation class when you do this with inner static classes. — Kevin Day, May 10 '18 at 01:13

Streamline27 · Answer 4 · 2019-05-14T09:40:16.250

By referencing answer by Joseph K. Strauss I came up with following solution.

Plain lombok annotations that worked out for me looks like this. Following annotations give you immutable classes with builder that can be serialized and deserialized by Jackson.

    @Data
    @Setter(AccessLevel.NONE)
    @Builder(toBuilder = true)
    @AllArgsConstructor
    @NoArgsConstructor(access = AccessLevel.PRIVATE)
    public class Clazz {
        private String field;
    }

I prefer this solution because it requires no additional Jackson specific annotations and no additional lombok specific files

Thank for this. But seems : – Breton F. Dec 11 '20 at 16:34 — Breton F., Dec 11 '20 at 16:34

Joseph K. Strauss · Answer 5 · 2018-11-06T18:22:39.170

Another alternative that is much less verbose:

@Data
@Setter(AccessLevel.NONE)
public class Clazz {
    private String field;
}

Of course, you could still have some private method that modifies the field directly, but it would be very unlikely to even have any actual code in a @Data POJO, so this would hopefully not happen.

Disclaimer: This will have the side-effect (perhaps beneficial) of not letting regular Java code create the object since there is only a default constructor with no mutators. To allow for normal construction you will need 2 more annotations:

@Data
@AllArgsConstructor
@NoArgsConstructor
@Setter(AccessLevel.NONE)
public class Clazz {
    private String field;
}

score 3 · Answer 6 · answered Nov 25 '20 at 15:16

3

The simplest way to configure immutable class for Jackson is to use lombok annotation: @Value and @Jacksonized:

    @Jacksonized
    @Builder
    @Value
    class Foo {

        
    }

answered Nov 25 '20 at 15:16

MariuszS

30,646
12
114
155

score 2 · Answer 7 · answered Jun 24 '20 at 16:55

2

Try the following set of annotations for your pojo:

@Value
@NoArgsConstructor(force = true, access = AccessLevel.PRIVATE)
@AllArgsConstructor

answered Jun 24 '20 at 16:55

Zon

18,610
7
91
99

score 2 · Answer 8 · answered Sep 20 '20 at 06:05

I've just solved it using this way:

@Value
@Builder(setterPrefix = "with")
@JsonDeserialize(builder = Clazz.ClazzBuilder.class)
public class Clazz {
    private String field;
}

In that case, you have to use the builder methods like withField(...), which is the default behaviour used by jackson.

Ajay Mathur · Answer 9 · 2020-02-13T18:01:28.680

Answer by Thomas Fritsch worked perfectly with Spring Boot after adding Jackson Dataformat dependency in pom.

@Data
@Builder(builderClassName = "PointBuilder")
@JsonDeserialize(builder = Point.PointBuilder.class)
public class Point {

    private final int x;

    private final int y;

    @JsonPOJOBuilder(withPrefix = "")
    public static class PointBuilder {
        // Lombok will add constructor, setters, build method
    }
}

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-xml -->
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

Immutable Lombok annotated class with Jackson

9 Answers9

Linked