Projet Java avec Lombok

Tutoriels

Java

Project Lombok est un outil très utile pour les projets Java afin de réduire le code redondant.

Énoncé du problème

Dans le débat Java contre autres langages, la première critique que vous recevez des partisans d’autres langages est que Java nécessite beaucoup de code redondant et que vous ne pouvez tout simplement pas vous en débarrasser, et vous êtes sans défense. Le même problème est également signalé sur de multiples plateformes et communautés de développeurs. Voyons un exemple de code qui contient du code redondant.

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.

Projet Lombok

Project Lombok est une bibliothèque Java qui se branche automatiquement sur votre éditeur et vos outils de construction et aide à réduire le code redondant. Voyons d’abord comment configurer le projet Lombok.

Comment fonctionne le projet Lombok pour Java ?

Lombok possède diverses annotations qui peuvent être utilisées dans notre code et qui seront traitées lors de la compilation. En fonction de l’annotation utilisée, une extension de code appropriée sera effectuée. Lombok ne réduit le code que lors de l’affichage, une fois la compilation terminée, le code binaire est injecté avec tout le code générique. Cela permet de maintenir notre codebase petite, propre, facile à lire et à entretenir.

Projet Lombok Maven

L’ajout de Lombok à votre projet est simple. Il suffit d’ajouter la dépendance suivante dans le fichier pom.xml de votre projet Maven.

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

Ajout du plugin Lombok dans Eclipse (IDE)

Voici les étapes d’installation pour Windows:

Téléchargez le jar depuis https://projectlombok.org/download ou utilisez le jar téléchargé depuis votre build Maven.
Exécutez la commande dans le terminal: java -jar lombok.jar
Cette commande ouvrira une fenêtre comme indiqué dans l’image ci-dessous, installez et quittez l’installateur, puis redémarrez Eclipse.

Si vous êtes sur MacOS, voici les étapes à suivre pour utiliser Lombok dans votre projet.

Copiez lombok.jar dans le répertoire Eclipse.app/Contents/MacOS.
Ajoutez -javaagent:lombok.jar à la fin du fichier Eclipse.app/Contents/Eclipse/eclipse.ini.
Redémarrez Eclipse et activez le « Traitement des annotations » dans les propriétés du projet comme indiqué dans l’image ci-dessous.

Aperçu de Lombok dans la structure d’Eclipse

Après l’installation, voyons comment nous pouvons voir notre code de base réduit. J’ai recréé la même classe que PersonLombok. La structure d’Eclipse affiche les getters et setters pour le prénom. Cela a été fait en fonction des annotations @Getter & @Setter de Lombok définies pour la variable d’instance firstName.

Aperçu de Lombok dans le bytecode Java

Nous pouvons vérifier l’ajout des méthodes getter & setter pour le prénom à partir du bytecode de la classe.

Annotations du Projet Lombok

Le projet Lombok fournit de nombreuses annotations qui aident à réduire le code redondant dans divers scénarios. Examinons-en quelques-unes.

Annotation du Constructeur
```
@AllArgsConstructor
public class PersonneLombok {
	@NonNull String prenom;
	String nom;
	LocalDate dateDeNaissance;
	public static void main(String[] args) {
		new PersonneLombok(null, "Kumar", LocalDate.now());
	}
}
```
Le code ci-dessus injecte ce qui suit dans la classe :
- Un constructeur avec tous les arguments par @AllArgsConstructor
- Vérification de null lors de la transmission d’un argument dans le constructeur par @NonNull. @NonNull peut également être utilisé lors de la transmission d’un argument en tant que paramètre à une méthode
Voici le résultat de l’exécution du programme. @RequiredArgsConstructor génère un constructeur avec 1 paramètre pour chaque champ nécessitant un traitement spécial. Tous les champs finaux non initialisés obtiennent un paramètre, ainsi que tout champ marqué @NonNull qui n’est pas initialisé à l’endroit où il est déclaré.
Annotations Getter/Setter

Ces annotations peuvent être utilisées soit au niveau du champ, soit au niveau de la classe. Si vous souhaitez un contrôle précis, utilisez-le au niveau du champ. Lorsqu’elles sont utilisées au niveau de la classe, tous les getter/setters sont créés. Travaillons sur la classe que nous avons créée précédemment.
```
@AllArgsConstructor @Getter @Setter
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Annotations equals, hashCode et toString

Il est recommandé de remplacer les méthodes hashCode() et equals() lors de la création d’une classe. Dans Lombok, nous avons l’annotation @EqualsAndHashCode qui injecte du code pour les méthodes equals() & hashCode() car elles vont ensemble. De plus, une annotation @ToString fournit une implémentation de toString(). Voyons cela :
```
@AllArgsConstructor @Getter @Setter
@EqualsAndHashCode 
@ToString
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Nous avons maintenant réussi à créer la classe Person sans aucun code boilerplate grâce aux annotations Lombok. Cependant, cela devient encore mieux car nous pouvons remplacer toutes les annotations utilisées dans la classe ci-dessus par @Data et obtenir la même fonctionnalité.
Annotations basées sur les Design Patterns

@Builder vous permet de produire automatiquement le code requis pour rendre votre classe instanciable en utilisant le pattern builder.
```
@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 génère des méthodes déléguées qui transfèrent l’appel à ce champ sur lequel l’annotation est utilisée. « Préférez la composition à l’héritage« , mais cela crée beaucoup de code redondant similaire au pattern Adaptateur. Lombok a pris l’indice de l’annotation Groovy du même nom lors de la mise en œuvre de cette fonctionnalité. Voyons une implémentation :
```
@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("Dans Adaptee.display()");
	}
}
```
Lombok fournit des fonctionnalités pour un contrôle très fin dans toutes les annotations.

Code Redondant : Les architectes Java écoutent-ils?

Oui, ils le sont. Vous devez comprendre qu’à la différence des autres langages, Java s’est efforcé de mettre à niveau le langage de manière à ne pas rompre les bases de code existantes qui sont dans des versions plus anciennes de Java. Cela constitue en soi une tâche énorme et ne peut être sous-estimé. Ils modifient déjà et développent de meilleures capacités d’inférence de type dans le langage qui ont été déployées. L’une des fonctionnalités importantes prévues pour Java 10 est L’inférence de type pour les variables locales. Bien que cette fonctionnalité ait davantage à voir avec l’ajout de typage dynamique qu’avec la réduction du code boilerplate, il s’agit d’une petite goutte dans l’océan pour gérer le code boilerplate.

Résumé

La réduction du code boilerplate contribue à une meilleure lisibilité, moins de code signifie également moins d’erreurs. Project Lombok est largement utilisé aujourd’hui dans presque toutes les grandes organisations. Nous vous avons fourni les fonctionnalités les plus utiles de Lombok. Nous espérons que vous les essayerez. Code source : Vous pouvez visiter mon lien Github pour télécharger le code source complet utilisé dans ce tutoriel.

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

Annotation du Constructeur

Annotations Getter/Setter

Annotations equals, hashCode et toString

Annotations basées sur les Design Patterns