TOC

Guide des conditions préalables de Goyave

Guide des conditions préalables de Goyave

1. Vue d'ensemble

Dans ce didacticiel, nous allons montrer comment utiliser la classePreconditions de Google Guava.

La classePreconditions fournit une liste de méthodes statiques pour vérifier qu'une méthode ou un constructeur est appelé avec des valeurs de paramètre valides. Si une condition préalable échoue, une exception personnalisée est levée.

2. Preconditions de Google Guava

Chaque méthode statique de la classePreconditions a trois variantes:

  • Aucun argument. Les exceptions sont levées sans message d'erreur

  • Un argumentObject supplémentaire agissant comme un message d'erreur. Les exceptions sont levées avec un message d'erreur

  • Un argument String supplémentaire, avec un nombre arbitraire d'argumentsObject supplémentaires agissant comme un message d'erreur avec un espace réservé. Cela se comporte un peu commeprintf, mais pour la compatibilité et l'efficacité GWT, il n'autorise que les indicateurs%s

Voyons comment utiliser la classePreconditions.

2.1. Dépendance Maven

Commençons par ajouter la dépendance de la bibliothèque Guava de Google dans lespom.xml: 


    com.google.guava
    guava
    21.0

La dernière version de la dépendance peut être vérifiéehere.

3. checkArgument

La méthodeThecheckArgument desPreconditions class garantit la véracité des paramètres passés à la méthode appelante. Cette méthode accepte une condition booléenne et renvoie unIllegalArgumentException lorsque la condition est fausse.

Voyons comment nous pouvons utiliser cette méthode avec quelques exemples.

3.1. Sans message d'erreur

Nous pouvons utilisercheckArgument sans passer de paramètre supplémentaire à la méthodecheckArgument: 

@Test
public void whenCheckArgumentEvaluatesFalse_throwsException() {
    int age = -18;

    assertThatThrownBy(() -> Preconditions.checkArgument(age > 0))
      .isInstanceOf(IllegalArgumentException.class)
      .hasMessage(null).hasNoCause();
}

3.2. Avec un message d'erreur

Nous pouvons obtenir un message d'erreur significatif de la méthodecheckArgument en passant un message d'erreur: 

@Test
public void givenErrorMsg_whenCheckArgEvalsFalse_throwsException() {
    int age = -18;
    String message = "Age can't be zero or less than zero.";

    assertThatThrownBy(() -> Preconditions.checkArgument(age > 0, message))
      .isInstanceOf(IllegalArgumentException.class)
      .hasMessage(message).hasNoCause();
}

3.3. Avec un message d'erreur de modèle

Nous pouvons obtenir un message d'erreur significatif avec des données dynamiques de la méthodecheckArgument en passant un message d'erreur: 

@Test
public void givenTemplateMsg_whenCheckArgEvalsFalse_throwsException() {
    int age = -18;
    String message = "Age should be positive number, you supplied %s.";

    assertThatThrownBy(
      () -> Preconditions.checkArgument(age > 0, message, age))
      .isInstanceOf(IllegalArgumentException.class)
      .hasMessage(message, age).hasNoCause();
}

4. checkElementIndex

La méthodecheckElementIndex vérifie qu'un index est un index valide dans une liste, une chaîne ou un tableau d'une taille spécifiée. Un index d'élément peut aller de 0 inclus à la taille exclusive. Vous ne transmettez pas directement une liste, une chaîne ou un tableau, vous transmettez simplement sa taille. Cette méthode renvoie unIndexOutOfBoundsException si l'index n'est pas un index d'élément valide, sinon elle renvoie un index qui est passé à la méthode.

Voyons comment nous pouvons utiliser cette méthode en affichant un message d'erreur significatif de la méthodecheckElementIndex en transmettant un message d'erreur lorsqu'il lève une exception: 

@Test
public void givenArrayAndMsg_whenCheckElementEvalsFalse_throwsException() {
    int[] numbers = { 1, 2, 3, 4, 5 };
    String message = "Please check the bound of an array and retry";

    assertThatThrownBy(() ->
      Preconditions.checkElementIndex(6, numbers.length - 1, message))
      .isInstanceOf(IndexOutOfBoundsException.class)
      .hasMessageStartingWith(message).hasNoCause();
}

