Biblioteca de Lombok

La biblioteca Lombok reduce la cantidad de código escrito, mejorando la legibilidad. Ejemplo de uso. Una clase regular Personcon tres campos:

public class Person {

    private String name;
    private int age;
    private Cat cat;

    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;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name) &&
                Objects.equals(cat, person.cat);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, cat);
    }

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

Lo mismo con lombok

@Data
public class Person {
    private String name;
    private int age;
    private Cat cat;
}

Eliminamos una gran cantidad de código, sin embargo, todos los métodos y modificadores permanecieron. Cómo funciona. Lombok genera código en tiempo de compilación. La propia biblioteca lombok falta en tiempo de ejecución. Su uso no aumenta el tamaño del programa. Al utilizar Lombok, nuestro código fuente no será código Java válido. Por lo tanto, deberá instalar un complemento para el IDE; de lo contrario, el entorno de desarrollo no entenderá con qué está tratando. Lombok es compatible con todos los principales IDE de Java. La integración es perfecta. Todas las funciones como "mostrar uso" e "ir a implementación" continúan funcionando como antes, llevándolo al campo/clase apropiado. Entonces, para clases simples puedes usar la anotación @Data. @Data- genera constructor, captadores, definidores, métodos equals, hashCode, toString. Para hacer que los objetos sean inmutables existe @Value. @Value- genera el constructor, solo captadores, métodos equals, hashCode, toString. Y también todos los campos privatey final.

@Value
public class Cat {
    String name;
    int age;
    Person person;
}

@WithLas anotaciones y .funcionan bien con clases inmutables @Builder.

@With
@Builder
@Value
public class Cat {
    String name;
    int age;
    Person person;
}

Si queremos cambiar el campo de un objeto inmutable, entonces necesitamos hacer un clon de este objeto con un parámetro modificado. @With- agrega métodos para cada campo que hacen una clonación del objeto con un campo modificado.

Cat anotherCat = cat.withName("vasya");

anotherCat- un nuevo objeto cuyos valores de campo son los mismos que los de cat, excepto el campo name. @Builder- genera métodos con los que inicializamos un objeto a lo largo de una cadena. Esto es conveniente cuando no queremos usar un constructor con todos los parámetros (si nuestra clase es inmutable, entonces tiene un único constructor con todos los parámetros).

Cat cat = Cat.builder()
                .name("Мурка")
                .age(3)
                .person(person)
                .build();

Llamada cíclica de métodos Si los objetos tienen comunicación bidireccional, es decir referencias entre sí, el uso de los métodos toStringgenerará equalsun hashCodeerror StackOverflowError. Porque habrá una llamada cíclica a métodos de objetos anidados. Este código generará un error:

public class Main {

    public static void main(String[] args) {
        Person person = new Person();

        Cat cat = Cat.builder()
                .name("Мурка")
                .age(3)
                .person(person)
                .build();

        person.setName("Iván");
        person.setAge(26);
        person.setCat(cat);

        System.out.println(person);
        System.out.println(cat);
    }
}

La solución al problema es interrumpir la llamada cíclica eliminando el campo del método. @ToString.Exclude- Excluir un campo en un método toString @EqualsAndHashCode.Exclude- Excluir un campo en un método equalsyhashCode

@Value
@With
@Builder
public class Cat {
    String name;
    int age;
    @ToString.Exclude
    @EqualsAndHashCode.Exclude
    Person person;
}

Un par de anotaciones más útiles @Slf4j: agrega un registrador a la clase @SneakyThrows, desactiva las excepciones marcadas

@Slf4j
public class Main {

    @SneakyThrows
    public static void main(String[] args) {
        log.info("start");
        Files.readAllBytes(Paths.get(""));
    }
}

Anota individualmente si por alguna razón solo necesitas ciertos métodos

@NoArgsConstructor //добавляет конструктор без аргументов
@AllArgsConstructor //добавляет конструктор со всеми параметрами
@RequiredArgsConstructor //добавляет конструктор для final полей
@Getter //добавляет геттеры для всех параметров класса
@Setter //добавляет сеттеры для всех параметров класса
@EqualsAndHashCode //добавляет реализации методов equals и hashCode
@ToString //добавляет реализацию метода toString
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) //делает все поля private и final

<h2>Conclusión</h2>Estas son sólo las anotaciones lombok básicas, pero son las más utilizadas y tienen el mayor efecto. Tampoco deberías dejarte llevar demasiado por la generación de código. <h2>Enlaces</h2>

• https://projectlombok.org/
• https://habr.com/ru/post/345520/