Java-Projekt Lombok

Tutorials

Java

Projekt Lombok ist ein sehr nützliches Werkzeug für Java-Projekte, um den Boilerplate-Code zu reduzieren.

Problemstellung

In der Debatte zwischen Java und anderen Sprachen ist der erste Einwand, den Sie von Unterstützern anderer Sprachen erhalten, dass Java viel Boilerplate-Code erfordert und Sie einfach nicht darüber hinwegkommen können, und Sie sind wehrlos. Das gleiche Problem wird auch in verschiedenen Plattformen und Entwicklergemeinschaften gemeldet. Schauen wir uns ein Beispiel für Code an, der Boilerplate-Code enthält.

package com.askrakesh.java.manage_boilerplate;

import java.time.LocalDate;

public class Person {

	String firstName;
	String lastName;
	LocalDate dateOfBirth;

	public Person(String firstName, String lastName, LocalDate dateOfBirth) {
		super();
		this.firstName = firstName;
		this.lastName = lastName;
		this.dateOfBirth = dateOfBirth;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public LocalDate getDateOfBirth() {
		return dateOfBirth;
	}

	public void setDateOfBirth(LocalDate dateOfBirth) {
		this.dateOfBirth = dateOfBirth;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((dateOfBirth == null) ? 0 : dateOfBirth.hashCode());
		result = prime * result + ((firstName == null) ? 0 : firstName.hashCode());
		result = prime * result + ((lastName == null) ? 0 : lastName.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (dateOfBirth == null) {
			if (other.dateOfBirth != null)
				return false;
		} else if (!dateOfBirth.equals(other.dateOfBirth))
			return false;
		if (firstName == null) {
			if (other.firstName != null)
				return false;
		} else if (!firstName.equals(other.firstName))
			return false;
		if (lastName == null) {
			if (other.lastName != null)
				return false;
		} else if (!lastName.equals(other.lastName))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Person [firstName=" + firstName + ", lastName=" + lastName + "dateOfBirth=" + dateOfBirth + "]";
	}

}

A class should have getter-setters for the instance variables, equals & hashCode method implementation, all field constructors and an implementation of toString method. This class so far has no business logic and even without it is 80+ lines of code. This is insane.

Projekt Lombok

Projekt Lombok ist eine Java-Bibliothek, die sich automatisch in Ihren Editor und Build-Tools einbindet und hilft, den Boilerplate-Code zu reduzieren. Schauen wir uns zunächst an, wie man das Lombok-Projekt einrichtet.

Wie funktioniert das Java-Projekt Lombok?

Lombok hat verschiedene Annotationen, die in unserem Code verwendet werden können und die zur Kompilierzeit verarbeitet werden, wobei je nach verwendeter Annotation eine entsprechende Codeerweiterung erfolgt. Lombok reduziert nur den Code zur Laufzeit, nachdem der Bytecode beim Kompilieren mit allen Standardcodes injiziert wurde. Dies hilft dabei, unsere Codebasis klein, sauber und leicht lesbar und wartbar zu halten.

Projekt Lombok Maven

Das Hinzufügen von Lombok in Ihr Projekt ist einfach. Fügen Sie einfach die untenstehende Abhängigkeit in Ihre Maven-Projekt-Datei pom.xml ein.

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.16.20</version>
</dependency>

Das Hinzufügen des Lombok-Plugins in die IDE (Eclipse)

Hier sind die Installationsschritte für Windows:

Laden Sie das JAR von https://projectlombok.org/download herunter oder verwenden Sie das JAR, das aus Ihrem Maven-Build heruntergeladen wurde.
Führen Sie den Befehl im Terminal aus: java -jar lombok.jar
Dieser Befehl öffnet ein Fenster wie im Bild unten gezeigt. Installieren Sie die Software und beenden Sie den Installer, und starten Sie dann Eclipse neu.

Wenn Sie auf MacOS sind, sind dies die Schritte zur Verwendung von Lombok in Ihrem Projekt.

Kopieren Sie lombok.jar in das Verzeichnis Eclipse.app/Contents/MacOS.
Fügen Sie -javaagent:lombok.jar am Ende der Datei Eclipse.app/Contents/Eclipse/eclipse.ini hinzu.
Starten Sie Eclipse neu und aktivieren Sie „Annotation Processing“ in den Projekteigenschaften, wie im untenstehenden Bild gezeigt.

Lomboks Vorschau im Eclipse-Überblick

Nach der Installation überprüfen wir, wie wir unseren reduzierten Boilerplate-Code sehen können. Ich habe die gleiche Klasse wie PersonLombok neu erstellt. Der Eclipse-Überblick zeigt Getter und Setter für den Vornamen, basierend auf den Lombok-@Getter & @Setter Annotation, die für die Instanzvariable firstName festgelegt sind.

Lomboks Vorschau im Java-Bytecode

Wir können die Hinzufügung von Getter- & Setter-Methoden für den Vornamen im Klassenbytecode überprüfen.

Projekt Lombok-Annotationen

Projekt Lombok bietet viele Annotationen, die dabei helfen, den Boilerplate-Code in verschiedenen Szenarien zu reduzieren. Lassen Sie uns einige davon durchgehen.

Konstruktor-Annotation
```
@AllArgsConstructor
public class PersonLombok {
	@NonNull String firstName;
	String lastName;
	LocalDate dateOfBirth;
	public static void main(String[] args) {
		new PersonLombok(null, "Kumar", LocalDate.now());
	}
}
```
Der obige Code fügt der Klasse Folgendes hinzu:
- Einen Konstruktor mit allen Argumenten durch @AllArgsConstructor
- Nullprüfung beim Übergeben eines Arguments im Konstruktor durch @NonNull. Die @NonNull-Annotation kann auch verwendet werden, wenn ein Argument als Parameter an eine Methode übergeben wird
Hier ist das Ergebnis des Programmablaufs. @RequiredArgsConstructor generiert einen Konstruktor mit 1 Parameter für jedes Feld, das eine spezielle Behandlung erfordert. Alle nicht initialisierten finalen Felder erhalten einen Parameter sowie alle Felder, die als @NonNull markiert sind und nicht initialisiert sind, wo sie deklariert werden.
Getter/Setter-Annotationen

Diese Annotationen können entweder auf Feld- oder Klassenebene verwendet werden. Wenn Sie eine fein abgestufte Steuerung wünschen, verwenden Sie sie auf Feldebene. Wenn sie auf Klassenebene verwendet werden, werden alle Getter/Setter erstellt. Lassen Sie uns an der Klasse arbeiten, die wir oben erstellt haben.
```
@AllArgsConstructor @Getter @Setter
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Equals-, hashCode- und toString-Annotationen

Es wird empfohlen, die Methoden hashCode() und equals() beim Erstellen einer Klasse zu überschreiben. In Lombok haben wir die @EqualsAndHashCode-Annotation, die Code für die Methoden equals() & hashCode() einfügt, da sie zusammengehören. Zusätzlich bietet die @ToString-Annotation eine Implementierung für toString(). Lass uns das anschauen:
```
@AllArgsConstructor @Getter @Setter
@EqualsAndHashCode 
@ToString
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Wir haben es jetzt geschafft, die Klasse Person ohne jeglichen Boilerplate-Code mit Hilfe von Lombok-Annotationen zu erstellen. Es wird jedoch noch besser, wir können alle Annotationen, die in der obigen Klasse verwendet wurden, durch @Data ersetzen und dieselbe Funktionalität erhalten.
Design Pattern basierte Annotationen

@Builder ermöglicht es Ihnen, automatisch den Code zu generieren, der erforderlich ist, um Ihre Klasse mit dem Builder-Muster instanziierbar zu machen.
```
@Builder
public class Employee {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;

	public static void main(String[] args) {
		Employee emp = new EmployeeBuilder().firstName("Rakesh")
				.lastName("Kumar")
				.dateOfBirth(LocalDate.now())
				.build();
	}
}
```
@Delegate generiert Delegationsmethoden, die den Aufruf an das Feld weiterleiten, auf dem die Annotation verwendet wird. „Composition über Vererbung bevorzugen“, aber dies erzeugt viel Boilerplate-Code, ähnlich dem Adaptermuster. Lombok hat den Hinweis von der gleichnamigen Annotation in Groovy übernommen, um diese Funktionalität zu implementieren. Hier ist eine Implementierung:
```
@RequiredArgsConstructor
public class AdapterImpl implements Adapter {
	@Delegate
	private final Adaptee instance;

	public static void main(String[] args) {
		AdapterImpl impl = new AdapterImpl(new Adaptee());
		impl.display();
	}
}

interface Adapter {
	public void display();
}

class Adaptee {
	public void display() {
		System.out.println("In Adaptee.display()");
	}
}
```
Lombok bietet Funktionalität zur feingranulierten Steuerung in allen Annotationen.

Boilerplate: Hören Java-Architekten zu?

Ja, das tun sie. Sie müssen verstehen, dass im Gegensatz zu anderen Sprachen Java größte Sorgfalt darauf verwendet hat, die Sprache so zu aktualisieren, dass sie keine vorhandene Codebasis bricht, die in älteren Versionen von Java vorhanden ist. Dies ist an sich schon eine riesige Aufgabe und darf nicht unterschätzt werden. Sie modifizieren bereits die Sprache und bauen bessere Typinferenzfähigkeiten ein, die bereits implementiert wurden. Eine der wichtigen Funktionen, die für Java 10 geplant sind, ist Local-Variable Type Inference. Obwohl die Funktion mehr mit der Hinzufügung von dynamischer Typisierung als mit dem Boilerplate zu tun hat, ist sie dennoch ein kleiner Tropfen im Ozean, um den Boilerplate-Code zu verwalten.

Zusammenfassung

Die Reduzierung des Boilerplate-Codes trägt zu einer besseren Lesbarkeit bei, weniger Code bedeutet auch weniger Fehler. Project Lombok wird heute in fast allen großen Organisationen stark genutzt. Wir haben Ihnen die nützlichsten Funktionen von Lombok zur Verfügung gestellt. Hoffentlich probieren Sie es aus. Quellcode: Sie können meinen Github-Link besuchen, um den vollständigen Quellcode herunterzuladen, der in diesem Tutorial verwendet wird.

Source:
https://www.digitalocean.com/community/tutorials/java-project-lombok

Konstruktor-Annotation

Getter/Setter-Annotationen

Equals-, hashCode- und toString-Annotationen

Design Pattern basierte Annotationen