Message d'erreur de vérification nul comme «est nul» ou «était nul»

Question

Lorsque vous effectuez des vérifications nuls dans le code Java et que vous lancez illégalArgumentExceptions pour les valeurs nulles, quel type de modèle de message utilisez-vous?

Nous avons tendance à utiliser quelque chose comme ça

public User getUser(String username){
   if (username == null){
     throw new IllegalArgumentException("username is null");   
   }
   // ...
}

Quoi de mieux: "Null est-il" ou "était nul", et pourquoi?

Pour moi "est nul" se sent plus naturel.

Answer 1

Depuis le Exception est lancé en raison d'un contrôle de précondition raté, je pense plutôt que de simplement énoncer un fait, vous devez indiquer le exigence qui a été violé.

C'est-à-dire au lieu de dire "username is null", dire "username should not be null".

---

Sur l'utilisation de bibliothèques pour des contrôles de précondition

En guise de conseil, vous pouvez utiliser l'une des nombreuses bibliothèques conçues pour faciliter les contrôles de précondition. De nombreux code dans les goyaves utilisent com.google.common.base.Preconditions

Des méthodes statiques simples à appeler au début de vos propres méthodes pour vérifier les arguments et l'état corrects. Cela permet des constructions telles que

 if (count <= 0) {
   throw new IllegalArgumentException("must be positive: " + count);
 }

être remplacé par les plus compacts

 checkArgument(count > 0, "must be positive: %s", count);

Plus directement pertinent ici checkNotNull, qui vous permet d'écrire simplement:

  checkNotNull(username, "username should not be null");

Notez à quel point le code ci-dessus se lit naturellement, le message détaillé indiquant explicitement le exigence qui a été violé.

L'alternative pour énoncer les faits est plus gênant:

 // Awkward!
 checkArgument(count > 0, "is negative or zero: %s", count);
 checkNotNull(username, "username is null");

De plus, cela est également potentiellement moins utile, car le client peut déjà être conscient du fait, et l'exception ne l'aide pas à déterminer ce que conditions sommes.

---

Sur IllegalArgumentException contre NullPointerException

Pendant que votre code d'origine lance IllegalArgumentException sur null arguments, goyave Preconditions.checkNotNull lancers NullPointerException Au lieu.

Ceci est conforme aux directives définies par l'API:

NullPointerException: Les applications doivent lancer des instances de cette classe pour indiquer d'autres utilisations illégales de la null objet.

De plus, voici une citation de Java efficace 2e édition: point 60: favoriser l'utilisation des exceptions standard:

Sans doute, toutes les invocations de méthode erronées se résument à un argument illégal ou à un état illégal, mais d'autres exceptions sont utilisées standard certains types des arguments et des États illégaux. Si un appelant passe null Dans certains paramètres pour lesquels les valeurs nulles sont interdites, la convention dicte que NullPointerException être jeté plutôt que IllegalArgumentException.

Answer 2

est nul, puisque l'argument est encore nul.

Cependant, pourquoi ne pas simplement lancer une nulpointerexception sans message?

Answer 3

Je suggère de dire

  if (userName == null) {
     throw new IllegalArgumentException("username == null");
   }

Comme cela est si fatal qu'un programmeur doit le regarder de toute façon. En référant l'extrait de code offensant dans le message d'exception est la chose la plus concise que je puisse imaginer.

Answer 4

Je serais enclin à écrire ceci:

public User getUser(String username) {
   if (username.length() == 0) {
       throw new IllegalArgumentException("username is empty");   
   }
   // ...
}

Cela tue deux oiseaux avec une pierre. Tout d'abord, il détecte le cas où le nom d'utilisateur est une chaîne vide, qui (pour le souci d'argument), je suppose que c'est une erreur. Deuxièmement, si le paramètre est null Tenter d'envoyer le length L'appel donnera un NullPointerException.

Pour mémoire, le attendu exception à lancer pour un inattendu null est NullPointerException. Si votre raison principale de ne pas l'utiliser est que NPE n'a généralement pas de message, codez-le comme ceci:

public User getUser(String username){
   if (username == null){
       throw new NullPointerException("username is null");   
   }
   if (username.length() == 0) {
       throw new IllegalArgumentException("username is empty");   
   }
   // ...
}

Pourquoi utiliser NPE ici? Parce que NPE indique presque toujours un Différents types de problèmes à un autre type d'erreur de validation d'argument; Par exemple, une cellule de champ ou de tableau qui n'a pas été initialisée ou une valeur "facultative" qui n'est pas gérée correctement.

Enfin à la question:

Qu'est-ce qui est mieux : "is null" ou "was null", et pourquoi?

C'est une question d'opinion, mais j'écrirai "is null".

• Parce que le message rapporte l'État lorsque l'exception a été lancée.
• Parce qu'il est conventionnel de le faire de cette façon.