Java Project Lombok

Java

Project Lombok is een zeer nuttige tool voor Java-projecten om boilerplate-code te verminderen.

Probleemstelling

In het debat tussen Java en andere talen is de eerste kritiek die je van supporters van andere talen krijgt, dat Java veel boilerplate-code vereist en dat je er gewoon niet overheen kunt komen, en je bent weerloos. Hetzelfde probleem wordt ook gemeld op meerdere platforms en in ontwikkelaarsgemeenschappen. Laten we eens een voorbeeld bekijken van code met boilerplate-code.

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.

Project Lombok

Project Lombok is een Java-bibliotheek die automatisch wordt geïntegreerd in uw editor en buildtools en helpt de boilerplate-code te verminderen. Laten we eerst eens kijken hoe u het Lombok-project instelt.

Hoe werkt het Java Project Lombok?

Lombok heeft verschillende annotaties die binnen onze code kunnen worden gebruikt en die worden verwerkt tijdens de compileertijd. Op basis van de gebruikte annotatie vindt passende code-uitbreiding plaats. Lombok voert alleen de codevermindering uit tijdens de weergavetijd; na het compileren wordt de bytecode geïnjecteerd met alle boilerplate. Dit helpt om onze codebase klein, schoon en gemakkelijk leesbaar en onderhoudbaar te houden.

Project Lombok Maven

Het toevoegen van Lombok aan uw project is eenvoudig. Voeg gewoon de onderstaande afhankelijkheid toe aan het pom.xml-bestand van uw Maven-project.

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

Het toevoegen van de Lombok-plug-in in de IDE (Eclipse)

Hier zijn de installatiestappen voor Windows:

Download de jar vanaf https://projectlombok.org/download of gebruik de jar die is gedownload vanuit uw Maven-build.
Voer het commando uit in de terminal: java -jar lombok.jar
Dit commando opent een venster zoals getoond in de onderstaande afbeelding. Installeer en sluit de installateur af en herstart Eclipse.

Als u op MacOS bent, zijn dit de stappen om Lombok in uw project te gebruiken.

Kopieer lombok.jar naar de map Eclipse.app/Contents/MacOS.
Voeg -javaagent:lombok.jar toe aan het einde van het bestand Eclipse.app/Contents/Eclipse/eclipse.ini.
Herstart Eclipse en schakel “Annotation Processing” in in de projecteigenschappen zoals weergegeven in onderstaande afbeelding.

Weergave van Lombok in de Eclipse-overzicht

Na installatie gaan we controleren hoe we onze verminderde boilerplate-code kunnen zien? Ik heb dezelfde klasse opnieuw aangemaakt als PersonLombok. Eclipse-overzicht toont getter en setter voor firstName. Dit is gedaan op basis van Lombok’s @Getter & @Setter annotatie ingesteld voor de instantievariabele firstName.

Weergave van Lombok in de Java-bytecode

We kunnen de toevoeging van getter & setter methoden voor de firstName controleren vanuit de klasse-bytecode.

Project Lombok-annotaties

Het Project Lombok biedt veel annotaties die helpen bij het verminderen van boilerplate-code in verschillende scenario’s. Laten we er een paar doornemen.

Constructor-annotatie
```
@AllArgsConstructor
public class PersoonLombok {
	@NonNull String voornaam;
	String achternaam;
	LocalDate geboortedatum;
	public static void main(String[] args) {
		new PersoonLombok(null, "Kumar", LocalDate.now());
	}
}
```
De bovenstaande code voegt het volgende toe aan de klasse:
- Een constructor met alle argumenten door @AllArgsConstructor
- Null-controle tijdens het doorgeven van een argument in de constructor door @NonNull. De @NonNull-annotatie kan ook worden gebruikt bij het doorgeven van een argument als een parameter naar een methode
Hier is het resultaat van het programma. @RequiredArgsConstructor genereert een constructor met 1 parameter voor elk veld dat speciale behandeling vereist. Alle niet-geïnitialiseerde eindvelden krijgen een parameter, evenals eventuele velden die zijn gemarkeerd als @NonNull die niet zijn geïnitialiseerd waar ze zijn gedeclareerd.
Getter/Setter-annotaties

