Boostez Java avec le projet Lombok : simplifiez votre code et augmentez votre productivité

Java est connu pour sa verbosité, en particulier lorsqu'il s'agit de code passe-partout répétitif comme les getters, les setters, les constructeurs et les méthodes toString. Bien que nécessaire, cet encombrement peut ralentir le développement et rendre le code plus difficile à lire et à maintenir. Le projet Lombok intervient pour résoudre ce problème en générant automatiquement du code passe-partout au moment de la compilation.

Dans ce guide, nous expliquerons en profondeur pourquoi Lombok est un outil indispensable en Java, comment le configurer et jetterons un œil dans les coulisses pour comprendre comment Lombok utilise le traitement des annotations pour mapper et modifier le résumé de Java. Arbre syntaxique (AST), garantissant que notre code est concis sans sacrifier la fonctionnalité.

Pourquoi avons-nous besoin de Lombok ?

Java nécessite une quantité importante de code passe-partout. Considérons un POJO simple qui comprend des champs, un constructeur, des getters, des setters et une méthode toString :

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + '}';
    }
}

Cela est gérable pour un petit projet, mais à mesure que les applications évoluent, le passe-partout peut rapidement devenir écrasant.

La solution : Lombok

Avec Lombok, on peut éviter tout ce code répétitif. Voici à quoi ressemble la même classe avec Lombok :

import lombok.Data;

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

Avec une seule annotation, Lombok génère les méthodes getters, setters, toString, equals et hashCode, rendant le code plus propre et plus facile à maintenir.

Comment configurer Lombok

Étape 1 : Ajout de la dépendance de Lombok

Pour utiliser Lombok dans un projet Maven, ajoutez cette dépendance à pom.xml :

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

Pour Gradle :

compileOnly 'org.projectlombok:lombok:1.18.28'
annotationProcessor 'org.projectlombok:lombok:1.18.28'

Étape 2 : configuration de l’EDI

Assurez-vous que le plugin Lombok est installé sur votre IDE. Dans IntelliJ IDEA :

1.  Go to Settings > Plugins.
2.  Search for Lombok.
3.  Install the Lombok plugin.
4.  Enable annotation processing under Settings > Build, Execution, Deployment > Compiler > Annotation Processors.

Comment fonctionne Lombok : dans les coulisses

La puissance du traitement des annotations

Lombok utilise des processeurs d'annotation Java pour interagir avec l'arbre de syntaxe abstraite Java (AST). Les processeurs d'annotation analysent et modifient potentiellement la structure du code pendant le processus de compilation. Le processeur d'annotation de Lombok exploite cela pour générer des méthodes telles que les getters, les setters et toString, entre autres, en les insérant directement dans l'AST avant la compilation du code.

Comprendre l'arbre de syntaxe abstraite (AST)

L'AST est une représentation interne du code, décomposant le source en une arborescence structurée que le compilateur peut traiter. Lorsque vous écrivez du code Java, chaque élément (comme les classes, les champs, les méthodes) est mappé à un nœud dans l'AST.

Lorsque le processeur d'annotations de Lombok rencontre une classe avec des annotations Lombok, il modifie les nœuds AST pour ajouter des méthodes directement dans l'arborescence. Cela signifie que les méthodes passe-partout sont générées lors de la compilation et ne font pas partie du code source. Au moment de la compilation du code, il a été complété par toutes les méthodes nécessaires, c'est pourquoi elles fonctionnent de manière transparente.

Timing : quand et comment Lombok génère du code

Les annotations de Lombok sont traitées pendant la phase de compilation, entre l'analyse du code source Java et la génération du bytecode. Voici le processus étape par étape :

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + '}';
    }
}

Par conséquent, lorsque vous exécutez votre code, les getters, setters et autres méthodes apparaissent comme s'ils faisaient partie du code source d'origine, même s'ils ont été ajoutés au moment de la compilation.

Les annotations de Lombok expliquées

• @Getter et @Setter

Ces annotations génèrent des méthodes getter et setter pour vos champs, vous évitant ainsi d'avoir à les écrire vous-même.

import lombok.Data;

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

• @ToString

@ToString génère une méthode toString qui inclut tous les champs par défaut, avec la possibilité d'exclure des champs spécifiques.

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

• @EqualsAndHashCode

Génère les méthodes égales et hashCode. Ces méthodes sont essentielles pour comparer des objets et les utiliser dans des collections comme HashMap ou HashSet.

compileOnly 'org.projectlombok:lombok:1.18.28'
annotationProcessor 'org.projectlombok:lombok:1.18.28'

• @NoArgsConstructor, @AllArgsConstructor et @RequiredArgsConstructor

Ces annotations génèrent des constructeurs avec différentes options de paramètres.

1.  Go to Settings > Plugins.
2.  Search for Lombok.
3.  Install the Lombok plugin.
4.  Enable annotation processing under Settings > Build, Execution, Deployment > Compiler > Annotation Processors.

1.  AST Creation: The compiler reads the Java source code and generates the AST.
2.  Annotation Processing: Lombok’s annotation processor scans the AST for Lombok annotations.
3.  AST Manipulation: When an annotation like @Getter or @Setter is found, Lombok adds nodes to the AST to represent the corresponding methods.
4.  Bytecode Generation: The modified AST is used to generate the final bytecode, which includes the methods added by Lombok.

• @Données

Combine @Getter, @Setter, @ToString, @EqualsAndHashCode et @RequiredArgsConstructor.

import lombok.Getter;
import lombok.Setter;

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

• @Constructeur

Implémente le modèle de construction, qui est particulièrement utile pour construire des objets complexes avec plusieurs paramètres.

import lombok.ToString;

@ToString(exclude = „password“)
public class User {
    private String name;
    private int age;
    private String password;
}

Utilisation :

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class User {
    private String name;
    private int age;
}

• @Slf4j (Journalisation)

Fournit une instance SLF4J Logger, simplifiant la configuration de la journalisation.

• @NoArgsConstructor: No-argument constructor.
• @AllArgsConstructor: Constructor with parameters for all fields.
• @RequiredArgsConstructor: Constructor for fields marked final or @NonNull.

Lombok dans les applications Spring Boot

Les fonctionnalités de Lombok sont particulièrement utiles dans les applications Spring Boot, où le code passe-partout peut facilement s'accumuler dans les services, les référentiels et les modèles. Voici un exemple d'utilisation de Lombok dans un service Spring Boot :

import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;

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

Dans cet exemple :

import lombok.Data;

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

Conclusion

Lombok est un outil inestimable pour les développeurs Java. Il réduit considérablement le code passe-partout, maintient les classes propres et améliore la productivité. En utilisant le traitement des annotations pour manipuler l'AST, Lombok injecte des méthodes directement lors de la compilation, garantissant la concision du code sans compromettre la fonctionnalité.

Lorsqu'il est combiné avec Spring Boot, Lombok rationalise encore davantage le développement. Des annotations telles que @Data, @Builder et @Slf4j offrent un moyen puissant d'écrire du code propre et maintenable, facile à étendre et à déboguer.

Si vous travaillez en Java, Lombok est un incontournable dans votre boîte à outils. Pourquoi écrire plus de code que nécessaire quand Lombok peut le gérer ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!