Proyecto Lombok: Reducción del código repetitivo de Java

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 repetitivas de código 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 autogenera el código de bytes para los métodos deseados en su .class archivos.

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

Configuración de Lombok

Instalación de Lombok en Eclipse

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

java -jar lombok.jar

Esto iniciará el instalador:

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’.

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

Instalación de Lombok en NetBeans

Descarga el Lombok .jar desde el sitio web oficial y agregarlo a las bibliotecas del proyecto.

Activar el plugin es tan fácil como seleccionar Project Properties -> Build - Compiling -> Enable Annotation Processing in Editor.

Instalación de NetBeans

Instalación de Lombok en IntelliJ

IntelliJ Idea hace que sea realmente fácil instalar plugins en el IDE:

• Ir File -> Settings -> Plugins y seleccione Browse Repositories
• Buscar Lombok Plugin y haga clic en Install Plugin

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

Para otros IDE, puede visitar su página de inicio y consulte la sección Instalar.

Dependencia de Lombok

Necesitamos agregar la siguiente dependencia en nuestro pom.xml:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>{version}</version>
    <scope>provided</scope>
</dependency>

Nota: El alcance es provided 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

@Getter y @Setter

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

@Getter
@Setter
public class User {

    private String name;
    private String email;
}

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

Si desea getters / setters solo para ciertos campos, anótelos en consecuencia:

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 AccessLevel argumento:

@Setter(AccessLevel.PROTECTED)
private String email;

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

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

Anotaciones de constructor

@TodosConstructor

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

@AllArgsConstructor
public class User {

    private String name;
    private String email;
}

El constructor generado se vería así:

public User(String name, String email) {
    this.name = name;
    this.email = email;
}

@NoArgsConstructor

@NoArgsConstructor generará un constructor sin argumentos:

@NoArgsConstructor
public class User {

    private String name;
    private String email;
}

El constructor generado se vería así:

public User() {}

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

@RequiredArgsConstructor

@RequiredArgsConstructor generará un constructor con todos los final campos en la clase:

@RequiredArgsConstructor
public class User {

    private final String name;
    private String email;
}

El constructor generado se vería así:

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

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

@EqualsAndHashCode

@EqualsAndHashCode se puede usar usado a nivel de clase que generará implementaciones para equals(Object other) y hashCode() métodos.

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

@EqualsAndHashCode
public class User {

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

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

@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):

@EqualsAndHashCode(onlyExplicitlyIncluded = true)
public class User {

    @EqualsAndHashCode.Include
    private String name;

    @EqualsAndHashCode.Include
    private String email;

    private Integer age;
}

@Encadenar

Similar, @ToString se puede utilizar para generar el toString() implementación. De forma predeterminada, se imprimirán todos los campos no estáticos. Puede especificar si desea incluir u omitir ciertos campos mediante una combinación de @ToString.Exclude, @ToString.Includey @ToString(onlyExplicitlyIncluded = true) justo como antes:

@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 juntos como si los hubieras apilado todos:

@Data
public class User {

    private final String name;
    private String email;
}

@Valor

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

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

@Value
public class User {

    private String name;
    private String email;
}

@Constructor

El patrón Builder es un patrón de diseño de creación 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 le permite producir automáticamente el código requerido para ello:

@Builder
@Data
public class User {

    private String name;
    private String email;
}

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

    User user = new User.UserBuilder()
        .email("[email protected]")
        .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 @Log que crea automáticamente este campo:

@Log
public class Test {

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

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

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

Se puede ver la lista completa de marcos compatibles aquí.

Escribir métodos seguros para subprocesos

En Java para aplicaciones multiproceso, usamos el synchronized palabra clave en secciones críticas del código.

Normalmente usamos un synchronized bloquear con un objeto como candado:

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 con el @Synchronized palabra clave:

public class SynchronizedExample {

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

}

Conclusión

En este artículo, proporcionamos una introducción al Proyecto Lombok y vimos cómo facilita nuestro proceso de desarrollo al reducir el código estándar 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.