Home » Java » Is it safe to use Project Lombok?

Is it safe to use Project Lombok?

Posted by: admin November 2, 2017 Leave a comment


In case you don’t know Project Lombok helps with some of the annoyances of Java with stuff like generating getters and setters with annotations and even simple JavaBean like generation with @Data. It could really help me, especially in 50 different event objects where you have up to 7 different fields that need to be constructed and hidden with getters. I could remove almost a thousand lines of code with this.

However I’m worried that in the long run it will be a regretful decision. Flamewars will erupt in the ##Java Freenode channel when I mention it, providing code snippets will confuse possible helpers, people will complain about missing JavaDoc, and future commiters might just remove it all anyway. I would really enjoy the positive, but I’m worried about the negative.

So: Is it safe to use on any project, small or large? Are the positive effects worth the negatives?


It sounds like you’ve already decided that Project Lombok gives you significant technical advantages for your proposed new project. (To be clear from the start, I have no particular views on Project Lombok, one way or the other.)

Before you use Project Lombok (or any other game-changing technology) in some project (open source or other wise), you need to make sure that the project stake holders agree to this. This includes the developers, and any important users (e.g. formal or informal sponsors).

You mention these potential issues:

Flamewars will erupt in the ##Java Freenode channel when I mention it,

Easy. Ignore / don’t participate in the flamewars, or simply refrain from mentioning Lombok.

providing code snippets will confuse possible helpers,

If the project strategy is to use Lombok, then the possible helpers will need to get used to it.

people will complain about missing JavaDoc,

That is their problem. Nobody in their right mind tries to rigidly apply their organization’s source code / documentation rules to third-party open source software. The project team should be free to set project source code / documentation standards that are appropriate to the technology being used.

(FOLLOWUP – The Lombok developers recognize that not generating javadoc comments for synthesized getter and setter methods is an issue. If this is a major problem for your project(s), then one alternative is to create and submit a Lombok patch to address this.)

and future commiters might just remove it all anyway.

That’s not on! If the agreed project strategy is to use Lombok, then commiters who gratuitously de-Lombok the code should be chastised, and if necessary have their commit rights withdrawn.

Of course, this assumes that you’ve got buy-in from the stakeholders … including the developers. And it assumes that you are prepared to argue your cause, and appropriately handle the inevitable dissenting voices.


Just started using Lombok today. So far I like it, but one drawback I didn’t see mentioned was refactoring support.

If you have a class annotated with @Data, it will generate the getters and setters for you based on the field names. If you use one of those getters in another class, then decide the field is poorly named, it will not find usages of those getters and setters and replace the old name with the new name.

I would imagine this would have to be done via an IDE plug-in and not via Lombok.

UPDATE (Jan 22 ’13)
After using Lombok for 3 months, I still recommend it for most projects. I did, however, find another drawback that is similar to the one listed above.

If you have a class, say MyCompoundObject.java that has 2 members, both annotated with @Delegate, say myWidgets and myGadgets, when you call myCompoundObject.getThingies() from another class, it’s impossible to know if it’s delegating to the Widget or Gadget because you can no longer jump to source within the IDE.

Using the Eclipse “Generate Delegate Methods…” provides you with the same functionality, is just as quick and provides source jumping. The downside is it clutters your source with boilerplate code that take the focus off the important stuff.

UPDATE 2 (Feb 26 ’13)
After 5 months, we’re still using Lombok, but I have some other annoyances. The lack of a declared getter & setter can get annoying at times when you are trying to familiarize yourself with new code.

For example, if I see a method called getDynamicCols() but I don’t know what it’s about, I have some extra hurdles to jump to determine the purpose of this method. Some of the hurdles are Lombok, some are the lack of a Lombok smart plugin. Hurdles include:

  • Lack of JavaDocs. If I javadoc the field, I would hope the getter and setter would inherit that javadoc through the Lombok compilation step.
  • Jump to method definition jumps me to the class, but not the property that generated the getter. This is a plugin issue.
  • Obviously you are not able to set a breakpoint in a getter/setter unless you generate or code the method.
  • NOTE: This Reference Search is not an issue as I first thought it was. You do need to be using a perspective that enables the Outline view though. Not a problem for most developers. My problem was I am using Mylyn which was filtering my Outline view, so I didn’t see the methods. Lack of References search. If I want to see who’s calling getDynamicCols(args...), I have to generate or code the setter to be able to search for references.

UPDATE 3 (Mar 7 ’13)
Learning to use the various ways of doing things in Eclipse I guess. You can actually set a conditional breakpoint (BP) on a Lombok generated method. Using the Outline view, you can right-click the method to Toggle Method Breakpoint. Then when you hit the BP, you can use the debugging Variables view to see what the generated method named the parameters (usually the same as the field name) and finally, use the Breakpoints view to right-click the BP and select Breakpoint Properties... to add a condition. Nice.

