Spring Assert-verklaringen

1. Overzicht

In deze tutorial concentreren we ons op en beschrijven we het doel van de lente Beweren class en laat zien hoe u deze kunt gebruiken.

2. Doel van de Beweren Klasse

De lente Beweren class helpt ons argumenten te valideren. Door gebruik te maken van methoden van de Beweren klasse, kunnen we aannames schrijven waarvan we verwachten dat ze waar zijn. En als ze niet worden gehaald, wordt er een runtime-uitzondering gegenereerd.

Elk Beweren’S methode kan worden vergeleken met de Java beweren uitspraak. Java beweren statement gooit een Fout tijdens runtime als de toestand ervan mislukt. Het interessante feit is dat die beweringen kunnen worden uitgeschakeld.

Hier zijn enkele kenmerken van de lente Beweren’S methoden:

  • Beweren’S methoden zijn statisch
  • Ze gooien ook IllegalArgumentException of IllegalStateException
  • De eerste parameter is meestal een argument voor validatie of een logische voorwaarde om te controleren
  • De laatste parameter is meestal een uitzonderingsbericht dat wordt weergegeven als de validatie mislukt
  • Het bericht kan worden doorgegeven als een Draad parameter of als een Leverancier parameter

Merk ook op dat ondanks de gelijkaardige naam, de beweringen van Spring niets gemeen hebben met de beweringen van JUnit en andere testframeworks. Spring-beweringen zijn niet bedoeld om te testen, maar om fouten op te sporen.

3. Voorbeeld van gebruik

Laten we een Auto klasse met een openbare methode rit():

openbare klasse Car {private String state = "stop"; public void drive (int speed) {Assert.isTrue (snelheid> 0, "snelheid moet positief zijn"); this.state = "drive"; // ...}}

We kunnen zien hoe snelheid een positief getal moet zijn. De bovenstaande rij is een korte manier om de voorwaarde te controleren en een uitzondering te genereren als de voorwaarde mislukt:

if (! (speed> 0)) {throw new IllegalArgumentException ("snelheid moet positief zijn"); }

Elk BewerenDe openbare methode bevat grofweg deze code: een voorwaardelijk blok met een runtime-uitzondering waarvan de toepassing naar verwachting niet zal herstellen.

Als we proberen het rit() methode met een negatief argument, een IllegalArgumentException uitzondering wordt gegenereerd:

Uitzondering in thread "main" java.lang.IllegalArgumentException: snelheid moet positief zijn

4. Logische beweringen

4.1. is waar()

Deze bewering is hierboven besproken. Het accepteert een boolean conditie en gooit een IllegalArgumentException wanneer de voorwaarde onwaar is.

4.2. staat()

De staat() methode heeft dezelfde handtekening als is waar() maar gooit de IllegalStateException.

Zoals de naam suggereert, moet het worden gebruikt wanneer de methode niet moet worden voortgezet vanwege een illegale status van het object.

Stel je voor dat we de brandstof() methode als de auto rijdt. Laten we de staat() bewering in dit geval:

public void fuel () {Assert.state (this.state.equals ("stop"), "auto moet worden gestopt"); // ...}

Natuurlijk kunnen we alles valideren met behulp van logische beweringen. Maar voor een betere leesbaarheid kunnen we aanvullende beweringen gebruiken die onze code expressiever maken.

5. Object en typ AssertioNS

5.1. niet nul()

We kunnen aannemen dat een object dat niet is nul door de niet nul() methode:

public void сhangeOil (String olie) {Assert.notNull (olie, "olie mag niet nul zijn"); // ...}

5.2. is niets()

Aan de andere kant kunnen we controleren of een object dat wel is nul de ... gebruiken is niets() methode:

public void replaceBattery (CarBattery carBattery) {Assert.isNull (carBattery.getCharge (), "om de batterij te vervangen moet de lading nul zijn"); // ...}

5.3. isInstanceOf ()

Om te controleren of een object een instantie is van een ander object van het specifieke type, kunnen we de isInstanceOf () methode:

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

In ons voorbeeld slaagt de cheque met succes als Toyota Motor is een subklasse van Motor.

5.4. isAssignable ()

Om typen te controleren, kunnen we gebruiken Assert.isAssignable ():

openbare ongeldige reparatieEngine (Engine engine) {Assert.isAssignable (Engine.class, ToyotaEngine.class); // ...}

Twee recente beweringen vertegenwoordigen een is een relatie.

6. Tekstbeweringen

Tekstbevestigingen worden gebruikt om controles uit te voeren op Draad argumenten.

6.1. hasLength ()

We kunnen controleren of a Draad is niet leeg, wat betekent dat het ten minste één witruimte bevat, door de hasLength () methode:

public void startWithHasLength (String key) {Assert.hasLength (key, "key mag niet null zijn en mag niet leeg zijn"); // ...}

6.2. hasText ()

We kunnen de aandoening versterken en controleren of a Draad bevat ten minste één niet-witruimte-teken, met behulp van de hasText () methode:

public void startWithHasText (String-sleutel) {Assert.hasText (sleutel, "sleutel mag niet null zijn en moet ten minste één niet-witruimteteken bevatten"); // ...}

6.3. bevat geen()

We kunnen bepalen of a Draad argument bevat geen specifieke subtekenreeks door de bevat geen() methode:

public void startWithNotContain (String key) {Assert.doesNotContain (key, "123", "key mag geen 123 bevatten"); // ...}

7. Verzameling en kaartbeweringen

7.1. niet leeg() voor collecties

Zoals de naam al zegt, de niet leeg() method beweert dat een collectie niet leeg is, wat betekent dat het niet leeg is nul en bevat minstens één element:

public void repair (Collectie repairParts) {Assert.notEmpty (repairParts, "collectie van repairParts mag niet leeg zijn"); // ...}

7.2. niet leeg() voor Maps

Dezelfde methode is overbelast voor kaarten en we kunnen controleren of een kaart niet leeg is en ten minste één item bevat:

public void repair (Map repairParts) {Assert.notEmpty (repairParts, "map of repairParts mag niet leeg zijn"); // ...}

8. Array-beweringen

8.1. niet leeg() voor arrays

Ten slotte kunnen we controleren of een array niet leeg is en ten minste één element bevat door de niet leeg() methode:

public void repair (String [] repairParts) {Assert.notEmpty (repairParts, "array van repairParts mag niet leeg zijn"); // ...}

8.2. noNullElements ()

We kunnen verifiëren dat een array geen nul elementen met behulp van de noNullElements () methode:

public void repairWithNoNull (String [] repairParts) {Assert.noNullElements (repairParts, "array van repairParts mag geen null-elementen bevatten"); // ...}

Merk op dat deze controle nog steeds doorgaat als de array leeg is, zolang er geen nul elementen erin.

9. Conclusie

In dit artikel hebben we de Beweren klasse. Deze klasse wordt veel gebruikt binnen het Spring-framework, maar we zouden gemakkelijk robuustere en expressievere code kunnen schrijven door er gebruik van te maken.

Zoals altijd is de volledige code voor dit artikel te vinden in het GitHub-project.