Est-il préférable d'utiliser assert ou IllegalArgumentException pour les paramètres de méthode requis?

En Java, qu'est-ce qui est le plus recommandé, et pourquoi? Les deux types jetteront des exceptions, de sorte que leur traitement est identique. assertest légèrement plus courte, mais je ne sais pas trop ce qui compte.

public void doStuff(Object obj) {
    assert obj != null;
    ...
}

contre

public void doStuff(Object obj) {
    if (obj == null) {
        throw new IllegalArgumentException("object was null");
    }
    ...
}

IL FAUT SE MÉFIER!

Les assertions sont supprimées au moment de l'exécution, à moins que vous ne spécifiiez explicitement d'activer les "assertions" lors de la compilation de votre code. Les assertions Java ne doivent pas être utilisées dans le code de production et doivent être limitées aux méthodes privées (voir Exception vs Assertion ), car les méthodes privées ne devraient être connues et utilisées que par les développeurs. En outre assertjetteront AssertionError qui Prolonge Errorpas Exception, et qui indique normalement vous avez une erreur très anormale (comme « OutOfMemoryError » qui est difficile à récupérer, non?) , Vous n'êtes pas censé être en mesure de traiter.

Supprimez l'indicateur "enable assertions" et vérifiez avec un débogueur et vous verrez que vous ne passerez pas à l'appel de levée IllegalArgumentException ... puisque ce code n'a pas été compilé (encore une fois, lorsque "ea" est supprimé).

Il est préférable d’utiliser la deuxième construction pour les méthodes publiques / protégées, et si vous voulez quelque chose qui est fait dans une ligne de code, il ya au moins une façon que je connaisse. Personnellement , j'utiliser le cadre du printemps de la Assertclasse qui a quelques méthodes de contrôle des arguments et que jeter « IllegalArgumentException » en cas d' échec. Fondamentalement, ce que vous faites est:

Assert.notNull(obj, "object was null");

... Ce qui exécutera en fait exactement le même code que celui que vous avez écrit dans votre deuxième exemple. Il existe quelques autres méthodes utiles telles que hasText, hasLengthici.

Je n'aime pas écrire plus de code que nécessaire, je suis donc content de réduire le nombre de lignes écrites de 2 (2 lignes> 1 ligne) :-)

Vous devez utiliser une exception. L'utilisation d'une assertion constituerait un abus de la fonctionnalité.

Les exceptions non contrôlées sont conçues pour détecter les erreurs de programmation des utilisateurs de votre bibliothèque, tandis que les assertions sont conçues pour détecter les erreurs dans votre propre logique. Ce sont des questions distinctes qui ne devraient pas être mélangées.

Par exemple, une assertion

assert myConnection.isConnected();

signifie "Je sais que chaque chemin de code menant à cette assertion garantit que la myConnectionconnexion est établie; si le code ci-dessus ne parvient pas à obtenir une connexion valide, il aurait dû déclencher une exception ou un retour avant d'atteindre ce point."

D'autre part, un chèque

if (!myConnection.isConnected()) {
    throw new IllegalArgumentException("connection is not established");
}

signifie que "Appeler ma bibliothèque sans établir de connexion est une erreur de programmation".

Si vous écrivez une fonction qui n'autorise pas nullune valeur de paramètre valide, vous devez ajouter l' @Nonnullannotation à la signature et l'utiliser Objects.requireNonNullpour vérifier si l'argument est nullet afficher un NullPointerExceptionsi. L' @Nonnullannotation est pour la documentation et fournira des avertissements utiles lors de la compilation dans certains cas. Cela n'empêche pas nulld'être transmis au moment de l'exécution.

void doStuff(@Nonnull Object obj) {
    Objects.requireNonNull(obj, "obj must not be null");

    // do stuff...
}

Mise à jour: L' @Nonnullannotation ne fait pas partie de la bibliothèque standard Java. Au lieu de cela, il existe de nombreux standards concurrents de bibliothèques tierces (voir Quelle annotation Java @NotNull dois-je utiliser? ). Cela ne signifie pas que c'est une mauvaise idée de l'utiliser, mais que ce n'est pas standard.

Je préfère toujours lancer l'exception IllegalArgumentException sur les assertions.

Les assertions sont principalement utilisées dans JUnit ou d'autres outils de test afin de vérifier / assert des résultats de test. Cela pourrait donc donner une fausse impression aux autres développeurs que votre méthode est une méthode de test.

De plus, il est logique de lancer IllegalArgumentException lorsqu'une méthode a été transmise à un argument illégal ou inapproprié . Ceci est plus cohérent avec la convention de gestion des exceptions suivie par les développeurs Java.

La deuxième solution IMO est légèrement meilleure, car elle apporte davantage d'informations et pourrait être encore étendue (par exemple en élargissant la classe des exceptions) pour être encore plus informative. De plus, elle n'utilise pas de comparaison négative plus facile à comprendre.

Je n'utilise pas beaucoup d'aserts, mais une approche commune avec Lombock @NonNull: https://projectlombok.org/features/NonNull

Implémentation de Lombok: import lombok.NonNull;

public class NonNullExample extends Something {
  private String name;

  public NonNullExample(@NonNull Person person) {
    super("Hello");
    this.name = person.getName();
  }
}

Version Java:

 import lombok.NonNull;

public class NonNullExample extends Something {
  private String name;

  public NonNullExample(@NonNull Person person) {
    super("Hello");
    if (person == null) {
      throw new NullPointerException("person");
    }
    this.name = person.getName();
  }
}

Lombok est vraiment une très belle bibliothèque que j'utilise partout