Spring Batch Reference

What Spring Batch is & running a first job — Spring Batch as a framework for finite, bounded bulk processing and explicitly not a scheduler, its origin and JSR-352 alignment, the module layout (spring-batch-core, spring-batch-infrastructure, spring-batch-test, spring-batch-integration, spring-boot-starter-batch), the 6.0.x release line, and a first runnable tasklet job.

Architecture & processing strategies — the application / core / infrastructure layering, general batch principles, and the processing strategies: the normal batch window, concurrent batch with online access and logical locking, parallel processing, and partitioning with its six break-up approaches.

Jobs, instances & parameters — Job, JobInstance as a job plus its identifying JobParameters, typed and identifying/non-identifying parameters, JobExecution with the BatchStatus lifecycle and ExitStatus, and running two executions of one instance.

Steps, executions & the ExecutionContext — Step and StepExecution with its read/write/commit/rollback/filter/skip counters, the job- and step-scoped ExecutionContext and when each is persisted, and passing data between steps with an ExecutionContextPromotionListener.

Infrastructure configuration — why @EnableBatchProcessing is left off under Spring Boot, the 6.0 split into @EnableBatchProcessing plus @EnableJdbcJobRepository/@EnableMongoJobRepository, DefaultBatchConfiguration for manual control, the resourceless defaults, and the JobRepository/JobExplorer and JobOperator/JobLauncher unification.

The job repository & metadata schema — the six metadata tables and their sequences, the per-vendor DDL and spring.batch.jdbc.* properties, the JDBC, MongoDB and resourceless repositories, the serializable isolation used when creating an execution, and querying run history.

Configuring a job — JobBuilder, step ordering, restartability and start limits, JobParametersValidator, JobParametersIncrementer, and JobExecutionListener.

Running a job — the unified JobOperator, synchronous versus asynchronous launching, Spring Boot’s JobLauncherApplicationRunner, the 6.0 CommandLineJobOperator, and launching on demand from an endpoint, a scheduled method or Quartz.

Stopping, restart & recovery — graceful stop and the 6.0 StoppableStep, failure and ExitStatus, controlling restart, rerunning a completed step, JobOperator.recover() for stranded executions, and failing a step that read nothing.

Chunk-oriented processing — the read/process/write loop, the commit interval as chunk size and transaction boundary, dynamic sizing with a CompletionPolicy, the 6.0 ChunkOrientedStepBuilder, transaction attributes, and stream registration.

Tasklet steps — the Tasklet contract and RepeatStatus, transaction semantics, the adapter tasklets, and when a tasklet beats a chunk step.

Fault tolerance: skip & retry — .faultTolerant(), skip policies and listeners, retry on Spring Framework 7’s retry support, back-off, .noRollback(…​), and the replay semantics that require an idempotent processor.

Step flow & listeners — sequential and conditional transitions, JobExecutionDecider, split flows, reusable flows and FlowStep, the listener interfaces and their annotations, and late binding with @StepScope/@JobScope.

ItemReader`s: files & XML/JSON — the reader contracts, `FlatFileItemReader and the tokenizer/FieldSet/mapper chain, multi-format and multi-line records, MultiResourceItemReader, StaxEventItemReader, JsonItemReader, and custom readers.

`ItemReader`s: databases — cursor versus paging, the JDBC, JPA, Hibernate, stored-procedure and Spring Data readers, and the driving-query pattern.

`ItemProcessor`s — transformation and type change, filtering versus skipping, composing and routing processors, validation, and why a processor must be idempotent.

ItemWriter`s: files & XML/JSON — the writer contracts, `FlatFileItemWriter with its aggregator/extractor chain and header/footer callbacks, the file-management flags, XML and JSON writers, output rollover, and composing writers.

ItemWriter`s: databases & alternative destinations — `JdbcBatchItemWriter and its parameter strategies, the JPA and Hibernate writers, the Spring Data writers, and the alternative-destination adapters.

Repeat & retry internals — RepeatOperations/RepeatTemplate with completion policies and exception handlers, RetryOperations/RetryTemplate, stateless versus stateful retry, and how a step’s settings map onto them.

Scaling & parallel processing — measuring first, then the multi-threaded step, parallel steps, the 6.0 producer/consumer model and local chunking, the async processor and writer, partitioning, and remote chunking and remote partitioning, with the restartability, ordering and durability trade-offs of each.

Profiling & tuning — profiling with VisualVM and Java Flight Recorder, choosing a chunk size, reader and writer costs, saveState, keeping the ExecutionContext small, the cost of metadata writes and indexing the metadata tables, and the common anti-patterns.

Spring Batch Integration — launching jobs from messages, the async processor and writer, SEDA-style stage decoupling with blocking queues, and how remote chunking and remote partitioning are wired over `MessageChannel`s.

Observability — the spring.batch.* Micrometer meters, tracing through the Observation API, the 6.0 Java Flight Recorder events, and what Spring Boot Actuator adds.

Cloud-native batch — the twelve-factor lens on a batch application, externalized configuration, guarding remote calls with a circuit breaker, Spring Cloud Task and Spring Cloud Data Flow, and running batch on Kubernetes.

Testing batch jobs — spring-batch-test, @SpringBatchTest, JobOperatorTestUtils and JobRepositoryTestUtils, MetaDataInstanceFactory, testing step- and job-scoped beans, end-to-end assertions and output validation, and mocking — on JUnit Jupiter only.

Spring Batch Cheat Sheet — a single-page, colour-coded summary of the essentials, with a downloadable printable PDF.