Különbség a @NotNull, @NotEmpty és @NotBlank korlátozások között a babellenőrzésben

1. Áttekintés

Babellenőrzés egy szabványos érvényesítési specifikáció, amely lehetővé teszi számunkra, hogy a tartományobjektumokat egyszerűen érvényesítsük annotációk formájában deklarált korlátok használatával.

Míg összességében a babellenőrzési megvalósítások, például a Hibernate Validator használata meglehetősen egyszerű, érdemes néhány finom - mégis releváns - különbséget feltárni e korlátok némelyikének végrehajtása tekintetében.

Ebben az oktatóanyagban észrevesszük a különbségeket a @Nem nulla, @Nem üres, és @NotBlank korlátok.

2. A Maven-függőségek

A munkakörnyezet gyors létrehozása és a @Nem nulla, @Nem üres, és @NotBlank korlátok, először hozzá kell adnunk a szükséges Maven-függőségeket.

Ebben az esetben a Hibernate Validator-t, a babellenőrzési referencia-megvalósítást fogjuk használni tartományobjektumaink érvényesítéséhez.

Itt van a vonatkozó szakaszunk pom.xml fájl:

  org.hibernate hibernate-validator 6.0.13. Végső org.glassfish javax.el 3.0.0 

Az egység tesztjeinél a JUnit és az AssertJ alkalmazásokat fogjuk használni, ezért mindenképpen ellenőrizze a hibernált validátor, a GlassFish EL megvalósításának, a junit és az assertj-core legújabb verzióit a Maven Centralon.

3. Az @Nem nulla Kényszer

Haladva haladjunk végre egy naiv módon UserNotNull domain osztály és korlátozza azt név mező a @Nem nulla kommentár:

