Lombok-Projekt in Java

Einführung

Lombok ist eine Bibliothek, die als Annotationsprozessor für Java fungiert und Redundanzen im Code beseitigen soll. Seine Hauptfunktion besteht darin, die Generierung von sich wiederholendem Code oder „Boilerplate“ zu automatisieren – jene Elemente, die zwar notwendig sind, aber keinen direkten Mehrwert für die Logik unseres Programms darstellen. Es wird hauptsächlich für die automatische Generierung von Getter- und Setter-Methoden, Konstruktoren, Equals()-, HashCode()- und toString()-Methoden zur Kompilierungszeit sowie anderen gängigen Elementen in Java-Klassen verwendet.

Anstatt Dutzende Codezeilen für diese Grundfunktionen manuell zu schreiben, können Sie diese mit Lombok mithilfe einfacher Anmerkungen definieren, was zu saubererem, besser wartbarem und weniger fehleranfälligem Code führt.

Einrichtung

Um Lombok in einem Java-Projekt zu verwenden, ist es notwendig, zusätzlich zur Installation die entsprechende Abhängigkeit in der Datei pom.xml (im Falle eines Maven-Projekts) oder build.gradle (im Falle eines Gradle-Projekts) hinzuzufügen das entsprechende Plugin in der von uns verwendeten IDE. In diesem Beitrag werden wir Maven und IntelliJ IDEA als Beispiel verwenden.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

Im Zweifelsfall können Sie jederzeit die offizielle Dokumentation von Lombok überprüfen:

• Lombok mit Maven
• Lombok in IntelliJ IDEA

@Daten

Wenn wir eine Klasse erstellen, führen wir regelmäßig die folgenden Aktionen aus, entweder manuell oder mit einer von unserer IDE bereitgestellten Verknüpfung:

• Kapseln Sie Attribute und generieren Sie ihre Getter- und Setter-Methoden
• Generieren Sie einen leeren Konstruktor und einen weiteren, der alle Attribute erhält
• Implementieren Sie die Methoden equal(), hashCode() und toString()

Nun, Lombok verfügt über die @Data-Annotation, die es uns ermöglicht, all dies in einer einzigen Zeile zu erledigen und alles zu generieren, was mit POJO (Plain Old Java Objects) zusammenhängt. Diese Annotation ist eine Kombination der Annotationen @Getter, @Setter, @EqualsAndHashCode, @NoArgsConstructor und @AllArgsConstructor, die wir später sehen werden.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@NoArgsConstructor, @AllArgsConstructor und @RequiredArgsConstructor

Diese Annotationen ermöglichen es uns, automatisch Konstruktoren mit unterschiedlichen Argumentkombinationen zu generieren, wobei berücksichtigt wird, dass die Attribute entsprechend der Reihenfolge verwendet werden, in der sie in der Klasse deklariert wurden.

• @NoArgsConstructor: Erzeugt einen Konstruktor ohne Argumente (leer). Wenn es nicht möglich ist, einen zu generieren, wird eine Ausnahme ausgelöst. Um dies zu vermeiden, verwenden Sie einfach die Annotation wie folgt: @NoArgsConstructor(force = true).
• @AllArgsConstructor: Erzeugt einen Konstruktor mit allen Attributen der Klasse als Argumente.
• @RequiredArgsConstructor: Erzeugt einen Konstruktor für alle endgültigen Felder und/oder markiert mit der @NonNull-Annotation.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@Getter und @setter

Diese Annotationen ermöglichen es uns, die Getter- und Setter-Methoden automatisch für alle Attribute der Klasse zu generieren, oder nur für diejenigen, die mit der entsprechenden Annotation gekennzeichnet sind, d. h. sie können auf Klassen- oder Attributebene verwendet werden.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@ToString

Diese Annotation generiert automatisch die Methode toString(), die eine String-Darstellung der Klasse und ihrer Attribute im folgenden Format zurückgibt: ClassName(attribute1=value1, attribute2=value2, ...). Standardmäßig sind alle nicht statischen Attribute der Klasse im Ergebnis enthalten, bestimmte Attribute können jedoch mithilfe des @ToString.Exclude-Attributs ausgeschlossen werden. Falls Sie nur den Wert des Attributs und nicht den Namen wie deklariert anzeigen möchten, können Sie @ToString(includeFieldNames = false) verwenden.

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persona {
    private String nombre;
}

@EqualsAndHashCode

Ermöglicht das Generieren der Methoden equal() und hashCode() aus allen Attributen der Klasse. Wenn Sie ein Attribut ausschließen oder einschließen möchten, können Sie dies mit der Annotation @EqualsAndHashCode.Exclude und @EqualsAndHashCode.Include tun bzw.

import lombok.*;

@Getter
@Setter
public class Persona {
    private String nombre;
    private String apellido;
}

@Wert

Zuvor war es in Java zum Erstellen einer unveränderlichen Klasse erforderlich, eine Reihe von Schritten auszuführen, z. B. dafür zu sorgen, dass die Klasse und/oder die Attribute den endgültigen Typ haben und dass die Setter-Methoden nicht generiert werden. Lombok macht es uns einfach, unveränderliche Klassen mithilfe der Annotation @Value zu erstellen, die die Annotationen @Getter, @ToString, @EqualsAndHashCode und @AllArgsConstructor kombiniert, um eine unveränderliche Klasse zu generieren. Alle Attribute sind als privat markiert und es werden keine Setter-Methoden generiert. Es ist die unveränderliche Variante von @Data.

