Spring Boot 4:n kattava opas · Oppitunti

Paloihin perustuvat Reader-Processor-Writer-työnkulut

Kytkekää ItemReader-, ItemProcessor- ja ItemWriter-komponentit skaalautuvaa paloittaista käsittelyä varten.

Oppitunti 2/413 vaihetta

Paloihin perustuvat Reader-Processor-Writer-työnkulut on ilmainen Spring Boot 4:n kattava opas-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Spring Boot 4:n kattava opas-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Spring Boot 4:n kattava opas-kurssilla on yhteensä 4 oppituntia.

Miksi lohkopohjainen käsittely?

Spring Batch lukee, käsittelee ja kirjoittaa dataa lohkoina yhden tietueen kerrallaan käsittelyn sijaan. Lohko on määritettävä määrä kohteita (commit-interval), jotka käsitellään yhden transaktion sisällä.

Lue N kohdetta yksi kerrallaan ItemReader-lukijalla.
Käsittele jokainen kohde ItemProcessor-käsittelijällä.
Kirjoita kaikki N kohdetta kerralla ItemWriter-kirjoittajalla.

Massakirjoitus ja lohkoittainen vahvistaminen mahdollistavat eräajojen skaalautumisen miljooniin riveihin ilman muistin loppumista.

Kolme keskeistä rajapintaa

Jokainen lohkopohjainen vaihe rakennetaan kolmesta yksimetodisesta rajapinnasta. Niiden sopimusten tunteminen on koko mallin perusta.

ItemReader<I> → I read() palauttaa seuraavan kohteen tai syötteen loputtua null.
ItemProcessor<I, O> → O process(I item) muuntaa syötteen tulosteeksi; null-arvon palauttaminen suodattaa kohteen pois.
ItemWriter<O> → void write(Chunk<? extends O> chunk) tallentaa kootun lohkon.

public interface ItemReader<I> {
    I read() throws Exception; // null = end of input
}

public interface ItemProcessor<I, O> {
    O process(I item) throws Exception; // null = filter
}

public interface ItemWriter<O> {
    void write(Chunk<? extends O> chunk) throws Exception;
}

Toimialatyypin määrittäminen

Lohkopohjainen vaihe välittää tyypitettyä dataa lukijalta käsittelijälle ja edelleen kirjoittajalle. Mallinnetaan yksinkertainen syöte ja tuloste. Lukija tuottaa käsittelemättömiä Customer-tietueita, ja kirjoittaja tallentaa normalisoidut tietueet.

Javan record-rakenteen avulla muuttumattomat arvotyypit pysyvät tiiviinä. Tämä koodikatkelma on tavallista Javaa ilman sovelluskehystä, joten se toimii itsenäisesti.

public class DomainDemo {
    record Customer(String name, String email) {}

    public static void main(String[] args) {
        Customer c = new Customer("  Ada ", "ADA@MAIL.COM");
        Customer normalized = new Customer(
                c.name().trim(),
                c.email().toLowerCase());
        System.out.println(normalized);
    }
}

ItemReaderin rakentaminen

Tietokantasyötteessä JdbcCursorItemReader lukee rivit yksi kerrallaan, joten muistin kulutus pysyy tasaisena. Sille annetaan DataSource, SQL-kysely ja RowMapper, joka muuntaa kunkin rivin toimialakohteeksi.

Spring Batch kutsuu read()-metodia toistuvasti, kunnes se palauttaa null-arvon, ja siirtää kohdistinta jokaisella kutsulla.

@Bean
public JdbcCursorItemReader<Customer> reader(DataSource dataSource) {
    return new JdbcCursorItemReaderBuilder<Customer>()
            .name("customerReader")
            .dataSource(dataSource)
            .sql("SELECT name, email FROM customers WHERE active = true")
            .rowMapper((rs, rowNum) ->
                    new Customer(rs.getString("name"), rs.getString("email")))
            .build();
}

ItemProcessorin rakentaminen