5. checkNotNull

La méthodecheckNotNull vérifie si une valeur fournie comme paramètre est nulle. Il renvoie la valeur qui a été vérifiée. Si la valeur qui a été transmise à cette méthode est nulle, unNullPointerException est renvoyé.

Ensuite, nous allons montrer comment utiliser cette méthode en montrant comment obtenir un message d'erreur significatif de la méthodecheckNotNull en passant un message d'erreur: 

@Test
public void givenNullString_whenCheckNotNullWithMessage_throwsException () {
    String nullObject = null;
    String message = "Please check the Object supplied, its null!";

    assertThatThrownBy(() -> Preconditions.checkNotNull(nullObject, message))
      .isInstanceOf(NullPointerException.class)
      .hasMessage(message).hasNoCause();
}

Nous pouvons également obtenir un message d'erreur significatif basé sur des données dynamiques de la méthodecheckNotNull en passant un paramètre au message d'erreur: 

@Test
public void whenCheckNotNullWithTemplateMessage_throwsException() {
    String nullObject = null;
    String message = "Please check the Object supplied, its %s!";

    assertThatThrownBy(
      () -> Preconditions.checkNotNull(nullObject, message,
        new Object[] { null }))
      .isInstanceOf(NullPointerException.class)
      .hasMessage(message, nullObject).hasNoCause();
}

6. checkPositionIndex

La méthodecheckPositionIndex vérifie qu'un index passé comme argument à cette méthode est un index valide dans une liste, une chaîne ou un tableau d'une taille spécifiée. Un indice de position peut aller de 0 inclus à la taille incluse. Vous ne transmettez pas directement la liste, la chaîne ou le tableau, vous transmettez simplement sa taille.

Cette méthode lève unIndexOutOfBoundsException si l'index passé n'est pas compris entre 0 et la taille donnée, sinon elle renvoie la valeur d'index.

Voyons comment nous pouvons obtenir un message d'erreur significatif de la méthodecheckPositionIndex: 

@Test
public void givenArrayAndMsg_whenCheckPositionEvalsFalse_throwsException() {
    int[] numbers = { 1, 2, 3, 4, 5 };
    String message = "Please check the bound of an array and retry";

    assertThatThrownBy(
      () -> Preconditions.checkPositionIndex(6, numbers.length - 1, message))
      .isInstanceOf(IndexOutOfBoundsException.class)
      .hasMessageStartingWith(message).hasNoCause();
}

7. checkState

La méthodecheckState vérifie la validité de l'état d'un objet et ne dépend pas des arguments de la méthode. Par exemple, unIterator peut l'utiliser pour vérifier que next a été appelé avant tout appel à supprimer. Cette méthode lève unIllegalStateException si l'état d'un objet (valeur booléenne passée en argument à la méthode) est dans un état invalide.

Voyons comment nous pouvons utiliser cette méthode en affichant un message d'erreur significatif de la méthodecheckState en transmettant un message d'erreur lorsqu'il lève une exception: 

@Test
public void givenStatesAndMsg_whenCheckStateEvalsFalse_throwsException() {
    int[] validStates = { -1, 0, 1 };
    int givenState = 10;
    String message = "You have entered an invalid state";

    assertThatThrownBy(
      () -> Preconditions.checkState(
        Arrays.binarySearch(validStates, givenState) > 0, message))
      .isInstanceOf(IllegalStateException.class)
      .hasMessageStartingWith(message).hasNoCause();
}

8. Conclusion

Dans ce tutoriel, nous avons illustré les méthodes de la classePreConditions de la bibliothèque Guava. La classePreconditions fournit une collection de méthodes statiques utilisées pour valider qu'une méthode ou un constructeur est appelé avec des valeurs de paramètre valides.

Le code appartenant aux exemples ci-dessus peut être trouvé dansthe GitHub project - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

Related