Faites voyager vos Entités à Lombok

Je sais qu’il existe quelques articles sur le sujet mais pas assez à mon goût. Je fais pas mal de veille et au final j’ai entendu parlé de cette lib assez tard, mais depuis je suis un grand fan.

La création de POJO

Depuis toujours, quand on crée nos POJO pour trimballer nos données ou autres, ça donne ça :

public final class PcNeufKc {
    private final String marque;
    private final ImmutableList<String> options;

    public PcNeufKc(String marque, List<String> options) {
        this.marque = marque;
        this.options = options;
    }

    public String getMarque() {
        return marque;
    }

    public List<String> getOptions() {
        return options;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PcNeufKc pcNeufKc = (PcNeufKc) o;
        return Objects.equals(marque, pcNeufKc.marque) &&
                Objects.equals(options, pcNeufKc.options);
    }

    @Override
    public int hashCode() {
        return Objects.hash(marque, options);
    }
}

Bon alors oui, je suis plus pour l’immutabilité alors je prends un exemple immutable. ImmutableList de Guava fait bien l’affaire. En vrai j’ai aussi tendance à mettre les membres public pour m’éviter les getters et simplifier les accès mais pour l’exemple ça m’arrangeait avec. Mais bon Immutable ou pas, c’est un autre sujet.

Alors certes, les IDE récents génèrent plus ou moins automatiquement tous ces trucs, getters, equals, hashcode, … certains même les Builders. Mais ça reste fastidieux et il ne faut pas oublier de les générer, sans parler de la verbosité de la classe qui fait pas loin de 40 lignes avec les imports pour ne rien faire.

Avec Lombok

C’est là qu’intervient Lombok . Cette librairie va pour simplifier la création des POJOs, grâce à des annotations que l’on pose sur la classe est les attributs.

@AllArgsConstructor
@Getter
@EqualsAndHashCode
public class PcNeufKc {
    private final String marque;
    private final ImmutableList<String> options;
}

Voilà ma classe avec les mêmes méthodes mais via lombok. On passe à 15 lignes !

La chose sympa c’est que lombok fonctionne par annotation processing, à la compilation. Donc pas de librairie supplémentaire au runtime, les lombok modifie le byte code lors de la compilation. Du coup dans maven, la dépendance est provided.

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>${lombok.version}</version>
    <scope>provided</scope>
</dependency>

Les petits plus de lombok

Si vous êtes pas encore convaincu, voici encore quelques fonctionnalités de lombok qui sont vraiment sympa à l’usage.

Les builders

Dans mon exemple plus haut, j’ai pas mis le builder, mais il est courant d’avoir besoin de builder pour des objets un peu volumineux. Avec lombok c’est une simple annotation de plus :

@Builder
@AllArgsConstructor
@Getter
@EqualsAndHashCode
public class PcNeufKc {
    private final String marque;
    private final ImmutableList<String> options;
}

Vous pouvez ensuite utiliser le code suivant :

PcNeufKc pc = PcNeufKc.builder()
        .marque("MSI")
        .options(ImmutableList.of("HDD 2To", "Wifi"))
        .build();

C’est plutôt sympa, mais on peut faire encore mieux. Là on constate que les options sont ajoutés en une ImmutableList, c’est contraignant, à minima une Collection aurait été sympa. Lombok prend en charge guava (et d’autre) pour créer des builders plus fluent à base de collections immutables:

@Builder
@AllArgsConstructor
@Getter
@EqualsAndHashCode
public class PcNeufKc {
    private final String marque;
    @Singular
    private final ImmutableList<String> options;
}

L’annotation @Singular va permettre d’utiliser un itérable à la place d’imposer une ImmutableList dans le builder pour le champ options. Il va aussi permettre de builder la liste elle-même avec le code suivant :

PcNeufKc pc = PcNeufKc.builder()
        .marque("MSI")
        .option("HDD 2To")
        .option("Wifi")
        .build();

Tout ça grâce à une seule annotation.

Les raccourcis

Dans un souci de lisibilité et pour éviter un trop grand nombre d’annotation, lombok possède des annotations raccourcis. Par exemple :

@Value
@Builder
public class PcNeufKc {
    private final String marque;
    @Singular
    private final ImmutableList<String> options;
}

L’annotation @Value regroupe les annotations nécessaires à la création d’entités immutables. Constructeur, getter, setter, toString, equals, hashcode, … @Value s’assure même que vos membres de classe finaux. A noter qu’il existe une annotation équivalente pour faire des objets mutables @Data.

Support IDE

Coté Maven, il n’y a rien a faire, ça fonctionne direct, ajout de la dépendance, mvn clean compile et c’est tout bon.

Coté IDE, il est nécessaire d’ajouter un plugin pour que l’IDE ne vous souligne pas toutes vos entitées en rouge. Coté IntelliJ le plugin lombok est facile à trouver sur le store, pour Eclipse, je n’ai jamais essayé. Au pire si ça ne fonctionne pas, c’est une bonne raison de passer sous IntelliJ.

Attention dans tous les cas que les “annotation processing” soit bien activés.

Conclusion

Voilà, j’espère vous avoir convaincu. Si ce n’est pas le cas, je vous invite à visiter le site du projet , la documentation est simple et concise. Il y a beaucoup d’autre annotations très pratiques, je n’ai parlé que de celle que j’utilise le plus souvent.