Tavaszi csomagtartó tavasszal
1. Áttekintés
A Spring Batch egy erőteljes keretrendszer a robusztus kötegelt alkalmazások fejlesztéséhez. Korábbi bemutatónkban bemutattuk a Spring Batch-et.
Ebben az oktatóanyagban az előzőre építünk, és megtanuljuk, hogyan állítsunk be és hozzunk létre egy alapszintű kötegelt alkalmazásokat a Spring Boot segítségével.
2. Maven-függőségek
Először tegyük hozzá a rugós-bakancs-indító-tétel a miénknek pom.xml:
org.springframework.boot spring-boot-starter-batch 2.4.0.FELHASZNÁLÁS
Hozzáadjuk a org.hsqldb függőség, amely elérhető a Maven Central-tól is:
org.hsqldb hsqldb 2.5.1 futásidejű
3. Egyszerű tavaszi kötegelt feladat meghatározása
Olyan munkát fogunk készíteni, amely egy kávé listát importál egy CSV fájlból, átalakítja azt egy egyedi processzor segítségével, és a végeredményeket a memóriában tárolja.
3.1. Elkezdeni
Kezdjük azzal, hogy meghatározzuk az alkalmazás belépési pontját:
@SpringBootApplication public class SpringBootBatchProcessingApplication {public static void main (String [] args) {SpringApplication.run (SpringBootBatchProcessingApplication.class, args); }}
Mint láthatjuk, ez egy szokásos Spring Boot alkalmazás. Mivel alapértelmezett konfigurációs értékeket akarunk használni, ahol lehetséges, az alkalmazás konfigurációs tulajdonságainak nagyon könnyű készletét fogjuk használni.
Ezeket a tulajdonságokat a src / main / resources / application.properties fájl:
file.input = kávé-lista.csv
Ez a tulajdonság tartalmazza a beviteli kávézási listánk helyét. Minden sor tartalmazza a kávé márkáját, eredetét és néhány jellemzőjét:
Blue Mountain, Jamaica, Gyümölcsös Lavazza, Kolumbia, Erős Folgers, Amerika, Smokey
Amint látni fogjuk, ez egy sima CSV fájl, ami azt jelenti, hogy a Spring különösebb testreszabás nélkül tudja kezelni.
Ezután hozzáadunk egy SQL szkriptet schema-all.sql hogy létrehozza a mi kávé táblázat az adatok tárolásához:
CSepegtető kávé, HA LÉTEZIK; CREATE TABLE kávé (coffee_id BIGINT IDENTITÁS NEM NULL PRIMARY KEY, márka VARCHAR (20), eredet VARCHAR (20), jellemzők VARCHAR (30));
Kényelmesen a Spring Boot automatikusan futtatja ezt a szkriptet az indítás során.
3.2. Kávé domain osztály
Ezt követően szükségünk lesz egy egyszerű domain osztályra a kávéelemek tárolásához:
public class Coffee {private String márka; privát húr eredetű; privát karakterlánc jellemzői; public Coffee (String márka, String eredet, String jellemzők) {this.brand = brand; ez.eredet = eredet; ez.jellemzők = jellemzők; } // szerelők és beállítók}
Mint korábban említettük, a mi Kávé Az objektum három tulajdonságot tartalmaz:
- Egy márka
- Eredet
- Néhány további jellemző
4. Munka konfigurálása
Most pedig a kulcskomponensről, a munkánk konfigurációjáról. Lépésről lépésre haladunk, felépítjük a konfigurációnkat és elmagyarázzuk az egyes részeket:
@Configuration @EnableBatchProcessing public class BatchConfiguration {@Autowired public JobBuilderFactory jobBuilderFactory; @Autowired public StepBuilderFactory stepBuilderFactory; @Value ("$ {file.input}") privát karakterlánc fileInput; // ...}
Először egy szokásos tavasszal indulunk @ Konfiguráció osztály. Ezután hozzáadjuk a @EnableBatchProcessing jegyzet az osztályunknak. Különösen ez sok hasznos babhoz jut, amelyek támogatják a munkahelyeket, és rengeteg lábmunkát spórolnak meg.
Ezenfelül ennek a megjegyzésnek a használata két hasznos gyárhoz is hozzáférést biztosít számunkra, amelyeket később felhasználunk a munkakonfiguráció és a munkalépések felépítésekor.
A kezdeti konfigurációnk utolsó részében hivatkozást adunk a file.input ingatlan, amelyet korábban bejelentettünk.
4.1. Olvasó és író a munkánkhoz
Most továbbléphetünk és meghatározhatunk egy olvasó babot a konfigurációnkban:
@Bean public FlatFileItemReader olvasó () {return new FlatFileItemReaderBuilder (). Name ("coffeeItemReader") .resource (new ClassPathResource (fileInput)) .delimited () .names (new String [] {"brand", "origin", "" jellemzők "}) .fieldSetMapper (új BeanWrapperFieldSetMapper () {{setTargetType (Coffee.class);}}) .build (); }
Röviden, a fentiekben definiált olvasó babunk egy fájlt keres kávé-lista.csv és az egyes sorokat a-ra elemzi Kávé tárgy.
Hasonlóképpen meghatározunk egy író babot:
@Bean public JdbcBatchItemWriter író (DataSource dataSource) {adja vissza az új JdbcBatchItemWriterBuilder () .itemSqlParameterSourceProvider (új BeanPropertyItemSqlParameterSourceProvider ()) .sql ("INSERT origin (márka: VALU, eredeti .dataSource (dataSource) .build (); }
Ezúttal hozzáadunk egy SQL-utasítást, amely egyetlen kávé tétel beillesztéséhez szükséges az adatbázisunkba, amelyet a Kávé tárgy. Kényelmesen a adatforrás automatikusan létrehozza @EnableBatchProcessing annotáció.
4.2. Munkánkat összerakva
Végül hozzá kell adnunk a munka tényleges lépéseit és konfigurációját:
@Bean nyilvános Job importUserJob (JobCompletionNotificationListener figyelő, 1. lépés) {return jobBuilderFactory.get ("importUserJob") .incrementer (új RunIdIncrementer ()) .listener (figyelő). Flow (1. lépés) .end () .build (); } @Bean public 1. lépés (JdbcBatchItemWriter író) {return stepBuilderFactory.get ("1. lépés"). darab (10) .olvasó (olvasó ()) .processzor (processzor ()) .író (író) .build (); } @Bean nyilvános CoffeeItemProcessor processzor () {return new CoffeeItemProcessor (); }
Amint láthatjuk, munkánk viszonylag egyszerű, és a lépésben meghatározott egy lépésből áll 1. lépés módszer.
Vizsgáljuk meg, mit csinál ez a lépés:
- Először úgy konfiguráljuk a lépésünket, hogy egyszerre legfeljebb tíz rekordot írjon a darab (10) nyilatkozat
- Ezután beolvassuk a kávéadatokat az olvasó babunk segítségével, amelyet a olvasó módszer
- Ezután átadjuk mindegyik kávétermékünket egy egyedi processzornak, ahol valamilyen egyedi üzleti logikát alkalmazunk
- Végül minden kávéelemet beírunk az adatbázisba a korábban látott író segítségével
Másrészt a mi importUserJob tartalmazza a munkánk definícióját, amely egy azonosítót tartalmaz a beépítés segítségével RunIdIncrementer osztály. Beállítottunk egy JobCompletionNotificationListener, amellyel értesítést kapunk, amikor a munka befejeződik.
A feladat konfigurálásának befejezéséhez felsoroljuk az egyes lépéseket (bár ennek a feladatnak csak egy lépése van). Most tökéletesen konfigurált munkánk van!
5. Egyéni kávéfőző
Vizsgáljuk meg részletesen az egyéni processzort, amelyet korábban a munkakonfigurációnkban definiáltunk:
public class CoffeeItemProcessor megvalósítja a ItemProcessor {private static final Logger LOGGER = LoggerFactory.getLogger (CoffeeItemProcessor.class); @A nyilvános kávéfolyamat felülbírálása (végső kávékávé) kiveti a {String brand = coffee.getBrand (). ToUpperCase () kivételt; Karakterlánc eredete = coffee.getOrigin (). ToUpperCase (); Karakterláncok = kávé.getCharacteristics (). ToUpperCase (); Kávé = új kávé (márka, eredet, jellemzők); LOGGER.info ("Converting ({}) into ({})", coffee, transformedCoffee); return transformedCoffee; }}
Különösen érdekes, hogy ItemProcessor interfész biztosítja számunkra azt a mechanizmust, amellyel bizonyos üzleti logikákat alkalmazhatunk a munkánk során.
A dolgok egyszerűsége érdekében meghatározzuk a mi CoffeeItemProcessor, amely bemenetet vesz fel Kávé objektumot, és az egyes tulajdonságokat nagybetűvé alakítja.
6. Munka befejezése
Ezen felül írunk egy a-t is JobCompletionNotificationListener visszajelzést adni, amikor a munkánk befejeződik:
@Orride public void afterJob (JobExecution jobExecution) {if (jobExecution.getStatus () == BatchStatus.COMPLETED) {LOGGER.info ("!!! FELADAT BETÉT! Ideje ellenőrizni az eredményeket"); Karakterlánc lekérdezés = "SELECT márka, eredet, jellemzők FROM kávéból"; jdbcTemplate.query (lekérdezés, (rs, sor) -> új kávé (rs.getString (1), rs.getString (2), rs.getString (3))) .forEach (kávé -> LOGGER.info ("Megtalált az adatbázisban. ", kávé)); }}
A fenti példában felülírjuk a utánJob módszert, és ellenőrizze, hogy a feladat sikeresen elkészült-e. Ezenkívül egy triviális lekérdezést futtatunk annak ellenőrzésére, hogy minden kávéelemet sikeresen tároltunk-e az adatbázisban.
7. A munkánk futtatása
Most, hogy minden a helyünkön van a munkánk lebonyolításához, itt jön a szórakoztató rész. Menjünk előre, és végezzük a munkánkat:
... 17: 41: 16.336 [main] INFO c.b.b.JobCompletionNotificationListener - !!! MUNKA BEFEJEZETT! Ideje ellenőrizni az eredményeket 17: 41: 16.336 [main] INFO c.b.b.JobCompletionNotificationListener - Megtalálható az adatbázisban. 17: 41: 16.337 [main] INFO c.b.b.JobCompletionNotificationListener - Megtalálható az adatbázisban. 17: 41: 16.337 [main] INFO c.b.b.JobCompletionNotificationListener - Megtalálható az adatbázisban. ...
Mint láthatjuk, munkánk sikeresen futott, és minden kávéelemet az elvárásoknak megfelelően tároltak az adatbázisban.
8. Következtetés
Ebben a cikkben megtanultuk, hogyan lehet egyszerű Spring Batch feladatot létrehozni a Spring Boot használatával. Először néhány alapvető konfigurációt definiáltunk.
Ezután láttuk, hogyan adhatunk hozzá fájlolvasót és adatbázis-írót. Végül megvizsgáltuk, hogyan alkalmazhatunk egyedi feldolgozást, és ellenőrizzük, hogy a munkánk sikeresen végrehajtásra került-e.
Mint mindig, a cikk teljes forráskódja elérhető a GitHubon.