Anotaciones. La segunda parte. lombok

Anotaciones. Primera parte, un poco aburrida En esta parte, decidí tocar la biblioteca de Lombok como un conocido representante de las anotaciones fuente. Con anotaciones en tiempo de ejecución en el próximo artículo. Érase una vez un programador de Java, todos los días escribía código normal, por ejemplo este:

package lombok;

public class Chelovek {
    private String name;
    private int age;

    public Chelovek(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Chelovek() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Chelovek chelovek = (Chelovek) o;

        if (age != chelovek.age) return false;
        return name != null ? name.equals(chelovek.name) : chelovek.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Chelovek{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Esta es una clase típica con solo 2 campos (pero a veces hay más de 10 a 15 campos). Sí, claro, todo esto se puede generar en el IDE, pero joder, ocupa espacio. Si hay entre 15 y 20 campos, todos necesitan captadores, definidores, constructores... Entre todo esto, un par de métodos más que son invisibles a la vista pueden perderse fácilmente. ¿Cómo puedo ayudar a un programador así a escribir más rápido y menos? Lombok. Directo al calor, la misma clase pero usando Lombok:

package lombok;

@Data
public class Chelovek {
    private String name;
    private int age;
}

Sí, eso es todo. ¿Fresco? ¿ Qué hará la anotación @Data ? En la etapa de compilación, generará captadores/definidores para todos los campos, toString y redefinirá iguales y hashCode de acuerdo con los estándares. Puede instalar un complemento en el IDE y verá todos los métodos que aún no se han creado. Espero que usted, el lector, lo haya encontrado interesante, porque lo que sigue es una breve introducción y enlaces a detalles. Lombok también brinda la oportunidad de personalizar la generación; no siempre es necesario generar todos los captadores, definidores o códigos hash de manera diferente. Por lo tanto, hay anotaciones separadas (creo que muchas de ellas no necesitan descripción) @Getter/@Setter @ToString @EqualsAndHashCode @NoArgsConstructor, @RequiredArgsConstructor y @AllArgsConstructor @Log Estas son las más típicas, se puede ver el conjunto completo aquí var y val merecen especial atención. Es posible escribir así:

package lombok;

import lombok.experimental.var;

@Data
public class Chelovek {
    private String name;
    private int age;

    public static void main(String[] args) {
        var chelovek = new Chelovek();
        chelovek.setAge(22);
        System.out.println(chelovek);
    }
}

¿Por qué es esto necesario? Por ejemplo, tenemos la clase RandomAccessFileChannel, bueno, ¿por qué necesitamos escribirla así?

RandomAccessFileChannel channel = new RandomAccessFileChannel();

Si es posible así:

var channel2 = new RandomAccessFileChannel();

En mi opinión, esto no siempre es aceptable. Por ejemplo, tenemos un método malvado que devuelve un mapa malvado:

public static Map<List<Set<Integer>>, Set<List<String>>> evilMap(){
    return new HashMap<>();
}

si lo llamas así:

Map<List<Set<Integer>>, Set<List<String>>> listSetMap = evilMap();

Está más o menos claro con qué estamos trabajando. Si la llamada es así:

var listSetMap = evilMap();

entonces, ¿quién diablos sabe qué devuelve evilMap(), y hasta que mires el método en sí, no lo sabrás? ¿Por qué molestarse en revisar las fuentes? En general, hay que tener más cuidado con esto. Hilo experimental: Aquí me gustaría señalar las anotaciones: @UtilityClass Crea un constructor privado y lanza una excepción allí (para que las manos sucias por la reflexión no entren aquí). Y muy bien al inicio de la clase nos dice que existen métodos de utilidad. @Delegate Implementa el patrón de delegación. Si tiene una clase que delega algo a otra clase, mientras realiza cambios solo en algunos métodos, esta anotación le evitará duplicar métodos y realizará un seguimiento de ellos. Si se elimina o agrega un método, ella lo notará. Hilo de anotaciones experimentales GITHUB Sitio web oficial Para que el IDE funcione normalmente con lombok y no resalte métodos como inexistentes, debe instalar el complemento. En el sitio web oficial hay una sección de configuración donde puedes ver cómo conectar el complemento para cada IDE. Como puedes ver, Lombok es popular. >5000 estrellas y >1000 horquillas. Spring usa lombok en sus clases. Si tienes un resorte en tu proyecto, mira, tal vez sacó el lombok, simplemente no lo sabes.