Proyecto Lombok: Reducción del código estándar de Java

Lombok es una biblioteca de código abierto que se utiliza para reducir el código repetitivo en las clases de Java. Esto se logra reemplazando muchas de las piezas repetitivas de código con...

Visión general

Lombok es una biblioteca de código abierto que se utiliza para reducir el código repetitivo en las clases de Java. Esto se logra reemplazando muchas de las piezas de código repetitivas con anotaciones simples y concisas.

Lombok se inyecta a sí mismo en el proceso de compilación (a través de su proyecto/IDE) y genera automáticamente el código de bytes para los métodos deseados en sus archivos .class.

Entonces, con Lombok, puede deshacerse de todos los métodos getter y setter, hashcode y los métodos equals y muchos más simplemente agregando anotaciones.

Configuración de Lombok

Instalación de Lombok en Eclipse

Descarga el archivo .jar de Lombok desde el sitio web oficial. Ejecute el archivo lombok.jar descargado o ejecute el comando en la terminal:

1
java -jar lombok.jar

Esto iniciará el instalador:

proyecto_lombok_setup_1

Si no detectó automáticamente la ubicación de su IDE preferido, puede especificar la ubicación manualmente y luego finalizar la instalación haciendo clic en 'Instalar/Actualizar'.

proyecto_lombok_setup_2

Puede verificar si la instalación está activa o no en el cuadro de diálogo “Acerca de” de Eclipse al final del texto de derechos de autor:

proyecto_lombok_setup_3

