Lombok project in Java

Introduction

Lombok is a library that acts as an annotation processor for Java, designed to eliminate redundancy in the code. Its main function is to automate the generation of repetitive code or "boilerplate" - those elements that, although necessary, do not add direct value to the logic of our program. Mainly, it is used for the automatic generation at compile time of getter and setter methods, constructors, equals(), hashCode(), toString() methods, among other common elements in Java classes.

Instead of manually writing dozens of lines of code for these basic functions, Lombok allows you to define them using simple annotations, resulting in cleaner, more maintainable, and less error-prone code.

Facility

To use Lombok in a Java project, it is necessary to add the corresponding dependency in the pom.xml file (in case of a Maven project) or build.gradle (in case of a Gradle project), in addition to installing the corresponding plugin in the IDE we are using. During this post, we will use Maven and IntelliJ IDEA as an example.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

In case of any doubt you can always check the official documentation of Lombok:

• Lombok with Maven
• Lombok in IntelliJ IDEA

@data

When we create a class we regularly perform the following actions, either manually or with a shortcut provided by our IDE:

• Encapsulate attributes and generate their getter and setter methods
• Generate an empty constructor and another that receives all attributes
• Implement the equals(), hashCode() and toString() methods

Well, Lombok has the @Data annotation that allows us to do all this in a single line, generating everything related to the POJO (Plain Old Java Objects). This annotation is a combination of the @Getter, @Setter, @EqualsAndHashCode, @NoArgsConstructor and @AllArgsConstructor annotations which we will see later.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@NoArgsConstructor, @AllArgsConstructor and @RequiredArgsConstructor

These annotations allow us to automatically generate constructors with different combinations of arguments, considering that the attributes are used according to the order in which they were declared in the class.

• @NoArgsConstructor: Generates a constructor without arguments (empty), if it is not possible to generate one, an exception will be thrown, to avoid this just use the annotation as follows @NoArgsConstructor(force = true).
• @AllArgsConstructor: Generates a constructor with all the attributes of the class as arguments.
• @RequiredArgsConstructor: Generates a constructor for all final fields and/or marked with the @NonNull annotation.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@Getter and @setter

These annotations allow us to generate the getter and setter methods automatically for all the attributes of the class, or only for those that are marked with the corresponding annotation, that is, they can be used at the class or attribute level.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@ToString

This annotation generates the toString() method automatically, which returns a string representation of the class and its attributes with the following format: ClassName(attribute1=value1, attribute2=value2, ...). By default all non-static attributes of the class are included in the result, but specific attributes can be excluded using the @ToString.Exclude attribute. In case you only want to display the value of the attribute and not the name as declared, you can use @ToString(includeFieldNames = false).

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persona {
    private String nombre;
}

@EqualsAndHashCode

Allows you to generate the equals() and hashCode() methods from all the attributes of the class. If you want to exclude or include an attribute, you can do so using the annotation @EqualsAndHashCode.Exclude and @EqualsAndHashCode.Include respectively.

import lombok.*;

@Getter
@Setter
public class Persona {
    private String nombre;
    private String apellido;
}

@Value

Previously in Java to create an immutable class it was necessary to carry out a series of steps, such as making the class and/or attributes be of the final type, and that the setter methods will not be generated. Lombok makes it easy for us to create immutable classes using the @Value annotation, which combines the @Getter, @ToString, @EqualsAndHashCode and @AllArgsConstructor annotations to generate an immutable class. All attributes are marked as private final and setter methods are not generated. It is the immutable variant of @Data.

import lombok.*;

public class Persona {
    @Getter @Setter
    private String nombre;
    private String apellido;
}

In recent versions of Java this annotation loses meaning compared to the use of Records, since they have the same purpose, and it is more practical to use records. If you are interested in knowing more about this topic, there are more posts on the blog about records.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@val

This annotation allows us to declare a variable as final and automatically infer its data type, that is, it is not necessary to specify the data type of the variable, Lombok takes care of inferring it. It is useful in case the variable data type is very long or complex, this way you avoid repeating it.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

This annotation may lose meaning if we directly use final var or simply var for type inference, which is more convenient since it is a characteristic of the language. If you are interested in knowing more about this, you can consult the following post

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@var

It works exactly the same as @val, but it does not declare the variable as final, it simply infers its type. It is necessary to consider the concept of type inference, since you cannot declare something of type String and because it is not final to want to assign it a value of type int. Again, this annotation is replaced by var in recent versions of Java.

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persona {
    private String nombre;
}

@NonNull

This annotation can be used on class attributes and parameters of a method, it basically indicates that the value of an attribute cannot be null, in case an attempt is made to assign a null value to an attribute marked with @NonNull it will be thrown a NullPointerException, that is, if (param == null) throw new NullPointerException("param is marked non-null but is null"); is used. Regardless of the exception it generates, its use is more visible within the IDE itself, since it will indicate to us in some way that this value cannot be null.

import lombok.*;

@Getter
@Setter
public class Persona {
    private String nombre;
    private String apellido;
}

@Cleanup

This annotation allows us to ensure that any resource that uses it if it has a close() method or that implements the AutoCloseable or Closeable interfaces is automatically closed at the end of the code block in which it is located. It is useful in case of working with resources that need to be released, such as files, connections to databases, etc.

import lombok.*;

public class Persona {
    @Getter @Setter
    private String nombre;
    private String apellido;
}

This result can be obtained manually if we use a try with resources.

import lombok.*;

@AllArgsConstructor
@ToString
public class Persona {
    private String nombre;
    @ToString.Exclude
    private String apellido;
}

// Output: Persona(nombre=Maria)

@builder

This annotation allows us to generate a design pattern Builder automatically, that is, an object that allows us to build complex objects step by step, so that different attributes of an object can be configured without having to call a constructor with many parameters. It is useful in case a class has many attributes and we do not want to have a constructor with many parameters.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@With

This annotation allows us to create a method that returns a copy of the current object with a modified attribute, that is, it generates a method withAttributeName(Object object) that allows us to create a copy of the current object with the object attribute modified by the value that we pass as an argument. It is useful in case we want to modify an attribute of an object without modifying the original object.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

Up to this point we have seen some of the annotations that can be used most frequently, each of these may or may not accept additional configurations, likewise there are others that are marked as experimental, in any case It is important to consult the official documentation to get the most out of all the features that Lombok offers us and the advantages regarding repetitive code generation.

The above is the detailed content of Lombok project in Java. For more information, please follow other related articles on the PHP Chinese website!