Thank you for unblocking ads; your support allows us to continue delivering free, high-quality content that truly matters to you.

Java • Avoid Getters & Setters Methods With Lombok



This article provides an overview of how to avoid the repetitive code associated with writing getter and setter methods in Java classes using Lombok. By using Lombok’s annotations, such as @Getter and @Setter, developers can generate these methods automatically, thereby reducing the amount of boilerplate code required in their classes. The article highlights the benefits of using Lombok to simplify code and improve readability, and provides a step-by-step guide on how to integrate Lombok into a Java project. Overall, the article presents a useful tool for developers looking to streamline their code and improve their productivity.

Java Getters and Setters

What issue are we trying to solve?

The use of getters and setters to encapsulate the data and methods of an object is a fundamental design pattern in object-oriented programming.

The use of getters and setters in object-oriented programming is a common implementation of the encapsulation principle, which is a fundamental design pattern in object-oriented programming. Encapsulation is often implemented using the Accessor and Mutator design pattern, where getters and setters are used to control access to an object’s properties.

The use of Accessor and Mutator design pattern has several advantages. It promotes good design practices such as information hiding, abstraction, and decoupling of implementation details from the user of the class. It also enables the implementation of the principle of least privilege, which restricts access to sensitive data or operations to only authorized code, and helps maintain the integrity of an object’s internal state.

Getters and Setters Are Long and Repetitive

Getters and setters can be an effective tool for encapsulating an object’s internal state and controlling access to it, as long as they are used judiciously and with good design principles in mind. However, overuse of getters and setters can make the code more verbose and less readable. For example, if a class has many properties that require getters and setters, the class definition can become long and repetitive, which can make it harder to understand and modify the code.

An example in Java of a simple data access object (DAO) class that uses getters and setters to encapsulate the data of a user:

Code Example #1. UserDao with Getters and Setters

