Agenda

Batch vs. Online Processing

When do you reach for batch?

Why Spring Batch?

You could write a loop. But then you'd also need to build:

The Building Blocks

Chunk-Oriented Processing

Instead of read-all then write-all, data flows in bounded chunks — each chunk is one database transaction.

Spring Batch Keeps Its Own History

Every run is automatically stored in a JobRepository — a set of tables in your database.

Basics Job — Overview

firstName,lastName
Jill,Doe
Joe,Doe
Justin,Doe
Jane,Doe
John,Doe

firstName,lastName
JILL,DOE
JOE,DOE
JUSTIN,DOE
JANE,DOE
JOHN,DOE

Basics — The Reader

basics/config/BasicsJobConfig.java

@Bean
public FlatFileItemReader<Person> basicsReader() {
    return new FlatFileItemReaderBuilder<Person>()
        .name("personItemReader")
        .resource(new ClassPathResource("basics/input.csv"))
        .delimited()
        .names("firstName", "lastName")   // CSV column names
        .targetType(Person.class)          // maps to POJO via reflection
        .build();
}

Basics — The Processor

basics/processing/PersonProcessor.java

public class PersonProcessor implements ItemProcessor<Person, Person> {

    @Override
    public Person process(Person person) {
        String firstName = person.firstName().toUpperCase();
        String lastName  = person.lastName().toUpperCase();

        Person transformed = new Person(firstName, lastName);
        log.info("Converting {} to {}", person, transformed);

        return transformed;   // return null here to SKIP this item entirely
    }
}

Basics — Wiring the Step & Job

@Bean
public Step basicsStep(JobRepository repo, PlatformTransactionManager tx,
                       FlatFileItemReader<Person> reader,
                       PersonProcessor processor,
                       FlatFileItemWriter<Person> writer) {

    return new StepBuilder("basicsStep", repo)
        .<Person, Person>chunk(10, tx)   // chunk size = 10 items per transaction
        .reader(reader)
        .processor(processor)
        .writer(writer)
        .build();
}

@Bean
public Job basicsJob(JobRepository repo, Step basicsStep) {
    return new JobBuilder("basicsJob", repo)
        .start(basicsStep)
        .build();
}

Everything assembled with builders. Every piece is a Spring bean — testable, injectable, familiar.

The Scenario

Step 1 — validate & load raw orders

Step 2 — aggregate for the dashboard

Real-World Data Quality Problems

The nightly CSV export is generated by multiple regional order systems — they don't agree on formatting conventions.

id,firstName,lastName,email,country,purchaseAmount
1,alex,johnson,alex.j@email.com,south africa,523.45   ← lowercase name & country
2,MARIA,SMITH,,united states,-15.00                   ← guest checkout (no email) + bad amount
3,Wei,Chen,wei@test.com,china,341.20                  ← clean record

CustomerProcessor — Filter & Clean

@Override
public Customer process(Customer c) {

    // FILTER — return null to skip this record silently
    if (c.email() == null || c.email().isBlank())             return null;
    if (c.purchaseAmount() == null || c.purchaseAmount() < 0) return null;

    // TRANSFORM
    return new Customer(
        c.id(),
        capitalize(c.firstName()),    // "ALEX" → "Alex"
        capitalize(c.lastName()),
        c.email().toLowerCase(),
        c.country().toUpperCase(),    // "south africa" → "SOUTH AFRICA"
        c.purchaseAmount()
    );
}

Step 1 — Writing to the Database

@Bean
public JdbcBatchItemWriter<Customer> customerWriter(DataSource ds) {
    return new JdbcBatchItemWriterBuilder<Customer>()
        .dataSource(ds)
        .sql("""
            INSERT INTO customers
                (id, first_name, last_name, email, country, purchase_amount)
            VALUES
                (:id, :firstName, :lastName, :email, :country, :purchaseAmount)
            """)
        .beanMapped()   // maps Java record fields to named SQL parameters
        .build();
}

Step 2 — Custom Aggregating Reader

Step 2 needs to aggregate rows by country. No built-in reader does this — so we implement ItemReader ourselves.

public class CountryStatisticsReader implements ItemReader<CountryStatistics> {
    private Iterator<CountryStatistics> iterator;

    @Override
    public CountryStatistics read() {
        if (iterator == null) {
            // Called once on the first read — load and aggregate everything
            List<Customer> all = jdbc.query("SELECT * FROM customers", ...);
            Map<String, CountryStatistics> map = new HashMap<>();
            for (Customer c : all)
                map.merge(c.country(), new CountryStatistics(c), CountryStatistics::merge);
            iterator = map.values().iterator();
        }
        return iterator.hasNext() ? iterator.next() : null;  // null = done
    }
}

Step 2 — Country Statistics Output

country,customerCount,totalRevenue,avgPurchase
CANADA,227,116600.54,513.66
VIETNAM,243,122213.53,502.94
TURKEY,212,99352.62,468.64
GERMANY,198,95432.11,481.98
...
ICELAND,1,850.75,850.75
(41 countries total)

public record CountryStatistics(
    String country,
    long   customerCount,
    double totalRevenue,
    double averagePurchaseAmount
) {}

Listeners — Hooks at Every Level

void beforeJob(JobExecution e);
void afterJob(JobExecution e);

void beforeStep(StepExecution e);
ExitStatus afterStep(StepExecution e);

void beforeChunk(ChunkContext c);
void afterChunk(ChunkContext c);
void afterChunkError(ChunkContext c);

new StepBuilder("processStep", repo)
    .listener(jobListener).listener(stepListener).listener(chunkListener)
    ...

Error Handling Strategies

Testing

@SpringBatchTest
@SpringBootTest
class BatchIntegrationTest {

    @Autowired JobLauncherTestUtils utils;

    @Test
    void customerJob_completesSuccessfully() throws Exception {
        JobExecution exec = utils.launchJob();

        assertEquals(COMPLETED, exec.getStatus());

        StepExecution step1 = getStep(exec, "processStep");
        assertEquals(13, step1.getWriteCount()); // 2 of 15 skipped
    }
}

class CountryStatisticsProcessorTest {

    @Test
    void roundsToTwoDecimals() {
        var input = new CountryStatistics(
            "CANADA", 10,
            116600.5432, 513.6612
        );
        var result = processor.process(input);

        assertThat(result.totalRevenue())
            .isEqualTo(116600.54);
        assertThat(result.averagePurchaseAmount())
            .isEqualTo(513.66);
    }
}

What to watch

Should I use Spring Batch?

Key Takeaways

• Read → Process → Write in chunks is the core pattern. Everything else builds on top.
• Returning null from a processor is how you skip items — no special API, just return null.
• Each chunk is one transaction — a failure never corrupts previously committed data.
• Spring Batch saves job history automatically — restart, auditing, and metrics come for free.
• Built-in readers/writers for CSV, JSON, JDBC, JPA, Kafka — you rarely write I/O plumbing.
• Listeners give you observability at Job, Step, and Chunk level with zero coupling to business logic.
• Everything is a Spring bean — familiar, testable, and injectable.