Käsittelijässä sijaitsee liiketoimintalogiikka: validointi, rikastaminen, muunnokset ja suodatus. Sen syöte- ja tulostetyypit voivat olla erilaiset.

Palauta muunnettu objekti, jotta se välitetään eteenpäin.
Palauta null, jos haluat ohittaa kohteen kokonaan — se ei koskaan päädy kirjoittajalle.

Pidä käsittelijät tilattomina ja idempotentteina, jotta ne toimivat oikein lohkojen uudelleenyrityksissä.

@Bean
public ItemProcessor<Customer, Customer> processor() {
    return customer -> {
        if (customer.email() == null || !customer.email().contains("@")) {
            return null; // filter invalid records out of the chunk
        }
        return new Customer(
                customer.name().trim(),
                customer.email().toLowerCase());
    };
}

ItemWriterin rakentaminen

Kirjoittaja saa koko käsitellyn lohkon kerralla Chunk<O>-oliona. Massakirjoitus — yksi erämuotoinen INSERT lohkoa kohden yhden rivikohtaisen kirjoituksen sijaan — on keskeinen suorituskykyetu.

JdbcBatchItemWriter käyttää parametroitua SQL-lausetta ja bean-ominaisuuksiin perustuvaa parametrilähdettä kenttien automaattiseen yhdistämiseen.

@Bean
public JdbcBatchItemWriter<Customer> writer(DataSource dataSource) {
    return new JdbcBatchItemWriterBuilder<Customer>()
            .dataSource(dataSource)
            .sql("INSERT INTO customers_clean (name, email) VALUES (:name, :email)")
            .beanMapped()
            .build();
}

Lohkopohjaisen vaiheen yhdistäminen

Step yhdistää nämä kolme komponenttia. Geneeriset tyypit <Customer, Customer> määrittävät lohkon syöte- ja tulostetyypit, ja kokonaisluku on vahvistusväli.

Kun lohkon koko on 100, Spring Batch lukee 100 kohdetta, käsittelee ne ja kirjoittaa kaikki jäljelle jäävät kohteet yhdessä transaktiossa ennen vahvistamista.

