According to the documentation, Lombok has 3 annotations for constructor generation:
#NoArgsConstructor - generates an empty constructor;
#AllArgsConstructor - generates a constructor that initializes all
fields;
#RequiredArgsConstructor - generates a constructor that
initializes only final fields.
They all have an onConstructor property that allows you to specify the annotations with which the generated constructor should be marked.
According to the Javadoc, the syntax for this feature depends on JDK version (nothing we can do about that; it's to work around javac bugs).
Up to JDK7:
#NoArgsConstructor(onConstructor=#__({#AnnotationsGoHere}))
From JDK8:
#NoArgsConstructor(onConstructor_={#AnnotationsGohere}) // note the underscore after onConstructor
I am working on JDK8. However, only the JDK7 variant works for me, while the JDK8 variant does not work (a constructor without annotations is generated).
I checked on JDK11 - same result.
I check with Refactor -> Delombok -> #Constructors.
For example, like this:
#AllArgsConstructor(onConstructor = #__(#Deprecated))
public class SomeClass {
}
the following code is generated:
public class SomeClass {
#Deprecated
public SomeClass() {
}
}
But like so:
#AllArgsConstructor(onConstructor_ = #Deprecated)
public class SomeClass {
}
code like this is generated:
public class SomeClass {
public SomeClass() {
}
}
I noticed that the documentation on the Lombok site only contains a JDK7 style example.
The Javadoc is incorrect or am I doing something wrong?
I found, that it's not the Lombok's bug, it's Lombok IntelliJ plugin bug.
Constructor annotations add in compiled code.
Delombok tool of Lombok IntelliJ plugin incorrect convert Lombok's annotations to vanilla Java code.
I have added Lombok's JAR file in STS (eclipse).
I am using Lombok to create object using builder(). But, I am facing issue in inheritance.
If I am using Lombok's builder pattern to create objects it's working in workspace & in executable JAR file.
But, If I am using Lombok's builder pattern to create objects which inherit another object, then it's not working.
#Data
#Builder
#AllArgsConstructor
#NoArgsConstructor
class BaseEmp {
private int a;
private int b;
}
#Data
#NoArgsConstructor
#Builder
class Emp extends BaseEmp implements Serializable {
private static final long serialVersionUID = 1L;
#Builder
public Emp(int a, int b) {
super(a, b);
}
}
Emp emp = Emp.builder.a(ipA).b(ipB).build();
In this one when I am printing object, a and b values are null in JAR and working in STS.
But, when I converted to normal object creation in workspace and JAR, in both places it is working.
Means, upon compile, Lombok processor somehow misses inheritance class field.
If you extend another class, you should really think about using #SuperBuilder. Although it is still experimental, the Lombok maintainers made clear that this is mainly because it is a very young, extremely complex feature that will not receive support/bugfixes as fast as the core features. It is unlikely that #SuperBuilder will be redesigned or dropped in the future.
However, if you want to stick with #Builder, you must not have #Builder annotations on both the class and the constructor. Just put it on the constructor and it should work.
Furthermore, your superclass should also not have #Builder, otherwise you'll get a name clash on the builder() method. (You can work around that by renaming it using the parameter builderMethodName.)
I have a Kotlin Gradle project. I added Lombok as a dependency and also registered it with kapt
compileOnly("org.projectlombok:lombok:$lombokVersion")
kapt("org.projectlombok:lombok:$lombokVersion")
I would like to use the #Slf4j annotation for automatic logger generation. It works for Java classes but not for the Kotlin ones.
Is using Kotlin and Lombok together even possible as of now? If I annotate a Kotlin class with #Slf4j and use log inside it I get
Unresolved reference: log
Evidently no annotation processing is applied.
Lombok does not run on your source code, but on the AST. Anyway, it is an annotation processor that is run at compile-time by the Java compiler. The Kotlin compiler does not use these annotation processors. See also the answer https://stackoverflow.com/a/35530223/2621917 straight from the horse’s mouth.
You cannot use annotation #Slf4j, but manually create its object in the class required.
Refer https://www.reddit.com/r/Kotlin/comments/8gbiul/slf4j_loggers_in_3_ways/
If all you want to use Lombok for is #Slf4j, then I'd suggest using kotlin-logging instead: https://github.com/MicroUtils/kotlin-logging
It's a simple wrapper around slf4j, so instead of annotating your class with #Slf4j, you use:
// Place definition above class declaration to make field static
private val logger = KotlinLogging.logger {}
// ...
logger.debug { "A message only logged if debug is enabled. With $variable support." }
Lombok's builder annotation support has been added to kotlin 1.8 as of late December 2022.
You can learn how to configure the plugin here.
In Short, add
plugins {
id 'org.jetbrains.kotlin.plugin.lombok' version '1.8.0'
id 'io.freefair.lombok' version '5.3.0'
}
to your Groovy/Gradle files, and/or take a look at the sample project.
It's not supported and, by the looks of things, it isn't going to be.
from kotlin 1.7.20 with K2 compiler it is possible.
https://kotlinlang.org/docs/whatsnew1720.html#support-for-kotlin-k2-compiler-plugins
For logging the best I could do - because #Slf4j did not work - was like creating abstract log class like:
package org.example
import org.slf4j.LoggerFactory
import org.slf4j.Logger
abstract class Log {
val log: Logger = LoggerFactory.getLogger(this.javaClass)
}
and usage:
package org.example
class MyClass {
companion object : Log() {}
#Test
fun someFun() {
log.info("Logging info")
}
}
I can't see how it would work without additional support from the lombok team.
Lombok is based on annotation processing so it runs during compilation time and runs on your source code, so I guess it assumes Java's syntax.
I wanted to use Lombok dependency in my project. So, I downloaded lombok-1.16.18.jar and added to the build path of on of my classes. The configuration is shown below.
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
#ToString(includeFieldNames=true)
public #Data class Student {
#Getter
#Setter
private Integer id;
#Getter
#Setter
private String name;
//private Date dob;
#Getter
#Setter
private String uid;
public static void main(String[] args) {
// TODO Auto-generated method stub
Student s = new Student();
System.out.println(s);
}
}
But, I am not getting proper output in console. I am getting Object classes toString() output like com.selflearn.sandesha.Student#7852e922
. I am also not able to use getters and setters. How to make Lombok work or what wrong I am doing?
Your configuration is incomplete. Review https://projectlombok.org/setup/eclipse and check if It compiles.
When it does, try again!
If you use netbeans go to properties->Build->compiling for checked the option Enable Annotation processing
or search this option in your editor
thanks for your help. In eclipse IDE, I was not exporting the lombok jar. Even though, I added jar to the build path, it seems I should export it to the project in order and export section of eclipse.
So, In eclipse editor,
right click on your project --> Build Path--> Configure Build Path...-->select order and export tab and check the jar you want to export to your project.
Or
you can also simply run the downloaded jar. This will detect the possible IDE's in the system and configure it to support all lombok features.
This solved my issue. Again thank you for your support.
Simply download the lombok-1.18.24.jar(any version) and once download, double click on that file, so it checks your system and detects the IDE's that are available on your system. Then verify the IDE's and click on install/update button. Once the above process is completed, restart your IDE maybe, sts or eclipse.
#Data on class level would be sufficient. Maybe it is a problem that you have put the #Data annotation between public and class.
Other question is whether your lombok.jar is on the classpath.
If I would rewrite your class, I would come up with the following:
#Data
public class Student {
private Integer id;
private String name;
private String uid;
public static void main(String[] args) {
// TODO Auto-generated method stub
Student s = new Student();
System.out.println(s);
}
}
I am experimenting in combining Jackson and Lombok. Those are my classes:
package testelombok;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Value;
import lombok.experimental.Wither;
#Value
#Wither
#AllArgsConstructor(onConstructor=#__(#JsonCreator))
public class TestFoo {
#JsonProperty("xoom")
private String x;
private int z;
}
package testelombok;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xebia.jacksonlombok.JacksonLombokAnnotationIntrospector;
import java.io.IOException;
public class TestLombok {
public static void main(String[] args) throws IOException {
TestFoo tf = new TestFoo("a", 5);
System.out.println(tf.withX("b"));
ObjectMapper om = new ObjectMapper().setAnnotationIntrospector(new JacksonLombokAnnotationIntrospector());
System.out.println(om.writeValueAsString(tf));
TestFoo tf2 = om.readValue(om.writeValueAsString(tf), TestFoo.class);
System.out.println(tf2);
}
}
Those are the JARs that I'm adding into the classpth:
Lombok: https://projectlombok.org/downloads/lombok.jar (version 1.16.10)
Jackson annotations: http://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-annotations/2.8.2/jackson-annotations-2.8.2.jar
Jackson core: http://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/2.8.2/jackson-core-2.8.2.jar
Jackson databind: http://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-databind/2.8.2/jackson-databind-2.8.2.jar
Jackson-lombok: http://repo1.maven.org/maven2/io/paradoxical/jackson-lombok/1.1/jackson-lombok-1.1.jar
I am compiling it with Netbeans (I don't think that this is really relevant, but I am reporting this anyway to make it perfectly and faithfully reproducible). The five JARs above are kept in a folder called "lib" inside the project folder (along with "src", "nbproject", "test" and "build"). I added them to Netbeans via the "Add JAR/Folder" button in the project properties and they are listed in the exact order as the list above. The project is a standard "Java application" type project.
Further, the Netbeans project is configured to "do NOT compile on save", "generate debugging info", "report deprecated APIs", "track java dependencies", "activacte annotation proccessing" and "activacte annotation proccessing in the editor". No annotation processor or annotation processing option is explicitly configured in Netbeans. Also, the "-Xlint:all" command line option is passed in the compiler command line, and the compiler runs on an external VM.
My javac's version is 1.8.0_72 and my java's version is 1.8.0_72-b15. My Netbeans is 8.1.
My project compiles fine. However, it throws an exception in its execution. The exception don't seems to be anything that looks easily or obvious fixable. Here is the output, including the stacktrace:
TestFoo(x=b, z=5)
{"z":5,"xoom":"a"}
Exception in thread "main" com.fasterxml.jackson.databind.JsonMappingException: Argument #0 of constructor [constructor for testelombok.TestFoo, annotations: {interface java.beans.ConstructorProperties=#java.beans.ConstructorProperties(value=[x, z]), interface com.fasterxml.jackson.annotation.JsonCreator=#com.fasterxml.jackson.annotation.JsonCreator(mode=DEFAULT)}] has no property name annotation; must have name when multiple-parameter constructor annotated as Creator
at [Source: {"z":5,"xoom":"a"}; line: 1, column: 1]
at com.fasterxml.jackson.databind.JsonMappingException.from(JsonMappingException.java:296)
at com.fasterxml.jackson.databind.deser.DeserializerCache._createAndCache2(DeserializerCache.java:269)
at com.fasterxml.jackson.databind.deser.DeserializerCache._createAndCacheValueDeserializer(DeserializerCache.java:244)
at com.fasterxml.jackson.databind.deser.DeserializerCache.findValueDeserializer(DeserializerCache.java:142)
at com.fasterxml.jackson.databind.DeserializationContext.findRootValueDeserializer(DeserializationContext.java:475)
at com.fasterxml.jackson.databind.ObjectMapper._findRootDeserializer(ObjectMapper.java:3890)
at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:3785)
at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2833)
at testelombok.TestLombok.main(TestLombok.java:14)
Caused by: java.lang.IllegalArgumentException: Argument #0 of constructor [constructor for testelombok.TestFoo, annotations: {interface java.beans.ConstructorProperties=#java.beans.ConstructorProperties(value=[x, z]), interface com.fasterxml.jackson.annotation.JsonCreator=#com.fasterxml.jackson.annotation.JsonCreator(mode=DEFAULT)}] has no property name annotation; must have name when multiple-parameter constructor annotated as Creator
at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory._addDeserializerConstructors(BasicDeserializerFactory.java:511)
at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory._constructDefaultValueInstantiator(BasicDeserializerFactory.java:323)
at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory.findValueInstantiator(BasicDeserializerFactory.java:253)
at com.fasterxml.jackson.databind.deser.BeanDeserializerFactory.buildBeanDeserializer(BeanDeserializerFactory.java:219)
at com.fasterxml.jackson.databind.deser.BeanDeserializerFactory.createBeanDeserializer(BeanDeserializerFactory.java:141)
at com.fasterxml.jackson.databind.deser.DeserializerCache._createDeserializer2(DeserializerCache.java:406)
at com.fasterxml.jackson.databind.deser.DeserializerCache._createDeserializer(DeserializerCache.java:352)
at com.fasterxml.jackson.databind.deser.DeserializerCache._createAndCache2(DeserializerCache.java:264)
... 7 more
I already tried about randomly poking with the #Value and #AllArgsConstructor annotations, but I couldn't make it any better.
I google'd the exception and found an old bug report on jackson, and another one that is open, but seems to be related to something else. However, this still do not tells anything about what is this bug or how to fix it. Also, I could not find anything useful looking that somewhere else.
Since what I am trying to do is very basic usage of both lombok and jackson, it seems odd that I couldn't find any more useful information about how to workaround this issue. Maybe I missed something?
Other than just saying "don't use lombok" or "don't use jackson", do anybody has any idea about how to solve this?
If you want immutable but a json serializable POJO using lombok and jackson.
Use jacksons new annotation on your lomboks builder #JsonPOJOBuilder(withPrefix = "")
I tried this solution and it works very well.
Sample usage
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
import lombok.Builder;
import lombok.Value;
#JsonDeserialize(builder = Detail.DetailBuilder.class)
#Value
#Builder
public class Detail {
private String url;
private String userName;
private String password;
private String scope;
#JsonPOJOBuilder(withPrefix = "")
public static class DetailBuilder {
}
}
If you have too many classes with #Builder and you want don't want the boilerplate code empty annotation you can override the annotation interceptor to have empty withPrefix
mapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector() {
#Override
public JsonPOJOBuilder.Value findPOJOBuilderConfig(AnnotatedClass ac) {
if (ac.hasAnnotation(JsonPOJOBuilder.class)) {//If no annotation present use default as empty prefix
return super.findPOJOBuilderConfig(ac);
}
return new JsonPOJOBuilder.Value("build", "");
}
});
And you can remove the empty builder class with #JsonPOJOBuilder annotation.
Immutable + Lombok + Jackson can be achieved in next way:
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Value;
#Value
#NoArgsConstructor(force = true, access = AccessLevel.PRIVATE)
#AllArgsConstructor
public class LocationDto {
double longitude;
double latitude;
}
class ImmutableWithLombok {
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
String stringJsonRepresentation = objectMapper.writeValueAsString(new LocationDto(22.11, 33.33));
System.out.println(stringJsonRepresentation);
LocationDto locationDto = objectMapper.readValue(stringJsonRepresentation, LocationDto.class);
System.out.println(locationDto);
}
}
I tried several of the above and they were all temperamental.
What really worked for me is the the answer I found here.
on your project's root directory add a lombok.config file (if you haven't done already)
lombok.config
and inside paste this
lombok.anyConstructor.addConstructorProperties=true
Then you can define your pojos like the following:
#Data
#AllArgsConstructor
public class MyPojo {
#JsonProperty("Description")
private String description;
#JsonProperty("ErrorCode")
private String errorCode;
}
Here is an example by using
#Jacksonized annotation:
import lombok.Value;
import lombok.Builder;
import lombok.extern.jackson.Jacksonized;
#Jacksonized
#Builder
#Value
public class User {
String name;
String surname;
}
It does require you to use #Builder annotation.
I had exactly the same issue, "solved" it by adding the suppressConstructorProperties = true parameter (using your example):
#Value
#Wither
#AllArgsConstructor(suppressConstructorProperties = true)
public class TestFoo {
#JsonProperty("xoom")
private String x;
private int z;
}
Jackson apparently does not like the java.beans.ConstructorProperties annotation added to constructors. The suppressConstructorProperties = true parameter tells Lombok not to add it (it does by default).
It can be done simpler, without extra annotations and the problem can be with the inheritance, i.e. child classes should be deserializable as well. So, my example:
Requirements:
lombok.config inside the project root directory with body containing:
lombok.anyConstructor.addConstructorProperties=true
/** The parent class **/
#Value
#NonFinal
#SuperBuilder
#RequiredArgsConstructor
public class Animal {
String name;
}
/** The child class **/
#Value
#SuperBuilder
#RequiredArgsConstructor
public class Cat {
Long tailLength;
#ConstructorProperties({"tailLength", "name})
public Cat(Long tailLength, String name) {
super(name);
this.tailLength = tailLength;
}
}
It:
Allows building of objects including fields of the parent
Serializes/Deserializes with the default ObjectMapper and Jackson
Instances of the parent and children classes are immutable
My advice against other examples:
Try not to put custom annotations on particular classes, it makes it inhomogeneous. Any way, you will come to a generic solution one day.
Try not to put Jackson annotations on any fields on constructors, it creates coupling, when Jackson is capable to serialize/deserialize without any annotations.
Do not use #AllArgsConstructor for immutable entities. When your class has only final fields, conceptually right is #RequiredArgsConstructor, that's how you guarantee that class-clients always will rely only on a constructor with the immutable entity. Will #AllArgsConstructor it might lead to passing nulls.
I found two options to solve this problem if you want to use #Builder with Jackson.
Option 1
Add private default noArgs and allArgs constructors.
#Builder
#Getter
#Setter
#JsonIgnoreProperties(ignoreUnknown = true)
#AllArgsConstructor(access = AccessLevel.PRIVATE)
#NoArgsConstructor(access = AccessLevel.PRIVATE)
public class Person {
#JsonProperty("user_name")
private String name;
}
Option 2
Thanks to this article.
Jackson expects the builder methods to start like .withProperty(...) but Lombok generates .property(...).
What you can do is to create the builder class yourself so that you can add Jackson annotations to it. Lombok will then re-use this class and add all the builder methods to it.
#JsonDeserialize(builder = MyDto.MyDtoBuilder.class)
#Builder
#Getter
public class MyDto {
#JsonProperty("user_id")
private String userId;
#JsonPOJOBuilder(withPrefix = "")
#JsonIgnoreProperties(ignoreUnknown = true)
public static class MyDtoBuilder {
}
}
You need to do some manual work
Still much better than writing the Builder yourself
Also note that additional properties like #JsonIgnorePropertie go on the builder
An additional drawback is that refactorings will not automatically rename the MyDtoBuilder. I hope in a future Lombok/Jackson version this issue is solved.
Update: I've found another solution (tested with lombok 1.18.20 and spring boot 2.4.5), added as Option 1.
#AllArgsConstructor(suppressConstructorProperties = true) is deprecated. Define lombok.anyConstructor.suppressConstructorProperties=true (https://projectlombok.org/features/configuration) and change POJO's lombok annotation from #Value to #Data + #NoArgsConstructor + #AllArgsConstructor works for me.
From Jan Rieke's Answer
Since lombok 1.18.4, you can configure what annotations are copied to
the constructor parameters. Insert this into your lombok.config:
lombok.copyableAnnotations += com.fasterxml.jackson.annotation.JsonProperty
Then just add #JsonProperty to your fields:
...
You'll need a #JsonProperty on every field even if the name matches, but that is a good practice to follow anyway. You can also set your fields to public final using this, which I prefer over getters.
#ToString
#EqualsAndHashCode
#Wither
#AllArgsConstructor(onConstructor=#__(#JsonCreator))
public class TestFoo {
#JsonProperty("xoom")
public final String x;
#JsonProperty("z")
public final int z;
}
It should also work with getters (+setters) though.
I've all my classes annotated like this:
#JsonAutoDetect(fieldVisibility = Visibility.ANY)
#JsonInclude(JsonInclude.Include.NON_DEFAULT)
#Data
#Accessors(fluent = true)
#NoArgsConstructor
#AllArgsConstructor
It worked with all Lombok and Jackson versions for, at least, a couple of years.
Example:
#JsonAutoDetect(fieldVisibility = Visibility.ANY)
#JsonInclude(JsonInclude.Include.NON_DEFAULT)
#Data
#Accessors(fluent = true)
#NoArgsConstructor
#AllArgsConstructor
public class Person {
String id;
String first;
String last;
}
And that's it.
Lombok and Jackson play together like a charm.
For me it worked when I have updated lombok version to:
'org.projectlombok:lombok:1.18.0'
I have managed to keep my classes immutable and also deserialize them by using this lombok annotation:
#NoArgsConstructor(force = true)
You can get Jackson to play with just about anything if you use its "mixin" pattern. Basically, it gives you a way to add Jackson annotations onto an existing class without actually modifying that class. I'm leaning towards recommending it here rather than a Lombok solution because this is solves a problem Jackson is having with a Jackson feature, so it's more likely to work long-term.
I would suggest you to use Gson as it does not give you all this hassle.
I added this in my spring boot app
spring.mvc.converters.preferred-json-mapper=gson
along with the dependency in maven and I solved all the problems. I didn't need to modify my lombok annotated pojos
#JsonInclude(JsonInclude.Include.NON_NULL)
#Data
public class Person {
String id;
String first;
String last;
}
Additional to the Data Class, it should be correct configured the ObjectMapper.
In this case, it is working ok with a ParameterNamesModule configuration, and setting visibility of Fields and Creator Methods
om.registerModule(new ParameterNamesModule());
om.setVisibility(FIELD, JsonAutoDetect.Visibility.ANY);
om.setVisibility(CREATOR, JsonAutoDetect.Visibility.ANY);
Then it should work as expected.
I was having issues with getting Lombok to not add the ConstructorProperies annotation so went the other way and disabled Jackson from looking at that annotation.
The culprit is JacksonAnnotationIntrospector.findCreatorAnnotation. Notice:
if (_cfgConstructorPropertiesImpliesCreator
&& config.isEnabled(MapperFeature.INFER_CREATOR_FROM_CONSTRUCTOR_PROPERTIES)
Also notice JacksonAnnotationIntrospector.setConstructorPropertiesImpliesCreator:
public JacksonAnnotationIntrospector setConstructorPropertiesImpliesCreator(boolean b)
{
_cfgConstructorPropertiesImpliesCreator = b;
return this;
}
So two options, either set the MapperFeature.INFER_CREATOR_FROM_CONSTRUCTOR_PROPERTIES to false or create a JacksonAnnotationIntrospector set setConstructorPropertiesImpliesCreator to false and set this AnnotationIntrospector into the ObjectMapper via ObjectMapper.setAnnotationIntrospector.
Notice a couple things, I am using Jackson 2.8.10 and in that version MapperFeature.INFER_CREATOR_FROM_CONSTRUCTOR_PROPERTIES does not exist. I am not sure in which version of Jackson it was added. So if it is not there, use the JacksonAnnotationIntrospector.setConstructorPropertiesImpliesCreator mechanism.
You need to have this module as well.
https://github.com/FasterXML/jackson-modules-java8
then turn on -parameters flag for your compiler.
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<compilerArgs>
<arg>-parameters</arg>
</compilerArgs>
</configuration>
</plugin>
I struggled with this for a moment as well. But looking through the documentation here
I can see that the onConstructor annotation parameter is considered experimental and is not supported well on my IDE (STS 4). According to the Jackson documentation, private members are not (de)serialized by default. There are quick ways to resolve this.
Add JsonAutoDetect annotation and set it appropriately to detect protected/private members. This is convenient for DTOs
#JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public class SomeClass
Add a factory function with #JsonCreator annotation, this works best if you need some object validation or additional transforms.
public class SomeClass {
// some code here
#JsonCreator
public static SomeClass factory(/* params here dressing them in #JsonProperty annotations*/) {
return new SomeClass();
}
}
Of course you could just manually add the constructor in yourself also as well.
Options which worked for me
This worked for me just by adding #AllArgsConstructor in my bean.
Add mapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true); object mapper instance.
None of the above answers worked for me, but this below did.
What happens is that Jackson does not support the fluent getters, BUT you can tell it to use reflection to read the fields.
Try this:
#Value
#Accessors(chain = true, fluent = true)
#Builder(builderClassName = "Builder")
public static class TestFoo {
// ...
}
var foo = ...
var writer = new ObjectMapper()
.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY)
.writer();
writer.writeValueAsString(foo);
I had a different issue and it was with the boolean primitive types.
private boolean isAggregate;
It was throwing the following error as a result
Exception: Unrecognized field "isAggregate" (class
Lambok converts isAggregate to isAggregate() as a getter making the property internally to lombok as aggregate instead isAggregate. The Jackson library doesn't like it and it needs isAggregate property instead.
I updated the primitive boolean to Wrapper Boolean to work around this issue. There are other options for you if you are dealing with boolean types, see the reference below.
Sol:
private Boolean isAggregate;
ref: https://www.baeldung.com/lombok-getter-boolean