Pause café #161. Comment gérer Null en Java en utilisant Facultatif

Source : Medium Cet article vous aidera à mieux comprendre le but de Facultatif lorsque vous travaillez avec du code Java. Lorsque j’ai commencé à travailler avec du code Java, on m’a souvent conseillé d’utiliser Facultatif. Mais à l’époque, je ne comprenais pas pourquoi il était préférable d’utiliser Facultatif plutôt que d’implémenter la gestion des valeurs nulles. Dans cet article, je souhaite partager avec vous pourquoi je pense que nous devrions tous utiliser davantage Optionnel et comment éviter de sur-optionnaliser votre code, ce qui nuit à la qualité du code.

Qu'est-ce qui est facultatif ?

Le paramètre facultatif est utilisé pour transporter des objets et permettre aux références nulles d'être gérées par diverses API. Regardons l'extrait de code :

Coffee coffee = new Coffee();
Integer quantity = coffee.getSugar().getQuantity();

Nous avons une instance Coffee dans laquelle nous récupérons du sucre à partir d'une instance de l' objet Sugar . Si nous supposons que la valeur de la quantité n'a jamais été définie dans le constructeur Coffee , alors coffee.getSugar().getQuantity() renverra une NullPointerException . Bien sûr, nous pouvons toujours utiliser de bonnes vieilles vérifications nulles pour résoudre le problème.

Coffee coffee = new Coffee();
Integer quantity = 0;
if (coffee.getSugar() != null) {
  quantity = coffee.getSugar().getQuantity();
}

Maintenant, tout semble aller bien. Mais lors de l'écriture de code Java, nous ferions mieux d'éviter d'implémenter des vérifications nulles . Voyons comment cela peut être fait en utilisant Optionnel.

Comment créer Facultatif

Il existe trois manières de créer des objets facultatifs :

• of(T value) — instanciation d'un objet facultatif non nul. Sachez que l'utilisation de of() pour faire référence à un objet nul lèvera une NullPointerException .

• ofNullable(T value) - crée une valeur facultative pour un objet qui peut être nulle.

• empty() - Crée une instance facultative qui représente une référence à null .

// пример использования Optional.of(T Value)
String name = "foo";
Optional<String> stringExample = Optional.of(name)
// пример использования Optional.ofNullable(T Value)
Integer age = null;
Optional<Integer> integerExample= Optional.ofNullable(age)
// пример использования Optional.empty()
Optional<Object> emptyExample = Optional.empty();

Vous avez donc un objet facultatif. Jetons maintenant un coup d'œil aux deux méthodes principales pour Facultatif :

• isPresent() - Cette méthode vous indique si l'objet facultatif contient une valeur non nulle.

• get() - Récupère la valeur de Facultatif avec la valeur actuelle. Sachez que l'appel de get() sur un facultatif vide entraînera une NullPointerException .

Veuillez noter que si vous utilisez uniquement get() et isPresent() lorsque vous travaillez avecOptional, vous ratez quelque chose ! Pour comprendre cela, réécrivons maintenant l'exemple ci-dessus avec Facultatif.

Améliorer la vérification nulle avec facultatif

Alors, comment pouvons-nous améliorer le code ci-dessus ? Avec Optionnel, nous pouvons comprendre la présence d'un objet en utilisant isPresent() et le récupérer en utilisant get() . Commençons par empaqueter le résultat de coffee.getSugar() avecOptional et en utilisant la méthode isPresent() . Cela nous aidera à déterminer si getSugar() renvoie null.

Coffee coffee = new Coffee();
Optional<String> sugar = Optional.ofNullable(coffee.getSugar());
int quantity = 0;
if (sugar.isPresent()) {
  Sugar sugar = sugar.get();
  int quantity = sugar.getQuantity();
}

En regardant cet exemple, regrouper le résultat de coffee.getSugar() dans Facultatif ne semble pas ajouter de valeur, mais ajoute plutôt des tracas. Nous pouvons améliorer le résultat en utilisant ce que je considère comme mes fonctions préférées de la classe Optionnel :