Instalación de Lombok en NetBeans {#instalación de lombokintonetbeans}

Descarga el .jar de Lombok desde el sitio web oficial y añádelo a las bibliotecas del proyecto.

Activar el complemento es tan fácil como seleccionar Propiedades del proyecto -> Construir - Compilación -> Habilitar el procesamiento de anotaciones en el Editor.

proyecto_lombok_setup_4
[Instalación de NetBeans]{.small}

Instalación de Lombok en IntelliJ

IntelliJ Idea hace que sea muy fácil instalar complementos en el IDE:

  • Vaya a Archivo -> Configuración -> Complementos y seleccione Examinar repositorios
    project_lombok_setup_5

  • Busque Complemento Lombok y haga clic en Instalar complemento
    project_lombok_setup_6

Después de esto, simplemente reinicie el IDE y estará listo.

Para otros IDE puedes visitar su página de inicio y consultar la sección Instalar.

Dependencia de Lombok {#dependencia de lombok}

Necesitamos agregar la siguiente dependencia en nuestro pom.xml:

1
2
3
4
5
6
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>{version}</version>
    <scope>provided</scope>
</dependency>

Nota: El alcance se “proporciona” ya que Lombok es una dependencia de compilación pura y no de tiempo de ejecución. Esto significa que esperamos que la aplicación nos proporcione la dependencia del tiempo de ejecución.

Anotaciones de Lombok {#notaciones de lombokan}

@Getter y @Setter

Estas anotaciones se pueden utilizar a nivel de campo o de clase. Si se usa a nivel de clase, generará getters y setters para todos los campos de la clase:

1
2
3
4
5
6
7
@Getter
@Setter
public class User {

    private String name;
    private String email;
}

proyecto_lombok_setup_6

Como se ve en la ventana del IDE, ambos campos ahora tienen sus respectivos métodos getter y setter, aunque en realidad no los definimos nosotros mismos.

Si desea captadores/establecedores solo para ciertos campos, anótelos en consecuencia:

1
2
3
4
5
6
7
public class User {

    @Getter
    @Setter
    private String name;
    private String email;
}

Si desea cambiar el nivel de acceso de los métodos y campos generados, puede hacerlo utilizando el argumento AccessLevel:

1
2
@Setter(AccessLevel.PROTECTED)
private String email;

Hay algunos niveles de acceso que ofrece Lombok en forma de argumentos:

  • MÓDULO
  • NINGUNO (Representa no generar nada o la falta total de un método)
  • PAQUETE
  • PRIVADO
  • PROTEGIDO
  • PÚBLICO

Anotaciones de constructores {#anotaciones de constructores}

@AllArgsConstructor

El decorador @AllArgsConstructor generará un constructor público con todos los campos declarados en su clase en el mismo orden en que están definidos:

1
2
3
4
5
6
@AllArgsConstructor
public class User {

    private String name;
    private String email;
}

El constructor generado se vería así:

1
2
3
4
public User(String name, String email) {
    this.name = name;
    this.email = email;
}

@NoArgsConstructor

@NoArgsConstructor generará un constructor sin argumentos:

1
2
3
4
5
6
@NoArgsConstructor
public class User {

    private String name;
    private String email;
}

El constructor generado se vería así:

1
public User() {}

Nota: Si no se puede generar el constructor debido a la presencia de campos finales, aparecerá un mensaje de error.

@RequiredArgsConstructor

@RequiredArgsConstructor generará un constructor con todos los campos finales de la clase:

1
2
3
4
5
6
@RequiredArgsConstructor
public class User {

    private final String name;
    private String email;
}

El constructor generado se vería así:

1
2
3
public User(final String name) {
    this.name = name;
}

Nota: @NoArgsConstructor y @RequiredArgsConstructor no se pueden usar juntos y arrojarán un error de tiempo de compilación si intenta hacerlo.

@EqualsAndHashCode

@EqualsAndHashCode puede usarse a nivel de clase, lo que generará implementaciones para los métodos equals(Object other) y hashCode().

De forma predeterminada, utilizará todos los campos no estáticos y no transitorios:

1
2
3
4
5
6
7
@EqualsAndHashCode
public class User {

    private String name;
    private String email;
    private Integer age;
}

Si hay ciertos campos que no desea incluir en los métodos equals o hashCode, entonces podemos excluir esos campos específicos usando @EqualsAndHashCode.Exclude:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
@EqualsAndHashCode
public class User {

    private String name;

    private String email;

    @EqualsAndHashCode.Exclude
    private Integer age;
}

Alternativamente, podemos especificar los campos que se incluirán usando @EqualsAndHashCode.Include y @EqualsAndHashCode(onlyExplicitlyIncluded = true):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
public class User {

    @EqualsAndHashCode.Include
    private String name;

    @EqualsAndHashCode.Include
    private String email;

    private Integer age;
}

@Encadenar

De manera similar, @ToString se puede usar para generar la implementación de toString(). De forma predeterminada, se imprimirán todos los campos no estáticos. Puede especificar incluir u omitir ciertos campos usando una combinación de @ToString.Exclude, @ToString.Include y @ToString(onlyExplicitlyIncluded = true) como antes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
@ToString(onlyExplicitlyIncluded = true)
public class User {

    @ToString.Include
    private String name;

    @ToString.Include
    private String email;

    private Integer age;
}

@Datos

Es común tener todas las anotaciones antes mencionadas en su POJO. En lugar de escribir una anotación para cada uno de ellos, Lombok proporcionó una anotación agregada @Data.

Esto agrupa las características de @Getter/@Setter, @EqualsAndHashCode, @ToString y @RequiredArgsConstructor como si las hubiera apilado todas:

1
2
3
4
5
6
@Data
public class User {

    private final String name;
    private String email;
}

@Valor

A veces quieres que tu objeto sea inmutable después de su creación. @Value es una variante inmutable de @Data y se usa exactamente para este propósito.

De forma predeterminada, todos los campos se hacen definitivos y no se crean setters:

1
2
3
4
5
6
@Value
public class User {

    private String name;
    private String email;
}

@Constructor

The Builder Pattern es un patrón de diseño creativo que se utiliza para ayudar a construir objetos paso a paso.

Como ya sabrá, si bien el patrón del constructor le permite crear instancias de objetos de una manera más detallada y limpia que con los constructores, el código subyacente necesario para implementar el patrón es bastante complicado.

@Builder te permite producir automáticamente el código requerido para ello:

1
2
3
4
5
6
7
@Builder
@Data
public class User {

    private String name;
    private String email;
}

Ahora puede crear el objeto Usuario utilizando el patrón Builder sin todo el código necesario para admitirlo:

1
2
3
4
5
6
    User user = new User.UserBuilder()
        .email("[correo electrónico protegido]")
        .name("test name")
        .build();

    System.out.println(user.getEmail());

Inicio sesión

Es común usar registradores en nuestra aplicación y, por lo general, necesitamos inicializar una variable de registro en la parte superior de la clase y luego usarla en nuestros métodos.

Esto se puede lograr con @Log que crea automáticamente este campo:

1
2
3
4
5
6
7
@Log
public class Test {

    public static void main(String[] args) {
        log.severe("Log message");
    }
}

@Log crea una variable de registro con un objeto java.util.logging.Logger.getLogger(LogExample.class.getName()).

Lombok también es compatible con otros marcos de registro, que pueden ser utilizados por anotaciones como @Log4j, @Slf4j, etc.

La lista completa de frameworks soportados se puede ver aquí.

Métodos seguros para subprocesos de escritura {#métodos seguros para subprocesos de escritura}

En Java para aplicaciones de subprocesos múltiples, usamos la palabra clave synchronized en las secciones críticas del código.

Normalmente usamos un bloque sincronizado con un objeto como candado:

1
2
3
4
5
6
7
8
9
public class SynchronizedJavaExample {
    private static final Object lock = new Object();

    public static void test() {
        synchronized (lock) {
            System.out.println("test");
        }
    }
}

Esto se puede generar automáticamente usando la palabra clave @Synchronized:

1
2
3
4
5
6
7
8
public class SynchronizedExample {

    @Synchronized
    public static void test() {
        System.out.println("test");
    }

}

Conclusión

En este artículo, brindamos una introducción al Proyecto Lombok y vimos cómo facilita nuestro proceso de desarrollo al reducir el código repetitivo con anotaciones simples. Esto mejora drásticamente la legibilidad y la brevedad.

El código de los ejemplos utilizados en este artículo se puede encontrar en Github.

Licensed under CC BY-NC-SA 4.0