Déclarations Spring Assert

1. Vue d'ensemble

Dans ce didacticiel, nous allons nous concentrer sur et décrire le but de la classe Spring Assert et montrer comment l'utiliser.

2. Objectif de la classe Assert

La classe Spring Assert nous aide à valider les arguments. En utilisant les méthodes de la classe Assert , nous pouvons écrire des hypothèses dont nous nous attendons à ce qu'elles soient vraies. Et s'ils ne sont pas satisfaits, une exception d'exécution est levée.

La méthode de chaque Assert peut être comparée à l' instruction d' assert Java . Java assert déclaration renvoie une erreur lors de l' exécution si son état échoue. Le fait intéressant est que ces affirmations peuvent être désactivées.

Voici quelques caractéristiques des méthodes de Spring Assert :

  • Les méthodes d' Assert sont statiques
  • Ils jettent soit IllegalArgumentException ou IllegalStateException
  • Le premier paramètre est généralement un argument de validation ou une condition logique à vérifier
  • Le dernier paramètre est généralement un message d'exception qui s'affiche si la validation échoue
  • Le message peut être passé en tant que paramètre String ou en tant que paramètre Supplier

Notez également que malgré le nom similaire, les assertions Spring n'ont rien de commun avec les assertions de JUnit et d'autres frameworks de test. Les assertions Spring ne sont pas destinées aux tests, mais au débogage.

3. Exemple d'utilisation

Définissons une classe Car avec une méthode publique drive () :

public class Car { private String state = "stop"; public void drive(int speed) { Assert.isTrue(speed > 0, "speed must be positive"); this.state = "drive"; // ... } }

Nous pouvons voir comment la vitesse doit être un nombre positif. La ligne ci-dessus est un moyen court de vérifier la condition et de lever une exception si la condition échoue:

if (!(speed > 0)) { throw new IllegalArgumentException("speed must be positive"); }

La méthode publique de chaque Assert contient à peu près ce code - un bloc conditionnel avec une exception d'exécution à partir de laquelle l'application n'est pas censée récupérer.

Si nous essayons d'appeler la méthode drive () avec un argument négatif, une exception IllegalArgumentException sera levée:

Exception in thread "main" java.lang.IllegalArgumentException: speed must be positive

4. Assertions logiques

4.1. est vrai()

Cette affirmation a été discutée ci-dessus. Il accepte une condition booléenne et lève une IllegalArgumentException lorsque la condition est fausse.

4.2. Etat()

La méthode state () a la même signature que isTrue () mais lève l' exception IllegalStateException .

Comme son nom l'indique, il doit être utilisé lorsque la méthode ne doit pas être poursuivie en raison d'un état illégal de l'objet.

Imaginez que nous ne pouvons pas appeler la méthode fuel () si la voiture est en marche. Utilisons l' assertion state () dans ce cas:

public void fuel() { Assert.state(this.state.equals("stop"), "car must be stopped"); // ... }

Bien sûr, nous pouvons tout valider à l'aide d'assertions logiques. Mais pour une meilleure lisibilité, nous pouvons utiliser des assertions supplémentaires qui rendent notre code plus expressif.

5. Assertio ns d' objets et de types

5.1. notNull ()

Nous pouvons supposer qu'un objet n'est pas nul en utilisant la méthode notNull () :

public void сhangeOil(String oil) { Assert.notNull(oil, "oil mustn't be null"); // ... }

5.2. isNull ()

D'autre part, nous pouvons vérifier si un objet est nul en utilisant la méthode isNull () :

public void replaceBattery(CarBattery carBattery) { Assert.isNull( carBattery.getCharge(), "to replace battery the charge must be null"); // ... }

5.3. isInstanceOf ()

Pour vérifier si un objet est une instance d'un autre objet du type spécifique, nous pouvons utiliser la méthode isInstanceOf () :

public void сhangeEngine(Engine engine) { Assert.isInstanceOf(ToyotaEngine.class, engine); // ... }

Dans notre exemple, la vérification réussit car ToyotaEngine est une sous-classe de Engine.

5.4. isAssignable ()

Pour vérifier les types, nous pouvons utiliser Assert.isAssignable () :

public void repairEngine(Engine engine) { Assert.isAssignable(Engine.class, ToyotaEngine.class); // ... }

Deux affirmations récentes représentent une relation is-a .

6. Assertions textuelles

Les assertions de texte sont utilisées pour effectuer des vérifications sur les arguments String .

6.1. hasLength ()

We can check if a String isn't blank, meaning it contains at least one whitespace, by using the hasLength() method:

public void startWithHasLength(String key) { Assert.hasLength(key, "key must not be null and must not the empty"); // ... }

6.2. hasText()

We can strengthen the condition and check if a String contains at least one non-whitespace character, by using the hasText() method:

public void startWithHasText(String key) { Assert.hasText( key, "key must not be null and must contain at least one non-whitespace character"); // ... }

6.3. doesNotContain()

We can determine if a String argument doesn’t contain a specific substring by using the doesNotContain() method:

public void startWithNotContain(String key) { Assert.doesNotContain(key, "123", "key mustn't contain 123"); // ... }

7. Collection and Map Assertions

7.1. notEmpty() for Collections

As the name says, the notEmpty() method asserts that a collection is not empty meaning that it’s not null and contains at least one element:

public void repair(Collection repairParts) { Assert.notEmpty( repairParts, "collection of repairParts mustn't be empty"); // ... }

7.2. notEmpty() for Maps

The same method is overloaded for maps, and we can check if a map is not empty and contains at least one entry:

public void repair(Map repairParts) { Assert.notEmpty( repairParts, "map of repairParts mustn't be empty"); // ... }

8. Array Assertions

8.1. notEmpty() for Arrays

Finally, we can check if an array is not empty and contains at least one element by using the notEmpty() method:

public void repair(String[] repairParts) { Assert.notEmpty( repairParts, "array of repairParts mustn't be empty"); // ... }

8.2. noNullElements()

We can verify that an array doesn’t contain null elements by using the noNullElements() method:

public void repairWithNoNull(String[] repairParts) { Assert.noNullElements( repairParts, "array of repairParts mustn't contain null elements"); // ... }

Notez que cette vérification réussit toujours si le tableau est vide, tant qu'il ne contient aucun élément nul .

9. Conclusion

Dans cet article, nous avons exploré la classe Assert . Cette classe est largement utilisée dans le framework Spring, mais nous pourrions facilement écrire du code plus robuste et expressif en en tirant parti.

Comme toujours, le code complet de cet article se trouve dans le projet GitHub.