public class UserNotNull {@NotNull (message = "A név nem lehet null") privát karakterlánc neve; // standard konstruktorok / getters / toString}

Most meg kell látnunk, hogyan @Nem nulla valójában a motorháztető alatt működik.

Ehhez hozzunk létre egy egyszerű egység tesztet az osztály számára, és érvényesítsük néhány példányát:

@BeforeClass public static void setupValidatorInstance () {validator = Validation.buildDefaultValidatorFactory (). GetValidator (); } @Test public void whenNotNullName_thenNoConstraintViolations () {UserNotNull user = new UserNotNull ("John"); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (0); } @Test public void whenNullName_thenOneConstraintViolation () {UserNotNull user = new UserNotNull (null); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (1); } @Test public void whenEmptyName_thenNoConstraintViolations () {UserNotNull user = new UserNotNull (""); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (0); } 

Ahogy az várható volt, a @Nem nulla A kényszer nem engedélyezi a korlátozott mező (k) nullértékeit. Ennek ellenére a mezők üresek lehetnek.

Ennek jobb megértése érdekében nézzük meg a NotNullValidator osztály' érvényes() módszer, amelyet a @Nem nulla kényszer használ. A módszer megvalósítása valóban triviális:

public boolean isValid (Object object) {return object! = null; }

A fentiek szerint egy mező (pl. CharSequence, Gyűjtemény, Térkép, vagy Sor) korlátozta @Nem nulla nem lehet null. Az üres érték azonban teljesen legális.

4. A @Nem üres Kényszer

Most hajtsunk végre egy mintát UserNotEmpty osztály és használja a @Nem üres kényszer:

public class UserNotEmpty {@NotEmpty (message = "A név nem lehet üres") privát karakterlánc neve; // standard konstruktorok / getters / toString}

Ha az osztály a helyén van, teszteljük csak úgy, hogy különböző értékeket rendelünk a név terület:

@Test public void whenNotEmptyName_thenNoConstraintViolations () {UserNotEmpty user = new UserNotEmpty ("John"); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (0); } @Test public void whenEmptyName_thenOneConstraintViolation () {UserNotEmpty user = new UserNotEmpty (""); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (1); } @Test public void whenNullName_thenOneConstraintViolation () {UserNotEmpty user = new UserNotEmpty (null); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (1); }

A @Nem üres kommentár használja a @Nem nulla osztály' érvényes() megvalósítás, és ezen felül ellenőrzi, hogy a szállított objektum mérete / hossza (természetesen ez az érvényesített objektum típusától függően) nagyobb-e, mint nulla.

Dióhéjban, ez azt jelenti, hogy egy mező (pl. CharSequence, Gyűjtemény, Térkép, vagy Sor) korlátozta @Nem üres nem lehet null, és méretének / hosszának nagyobbnak kell lennie, mint nulla.

Ezenkívül még korlátozóbbak lehetünk, ha a @Nem üres annotációval együtt @Méret.

Ennek során azt is kikényszerítjük, hogy az objektum min és max mérete a megadott min / max tartományban legyen:

@NotEmpty (message = "A név nem lehet üres") @Size (min = 2, max = 32, message = "A névnek 2 és 32 karakter között kell lennie") privát karakterlánc neve; 

5. A @NotBlank Kényszer

Hasonlóképpen korlátozhatunk egy osztálymezőt a @NotBlank kommentár:

public class UserNotBlank {@NotBlank (message = "A név nem lehet üres") privát karakterlánc neve; // standard konstruktorok / getters / toString}

Ugyanezen a vonalon megvalósíthatunk egy egységtesztet is, hogy megértsük, hogyan @NotBlank kényszer működik:

@Test public void whenNotBlankName_thenNoConstraintViolations () {UserNotBlank user = new UserNotBlank ("John"); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (0); } @Test public void whenBlankName_thenOneConstraintViolation () {UserNotBlank user = new UserNotBlank (""); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (1); } @Test public void whenEmptyName_thenOneConstraintViolation () {UserNotBlank user = new UserNotBlank (""); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (1); } @Test public void whenNullName_thenOneConstraintViolation () {UserNotBlank user = new UserNotBlank (null); Készlet megsértések = validator.validate (felhasználó); assertThat (sértések.méret ()). isEqualTo (1); } 

A @NotBlank az annotáció a NotBlankValidator osztály, amely ellenőrzi, hogy a karaktersorozat nyírt hossza nem üres-e:

public logikai isValid (CharSequence charSequence, ConstraintValidatorContext constraintValidatorContext) if (charSequence == null) {return true; } return charSequence.toString (). trim (). hossz ()> 0; } 

Elég vicces, a metódus null értékekre igaz. Tehát azt gondolhatjuk @NotBlank megengedi a null értékeket, de valójában nem.

A @Nem nulla class 'isValid () metódust hívjuk meg a @NotBlank class 'isValid (), ezért tiltja a null értékeket.

Egyszerűen szólva, a Húr mező korlátozott @NotBlank nem lehet null, a vágott hossznak pedig nullánál nagyobbnak kell lennie.

6. Egymás melletti összehasonlítás

Eddig alaposan megvizsgáltuk, hogyan @Nem nulla, @Nem üres, és @NotBlank a korlátok egyenként működnek az osztályterületeken.

Végezzünk gyors egymás melletti összehasonlítást, így madártávlatból szemlélhetjük a korlátok funkcionalitását, és könnyen észrevehetjük különbségeiket:

  • @Nem nulla: egy korlátozott CharSequence, Gyűjtemény, Térkép, vagy Sor addig érvényes, amíg nem null, de lehet üres is
  • @Nem üres: egy korlátozott CharSequence, Gyűjtemény, Térkép, vagy Sor addig érvényes, amíg nem null, és mérete / hossza nagyobb, mint nulla
  • @NotBlank: egy korlátozott Húr addig érvényes, amíg nem nulla, és a vágott hossz nagyobb, mint nulla

7. Következtetés

Ebben a cikkben megnéztük a Nem nulla, @Nem üres, és @NotBlank a babellenőrzés során alkalmazott korlátozások, és kiemelték azok hasonlóságait és különbségeit.

Szokás szerint a cikkben bemutatott összes kódminta elérhető a GitHubon.


$config[zx-auto] not found$config[zx-overlay] not found