Hibernate Validator Specifieke beperkingen

1. Overzicht

In deze zelfstudie gaan we de Hibernate Validator-beperkingen bekijken, die zijn ingebouwd in Hibernate Validator maar buiten de Bean Validation-specificatie vallen.

Voor een samenvatting van Bean Validation, verwijzen wij u naar ons artikel over Java Bean Validation Basics.

2. Slaapstandvalidator instellen

Op z'n minst, we moeten Hibernate Validator toevoegen aan onze afhankelijkheden:

 org.hibernate.validator slaapstand-validator 6.0.16.Final 

Merk op dat Hibernate Validator niet afhankelijk is van Hibernate, de ORM, die we in veel andere artikelen hebben behandeld.

Bovendien zijn sommige van de annotaties die we introduceren alleen van toepassing als ons project gebruikmaakt van bepaalde bibliotheken. Dus voor elk daarvan geven we de noodzakelijke afhankelijkheden aan.

3. Validatie van geldgerelateerde waarden

3.1. Creditcardnummers valideren

Geldige creditcardnummers moeten voldoen aan een checksum, die we berekenen met behulp van het algoritme van Luhn. De @Creditcardnummer beperking slaagt wanneer een string voldoet aan de checksum.

@Creditcardnummer voert geen andere controle uit op de invoertekenreeks. In het bijzonder wordt de lengte van de invoer niet gecontroleerd. Daarom kan het alleen nummers detecteren die ongeldig zijn vanwege een kleine typefout.

Merk op dat de beperking standaard mislukt als de tekenreeks tekens bevat die geen cijfers zijn, maar we kunnen hem vertellen om ze te negeren:

@CreditCardNumber (ignoreNonDigitCharacters = true) privé String lenientCreditCardNumber;

Vervolgens kunnen we tekens zoals spaties of streepjes opnemen:

validations.setLenientCreditCardNumber ("7992-7398-713"); constraintViolations = validator.validateProperty (validaties, "lenientCreditCardNumber"); assertTrue (constraintViolations.isEmpty ());

3.2. Validatie van monetaire waarden

De @Valuta validator controleert of een bepaald geldbedrag in de opgegeven valuta is:

@Currency ("EUR") privé monetair saldo;

De klas Monetair bedrag is onderdeel van Java Money. Daarom @Valuta is alleen van toepassing als een Java Money-implementatie beschikbaar is.

Zodra we Java Money correct hebben ingesteld, kunnen we de beperking controleren:

bean.setBalance (Money.of (new BigDecimal (100.0), Monetary.getCurrency ("EUR"))); constraintViolations = validator.validateProperty (boon, "balans"); assertEquals (0, constraintViolations.size ());

4. Validatiebereiken

4.1. Numeriek en monetair bereik

De bean-validatiespecificatie definieert verschillende beperkingen die we kunnen afdwingen op numerieke velden. Daarnaast biedt Hibernate Validator een handige annotatie, @Range, dat fungeert als een combinatie van @Min en @Max,passend bij een assortiment inclusief:

@Range (min = 0, max = 100) privé BigDecimal procent;

Leuk vinden @Min en @Max, @Range is van toepassing op velden met primitieve nummertypes en hun wrappers; BigInteger en BigDecimal, Draad representaties van het bovenstaande, en, tot slot, Monetaire waarde velden.

4.2. Duur van de tijd

Naast standaard JSR 380-annotaties voor waarden die punten in de tijd vertegenwoordigen, bevat Hibernate Validator beperkingen voor Looptijds ook. Zorg ervoor dat u het Periode en Looptijd klassen Java Time eerst.

Zo, we kunnen minimale en maximale looptijden op een woning afdwingen:

@DurationMin (dagen = 1, uren = 2) @DurationMax (dagen = 2, uren = 1) privé Duur duur;

Zelfs als we ze hier niet allemaal hebben laten zien, heeft de annotatie parameters voor alle tijdseenheden van nanoseconden tot dagen.

Houd er rekening mee dat standaard minimum- en maximumwaarden zijn inclusief. Dat wil zeggen, een waarde die exact hetzelfde is als het minimum of het maximum, zal voor validatie slagen.

Als we willen dat grenswaarden ongeldig zijn, definiëren we in plaats daarvan de inclusief eigenschap om onwaar te zijn:

@DurationMax (minuten = 30, inclusief = false)

5. Tekenreeksen valideren

5.1. Draadlengte

We kunnen twee enigszins verschillende beperkingen gebruiken om af te dwingen dat een string een bepaalde lengte heeft.