@Bean
public Step chunkStep(JobRepository jobRepository,
                      PlatformTransactionManager txManager,
                      ItemReader<Customer> reader,
                      ItemProcessor<Customer, Customer> processor,
                      ItemWriter<Customer> writer) {
    return new StepBuilder("chunkStep", jobRepository)
            .<Customer, Customer>chunk(100, txManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .build();
}

Jobin kokoaminen

Job on järjestetty joukko vaiheita. Kun job sisältää yhden lohkopohjaisen vaiheen, se vain käynnistyy kyseisestä vaiheesta. Spring Boot tunnistaa Job-beanin automaattisesti ja suorittaa sen käynnistyksen yhteydessä.

JobRepository tallentaa suorituksen metatiedot — tilan, luku- ja kirjoitusmäärät sekä viimeksi vahvistetun sijainnin — mikä mahdollistaa uudelleenkäynnistyksen.

@Bean
public Job importCustomersJob(JobRepository jobRepository, Step chunkStep) {
    return new JobBuilder("importCustomersJob", jobRepository)
            .start(chunkStep)
            .build();
}

Lohkon koon valitseminen

Vahvistusväli on säätöparametri, ei taianomainen vakio.

Liian pieni (esimerkiksi 1): yksi transaktio riviä kohden — suuri vahvistamisen aiheuttama kuormitus ja hidas suoritus.
Liian suuri (esimerkiksi 100 000): suuremmat transaktiot sekä suurempi muistin tarve ja palautuskustannus, jos lohko epäonnistuu.
Tyypillinen sopiva alue: 100–1000; säädä arvo mittaamalla suorituskyky tietokannan ja rivikoon mukaan.

Muista: epäonnistunut kohde palauttaa koko lohkon, joten suuremmat lohkot tarkoittavat epäonnistumisen jälkeen enemmän uudelleen tehtävää työtä.

Vikasietoisuus: ohitus ja uudelleenyritys

Oikean maailman syöte on sotkuista. Kääri vaihe .faultTolerant()-määreellä, jotta käsittely voi jatkua yksittäisistä virheistä huolimatta.

.skip(...) — salli enintään skipLimit virheellistä kohdetta jobin epäonnistumisen sijaan.
.retry(...) — yritä tilapäisiä virheitä (esimerkiksi lukkiutumistilanteita) uudelleen enintään retryLimit kertaa ennen luovuttamista.

Ohituksen tai uudelleenyrityksen yhteydessä Spring Batch käy lohkon uudelleen läpi kohde kerrallaan ja eristää ongelmallisen tietueen.

@Bean
public Step faultTolerantStep(JobRepository jobRepository,
                              PlatformTransactionManager txManager,
                              ItemReader<Customer> reader,
                              ItemProcessor<Customer, Customer> processor,
                              ItemWriter<Customer> writer) {
    return new StepBuilder("ftStep", jobRepository)
            .<Customer, Customer>chunk(100, txManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .skip(FlatFileParseException.class)
            .skipLimit(20)
            .retry(DeadlockLoserDataAccessException.class)
            .retryLimit(3)
            .build();
}

Lohkon elinkaari järjestyksessä

Kokonaisuutena jokainen lohko noudattaa samaa silmukkaa yhden transaktion sisällä:

1. Lue: kutsu read()-metodia toistuvasti, kunnes lohkon koon verran kohteita on puskuroidu (tai null päättää syötteen).
2. Käsittele: kutsu process()-metodia jokaiselle kohteelle; null-arvot suodatetaan pois.
3. Kirjoita: välitä jäljelle jäävät kohteet yhtenä Chunk-oliona write()-metodille.
4. Vahvista: vahvista transaktio ja tallenna edistyminen JobRepository-repositoryyn.

Tämän jälkeen silmukka toistuu seuraavalle lohkolle, kunnes lukijan syöte loppuu.

Pikatarkistus

Testaa ymmärryksesi lohkoputkesta.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Yhdistit Spring Batchissa täydellisen lohkopohjaisen työnkulun:

ItemReader lukee syötettä yksi kohde kerrallaan ja palauttaa lopussa null-arvon.
ItemProcessor muuntaa tai suodattaa kohteita; null poistaa kohteen.
ItemWriter tallentaa koko lohkon kerralla suorituskyvyn parantamiseksi.
Step yhdistää ne chunk(size, txManager)-vahvistusvälillä, ja Job ohjaa vaiheiden suorittamista.
Säädä lohkon koko suorituskyvyn mukaan ja lisää vikasietoisiin putkiin .faultTolerant() sekä ohitus ja uudelleenyritys.

Tämä lohkoittain vahvistettava lue–käsittele–kirjoita-silmukka on skaalautuvan eräkäsittelyn selkäranka.

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 21
Oppitunnit: 84

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Paloihin perustuvat Reader-Processor-Writer-työnkulut” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Spring Boot 4:n kattava opas-oppimispolun 3 oppituntia, myös oppitunnin “Paloihin perustuvat Reader-Processor-Writer-työnkulut”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Spring Boot 4:n kattava opas-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Paloihin perustuvat Reader-Processor-Writer-työnkulut”?

Kytkekää ItemReader-, ItemProcessor- ja ItemWriter-komponentit skaalautuvaa paloittaista käsittelyä varten. Harjoittelet Spring Boot 4:n kattava opas-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Spring Boot 4:n kattava opas-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Spring Boot 4:n kattava opas-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Paloihin perustuvat Reader-Processor-Writer-työnkulut”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Spring Boot 4:n kattava opas-oppitunnilla?

Kyllä. Jokainen Spring Boot 4:n kattava opas-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Työt, vaiheet ja JobRepository-malli
Paloihin perustuvat Reader-Processor-Writer-työnkulut
Vikasietoisuus, ohitus- ja uudelleenyrityskäytännöt
Osiointi ja vaiheiden rinnakkainen suoritus

← Takaisin: Spring Boot 4:n kattava opas