TOC

Spring Assert-Anweisungen

Spring Assert-Anweisungen

1. Überblick

In diesem Tutorial konzentrieren wir uns auf den Zweck derSpring Assert-Klasse und beschreiben deren Verwendung.

2. Zweck derAssert-Klasse

Die SpringAssert-Klasse hilft uns, Argumente zu validieren. By using methods of the Assert class, we can write assumptions which we expect to be true. Und wenn sie nicht erfüllt sind, wird eine Laufzeitausnahme ausgelöst.

Die Methode jedesAssertkann mit der Javaassert-Anweisung verglichen werden. Die Anweisung Javaassertlöst zur Laufzeit einError aus, wenn der Zustand fehlschlägt. Die interessante Tatsache ist, dass diese Behauptungen deaktiviert werden können.

Hier sind einige Merkmale der Methoden von SpringAssert:

  • Die Methoden vonAssertind statisch

  • Sie werfen entwederIllegalArgumentException oderIllegalStateException

  • Der erste Parameter ist normalerweise ein Argument für die Validierung oder eine zu überprüfende logische Bedingung

  • Der letzte Parameter ist normalerweise eine Ausnahmemeldung, die angezeigt wird, wenn die Validierung fehlschlägt

  • Die Nachricht kann entweder alsString-Parameter oder alsSupplier<String> -Sparameter übergeben werden

Beachten Sie auch, dass Spring-Assertions trotz des ähnlichen Namens nichts mit den Assertions vonJUnit und anderen Test-Frameworks gemein haben. Spring Assertions dienen nicht zum Testen, sondern zum Debuggen.

3. Anwendungsbeispiel

Definieren wir eineCar-Klasse mit einer öffentlichen Methodedrive(): 

public class Car {
    private String state = "stop";

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

Wir können sehen, wie schnell eine positive Zahl sein muss. Die obige Zeile ist eine kurze Möglichkeit, die Bedingung zu überprüfen und eine Ausnahme auszulösen, wenn die Bedingung fehlschlägt: 

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

Die öffentliche Methode jedesAssertenthält ungefähr diesen Code - einen bedingten Block mit einer Laufzeitausnahme, von der die Anwendung voraussichtlich keine Wiederherstellung durchführen wird.

Wenn wir versuchen, die Methodedrive()mit einem negativen Argument aufzurufen, wird eine Ausnahme vonIllegalArgumentExceptionausgelöst: 

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

4. Logische Aussagen

4.1. ist wahr()

Diese Behauptung wurde oben diskutiert. Es akzeptiert eineboolean-Bedingung und löst eineIllegalArgumentException aus, wenn die Bedingung falsch ist.

4.2. Zustand()

Die Methodestate() hat dieselbe Signatur wieisTrue(), löst jedochIllegalStateException. aus

Wie der Name schon sagt, sollte es verwendet werden, wenn die Methode wegen eines unzulässigen Zustands des Objekts nicht fortgesetzt werden darf.

Stellen Sie sich vor, wir können diefuel()-Methode nicht aufrufen, wenn das Auto fährt. Verwenden wir in diesem Fall die Behauptung vonstate(): 

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

Natürlich können wir alles anhand logischer Aussagen überprüfen. Zur besseren Lesbarkeit können wir jedoch zusätzliche Aussagen verwenden, die unseren Code aussagekräftiger machen.

5. Object and Type Assertions

5.1. nicht null()

Mit der MethodenotNull() können wir annehmen, dass ein Objekt nichtnull ist: 

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

5.2. isNull()

Andererseits können wir mit der MethodeisNull() überprüfen, ob ein Objektnull ist: 

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

5.3. isInstanceOf()

Um zu überprüfen, ob ein Objekt eine Instanz eines anderen Objekts des bestimmten Typs ist, können Sie die MethodeisInstanceOf()verwenden: 

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

In unserem Beispiel besteht die Prüfung erfolgreich, daToyotaEngine eine Unterklasse vonEngine. ist

5.4. isAssignable()

Um Typen zu überprüfen, können wirAssert.isAssignable() verwenden: 

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

Zwei aktuelle Behauptungen repräsentieren die Beziehung vonis-a.

6. Textbehauptungen

Textzusicherungen werden verwendet, um die Argumente vonStringzu überprüfen.

6.1. hasLength()

Mit der MethodehasLength()können wir überprüfen, ob einString nicht leer ist, dh mindestens ein Leerzeichen enthält: 

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

6.2. hasText()

Mit der MethodehasText()können wir die Bedingung verstärken und prüfen, ob einString mindestens ein Nicht-Leerzeichen enthält: 

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

Mit der MethodedoesNotContain()können wir feststellen, ob das ArgumentStringkeinen bestimmten Teilstring enthält: 

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

7. Sammlungs- und Kartenbehauptungen

7.1. notEmpty() für Sammlungen

Wie der Name schon sagt, behauptet die MethodenotEmpty(), dass eine Sammlung nicht leer ist, was bedeutet, dass sie nichtnullist und mindestens ein Element enthält: 

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

7.2. notEmpty() für Karten

Dieselbe Methode ist für Karten überladen, und wir können überprüfen, ob eine Karte nicht leer ist und mindestens einen Eintrag enthält: 

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

8. Array-Zusicherungen

8.1. notEmpty() für Arrays

Schließlich können wir mithilfe der MethodenotEmpty()überprüfen, ob ein Array nicht leer ist und mindestens ein Element enthält: 

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

8.2. noNullElements()

Mit der MethodenoNullElements()können wir überprüfen, ob ein Array keinenull-Elemente enthält: 

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

Beachten Sie, dass diese Prüfung weiterhin besteht, wenn das Array leer ist, solange keinenull-Elemente enthalten sind.

9. Fazit

In diesem Artikel haben wir die KlasseAssertuntersucht. Diese Klasse ist im Spring-Framework weit verbreitet, aber wir könnten leicht robusteren und aussagekräftigeren Code schreiben, indem wir sie nutzen.

Wie immer finden Sie den vollständigen Code für diesen Artikel inGitHub project.

Related