Contenu du cours

Manipulation des Données Java avec Hibernate

Génération Automatique de Code Standard

Économie d'espace dans le code Java

Avez-vous déjà remarqué combien de choses standard il y a dans chaque code Java ? Par exemple, lorsque vous écrivez un modèle, vous devez déclarer un constructeur sans argument, un constructeur avec arguments, des getters, des setters, remplacer les méthodes toString() et hashCode(), et bien plus encore. En général, cela prend plus de 70 lignes de code, ce qui rend difficile la détection de la logique supplémentaire dans la classe si elle est présente.

Conclusion : les getters, setters et autres constructions standard peuvent encombrer considérablement votre code. Cependant, il existe une extension qui résout efficacement ce problème - Project Lombok.

Lombok

Pour commencer avec Project Lombok, nous devons l'importer dans le pom.xml (si vous utilisez Maven) :

Super, nous pouvons maintenant commencer à améliorer notre code.

Jetons un coup d'œil à certaines des annotations clés :

Getter et Setter

@Getter et @Setter : Génèrent des getters et setters standards pour un champ. Ils peuvent être appliqués au niveau du champ ou de la classe.

Constructeurs

@NoArgsConstructor : Génère un constructeur sans argument ;
@RequiredArgsConstructor : Génère un constructeur avec un paramètre pour chaque champ nécessitant un traitement spécial (comme les champs annotés avec @NonNull ou les champs finaux) ;
@AllArgsConstructor : Génère un constructeur avec un paramètre pour chaque champ de la classe.

Jetons un coup d'œil à quelques exemples de code sur la façon d'appliquer ces annotations.

Ces annotations doivent être placées au-dessus d'une classe :

OldEmployee


              12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
            
package com.example;

import java.util.Date;

public class Employee {

    private int id;

    private String name;

    private String position;

    private double salary;

    private Date hireDate;

    public Employee() {
    }

    public Employee(int id, String name, String position, double salary, Date hireDate) {
        this.id = id;
        this.name = name;
        this.position = position;
        this.salary = salary;
        this.hireDate = hireDate;
    }

    public int getId() {
        return id;
    }

    public Employee(String name, String position, double salary) {
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Date getHireDate() {
        return hireDate;
    }

    public void setHireDate(Date hireDate) {
        this.hireDate = hireDate;
    }
}

Comme vous pouvez le voir, ce code semble assez long, et il peut être difficile de lire quoi que ce soit dedans, même s'il est structuré.

Améliorons-le avec l'aide des annotations Lombok :

improvedEmployee


              12345678910111213141516171819202122232425
            
package com.example;

import lombok.*;

import java.util.Date;

@Getter
@Setter
@AllArgsConstructor
@RequiredArgsConstructor
public class Employee {

    private int id;

    @NonNull
    private String name;

    @NonNull
    private String position;

    @NonNull
    private double salary;

    private Date hireDate;
}

Donc, de 73 lignes, nous l'avons réduit à 25. Maintenant, nous pouvons clairement voir quels sont les champs dans cette classe, qu'il y a des getters, des setters, un constructeur qui prend tous les arguments, et un constructeur qui prend 3 arguments : name, position, et salary. De cette manière, nous avons considérablement réduit le code tout en conservant la même fonctionnalité.

Annotations supplémentaires :

Project Lombok fournit également des annotations supplémentaires, telles que celles pour remplacer toString(), equals(), et hashCode().

Jetons un coup d'œil à quelques annotations supplémentaires qui peuvent être utiles :

Voici quelques annotations supplémentaires au format Markdown:

Annotation	Description
`@ToString`	Génère une méthode `toString()` pour la classe.
`@EqualsAndHashCode`	Génère les méthodes `equals(Object other)` et `hashCode()`.
`@NonNull`	Marque un champ comme n'autorisant pas les valeurs nulles et génère automatiquement les vérifications correspondantes.
`@Value`	Marque la classe comme immuable, ajoutant `@Getter`, et rendant tous les champs `final` et `private`.
`@Data`	Combine `@Getter`, `@Setter`, et `@RequiredArgsConstructor`.

Maintenant, améliorons notre code en remplaçant @Getter, @Setter, et @AllArgsConstructor par l'annotation @Data, qui est placée avant le mot-clé class. De plus, ajoutons les annotations @ToString et @EqualsAndHashCode.

Le résultat sera le code suivant:

ImprovedImprovedEmployee


              123456789101112131415161718192021222324
            
package com.example;

import lombok.*;

import java.util.Date;

@EqualsAndHashCode
@ToString
@RequiredArgsConstructor
public @Data class Employee {

    private int id;

    @NonNull
    private String name;

    @NonNull
    private String position;

    @NonNull
    private double salary;

    private Date hireDate;
}

Remarque

Nous n'avons pas couvert toutes les annotations de la bibliothèque Project Lombok. Ce chapitre couvre les principales annotations et fonctions de cette bibliothèque. À l'avenir, si nous devons utiliser une annotation spécifique que je n'ai pas décrite dans ce chapitre, j'expliquerai séparément ce que signifie cette annotation particulière.

En résumé, Lombok est un outil puissant pour optimiser le code Java, mais son utilisation nécessite une certaine prudence. Tous les changements sont effectués lors de la compilation, et vous devrez installer le plugin Lombok dans votre environnement de développement intégré (IDE) pour voir ces changements reflétés. De plus, il est important de noter qu'une utilisation excessive de Lombok peut rendre le code difficile à lire et à déboguer si les développeurs ne sont pas habitués à ce style.

Dans notre cours, nous utiliserons Lombok car nous travaillerons beaucoup avec des entités, qui prennent la forme de classes modèles.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 5

Manipulation des Données Java avec Hibernate

Génération Automatique de Code Standard

Économie d'espace dans le code Java

Lombok

Getter et Setter

Constructeurs

Annotations supplémentaires :

1. Quel est le principal avantage d'utiliser Project Lombok dans le code Java ?

2. Quel élément de dépendance Maven est essentiel pour définir la portée de Lombok dans votre projet ?

3. Que fait l'annotation Lombok `@NoArgsConstructor` ?

4. Quelle annotation Lombok est utilisée pour inclure tous les getters, setters et constructeurs d'arguments requis dans une classe ?

5. L'annotation `@NonNull` dans Lombok est utilisée pour :

Manipulation des Données Java avec Hibernate

Génération Automatique de Code Standard

Économie d'espace dans le code Java

Lombok

Getter et Setter

Constructeurs

Annotations supplémentaires :

1. Quel est le principal avantage d'utiliser Project Lombok dans le code Java ?

2. Quel élément de dépendance Maven est essentiel pour définir la portée de Lombok dans votre projet ?

3. Que fait l'annotation Lombok @NoArgsConstructor ?

4. Quelle annotation Lombok est utilisée pour inclure tous les getters, setters et constructeurs d'arguments requis dans une classe ?

5. L'annotation @NonNull dans Lombok est utilisée pour :

3. Que fait l'annotation Lombok `@NoArgsConstructor` ?

5. L'annotation `@NonNull` dans Lombok est utilisée pour :