Deze annotaties kunnen zowel op het veld- als op het klasseniveau worden gebruikt. Als u fijnkorrelige controle wilt, gebruik het dan op veldniveau. Wanneer gebruikt op het klasseniveau worden alle getter/setters gemaakt. Laten we werken aan de klasse die we hierboven hebben aangemaakt.
```
@AllArgsConstructor @Getter @Setter
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
equals, hashCode en toString annotaties

Het wordt aanbevolen om de hashCode() en equals() methoden te overschrijven bij het maken van een klasse. In Lombok hebben we de @EqualsAndHashCode-annotatie die code injecteert voor de equals() & hashCode() methoden, omdat ze samenwerken. Daarnaast voorziet de @ToString-annotatie in een toString() implementatie. Laten we dit bekijken:
```
@AllArgsConstructor @Getter @Setter
@EqualsAndHashCode 
@ToString
public class PersoonLombok {
	String voornaam;
	String achternaam;
	LocalDate geboortedatum;
}
```
We hebben nu de Persoon-klasse gemaakt zonder enige standaardcode met behulp van Lombok-annotaties. Het wordt echter nog beter: we kunnen alle annotaties in de bovenstaande klasse vervangen door @Data en dezelfde functionaliteit behouden.

Ontwerp Patroon gebaseerde annotaties

@Builder stelt u in staat automatisch de code te produceren die nodig is om uw klasse instantieerbaar te maken met behulp van het bouwer patroon.

@Builder
public class Werknemer {
	String voornaam;
	String achternaam;
	LocalDate geboortedatum;

	public static void main(String[] args) {
		Werknemer werknemer = new WerknemerBuilder().voornaam("Rakesh")
				.achternaam("Kumar")
				.geboortedatum(LocalDate.now())
				.build();
	}
}

@Delegate genereert delegerende methoden die de oproep doorsturen naar dit veld waarop de annotatie wordt gebruikt. “Geef de voorkeur aan samenstelling boven overerving“, maar dit zorgt voor veel boilerplate-code vergelijkbaar met het Adapter Patroon. Lombok heeft de aanwijzing overgenomen van de gelijknamige annotatie in Groovy bij het implementeren van deze functionaliteit. Laten we een implementatie bekijken:

@RequiredArgsConstructor
public class AdapterImplementatie implementeert Adapter {
	@Delegate
	private final Adaptee exemplaar;

	public static void main(String[] args) {
		AdapterImplementatie implementatie = new AdapterImplementatie(new Adaptee());
		implementatie.weergeven();
	}
}

interface Adapter {
	public void weergeven();
}

class Adaptee {
	public void weergeven() {
		System.out.println("In Adaptee.weergeven()");
	}
}

Lombok biedt functionaliteit voor fijnmazige controle in alle annotaties.

Boilerplate: Luisteren Java-architecten?

Ja, dat zijn ze. U moet begrijpen dat in tegenstelling tot andere talen, Java de grootste zorg heeft besteed aan het upgraden van de taal, zodat ze geen bestaande codebreuk veroorzaken die in oudere versies van Java staat. Dit op zichzelf is een enorme taak en mag niet worden onderschat. Ze zijn al bezig met het aanpassen en verbeteren van de mogelijkheden voor type-inferentie in de taal, die zijn uitgerold. Een van de belangrijke functies die gepland staan voor Java 10 is Lokale variabele type-inferentie. Hoewel de functie meer te maken heeft met het toevoegen van dynamische typen dan met de boilerplate, is het een kleine druppel in de oceaan om de boilerplate-code te beheren.

Samenvatting

Het verminderen van boilerplate-code helpt bij een betere leesbaarheid, minder code betekent ook minder fouten. Project Lombok wordt vandaag de dag veel gebruikt in bijna alle grote organisaties. We hebben u de meest nuttige functies van Lombok gegeven. Hopelijk probeert u het eens. Broncode: U kunt mijn Github-link bezoeken om de volledige broncode te downloaden die in deze tutorial wordt gebruikt.

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

Constructor-annotatie

Getter/Setter-annotaties

equals, hashCode en toString annotaties

Ontwerp Patroon gebaseerde annotaties