public class UserDAO {
    private String username;
    private String password;
    // Getters
    public String getUsername() {
        return username;
    public String getPassword() {
        return password;
    // Setters
    public void setUsername(String username) {
        this.username = username;
    public void setPassword(String password) {
        this.password = password;

In this example, the UserDAO class has two private instance variables username and password. The class provides public getter and setter methods for these variables to control access to them.

The getter methods getUsername() and getPassword() return the values of the username and password variables, respectively. The setter methods setUsername(String username) and setPassword(String password) set the values of the username and password variables, respectively.

Using these getter and setter methods, other classes can access and modify the username and password variables of a UserDAO object, while the UserDAO class can maintain control over how these variables are accessed and modified, ensuring that its internal state is consistent and valid.

The example code only has two properties, but envision a Data Access Object with 10+ properties or more, and you’ll see the growing pains. The long and repetitive series of getter and setter methods can make your code hard to read and maintain.

Eliminating Repetitive Code with Lombok

Lombok can solve the issue of verbose and repetitive (boiler plate) code in Java classes by generating getters and setters automatically through its annotations. Instead of manually defining getter and setter methods for each class property, developers can simply annotate the class with @Getter and/or @Setter, and Lombok will generate the necessary methods at compile-time.

What is Project Lombok?

Project Lombok is a Java library that provides annotations to automate common tasks performed in Java code, such as generating getters and setters, constructors, toString() and equals() methods, and more. It eliminates boilerplate code and simplifies the development process by generating code at compile-time instead of writing it by hand.

With Lombok, The UserDao can then be represented in Code as

As you can see, the getters and setters for the username and password properties are manually defined in Code Example #1. The approach in that example can become repetitive and tedious when working with larger classes or when many properties need to be accessed or modified.

By using Lombok’s annotations, we can eliminate this repetitive code and make our classes more concise and readable as shown in the example below.

Code Example #2. UserDao using Lombok

import lombok.Getter;
import lombok.Setter;

public class UserDao {
    private String username;
    private String password;

Did we really eliminate the repetitive getter and setter methods?

While Lombok’s annotations can help eliminate the repetitive code of getter and setter methods visually, the underlying code still exists, but is generated at compile time by Lombok. The generated code is hidden from the developer’s perspective, but it is still present in the compiled bytecode of the program.

What is an Annotation Processor in Java?

Lombok uses an annotation processor to generate code automatically at compile-time. When you annotate your Java classes with Lombok annotations, such as @Getter, @Setter, @NoArgsConstructor, etc., the Lombok annotation processor generates the corresponding methods or constructors based on the properties of the annotated class.

During the compilation process, the Java compiler sends the Lombok annotations to the Lombok annotation processor, which analyzes them and generates the necessary code for the annotated classes. The generated code is then compiled along with the original source code to produce the final bytecode.

Lombok’s annotation processing mechanism helps to reduce the amount of boilerplate code in Java classes, making them more concise and easier to read.

Enhanced Developer Experience

A user can use tools like Maven or an ide like IntelliJ or Visual Studio Code with the use of plug-ins to de-Lombok a piece of code. Doing so will render a code similar to Code Example #1.

What if I’m using an IDE? Will the Getters and Setters Show Up?

Plainly without using an Integrated Development Environment (IDE) or Editor plugins, the development environment of choice will not be able to recognize Lombok’s Java Annotations by default. This experience can be enhanced by installing a Lombok plugin.

In Conclusion

We’ve discussed the concept of getters and setters in object-oriented programming, their benefits and drawbacks, and how Lombok can help simplify the code associated with them. While getters and setters can provide an effective means of controlling access to an object’s internal state, they can also make the code more verbose and harder to read.

Lombok’s annotations provide an efficient way to generate these methods automatically, thereby reducing the amount of repetitive code and making Java classes more concise and readable. By adopting Lombok in their Java projects, developers can streamline their code, improve their productivity, and focus on the core business logic of their applications.

Lombok • The Good, The Bad, and The Ugly
Within the Java development community, Lombok often emerges as a polarizing subject. This library’s chief aim is to minimize the tedium of boilerplate code—a persistent thorn in the side of many Java developers. Nevertheless, every tool brings its own concessions to the table.
Lombok • @Value Annotation Best Practices
When it comes to clean coding and enhanced testability in Java applications, Project Lombok is a game-changer. Its @Value annotation not only simplifies your code but also enhances its readability, maintainability, and testability.
Lombok • @Data Annotation Best Practices
When it comes to clean and efficient Java coding, the power of Project Lombok cannot be overstated. Specifically, the @Data annotation provided by Lombok stands out as a valuable tool for Java developers.
Cleaner Code and Enhanced Testability: Harnessing the Power of Lombok Builders
In the realm of Java development, the quest for cleaner code and improved testability is ever-present. One formidable ally in this quest is Project Lombok, a mature library that revolutionizes the way Java developers handle boilerplate code.
Lombok val vs var
Lombok has gained immense popularity among Java developers for its ability to simplify coding practices by reducing boilerplate code. In the vast ocean of features offered by Lombok, two features stand out: val and var. In this deep dive, we’ll uncover the secrets of these two variables and demonstrate their utility.
Lombok Test Coverage
When it comes to software development, testing plays a crucial role in ensuring the quality and reliability of the codebase. Test coverage, in particular, is a metric that measures the extent to which the source code of a program has been tested.
Lombok Disadvantages
In the world of Java development, optimizing code efficiency and reducing boilerplate is a constant pursuit. To address these challenges, various tools and libraries have emerged, and one such popular option is Lombok—a Java library that offers annotations for code generation, resulting in benefits such as time-saving and code simplification. However, as with any tool, there are both advantages and drawbacks to consider.
Lombok @Singular Annotation
Lombok is a Java library that provides a set of annotations and utility classes to reduce boilerplate code in Java projects. One of its popular annotations is @Singular, which generates builder methods for collections.
Lombok • @AllArgsConstruct vs @RequiredArgsConstructor
What is the difference between @AllArgsConstruct and @RequiredArgsConstructor in Lombok? The main difference between @AllArgsConstructor and @RequiredArgsConstructor is in the fields that are included in the generated constructor.
Lombok • How to Use Constructor
To use the constructor with Lombok, you can annotate your class with @AllArgsConstructor or @RequiredArgsConstructor. @AllArgsConstructor generates a constructor that takes in all the fields in the class as arguments, while @RequiredArgsConstructor generates a constructor that takes in only the final or @NonNull fields as arguments.
Lombok • An Overview
Lombok is a Java library that provides annotations to help reduce boilerplate code and increase developer productivity. By using Lombok annotations, Java developers can automatically generate common code such as getters, setters, constructors, equals and hashCode methods, and more.
Lombok • Exclude Generated Code From Test Coverage
When using Lombok in a Java project, the library generates code at compile-time, such as getters, setters, constructors, equals and hashCode methods, and more.
Lombok • Using @With Annotation to Clone Immutable Objects
Using Lombok’s @With Annotation to Clone Immutable Objects is a beneficial feature that helps developers minimize code replication and ceremonial code. It is the next best alternative to Copy Constructs in object-oriented programming. The @With annotation also requires @AllArgsConstructor to function correctly.
Lombok • Builders and Copy Constructors
Lombok’s builder and copy constructor feature using @Builder is a mechanism that allows the implementation of the Builder Pattern and Copy Constructors in Object-Oriented Programming. This article further illustrates how Lombok mitigates the disadvantages of creating builder methods and copy constructors making Lombok’s @Builder a good foundation for design and code maintainability.