UPDATE 4 (Aug 16 ’13)
Netbeans doesn’t like it when you update your Lombok dependencies in your Maven pom. The project still compiles, but files get flagged for having compilation errors because it can’t see the methods Lombok is creating. Clearing the Netbeans cache resolves the issue. Not sure if there is a “Clean Project” option like there is in Eclipse. Minor issue, but wanted to make it known.

UPDATE 5 (Jan 17 ’14)
Lombok doesn’t always play nice with Groovy, or at least the groovy-eclipse-compiler. You might have to downgrade your version of the compiler.
Maven Groovy and Java + Lombok

UPDATE 6 (Jun 26 ’14)
A word of warning. Lombok is slightly addictive and if you work on a project where you can’t use it for some reason, it will annoy the piss out of you. You may be better off just never using it at all.

UPDATE 7 (Jul 23 ’14)
This is a bit of an interesting update because it directly addresses the safety of adopting Lombok that the OP asked about.

As of v1.14, the @Delegate annotation has been demoted to an Experimental status. The details are documented on their site (Lombok Delegate Docs).

The thing is, if you were using this feature, your backout options are limited. I see the options as:

  • Manually remove @Delegate annotations and generate/handcode the delegate code. This is a little harder if you were using attributes within the annotation.
  • Delombok the files that have the @Delegate annotation and maybe add back in the annotations that you do want.
  • Never update Lombok or maintain a fork.
  • Delombok your entire project and stop using Lombok.

As far as I can tell, Delombok doesn’t have an option to remove a subset of annotations; it’s all or nothing at least for the context of a single file. I opened a ticket to request this feature with Delombok flags, but I wouldn’t expect that in the near future.

UPDATE 8 (Oct 20 ’14)
If it’s an option for you, Groovy offers most of the same benefits of Lombok, plus a boat load of other features, including @Delegate. If you think you’ll have a hard time selling the idea to the powers that be, take a look at the @CompileStatic or @TypeChecked annotation to see if that can help your cause. In fact, the primary focus of the Groovy 2.0 release was static safety.

UPDATE 9 (Sep 1 ’15)
Lombok is still being actively maintained and enhanced, which bodes well to the safety level of adoption. The @Builder annotations is one of my favorite new features.

UPDATE 10 (Nov 17 ’15)
This may not seem directly related to the OP’s question, but worth sharing. If you’re looking for tools to help you reduce the amount of boilerplate code you write, you can also check out Google Auto – in particular AutoValue. If you look at their slide deck, the list Lombok as a possible solution to the problem they are trying to solve. The cons they list for Lombok are:

  • The inserted code is invisible (you can’t “see” the the methods it generates) [ed note – actually you can, but it just requires a decompiler]
  • The compiler hacks are non-standard and fragile
  • “In our view, your code is no longer really Java”

I’m not sure how much I agree with their evaluation. And given the cons of AutoValue that are documented in the slides, I’ll be sticking with Lombok (if Groovy is not an option).

UPDATE 11 (Feb 8 ’16)
I found out Spring Roo has some similar annotations. I was a little surprised to find out Roo is still a thing and finding documentation for the annotations is a bit rough. Removal also doesn’t look as easy as de-lombok. Lombok seems like the safer choice.

UPDATE 12 (Feb 17 ’16)
While trying to come up with justifications for why it’s safe to bring in Lombok for the project I’m currently working on, I found a piece of gold that was added with v1.14 – The Configuration System! This is means you can configure a project to dis-allow certain features that your team deems unsafe or undesirable. Better yet, it can also create directory specific config with different settings. This is AWESOME.

UPDATE 13 (Oct 4 ’16)
If this kind of thing matters to you, Oliver Gierke felt it was safe to add Lombok to Spring Data Rest.

UPDATE 14 (Sep 26 ’17)
As pointed out by @gavenkoa in the comments on the OPs question, JDK9 compiler support isn’t yet available. It also sounds like it’s not going to be an easy fix for the Lombok team to get around.


Go ahead and use Lombok, you can if necessary “delombok” your code afterwards http://projectlombok.org/features/delombok.html


Personally (and therefore subjectively) I’ve found that using Lombok makes my code more expressive about what I’m trying to achieve when compared to IDE/own implementations of intricate methods such as hashcode & equals.

When using

@EqualsAndHashCode(callSuper = false, of = { "field1", "field2", "field3" })

it’s much easier to keep Equals & HashCode consistent and keep track of which fields are evaluated, than any IDE/own implementation. This is especially true when you’re still adding / removing fields regularly.

