Dichiarazioni di affermazione della primavera

1. Panoramica

In questo tutorial, ci concentreremo e descriveremo lo scopo della classe Spring Assert e dimostreremo come usarla.

2. Scopo della classe Assert

La classe Spring Assert ci aiuta a convalidare gli argomenti. Utilizzando i metodi della classe Assert , possiamo scrivere ipotesi che ci aspettiamo siano vere. E se non vengono soddisfatte, viene generata un'eccezione di runtime.

Ogni asserzione metodo ‘s può essere confrontato con il Java assert dichiarazione. L' istruzione di asserzione Java genera un errore in fase di esecuzione se la sua condizione non riesce. Il fatto interessante è che queste affermazioni possono essere disabilitate.

Di seguito sono riportate alcune caratteristiche dei metodi di Spring Assert :

  • I metodi di Assert sono statici
  • Gettano uno IllegalArgumentException o IllegalStateException
  • Il primo parametro è solitamente un argomento per la convalida o una condizione logica da controllare
  • L'ultimo parametro è solitamente un messaggio di eccezione che viene visualizzato se la convalida non riesce
  • Il messaggio può essere passato come parametro String o come parametro Supplier

Si noti inoltre che, nonostante il nome simile, le asserzioni Spring non hanno nulla in comune con le asserzioni di JUnit e altri framework di test. Le asserzioni di primavera non sono per il test, ma per il debug.

3. Esempio di utilizzo

Definiamo una classe Car con un metodo pubblico drive () :

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

Possiamo vedere come la velocità debba essere un numero positivo. La riga sopra è un modo breve per verificare la condizione e generare un'eccezione se la condizione non riesce:

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

Il metodo pubblico di ogni Assert contiene approssimativamente questo codice: un blocco condizionale con un'eccezione di runtime da cui non è previsto il ripristino dell'applicazione.

Se proviamo a chiamare il metodo drive () con un argomento negativo, verrà generata un'eccezione IllegalArgumentException :

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

4. Asserzioni logiche

4.1. è vero()

Questa affermazione è stata discussa sopra. Accetta una condizione booleana e genera un'eccezione IllegalArgumentException quando la condizione è falsa.

4.2. stato()

Il metodo state () ha la stessa firma di isTrue () ma genera IllegalStateException.

Come suggerisce il nome, dovrebbe essere usato quando il metodo non deve essere continuato a causa di uno stato illegale dell'oggetto.

Immagina di non poter chiamare il metodo fuel () se l'auto è in funzione. Usiamo l' asserzione state () in questo caso:

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

Naturalmente, possiamo convalidare tutto utilizzando asserzioni logiche. Ma per una migliore leggibilità, possiamo usare asserzioni aggiuntive che rendono il nostro codice più espressivo.

5. tipi e gli oggetti Assertio ns

5.1. non nullo()

Possiamo supporre che un oggetto non sia nullo usando il metodo notNull () :

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

5.2. è zero()

D'altra parte, possiamo controllare se un oggetto è nullo usando il metodo isNull () :

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

5.3. isInstanceOf ()

Per verificare se un oggetto è un'istanza di un altro oggetto del tipo specifico possiamo utilizzare il metodo isInstanceOf () :

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

Nel nostro esempio, il controllo ha esito positivo poiché ToyotaEngine è una sottoclasse di Engine.

5.4. isAssignable ()

Per controllare i tipi, possiamo usare Assert.isAssignable () :

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

Due recenti affermazioni rappresentano una relazione è-un .

6. Asserzioni di testo

Le asserzioni di testo vengono utilizzate per eseguire controlli sugli argomenti 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"); // ... }

Notare che questo controllo viene comunque superato se l'array è vuoto, purché non contenga elementi nulli .

9. Conclusione

In questo articolo abbiamo esplorato la classe Assert . Questa classe è ampiamente utilizzata nel framework Spring, ma potremmo facilmente scrivere codice più robusto ed espressivo sfruttandone i vantaggi.

Come sempre, il codice completo per questo articolo può essere trovato nel progetto GitHub.