Lombok avec Java

Simplification et amélioration du code

Lombok est une bibliothèque Java qui permet d'automatiser la création de méthodes telles que les getters, les setters, les constructeurs, les méthodes equals, hashCode et toString grâce aux annotations. L'utilisation de Lombok permet de réduire la quantité de code-boilerplate.

I. Installation et configuration de Lombok

Vous pouvez télécharger Lombok depuis le site officiel : https://projectlombok.org/download
Pour une installation via Maven, vous pouvez ajouter la dépendance suivante à votre fichier pom.xml :

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

Il est ensuite nécessaire d'installer le plugin Lombok dans votre IDE :

• Pour IntelliJ IDEA, installer le plugin Lombok. Allez dans "File" -> "Settings" -> "Plugins", rechercher "Lombok" et cliquer sur "Install".
• Pour Eclipse, téléchargez le fichier "lombok.jar" et exécutez-le. Un installateur s'ouvrira. Sélectionner le répertoire Eclipse, puis cliquer sur "Install/Update".
• Pour NetBeans, ajouter le fichier "lombok.jar" à la bibliothèque de votre projet.

II. Annotations de base de Lombok

II.1 @Data

L'annotation @Data de Lombok est une annotation de commodité regroupant les annotations @ToString, @EqualsAndHashCode, @Getter, @Setter et @RequiredArgsConstructor. Elle permet de générer tout le code-boilerplate en une seule ligne.

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

II.2 @Getter et @Setter

Ces annotations permettent de générer automatiquement les getters et les setters pour les attributs d'une classe.
 

@Getter @Setter
public class Person {
  private String name;
  private int age;
}

A noter qu'il est possible de demander à Lombok de mettre en cache les données récupérées la première fois (si non null) en utilisant l'annotation @Getter(lazy=true).

II.3 @NoArgsConstructor, @RequiredArgsConstructor et @AllArgsConstructor

Ces trois annotations génèrent différents types de constructeurs pour une classe :

• @NoArgsConstructor crée un constructeur sans arguments,
• @RequiredArgsConstructor crée un constructeur avec un argument pour chaque champ final qui n'a pas été initialisé,
• @AllArgsConstructor crée un constructeur avec un argument pour chaque champ de la classe.

@NoArgsConstructor
@RequiredArgsConstructor
@AllArgsConstructor
public class Person {
  private String name;
  private int age;
}

Il est possible de définir la visibilité du constructeur généré. Par exemple, @NoArgsConstructor(access = AccessLevel.PRIVATE) génère un constructeur privé sans arguments.

II.4 @Builder - Patron de conception Builder

L'annotation @Builder de Lombok facilite la mise en œuvre du design pattern Builder.

@Builder
public class Employee {
  private String name;
  private String department;
  private double salary;
}

// Use
Employee e = Employee.builder().name("John").department("IT").salary(50000.00).build();

II.5. @Slf4j pour la journalisation

Lombok propose également l'annotation @Slf4j, qui génère automatiquement un Logger Slf4j pour la classe concernée.

@Slf4j
public class Employee {
    public void someMethod() {
        log.info("This is an info message");
    }
}

II.6. @Value pour les classes immuables

L'annotation @Value est utile pour créer des classes immuables. Elle regroupe les annotations @Getter, @AllArgsConstructor, @EqualsAndHashCode, @ToString et @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE). Aucun setter n'est créé et toutes les variables (de même que la classe) sont notés final.

@Value
public class Point {
  int x;
  int y;
}

III. Avantages et inconvénients

L'utilisation de Lombok est à double tranchant. On peut citer plusieurs avantages non négligeables :

• Gain de temps et productivité accrue : il permet de gagner beaucoup de temps en automatisant la génération de code-boilerplate.
• Code plus lisible et plus facile à maintenir : En réduisant la quantité de code-boilerplate, il rend le code plus propre et plus facile à lire et à maintenir.
• Amélioration de la qualité du code et réduction des erreurs : le code généré a été testé et éprouvé, ce qui diminue le risque d'erreur.

Cependant, plusieurs inconvénients peuvent survenir :

• Complexité cachée : il rend le code plus propre, mais en cachant la complexité. Cela peut rendre le débogage plus difficile.
• Dépendance à une bibliothèque externe : Son utilisation ajoute une dépendance à votre projet (maven et plugin pour l'IDE par exemple). S'il n'est plus maintenu, cela pourrait devenir un problème majeur.
• Incompatibilité de @EqualsAndHashCode avec les modèles JPA : l'utilisation de l'annotation @EqualsAndHashCode sur des modèles JPA peut entraîner des erreurs à l'exécution. Pour en savoir davantage, cet article détaille le problème.

IV. Conclusion

Cet article a abordé l'installation, la configuration et l'utilisation de Lombok dans un environnement Java ainsi que les avantages et les inconvénients de son utilisation.

Lombok, malgré ses inconvénients, est un outil précieux pour améliorer la productivité, la lisibilité du code et la qualité du code dans le développement Java et est largement utilisé dans le développement logiciel en Java.

Pour approfondir, je vous conseille d'examiner les annotations @SneakyThrows, @Cleanup et @Synchronized ou encore de découvrir comment retirer Lombok du projet tout en conservant un code fonctionnel.

À noter que cet article, pour des besoins de test, a été en partie rédigé par une IA et presque entièrement reformulé, complété et vérifié par un humain.