• map(Function<? super T,? extends U> mapper) - Mappe la valeur contenue dans Facultatif à la fonction fournie. Si le paramètre Optionnel est vide, alors map() renverra Optionnel.empty() .

• orElse(T other) est une version « spéciale » de la méthode get() . Il peut obtenir la valeur contenue dans Facultatif. Cependant, dans le cas d'un facultatif vide, cela renverra la valeur passée à la méthode orElse() .

La méthode renverra la valeur contenue dans l’instance facultative. Mais si le paramètre facultatif est vide, ce qui signifie qu'il ne contient aucune valeur, alors orElse() renverra la valeur transmise à sa signature de méthode, appelée valeur par défaut.

Coffee coffee = new Coffee();

Integer quantity = Optional.ofNullable(coffee.getSugar())
    .map(it -> it.getQuantity())
    .orElse(0);

C'est vraiment cool – du moins je le pense. Maintenant, si en cas de valeur vide, nous ne voulons pas renvoyer la valeur par défaut, nous devons alors lever une sorte d'exception. orElseThrow(Supplier<? extends X> exceptionSupplier) renvoie la valeur contenue dans les paramètres facultatifs ou lève une exception si le paramètre facultatif est vide.

Coffee coffee = new Coffee();

Integer quantity = Optional.ofNullable(coffee.getSugar())
  .map(it -> it.getQuantity())
  .orElseThrow(IllegalArgumentException::new);

Comme vous pouvez le constater, Optionnel offre plusieurs avantages :

• résumés contrôles nuls
• fournit une API pour gérer les objets nuls
• permet à l’approche déclarative d’exprimer ce qui est réalisé

Comment devenir efficace avec Optionnel

Dans mon travail, j'utilise Facultatif comme type de retour lorsqu'une méthode peut renvoyer un état « aucun résultat ». Je l'utilise habituellement lors de la définition des types de retour pour les méthodes.

Optional<Coffee> findByName(String name) {
   ...
}

Parfois, ce n'est pas nécessaire. Par exemple, si j'ai une méthode qui renvoie un int , telle que getQuantity() dans la classe Sugar , alors la méthode peut renvoyer 0 si le résultat est nul pour représenter « aucune quantité ». Maintenant, sachant cela, nous pouvons penser que le paramètre Sugar dans la classe Coffee peut être représenté comme Facultatif. À première vue, cela semble être une bonne idée puisque, en théorie, le sucre n’a pas besoin d’être présent dans le café. Cependant, c’est là que je voudrais expliquer quand ne pas utiliser Facultatif. Nous devons éviter d'utiliser Facultatif dans les scénarios suivants :

• En tant que types de paramètres pour les POJO , tels que les DTO . Les options ne sont pas sérialisables, donc leur utilisation dans un POJO rend l'objet non sérialisable.

• Comme argument de méthode. Si un argument de méthode peut être null , alors du point de vue du code pur, passer null est toujours préférable à passer Facultatif. De plus, vous pouvez créer des méthodes surchargées pour gérer de manière abstraite l’absence d’argument de méthode nul.

• Pour représenter un objet Collection manquant. Les collections peuvent être vides, donc une Collection vide , comme un Set ou List vide , doit être utilisée pour représenter une Collection sans valeurs.

Conclusion

Facultatif est devenu un ajout puissant à la bibliothèque Java. Il fournit un moyen de gérer des objets qui peuvent ne pas exister. Il convient donc d’en tenir compte lors de l’élaboration de méthodes sans tomber dans le piège des abus. Oui, vous pouvez écrire du bon code qui implémente les vérifications nulles et la gestion des valeurs nulles, mais la communauté Java préfère utiliser Facultatif. Il indique efficacement comment gérer les valeurs manquantes, est beaucoup plus facile à lire que les vérifications Null désordonnées et entraîne moins de bogues dans votre code à long terme.