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

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. In this article, we’ll delve into the best practices for utilizing the @Value annotation in your Java projects, providing detailed examples and insights to help you master this powerful feature.

Embed from Getty Images

The Significance of @Value Annotation in Java Applications

The @Value annotation in Java Applications serves as a crucial tool in significantly reducing boilerplate code. As a class-level annotation, its primary role is to automatically transform all fields in a class to final, subsequently generating getter methods for each field and promoting a clean, immutable design pattern. In addition to these functionalities, @Value furnishes the class with essential equals and hashCode methods, as well as an all-args constructor, thereby establishing a strong foundation for any robust Java application.

It is pivotal to underscore the fact that @Value is strictly a class-level annotation and is not designed to be utilized at the field level. Consequently, annotating a class with @Value implies that all fields within said class are implicitly treated as final, with the corresponding getter methods being automatically generated. For scenarios where mutable fields are required within a @Value annotated class, developers are afforded the flexibility to selectively employ the @Setter annotation on specific non-final fields. This strategic approach effectively balances the dichotomy between immutability and mutability in accordance with the application’s unique requirements.

The @Value annotation is integral to the Java development ecosystem as it proficiently facilitates the generation of final fields replete with getter methods, alongside equals and hashCode methods, and an indispensable all-args constructor.

When the @Value annotation from Lombok is leveraged, it significantly champions the cause of immutability by intrinsically transforming annotated fields to final. This attribute is foundational in cementing the immutability of a class.

In the realm of Java, immutability is synonymous with the restriction placed on altering an object’s state post-instantiation. This restriction is paramount for a host of practical applications, ranging from bolstering thread safety and augmenting code readability to streamlining the testing process.

Consider the following example:

public class Product {
  String name;
  double price;

In this illustrative example, Lombok diligently generates all requisite getter methods, an all-args constructor, as well as equals and hashCode methods for the Product class. This automation not only purifies the code but also significantly enhances its testability by mitigating the volume of code that necessitates maintenance and testing.

It’s pertinent to note that the @Value annotation is fundamentally a stereotype, encapsulating a suite of annotations, as illustrated below:

@FieldDefaults(makeFinal=true, level=AccessLevel.PRIVATE) 
public class Product {
    String name;
    double price;

Here’s the equivalent source code for the Product class after running delombok, which removes the Lombok annotations and generates the boilerplate code that Lombok would create during compilation:

public final class Product {
    private final String name;
    private final double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;

