TOC

déclarations d’assertion de printemps

Affirmation de printemps

1. Vue d'ensemble

Dans ce didacticiel, nous allons nous concentrer sur et décrire l'objectif de la classeSpring Assert et montrer comment l'utiliser.

2. Objectif de la classeAssert

La classe SpringAssert nous aide à valider les arguments. By using methods of the Assert class, we can write assumptions which we expect to be true. Et s'ils ne sont pas satisfaits, une exception d'exécution est levée.

Chaque méthode deAssert peut être comparée à l'instruction Javaassert. L'instruction Javaassert renvoie unError à l'exécution si sa condition échoue. Le fait intéressant est que ces assertions peuvent être désactivées.

Voici quelques caractéristiques des méthodes de SpringAssert:

  • Les méthodes deAssert sont statiques

  • Ils lancent soitIllegalArgumentException, soitIllegalStateException

  • 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é soit en tant que paramètreString, soit en tant que sparamètreSupplier<String> 

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

3. Exemple d'utilisation

Définissons une classeCar avec une méthode publiquedrive(): 

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 à quel point la vitesse doit être un nombre positif. La ligne ci-dessus est un moyen simple 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 chaqueAssert contient à peu près ce code - un bloc conditionnel avec une exception d'exécution à partir de laquelle l'application ne devrait pas récupérer.

Si nous essayons d'appeler la méthodedrive() avec un argument négatif, une exceptionIllegalArgumentException 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 conditionboolean et lance unIllegalArgumentException lorsque la condition est fausse.

4.2. Etat()

La méthodestate() a la même signature queisTrue() mais jette lesIllegalStateException.

Comme son nom l'indique, il convient de l'utiliser 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éthodefuel() si la voiture est en marche. Utilisons l'assertionstate() dans ce cas: 

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

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

5. Object and Type Assertions

5.1. notNull ()

Nous pouvons supposer qu'un objet n'est pasnull en utilisant la méthodenotNull(): 

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 estnull en utilisant la méthodeisNull(): 

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éthodeisInstanceOf(): 

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

Dans notre exemple, la vérification réussit carToyotaEngine est une sous-classe deEngine.

5.4. isAssignable()

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

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

Deux assertions récentes représentent une relationis-a.

6. Assertions de texte

Les assertions textuelles sont utilisées pour effectuer des vérifications sur les argumentsString.

6.1. hasLength()

Nous pouvons vérifier si unString n'est pas vide, c'est-à-dire qu'il contient au moins un espace, en utilisant la méthodehasLength(): 

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

6.2. hasText()

Nous pouvons renforcer la condition et vérifier si unString contient au moins un caractère non blanc, en utilisant la méthodehasText(): 

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()

Nous pouvons déterminer si un argumentString ne contient pas de sous-chaîne spécifique en utilisant la méthodedoesNotContain(): 

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

7. Assertions de collection et de carte

7.1. notEmpty() pour les collections

Comme son nom l'indique, la méthodenotEmpty() affirme qu'une collection n'est pas vide, ce qui signifie qu'elle n'est pasnull et qu'elle contient au moins un élément: 

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

7.2. notEmpty() pour les cartes

La même méthode est surchargée pour les cartes et nous pouvons vérifier si une carte n'est pas vide et contient au moins une entrée: 

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

8. Assertions de tableau

8.1. notEmpty() pour les tableaux

Enfin, nous pouvons vérifier si un tableau n'est pas vide et contient au moins un élément en utilisant la méthodenotEmpty(): 

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

8.2. noNullElements()

Nous pouvons vérifier qu’un tableau ne contient pas d’élémentsnull en utilisant la méthodenoNullElements(): 

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 n'y a pas d'élémentsnull dedans.

9. Conclusion

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

Comme toujours, le code complet de cet article se trouve dans lesGitHub project.

Related