95 lines
3.3 KiB
Plaintext
95 lines
3.3 KiB
Plaintext
[[configuringAStep]]
|
|
= Configuring a Step
|
|
|
|
Despite the relatively short list of required dependencies for a `Step`, it is an
|
|
extremely complex class that can potentially contain many collaborators.
|
|
|
|
[tabs]
|
|
====
|
|
Java::
|
|
+
|
|
When using Java configuration, you can use the Spring Batch builders, as the
|
|
following example shows:
|
|
+
|
|
.Java Configuration
|
|
[source, java]
|
|
----
|
|
/**
|
|
* Note the JobRepository is typically autowired in and not needed to be explicitly
|
|
* configured
|
|
*/
|
|
@Bean
|
|
public Job sampleJob(JobRepository jobRepository, Step sampleStep) {
|
|
return new JobBuilder("sampleJob", jobRepository)
|
|
.start(sampleStep)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Note the TransactionManager is typically autowired in and not needed to be explicitly
|
|
* configured
|
|
*/
|
|
@Bean
|
|
public Step sampleStep(JobRepository jobRepository, // <2>
|
|
PlatformTransactionManager transactionManager) { // <1>
|
|
return new StepBuilder("sampleStep", jobRepository)
|
|
.<String, String>chunk(10, transactionManager) // <3>
|
|
.reader(itemReader())
|
|
.writer(itemWriter())
|
|
.build();
|
|
}
|
|
----
|
|
<1> `transactionManager`: Spring's `PlatformTransactionManager` that begins and commits
|
|
transactions during processing.
|
|
<2> `repository`: The Java-specific name of the `JobRepository` that periodically stores
|
|
the `StepExecution` and `ExecutionContext` during processing (just before committing).
|
|
<3> `chunk`: The Java-specific name of the dependency that indicates that this is an
|
|
item-based step and the number of items to be processed before the transaction is
|
|
committed.
|
|
+
|
|
NOTE: Note that `repository` defaults to `jobRepository` (provided through `@EnableBatchProcessing`)
|
|
and `transactionManager` defaults to `transactionManager` (provided from the application context).
|
|
Also, the `ItemProcessor` is optional, since the item could be
|
|
directly passed from the reader to the writer.
|
|
|
|
|
|
XML::
|
|
+
|
|
To ease configuration, you can use the Spring Batch XML namespace, as
|
|
the following example shows:
|
|
+
|
|
.XML Configuration
|
|
[source, xml]
|
|
----
|
|
<job id="sampleJob" job-repository="jobRepository"> <!--2-->
|
|
<step id="step1">
|
|
<tasklet transaction-manager="transactionManager"> <!--1-->
|
|
<chunk reader="itemReader" writer="itemWriter" commit-interval="10"/> <!--3-->
|
|
</tasklet>
|
|
</step>
|
|
</job>
|
|
----
|
|
<1> `transaction-manager`: Spring's `PlatformTransactionManager` that begins and commits
|
|
transactions during processing.
|
|
<2> `job-repository`: The XML-specific name of the `JobRepository` that periodically stores
|
|
the `StepExecution` and `ExecutionContext` during processing (just before committing). For
|
|
an in-line `<step/>` (one defined within a `<job/>`), it is an attribute on the `<job/>`
|
|
element. For a standalone `<step/>`, it is defined as an attribute of the `<tasklet/>`.
|
|
<3> `commit-interval`: The XML-specific name of the number of items to be processed
|
|
before the transaction is committed.
|
|
+
|
|
NOTE: Note that `job-repository` defaults to `jobRepository` and
|
|
`transaction-manager` defaults to `transactionManager`. Also, the `ItemProcessor` is
|
|
optional, since the item could be directly passed from the reader to the writer.
|
|
====
|
|
|
|
|
|
|
|
The preceding configuration includes the only required dependencies to create a item-oriented
|
|
step:
|
|
|
|
* `reader`: The `ItemReader` that provides items for processing.
|
|
* `writer`: The `ItemWriter` that processes the items provided by the `ItemReader`.
|
|
|
|
|