Over het algemeen willen we ervoor zorgen dat de lengte van een tekenreeks in tekens wordt weergegeven - degene die we meten met de lengte methode - ligt tussen een minimum en een maximum. In dat geval gebruiken we @Lengte op een String-eigenschap of -veld:

@Length (min = 1, max = 3) private String someString;

Vanwege de fijne kneepjes van Unicode verschillen soms de lengte in tekens en de lengte in codepunten. Als we het laatste willen controleren, gebruiken we @CodePointLength:

@CodePointLength (min = 1, max = 3) private String someString;

De tekenreeks "aa \ uD835 \ uDD0A" is bijvoorbeeld 4 tekens lang, maar bevat slechts 3 codepunten, dus het voldoet niet aan de eerste beperking en geeft de tweede door.

Ook kunnen we bij beide annotaties de minimum- of maximumwaarde weglaten.

5.2. Controles op cijferreeksen

We hebben al gezien hoe u kunt controleren of een string een geldig creditcardnummer is. Hibernate Validator bevat echter verschillende andere beperkingen voor cijferreeksen.

De eerste die we aan het beoordelen zijn, is @LuhnCheck. Dit is de gegeneraliseerde versie van @Creditcardnummer, in dat het voert dezelfde controle uit, maar maakt aanvullende parameters mogelijk:

@LuhnCheck (startIndex = 0, endIndex = Integer.MAX_VALUE, checkDigitIndex = -1) private String someString;

Hier hebben we de standaardwaarden van de parameters getoond, dus het bovenstaande is equivalent aan een simple @LuhnCheck annotatie.

Maar zoals we kunnen zien, kunnen we de controle uitvoeren op een substring (startIndex en endIndex) en vertel de beperking welk cijfer het checksum-cijfer is, waarbij -1 de laatste in de gecontroleerde substring betekent.

Andere interessante beperkingen zijn de modulo 10-check (@ Mod10Check) en de modulo 11 check (@ Mod11Check), die doorgaans worden gebruikt voor streepjescodes en andere codes zoals ISBN.

Voor die specifieke gevallen biedt Hibernate Validator echter een beperking om ISBN-codes te valideren, @ISBN, evenals een @EAN beperking voor EAN-streepjescodes.

5.3. URL- en HTML-validatie

De @Url beperking controleert of een tekenreeks een geldige weergave is van een URL. Bovendien kunnen we controleren of een specifiek onderdeel van de URL een bepaalde waarde heeft:

@URL (protocol = "https") privé-tekenreeks-url;

Zo kunnen we het protocol, de host en de poort controleren. Als dat niet voldoende is, is er een regexp eigenschap die we kunnen gebruiken om de URL te vergelijken met een reguliere expressie.

We kunnen ook controleren of een eigenschap 'veilige' HTML-code bevat (bijvoorbeeld zonder scripttags):

@SafeHtml private String html;

@SafeHtml gebruikt de JSoup-bibliotheek, die moet worden opgenomen in onze afhankelijkheden.

We kunnen de HTML-opschoning aanpassen aan onze behoeften met behulp van ingebouwde witte lijsten voor tags (de witte lijst eigenschap van de annotatie) en inclusief extra tags en attributen (de aanvullende tags en additioneleTagsWithAttributes parameters).

6. Andere beperkingen

Laten we kort vermelden dat Hibernate Validator enkele land- en locale-specifieke beperkingen bevat, in het bijzonder voor sommige Braziliaanse en Poolse identificatienummers, belastingbetalerscodes en dergelijke. Raadpleeg het relevante gedeelte van de documentatie voor een volledige lijst.

We kunnen ook controleren of een collectie geen duplicaten bevat met @UniqueElements.

Ten slotte kunnen we voor complexe gevallen die niet worden gedekt door bestaande annotaties, een script aanroepen dat is geschreven in een JSR-223-compatibele script-engine. We hebben JSR-223 natuurlijk aangestipt in ons artikel over Nashorn, de JavaScript-implementatie die in moderne JVM's is opgenomen.

In dit geval is de annotatie op klassenniveau en wordt het script aangeroepen voor de hele instantie, doorgegeven als de variabele _dit:

@ScriptAssert (lang = "nashorn", script = "_this.valid") openbare klasse AdditionalValidations {private boolean valid = true; // standaard getters en setters}

Vervolgens kunnen we de beperking voor de hele instantie controleren:

bean.setValid (false); constraintViolations = validator.validate (bean); assertEquals (1, constraintViolations.size ());

7. Conclusie

In dit artikel hebben we de beperkingen in Hibernate Validator vermeld die verder gaan dan de minimale set die is gedefinieerd in de Bean Validation-specificatie.

De implementatie van al deze voorbeelden en codefragmenten is te vinden op GitHub.