The same goes for the @ToString annotation and its parameters which clearly communicate the desired behavior regarding included / excluded fields, usage of getters or field access and wether or not to call super.toString().

And again by annotating an entire class with @Getter or @Setter(AccessLevel.NONE) (and optionally overriding any divergent methods) it’s immediately clear what methods will be available for the fields.

The benefits go on and on..

In my mind it’s not about reducing code, but about clearly communicating what you desire to achieve, rather than having to figure it out from Javadoc or implementations. The reduced code just makes it easier to spot any divergent-method implementations.


I know I’m late, but I can’t resist the temptation: anybody liking Lombok should also have a look at Scala. Many good ideas that you find in Lombok are part of the Scala language.

On your question: it’s definitely easier to get your developers trying Lombok than Scala. Give it a try and if they like it, try Scala.

Just as a disclaimer: I like Java, too!


When I showed the project to my team the enthusiasm was high, so I think you should not be afraid of team response.

  • As far as ROI, it is a snap to integrate, and requires no code change in its basic form. (just adding a single annotation to your class)

  • And last, if you change your mind, you can run the unlombok, or let your IDE create these setters, getters, and ctors, (which I think no one will ask for once they see how clear your pojo becomes)


There are long-term maintenance risks as well. First, I’d recommend reading about how Lombok actually works, e.g. some answers from its developers here.

The official site also contains a list of downsides, including this quote from Reinier Zwitserloot:

It’s a total hack. Using non-public API. Presumptuous casting (knowing
that an annotation processor running in javac will get an instance of
JavacAnnotationProcessor, which is the internal implementation of
AnnotationProcessor (an interface), which so happens to have a couple
of extra methods that are used to get at the live AST).

On eclipse, it’s arguably worse (and yet more robust) – a java agent
is used to inject code into the eclipse grammar and parser class,
which is of course entirely non-public API and totally off limits.

If you could do what lombok does with standard API, I would have done
it that way, but you can’t. Still, for what its worth, I developed the
eclipse plugin for eclipse v3.5 running on java 1.6, and without
making any changes it worked on eclipse v3.4 running on java 1.5 as
well, so it’s not completely fragile.

As a summary, while Lombok may save you some development time, if there is a non-backwards compatible javac update (e.g. a vulnerability mitigation) Lombok might get you stuck with an old version of Java while the developers scramble to update their usage of those internal APIs. Whether this is a serious risk obviously depends on the project.


Lombok is great, but…

Lombok breaks the rules of annotation processing, in that it doesn’t generate new source files. This means it cant be used with another annotation processors if they expect the getters/setters or whatever else to exist.

Annotation processing runs in a series of rounds. In each round, each one gets a turn to run. If any new java files are found after the round is completed, another round begins. In this way, the order of annotation processors doesn’t matter if they only generate new files. Since lombok doesn’t generate any new files, no new rounds are started so some AP that relies on lombok code don’t run as expected. This was a huge source of pain for me while using mapstruct, and delombok-ing isn’t a useful option since it destroys your line numbers in logs.

I eventually hacked a build script to work with both lombok and mapstruct. But I want to drop lombok due to how hacky it is — in this project at least. I use lombok all the time in other stuff.


Wanted to use lombok’s @ToString but soon faced random compile errors on project rebuild in Intellij IDEA. Had to hit compile several times before incremental compilation could complete with success.

Tried both lombok 1.12.2 and 0.9.3 with Intellij IDEA 12.1.6 and 13.0 without any lombok plugin under jdk 1.6.0_39 and 1.6.0_45.

Had to manually copy generated methods from delomboked source and put lombok on hold until better times.


The problem happens only with parallel compile enabled.

Filed an issue:


i have used Lombok almost all my projects for one year but unfortunately removed it. In the beginning it was a very clean way of development but setting up the development environment for new team members is not very easy and straightforward. When it comes to a headeche i just removed it. But it is a good work and needs some more simplicity to setting up.


I have encountered a problem with Lombok and Jackson CSV, when I marshalized my object (java bean) to a CSV file, columns where duplicated, then I removed Lombok’s @Data annotation and marshalizing worked fine.


I haven’t tried using Lombok yet – it is/was next on my list, but it sounds as if Java 8 has caused significant problems for it, and remedial work was still in progress as of a week ago. My source for that is https://code.google.com/p/projectlombok/issues/detail?id=451 .


I’m not recommend it. I used to use it, but then when I work with NetBeans 7.4 it was messing my codes. I’ve to remove lombok in all of files in my projects. There is delombok, but how can I be sure it would not screw my codes. I have to spends days just to remove lombok and back to ordinary Java styles. I just too spicy…