Spring Boot 4 – komplett guide · Lektion

Chunk-baserade Reader-Processor-Writer-flöden

Koppla in komponenterna ItemReader, ItemProcessor och ItemWriter för skalbar chunk-bearbetning.

Lektion 2 av 413 steg

Chunk-baserade Reader-Processor-Writer-flöden är en gratis lektion i Spring Boot 4 – komplett guide på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Spring Boot 4 – komplett guide, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Varför chunk-baserad bearbetning?

Spring Batch läser, bearbetar och skriver data i chunkar i stället för en post i taget. En chunk består av ett konfigurerbart antal objekt (commit-interval) som hanteras i en och samma transaktion.

Läs N objekt, ett i taget, med en ItemReader.
Bearbeta varje objekt med en ItemProcessor.
Skriv hela gruppen med N objekt på en gång med en ItemWriter.

Det är masskrivning och commit per chunk som gör att batchjobb kan skalas till miljontals rader utan att minnet tar slut.

De tre centrala gränssnitten

Varje chunk-steg byggs av tre gränssnitt med en enda metod. Att känna till deras kontrakt är grunden för hela mönstret.

ItemReader<I> → I read() returnerar nästa objekt, eller null när indatan är slut.
ItemProcessor<I, O> → O process(I item) omvandlar en indata till en utdata; om null returneras filtreras objektet bort.
ItemWriter<O> → void write(Chunk<? extends O> chunk) sparar den ackumulerade chunken.

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;
}

Definiera en domäntyp

Ett chunk-steg skickar typad data från läsaren till processorn och vidare till skrivaren. Låt oss modellera en enkel indata och utdata. Läsaren skickar ut råa Customer-poster och skrivaren lagrar normaliserade poster.

Genom att använda en Java-record blir dessa oföränderliga värdetyper kortfattade. Kodsnutten är vanlig Java utan ramverk och kan därför köras fristående.

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);
    }
}

Bygg ItemReader

För indata från en databas strömmar JdbcCursorItemReader raderna en i taget, så att minnesanvändningen förblir konstant. Du anger en DataSource, en SQL-fråga och en RowMapper som omvandlar varje rad till ett domänobjekt.

Spring Batch anropar read() upprepade gånger tills den returnerar null; markören flyttas fram varje gång.

@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();
}

Bygg ItemProcessor

Det är i processorn som affärslogiken finns: validering, berikning, omvandling eller filtrering. In- och utdatatypen kan skilja sig åt.

Returnera ett omvandlat objekt för att skicka det vidare i flödet.
Returnera null för att hoppa över objektet helt — det når aldrig skrivaren.

Håll processorer tillståndslösa och idempotenta så att de fungerar korrekt när chunkar försöks igen.

@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());
    };
}

Bygg ItemWriter

Skrivaren tar emot hela den bearbetade chunken på en gång via en Chunk<O>. Masskrivning — en batchad INSERT per chunk i stället för en per rad — är den stora prestandavinsten.

JdbcBatchItemWriter använder en parametriserad SQL-sats och en parameterkälla baserad på bean-egenskaper för att mappa fält automatiskt.

@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();
}

Koppla ihop chunk-steget

Ett Step kopplar ihop de tre komponenterna. De generiska typerna <Customer, Customer> anger chunkens in- och utdata, och heltalet är commit-intervallet.

Med en chunkstorlek på 100 läser Spring Batch 100 objekt, bearbetar vart och ett och skriver sedan alla kvarvarande objekt i en transaktion innan den genomför commit.

@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();
}

Sätt ihop jobbet

Ett Job är en ordnad uppsättning steg. För ett jobb med ett enda chunk-steg startar jobbet helt enkelt med det steget. Spring Boot identifierar automatiskt Job-beanen och kör den vid uppstart.

JobRepository registrerar körningsmetadata — status, antal lästa och skrivna objekt samt den senast committade positionen — vilket möjliggör omstart.

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

Välj chunkstorlek

Commit-intervallet är en parameter för finjustering, inte ett magiskt tal.

För litet (t.ex. 1): en transaktion per rad — hög commit-kostnad och långsam körning.
För stort (t.ex. 100 000): större transaktioner, mer minne och högre kostnad för återställning om en chunk misslyckas.
Typiskt bra intervall: 100–1000, justerat genom att mäta genomströmningen mot databasen och radstorleken.

Kom ihåg: ett misslyckat objekt återställer hela chunken, så större chunkar innebär att mer arbete måste göras om vid ett fel.

Feltolerans: hoppa över och försöka igen

Verklig indata är sällan perfekt. Omslut steget med .faultTolerant() för att fortsätta bearbetningen trots enstaka fel.

.skip(...) — tolerera upp till skipLimit felaktiga objekt i stället för att låta jobbet misslyckas.
.retry(...) — försök igen vid tillfälliga fel (t.ex. dödlägen) upp till retryLimit gånger innan försöken avbryts.

Vid ett skip eller ett nytt försök skannar Spring Batch chunken igen objekt för objekt och isolerar den felaktiga posten.

@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();
}

Chunkens livscykel i ordning

När allt sätts ihop följer varje chunk samma loop i en enda transaktion:

1. Läs: anropa read() upprepade gånger tills chunkstorlekens antal objekt har buffrats (eller null markerar slutet på indatan).
2. Bearbeta: anropa process() för varje objekt; null-värden filtreras bort.
3. Skriv: skicka de kvarvarande objekten som en enda Chunk till write().
4. Genomför commit: genomför transaktionen och registrera förloppet i JobRepository.

Därefter upprepas loopen för nästa chunk tills läsaren inte har mer data.

Snabb kontroll

Testa din förståelse av chunk-flödet.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har kopplat ihop ett komplett chunk-baserat flöde i Spring Batch:

ItemReader strömmar indata ett objekt i taget och returnerar null när indatan är slut.
ItemProcessor omvandlar eller filtrerar objekt; null tar bort ett objekt.
ItemWriter sparar hela chunken i en enda massoperation för bättre prestanda.
Step kopplar ihop dem med ett commit-intervall via chunk(size, txManager), och Job samordnar stegen.
Justera chunkstorleken för genomströmning och lägg till .faultTolerant() med skip/retry för robusta flöden.

Denna läs-bearbeta-skriv-loop, med commit per chunk, är grunden för skalbar batchbearbetning.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Chunk-baserade Reader-Processor-Writer-flöden” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Spring Boot 4 – komplett guide, inklusive ”Chunk-baserade Reader-Processor-Writer-flöden”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Spring Boot 4 – komplett guide innehåller totalt 4 lektioner.

Vad lär jag mig i ”Chunk-baserade Reader-Processor-Writer-flöden”?

Koppla in komponenterna ItemReader, ItemProcessor och ItemWriter för skalbar chunk-bearbetning. Ni övar på Spring Boot 4 – komplett guide med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Boot 4 – komplett guide?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4 – komplett guide på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Chunk-baserade Reader-Processor-Writer-flöden”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Boot 4 – komplett guide-lektionen?

Ja. Varje Spring Boot 4 – komplett guide-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Jobb, steg och JobRepository-modellen
Chunk-baserade Reader-Processor-Writer-flöden
Feltolerans samt skip- och retry-policyer
Partitionering och parallell körning av steg

← Tillbaka till Spring Boot 4 – komplett guide