    public String getName() {
        return this.name;

    public double getPrice() {
        return this.price;

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        if (!(o instanceof Product)) {
            return false;
        final Product other = (Product) o;
        if (!other.canEqual((Object) this)) {
            return false;
        final Object this$name = this.getName();
        final Object other$name = other.getName();
        if (this$name == null ? other$name != null : !this$name.equals(other$name)) {
            return false;
        if (Double.compare(this.getPrice(), other.getPrice()) != 0) {
            return false;
        return true;

    public int hashCode() {
        final int PRIME = 59;
        int result = 1;
        final Object $name = this.getName();
        result = result * PRIME + ($name == null ? 43 : $name.hashCode());
        final long $price = Double.doubleToLongBits(this.getPrice());
        result = result * PRIME + (int) ($price >>> 32 ^ $price);
        return result;

    protected boolean canEqual(Object other) {
        return other instanceof Product;

    public String toString() {
        return "Product(name=" + this.getName() + ", price=" + this.getPrice() + ")";

The provided Java code is a representation of the Product class after utilizing the delombok tool, which effectively eradicates Lombok annotations and manifests the implicit boilerplate code Lombok generates during the compilation phase. This delombok version of Product includes explicitly defined final fields name and price, a parameterized constructor, getter methods for each field, and the necessary equals, hashCode, and toString methods that collectively facilitate the object’s proper functioning and interaction within Java’s ecosystem.

How to Implement @Value Annotation in Your Project

To use the @Value annotation in your Java applications, you first need to add Lombok as a dependency to your project. If you are using Maven, add the following to your pom.xml file:

    <version>1.18.30</version> <!-- use the latest version -->

After adding the dependency, you can now use the @Value annotation in your classes.

Best Practices for Using @Value Annotation

Here are some best practices you should follow when using the @Value annotation in your Java applications:

Use @Value for Immutable Classes

The @Value annotation is the perfect tool for creating immutable classes in Java, ensuring that once an object of the class is instantiated, its state remains constant and unalterable.

One of the greatest advantages of using the @Value annotation in Lombok is that it inherently treats all fields as final, eliminating the need for developers to explicitly declare them as such. This not only streamlines the coding process but also ensures that immutability is maintained, as fields cannot be modified once the object has been created.

By leveraging the @Value annotation, developers can easily adhere to best practices for immutable class design in Java, resulting in cleaner, more maintainable, and robust code.


public class Customer {
  String name;
  int age;

In this example, the Customer class is immutable as all fields are final, and the @Value annotation will generate the necessary methods.

Avoid Using @Value with @Data

Both @Value and @Data are Lombok-specific annotations that generate getter and setter methods, among other things. However, @Data generates setter methods that can modify the state of the object, which contradicts the purpose of @Value for creating immutable objects. Therefore, avoid using @Value with @Data.

Test Generated Methods

Even though @Value generates getter methods, equals and hashCode methods, and an all-args constructor, it is crucial to thoroughly test these methods to verify that they are functioning as intended.

Consider a scenario in which you have a Cart class that contains a list of Product objects:

public class Cart {
    List<Product> products;

Each Product is defined as follows:

public class Product {
    String name;
    double price;

Testing the equals and hashCode methods is of paramount importance, especially when dealing with collections that rely on these methods, such as HashSet. In this example, adding a Product to a HashSet should not allow duplicates. This is where the equals and hashCode methods come into play, as they are used to determine whether two objects are the same.

Here is an example of how you can test the equals and hashCode methods for the Product class:

public void testEqualsAndHashCode() {
    Product product1 = new Product("Apple", 1.0);
    Product product2 = new Product("Apple", 1.0);
    Product product3 = new Product("Banana", 2.0);

    assertEquals(product1, product2);
    assertNotEquals(product1, product3);

    Set<Product> products = new HashSet<>();
    products.add(product2); // Should not add to set since product1 equals product2

    assertEquals(2, products.size()); // Should be 2 since product1 and product2 are the same

This test case verifies that the equals method is working correctly by asserting that product1 equals product2 but not product3. Additionally, it tests the hashCode method by adding the products to a HashSet and asserting the correct size of the set. If the equals and hashCode methods are not functioning properly, the test will fail, thus highlighting any potential issues that need addressing.

Omit Lombok Synthesized Files from Code Coverage Metrics

In scenarios where Lombok is employed, it becomes imperative to omit the files synthesized by Lombok from your code coverage metrics, given that these files do not form a part of your application’s core business logic. With Maven, a configuration can be established within your code coverage plugin to specifically exclude files generated by Lombok. A pertinent example in this regard would be the integration of the JaCoCo Maven plugin, as illustrated below:

  <!-- other plugins -->
    <version>0.8.10</version> <!-- use the latest version -->
        <exclude>**/Product.class</exclude> <!-- exclude the Lombok generated class -->

In Conclusion

The @Value annotation in Project Lombok stands as a testament to the potential for refined quality within your Java Applications. This feature is instrumental in propelling your code towards a paradigm of clarity and heightened testability. By diligently adhering to the best practices delineated in this comprehensive guide, you are poised to unlock the immense potential harbored by this powerful annotation. The end result is a metamorphosis of your Java code, transforming it into a more efficient, intelligible, and effortlessly maintainable entity, thereby significantly amplifying the overall effectiveness and robustness of your software development endeavors.

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 • @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.
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.
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.