Biblioteca di Lombok

La libreria Lombok riduce la quantità di codice scritto, migliorando la leggibilità. Esempio di utilizzo. Una classe normale Personcon tre campi:

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

Stessa cosa con Lombok

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

Abbiamo rimosso un sacco di codice, tuttavia, tutti i metodi e i modificatori sono rimasti. Come funziona. Lombok genera codice in fase di compilazione. La stessa libreria lombok manca in fase di esecuzione. Il suo utilizzo non aumenta le dimensioni del programma. Quando si utilizza Lombok, il nostro codice sorgente non sarà un codice Java valido. Sarà quindi necessario installare un plugin per l'IDE, altrimenti l'ambiente di sviluppo non capirà con cosa ha a che fare. Lombok supporta tutti i principali IDE Java. L'integrazione è perfetta. Tutte le funzioni come "mostra utilizzo" e "vai all'implementazione" continuano a funzionare come prima, portandoti al campo/classe appropriato. Quindi, per le classi semplici puoi usare l'annotazione @Data. @Data- genera costruttore, getter, setter, metodi equals, hashCode, toString. Per rendere gli oggetti immutabili c'è @Value. @Value- genera il costruttore, solo getter, metodi equals, hashCode, toString. E fa anche tutti i campi privatee final.

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

@WithAnnotazioni e .funzionano bene con classi immutabili @Builder.

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

Se vogliamo cambiare il campo di un oggetto immutabile, allora dobbiamo creare un clone di questo oggetto con un parametro modificato. @With- aggiunge metodi per ciascun campo che creano un clone dell'oggetto con un campo modificato.

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

anotherCat- un nuovo oggetto i cui valori di campo sono gli stessi di cat, ad eccezione del campo name. @Builder- genera metodi con cui inizializziamo un oggetto lungo una catena. Ciò è utile quando non vogliamo utilizzare un costruttore con tutti i parametri (se la nostra classe è immutabile, allora ha un singolo costruttore con tutti i parametri).

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

Richiamo ciclico dei metodi Se gli oggetti hanno una comunicazione bidirezionale, ad es. riferimenti reciproci, l'utilizzo dei metodi toStringporterà equalsa hashCodeun errore StackOverflowError. Perché ci sarà una chiamata ciclica ai metodi degli oggetti annidati. Questo codice genererà un errore:

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("Ivan");
        person.setAge(26);
        person.setCat(cat);

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

La soluzione al problema è interrompere la chiamata ciclica rimuovendo il campo dal metodo. @ToString.Exclude- Escludi un campo in un metodo toString @EqualsAndHashCode.Exclude- Escludi un campo in un metodo equalsehashCode

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

Un paio di annotazioni più utili @Slf4j: aggiunge un logger alla classe @SneakyThrows, rende deselezionate le eccezioni selezionate

@Slf4j
public class Main {

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

Annota individualmente Se per qualche motivo hai bisogno solo di determinati metodi

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

<h2>Conclusione</h2>Queste sono solo le annotazioni lombok di base, ma sono le più comunemente utilizzate e hanno l'effetto maggiore. Non dovresti nemmeno lasciarti trasportare troppo dalla generazione del codice. <h2>Collegamenti</h2>

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