import lombok.*;

public class Persona {
    @Getter @Setter
    private String nombre;
    private String apellido;
}

In neueren Java-Versionen verliert diese Anmerkung im Vergleich zur Verwendung von Datensätzen an Bedeutung, da sie denselben Zweck haben und die Verwendung von Datensätzen praktischer ist. Wenn Sie mehr über dieses Thema erfahren möchten, finden Sie im Blog weitere Beiträge zum Thema Schallplatten.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@val

Mit dieser Annotation können wir eine Variable als endgültig deklarieren und automatisch auf ihren Datentyp schließen. Das heißt, es ist nicht notwendig, den Datentyp der Variablen anzugeben, Lombok kümmert sich um die Ableitung. Dies ist nützlich, wenn der variable Datentyp sehr lang oder komplex ist. Auf diese Weise vermeiden Sie Wiederholungen.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

Diese Anmerkung kann an Bedeutung verlieren, wenn wir final var direkt oder einfach var für die Typinferenz verwenden, was praktischer ist, da es sich um ein Merkmal der Sprache handelt. Wenn Sie mehr darüber erfahren möchten, können Sie den folgenden Beitrag lesen

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@var

Es funktioniert genauso wie @val, deklariert die Variable jedoch nicht als final, sondern leitet einfach ihren Typ ab. Es ist notwendig, das Konzept der Typinferenz zu berücksichtigen, da Sie nichts vom Typ String deklarieren können und es nicht endgültig ist, ihm einen Wert vom Typ int zuweisen zu wollen. Auch diese Annotation wird in neueren Java-Versionen durch var ersetzt.

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persona {
    private String nombre;
}

@NonNull

Diese Annotation kann für Klassenattribute und Parameter einer Methode verwendet werden. Sie zeigt grundsätzlich an, dass der Wert eines Attributs nicht null sein kann. Falls versucht wird, einem mit @NonNull markierten Attribut einen Nullwert zuzuweisen, wird dies der Fall sein eine NullPointerException ausgelöst werden, das heißt, wenn (param == null) throw new NullPointerException("param ist als nicht null markiert, aber null"); Unabhängig von der Ausnahme, die es generiert, ist seine Verwendung innerhalb der IDE selbst besser sichtbar, da es uns auf irgendeine Weise anzeigt, dass dieser Wert nicht null sein darf.

import lombok.*;

@Getter
@Setter
public class Persona {
    private String nombre;
    private String apellido;
}

@Cleanup

Mit dieser Annotation können wir sicherstellen, dass jede Ressource, die sie verwendet, wenn sie über eine close()-Methode verfügt oder die AutoCloseable- oder Closeable-Schnittstellen implementiert, am Ende des Codeblocks, in dem sie sich befindet, automatisch geschlossen wird. Dies ist nützlich, wenn Sie mit Ressourcen arbeiten, die freigegeben werden müssen, z. B. Dateien, Verbindungen zu Datenbanken usw.

import lombok.*;

public class Persona {
    @Getter @Setter
    private String nombre;
    private String apellido;
}

Dieses Ergebnis kann manuell erhalten werden, wenn wir einen Versuch mit Ressourcen verwenden.

import lombok.*;

@AllArgsConstructor
@ToString
public class Persona {
    private String nombre;
    @ToString.Exclude
    private String apellido;
}

// Output: Persona(nombre=Maria)

@builder

Diese Annotation ermöglicht es uns, automatisch ein Entwurfsmuster Builder zu generieren, d. h. ein Objekt, das es uns ermöglicht, komplexe Objekte Schritt für Schritt zu erstellen, sodass verschiedene Attribute eines Objekts konfiguriert werden können, ohne dass dies erforderlich ist Rufen Sie einen Konstruktor mit vielen Parametern auf. Dies ist nützlich, wenn eine Klasse viele Attribute hat und wir keinen Konstruktor mit vielen Parametern haben möchten.

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@Mit

Diese Annotation ermöglicht es uns, eine Methode zu erstellen, die eine Kopie des aktuellen Objekts mit einem geänderten Attribut zurückgibt, d. h. sie generiert eine Methode withAttributeName(Object object), die es uns ermöglicht, eine Kopie des aktuellen Objekts mit dem Objekt zu erstellen Attribut, das durch den Wert geändert wird, den wir als Argument übergeben. Dies ist nützlich, wenn wir ein Attribut eines Objekts ändern möchten, ohne das ursprüngliche Objekt zu ändern.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

Bis jetzt haben wir einige der Anmerkungen gesehen, die am häufigsten verwendet werden können. Jede dieser Anmerkungen kann zusätzliche Konfigurationen akzeptieren oder auch nicht, ebenso gibt es andere, die als experimentell gekennzeichnet sind. In jedem Fall ist eine Rücksprache wichtig die offizielle Dokumentation, um alle Funktionen, die Lombok uns bietet, und die Vorteile der repetitiven Codegenerierung optimal zu nutzen.

Das obige ist der detaillierte Inhalt vonLombok-Projekt in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!