Projet Lombok en Java

Introduction

Lombok est une bibliothèque qui agit comme un processeur d'annotation pour Java, conçu pour éliminer la redondance dans le code. Sa fonction principale est d'automatiser la génération de code répétitif ou « passe-partout » - ces éléments qui, bien que nécessaires, n'ajoutent pas de valeur directe à la logique de notre programme. Principalement, il est utilisé pour la génération automatique au moment de la compilation des méthodes getter et setter, des constructeurs, des méthodes equals(), hashCode(), toString(), entre autres éléments courants dans les classes Java.

Au lieu d'écrire manuellement des dizaines de lignes de code pour ces fonctions de base, Lombok vous permet de les définir à l'aide d'annotations simples, ce qui donne un code plus propre, plus maintenable et moins sujet aux erreurs.

Facilité

Pour utiliser Lombok dans un projet Java, il est nécessaire d'ajouter la dépendance correspondante dans le fichier pom.xml (dans le cas d'un projet Maven) ou build.gradle (dans le cas d'un projet Gradle), en plus d'installer le plugin correspondant dans l'IDE que nous utilisons. Au cours de cet article, nous utiliserons Maven et IntelliJ IDEA comme exemple.

<dependencies>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

En cas de doute vous pouvez toujours consulter la documentation officielle de Lombok :

• Lombok avec Maven
• Lombok dans IntelliJ IDEA

@données

Lorsque nous créons une classe, nous effectuons régulièrement les actions suivantes, soit manuellement, soit avec un raccourci fourni par notre IDE :

• Encapsuler les attributs et générer leurs méthodes getter et setter
• Générer un constructeur vide et un autre qui reçoit tous les attributs
• Implémenter les méthodes equals(), hashCode() et toString()

Eh bien, Lombok a l'annotation @Data qui nous permet de faire tout cela sur une seule ligne, générant tout ce qui concerne le POJO (Plain Old Java Objects). Cette annotation est une combinaison des annotations @Getter, @Setter, @EqualsAndHashCode, @NoArgsConstructor et @AllArgsConstructor que nous verrons plus tard.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@NoArgsConstructor, @AllArgsConstructor et @RequiredArgsConstructor

Ces annotations nous permettent de générer automatiquement des constructeurs avec différentes combinaisons d'arguments, en considérant que les attributs sont utilisés selon l'ordre dans lequel ils ont été déclarés dans la classe.

• @NoArgsConstructor : Génère un constructeur sans arguments (vide), s'il n'est pas possible d'en générer un, une exception sera levée, pour éviter cela utilisez simplement l'annotation comme suit @NoArgsConstructor(force = true).
• @AllArgsConstructor : Génère un constructeur avec tous les attributs de la classe comme arguments.
• @RequiredArgsConstructor : génère un constructeur pour tous les champs finaux et/ou marqués de l'annotation @NonNull.

<dependencies>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@Getter et @setter

Ces annotations nous permettent de générer automatiquement les méthodes getter et setter pour tous les attributs de la classe, ou uniquement pour ceux qui sont marqués avec l'annotation correspondante, c'est-à-dire qu'elles peuvent être utilisées au niveau de la classe ou de l'attribut.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@ToString

Cette annotation génère automatiquement la méthode toString(), qui renvoie une représentation sous forme de chaîne de la classe et de ses attributs au format suivant : ClassName(attribute1=value1,attribut2=value2, ...). Par défaut, tous les attributs non statiques de la classe sont inclus dans le résultat, mais des attributs spécifiques peuvent être exclus à l'aide de l'attribut @ToString.Exclude. Si vous souhaitez afficher uniquement la valeur de l'attribut et non le nom tel que déclaré, vous pouvez utiliser @ToString(includeFieldNames = false).

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persona {
    private String nombre;
}

@EqualsAndHashCode

Permet de générer les méthodes equals() et hashCode() à partir de tous les attributs de la classe. Si vous souhaitez exclure ou inclure un attribut, vous pouvez le faire en utilisant l'annotation @EqualsAndHashCode.Exclude et @EqualsAndHashCode.Include. respectivement.

import lombok.*;

@Getter
@Setter
public class Persona {
    private String nombre;
    private String apellido;
}

@Valeur

Auparavant en Java pour créer une classe immuable, il fallait effectuer une série d'étapes, comme faire en sorte que la classe et/ou les attributs soient du type final, et que les méthodes setter ne soient pas générées. Lombok nous permet de créer facilement des classes immuables à l'aide de l'annotation @Value, qui combine les annotations @Getter, @ToString, @EqualsAndHashCode et @AllArgsConstructor pour générer une classe immuable. Tous les attributs sont marqués comme privés finaux et les méthodes setter ne sont pas générées. C'est la variante immuable de @Data.

import lombok.*;

public class Persona {
    @Getter @Setter
    private String nombre;
    private String apellido;
}

Dans les versions récentes de Java, cette annotation perd du sens par rapport à l'utilisation des Records, puisqu'ils ont le même but, et qu'il est plus pratique d'utiliser des records. Si vous souhaitez en savoir plus sur ce sujet, il y a d'autres articles sur le blog sur les records.

<dependencies>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@val

Cette annotation nous permet de déclarer une variable comme finale et de déduire automatiquement son type de données, c'est-à-dire qu'il n'est pas nécessaire de spécifier le type de données de la variable, Lombok se charge de le déduire. C'est utile dans le cas où le type de données variable est très long ou complexe, vous évitez ainsi de le répéter.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

Cette annotation peut perdre son sens si on utilise directement final var ou simplement var pour l'inférence de type, ce qui est plus pratique puisque c'est une caractéristique du langage. Si vous souhaitez en savoir plus à ce sujet, vous pouvez consulter l'article suivant

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

@var

Cela fonctionne exactement de la même manière que @val, mais il ne déclare pas la variable comme finale, il en déduit simplement son type. Il est nécessaire de considérer la notion d'inférence de type, puisqu'on ne peut pas déclarer quelque chose de type String et qu'il n'est pas définitif de vouloir lui attribuer une valeur de type int. Encore une fois, cette annotation est remplacée par var dans les versions récentes de Java.

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persona {
    private String nombre;
}

@NonNull

Cette annotation peut être utilisée sur les attributs de classe et les paramètres d'une méthode, elle indique essentiellement que la valeur d'un attribut ne peut pas être nulle, dans le cas où une tentative est faite pour attribuer une valeur nulle à un attribut marqué avec @NonNull, cela le fera être lancé une NullPointerException, c'est-à-dire si (param == null) throw new NullPointerException("param est marqué non nul mais nul"); Quelle que soit l'exception qu'elle génère, son utilisation est plus visible au sein de l'EDI lui-même, puisqu'elle nous indiquera d'une manière ou d'une autre que cette valeur ne peut pas être nulle.

import lombok.*;

@Getter
@Setter
public class Persona {
    private String nombre;
    private String apellido;
}

@Nettoyage

Cette annotation permet de s'assurer que toute ressource qui l'utilise si elle possède une méthode close() ou qui implémente les interfaces AutoCloseable ou Closeable est automatiquement fermée à la fin du bloc de code dans lequel elle se trouve. Il est utile en cas de travail avec des ressources qui doivent être libérées, telles que des fichiers, des connexions à des bases de données, etc.

import lombok.*;

public class Persona {
    @Getter @Setter
    private String nombre;
    private String apellido;
}

Ce résultat peut être obtenu manuellement si on utilise un essai avec des ressources.

import lombok.*;

@AllArgsConstructor
@ToString
public class Persona {
    private String nombre;
    @ToString.Exclude
    private String apellido;
}

// Output: Persona(nombre=Maria)

@constructeur

Cette annotation nous permet de générer automatiquement un modèle de conception Builder, c'est-à-dire un objet qui nous permet de construire des objets complexes étape par étape, afin que différents attributs d'un objet puissent être configurés sans avoir à le faire. appeler un constructeur avec de nombreux paramètres. C'est utile dans le cas où une classe a de nombreux attributs et que nous ne voulons pas avoir un constructeur avec de nombreux paramètres.

<dependencies>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <version>1.18.36</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

@Avec

Cette annotation nous permet de créer une méthode qui renvoie une copie de l'objet actuel avec un attribut modifié, c'est-à-dire qu'elle génère une méthode withAttributeName(Object object) qui nous permet de créer une copie de l'objet actuel avec l'objet attribut modifié par la valeur que nous passons en argument. C'est utile dans le cas où nous souhaitons modifier un attribut d'un objet sans modifier l'objet d'origine.

import lombok.Data;

@Data
public class Persona {
    private String nombre;
}

public class Main {
    public static void main(String[] args) {
        Persona p1 = new Persona();
        p2.setNombre("Maria");

        System.out.println(p1.getNombre());
    }
}

Jusqu'à présent, nous avons vu certaines des annotations qui peuvent être utilisées le plus fréquemment, chacune d'elles peut ou non accepter des configurations supplémentaires, de même il y en a d'autres qui sont marquées comme expérimentales, dans tous les cas Il est important de consulter la documentation officielle pour tirer le meilleur parti de toutes les fonctionnalités que Lombok nous offre et des avantages en matière de génération de code répétitive.

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!