Az átugrási logika beállítása tavaszi kötegben

1. Bemutatkozás

Alapértelmezés szerint a Spring Batch job feldolgozása során felmerült hibák a megfelelő lépést meghiúsítják. Számos olyan helyzet azonban előfordul, amikor bizonyos kivételektől eltekintve inkább az éppen feldolgozott tételt szeretnénk kihagyni.

Ebben az oktatóanyagban két megközelítést vizsgálunk meg az átugrási logika konfigurálásához a Spring Batch keretrendszerben.

2. Felhasználási esetünk

A példák céljából újrafelhasználjuk a Spring Batch bevezető cikkünkben bemutatott egyszerű, darabokra összpontosító munkát.

Ez a feladat néhány pénzügyi adatot konvertál CSV formátumból XML formátumba.

2.1. Beviteli adat

Először adjunk hozzá néhány sort az eredeti CSV-fájlhoz:

felhasználónév, felhasználói azonosító, tranzakció_dátum, tranzakció_összeg devendra, 1234, 2015.10.31., 10000 john, 2134, 2015.12.3., 12321 robin, 2134, 2015.02.22., 23411, 2536, 2019.03.10., 100 mike, 9876, 2018.11.11., -500, 3425, 2017.10.10., 9999

Mint láthatjuk, az utolsó három sor tartalmaz néhány érvénytelen adatot - az 5. és a 7. sorból hiányzik a felhasználónév mező, és a 6. sorban szereplő tranzakció összege negatív.

A későbbi szakaszokban konfiguráljuk kötegelt feladatunkat úgy, hogy kihagyja ezeket a sérült rekordokat.

3. Az átugrási határ és az átugorható kivételek konfigurálása

3.1. Használata kihagy és skipLimit

Most beszéljük meg az első két lehetőséget, amellyel konfigurálhatjuk munkánkat az elemek kihagyására hiba esetén - a kihagy és skipLimit mód:

@Bean public Step skippingStep (ItemProcessor processzor, ItemWriter író) dobja a ParseException {return stepBuilderFactory .get ("skippingStep") .chunk (10) .reader (itemReader (érvénytelenInputCsv)) .processzor (processzor) .writer (író) .faultTolerant ( ) .skipLimit (2) .skip (MissingUsernameException.class) .skip (NegativeAmountException.class) .build (); }

Először is, az átugrási funkció engedélyezéséhez fel kell tüntetnünk egy hívást hibatűrő() a lépésépítési folyamat során.

Belül kihagy () és skipLimit (), meghatározzuk az átugorni kívánt kivételeket és az átugrott elemek maximális számát.

A fenti példában, ha bármelyik a MissingUsernameException vagy NegativeAmountException az olvasási, a feldolgozási vagy az írási szakasz során eldobásra kerül, akkor az éppen feldolgozott elem kihagyásra kerül, és beleszámít a kettő teljes határába.

Következésképpen, ha valamilyen kivételt harmadszor dobnak meg, akkor az egész lépés kudarcot vall.

3.1. Használata noSkip

Az előző példában minden egyéb kivétel MissingUsernameException és NegativeAmountException kudarcot vall a lépésünkön.

Bizonyos helyzetekben azonban megfelelőbb lehet azonosítsa azokat a kivételeket, amelyek miatt kudarcot vallhat a lépésünkben, és hagyja ki a másikat.

Nézzük meg, hogyan tudjuk ezt konfigurálni a használatával kihagy, skipLimit, és noSkip:

@Bean public Step skippingStep (ItemProcessor processzor, ItemWriter író) dobja a ParseException {return stepBuilderFactory .get ("skippingStep") .chunk (10) .reader (itemReader (érvénytelenInputCsv)) .processzor (processzor) .writer (író) .faultTolerant ( ) .skipLimit (2) .skip (Exception.class) .noSkip (SAXException.class) .build (); }

A fenti konfigurációval utasítjuk a Spring Batch keretrendszert, hogy hagyja ki bármelyiket Kivétel (egy beállított határon belül), kivéve SAXException. Ez azt jelenti, hogy SAXException mindig lépéskiesést okoz.

A. Sorrendje kihagy () és noSkip () a hívások nem számítanak.

4. Az Egyéni használata SkipPolicy

Néha szükség lehet egy kifinomultabb kihagyás-ellenőrző mechanizmusra. Ebből a célból A Spring Batch keretrendszer biztosítja a SkipPolicy felület.

Ezután biztosíthatjuk az átugrási logika saját megvalósítását és beépíthetjük a lépésdefiníciónkba.

Az előző példát szem előtt tartva képzelje el, hogy továbbra is meg szeretnénk határozni két tétel kihagyási korlátját, és csak azt tennénk MissingUsernameException és NegativeAmountException átugorható.

Azonban, további korlát, hogy átugorhatjuk NegativeAmountException, de csak akkor, ha az összeg nem haladja meg a meghatározott határt.

Vezessük be szokásunkat SkipPolicy:

public class CustomSkipPolicy megvalósítja a SkipPolicy {private static final int MAX_SKIP_COUNT = 2; privát statikus végső int INVALID_TX_AMOUNT_LIMIT = -1000; @Orride public boolean shouldSkip (Throwable dobható, int skipCount) dobja SkipLimitExceededException {if (MissingUsernameException && skipCount <MAX_SKIP_COUNT) dobható példánya {true true; } if (a NegativeAmountException && skipCount <MAX_SKIP_COUNT dobható példánya) {NegativeAmountException ex = (NegativeAmountException) dobható; if (ex.getAmount () <INVALID_TX_AMOUNT_LIMIT) {false értéket ad vissza; } else {return true; }} return false; }}

Most az egyéni házirendünket lépésdefinícióban használhatjuk:

 @Bean public Step skippingStep (ItemProcessor processzor, ItemWriter író) dobja a ParseException {return stepBuilderFactory .get ("skippingStep") .chunk (10) .reader (itemReader (érvénytelenInputCsv)) .processzor (processzor) .writer (író) .faultTolerant ( ) .skipPolicy (új CustomSkipPolicy ()) .build (); }

És hasonlóan az előző példánkhoz, továbbra is használnunk kell hibatűrő() az átugrási funkció engedélyezéséhez.

Ezúttal azonban nem hívunk kihagy () vagy noSkip (). Helyette, használjuk a skipPolicy () módszer a saját megvalósításunk biztosítására SkipPolicy felület.

Ahogy látjuk, ez a megközelítés nagyobb rugalmasságot biztosít számunkra, így bizonyos felhasználási esetekben jó választás lehet.

5. Következtetés

Ebben az oktatóanyagban kétféle módon mutattuk be a Spring Batch munka hibatűrővé tételét.

Annak ellenére, hogy a skipLimit () együtt kihagy () és noSkip () A módszerek népszerűbbnek tűnnek, előfordulhat, hogy megvalósítunk egy szokást SkipPolicy hogy bizonyos helyzetekben kényelmesebb legyen.

Szokás szerint az összes kódpélda elérhető a GitHubon.