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.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *