Java is known for its verbosity, especially when dealing with repetitive boilerplate code like getters, setters, constructors, and toString methods. While necessary, this clutter can slow down development and make code harder to read and maintain. Project Lombok steps in to solve this problem by automatically generating boilerplate code at compile time.
In this guide, we’ll dive deep into why Lombok is a must-have tool in Java, how to set it up, and take a look behind the scenes to understand how Lombok uses annotation processing to map and modify Java’s Abstract Syntax Tree (AST), making sure our code is concise without sacrificing functionality.
Why Do We Need Lombok?
Java requires a significant amount of boilerplate code. Consider a simple POJO that includes fields, a constructor, getters, setters, and a toString method:
public class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{name='" + name + "', age=" + age + '}';
}
}
This is manageable for a small project, but as applications scale, the boilerplate can quickly become overwhelming.
The Solution: Lombok
With Lombok, we can avoid all this repetitive code. Here’s how the same class looks with Lombok:
import lombok.Data;
@Data
public class User {
private String name;
private int age;
}
With just one annotation, Lombok generates the getters, setters, toString, equals, and hashCode methods, making the code cleaner and easier to maintain.
How to Set Up Lombok
Step 1: Adding Lombok Dependency
To use Lombok in a Maven project, add this dependency to pom.xml:
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.28</version>
<scope>provided</scope>
</dependency>
For Gradle:
compileOnly 'org.projectlombok:lombok:1.18.28'
annotationProcessor 'org.projectlombok:lombok:1.18.28'
Step 2: IDE Setup
Make sure your IDE has the Lombok plugin installed. In IntelliJ IDEA:
1. Go to Settings > Plugins.
2. Search for Lombok.
3. Install the Lombok plugin.
4. Enable annotation processing under Settings > Build, Execution, Deployment > Compiler > Annotation Processors.
How Lombok Works: Behind the Scenes
The Power of Annotation Processing
Lombok uses Java Annotation Processors to interact with the Java Abstract Syntax Tree (AST). Annotation processors analyze and potentially modify the code’s structure during the compilation process. Lombok’s annotation processor leverages this to generate methods like getters, setters, and toString, among others, by inserting them directly into the AST before the code is compiled.
Understanding the Abstract Syntax Tree (AST)
The AST is an internal representation of the code, breaking down the source into a structured tree that the compiler can process. When you write Java code, each element (like classes, fields, methods) is mapped to a node in the AST.
When Lombok’s annotation processor encounters a class with Lombok annotations, it modifies the AST nodes to add methods directly into the tree. This means the boilerplate methods are generated during compilation and are not part of the source code. By the time the code compiles, it has been augmented with all necessary methods, which is why they work seamlessly.
Timing: When and How Lombok Generates Code
Lombok’s annotations are processed during the compilation phase, between parsing the Java source code and generating bytecode. Here’s the step-by-step process:
1. AST Creation: The compiler reads the Java source code and generates the AST.
2. Annotation Processing: Lombok’s annotation processor scans the AST for Lombok annotations.
3. AST Manipulation: When an annotation like @Getter or @Setter is found, Lombok adds nodes to the AST to represent the corresponding methods.
4. Bytecode Generation: The modified AST is used to generate the final bytecode, which includes the methods added by Lombok.
As a result, when you run your code, the getters, setters, and other methods appear as if they were part of the original source code, even though they were added at compile time.
Lombok Annotations Explained
-
@Getterand@Setter
These annotations generate getter and setter methods for your fields, effectively saving you the effort of writing them yourself.
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class User {
private String name;
private int age;
}
@ToString
@ToString generates a toString method that includes all fields by default, with the option to exclude specific fields.
import lombok.ToString;
@ToString(exclude = „password“)
public class User {
private String name;
private int age;
private String password;
}
@EqualsAndHashCode
Generates equals and hashCode methods. These methods are essential for comparing objects and using them in collections like HashMap or HashSet.
import lombok.EqualsAndHashCode;
@EqualsAndHashCode
public class User {
private String name;
private int age;
}
@NoArgsConstructor, @AllArgsConstructor, and @RequiredArgsConstructor
These annotations generate constructors with different parameter options.
• @NoArgsConstructor: No-argument constructor.
• @AllArgsConstructor: Constructor with parameters for all fields.
• @RequiredArgsConstructor: Constructor for fields marked final or @NonNull.
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
@RequiredArgsConstructor
public class User {
private final String name;
private int age;
}
@Data
Combines @Getter, @Setter, @ToString, @EqualsAndHashCode, and @RequiredArgsConstructor.
import lombok.Data;
@Data
public class User {
private String name;
private int age;
}
@Builder
Implements the builder pattern, which is especially useful for constructing complex objects with multiple parameters.
import lombok.Builder;
@Builder
public class User {
private String name;
private int age;
}
Usage:
User user = User.builder()
.name("John Doe")
.age(30)
.build();
@Slf4j (Logging)
Provides an SLF4J Logger instance, simplifying logging setup.
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class UserService {
public void createUser() {
log.info("User is being created");
}
}
Lombok in Spring Boot Applications
Lombok’s features are particularly useful in Spring Boot applications, where boilerplate code can easily accumulate in services, repositories, and models. Here’s an example of using Lombok in a Spring Boot service:
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
@RequiredArgsConstructor
public class UserService {
private final UserRepository userRepository;
public void saveUser(User user) {
log.info("Saving user: {}", user);
userRepository.save(user);
}
}
In this example:
• @RequiredArgsConstructor generates a constructor for userRepository, which Spring Boot uses for dependency injection.
• @Slf4j adds a logger, so we don’t need to manually define a logging instance.
Conclusion
Lombok is an invaluable tool for Java developers. It significantly reduces boilerplate code, keeps classes clean, and enhances productivity. By using annotation processing to manipulate the AST, Lombok injects methods directly during compilation, ensuring code conciseness without compromising on functionality.
When combined with Spring Boot, Lombok streamlines development even further. Annotations like @Data, @Builder, and @Slf4j provide a powerful way to write clean, maintainable code that’s easy to extend and debug.
If you’re working in Java, Lombok is a must-have in your toolkit. Why write more code than necessary when Lombok can handle it?
Top comments (2)
I recommend to use records instead of Lombok...
Of course, but only for Java 16+ . Some legacy code base and more customisation Lombok is the solution. It’s always nice to get more than one solution I think. I will also write about Records, as it is nativ to java. :)