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.