Update reference documentation for v6.0

Author: fmbenhassine

README.md

@@ -28,88 +28,51 @@ In your favorite IDE, create a new Maven-based Java 17+ project and add the foll
         <artifactId>spring-batch-core</artifactId>
         <version>${LATEST_VERSION}</version>
     </dependency>
-    <dependency>
-        <groupId>org.hsqldb</groupId>
-        <artifactId>hsqldb</artifactId>
-        <version>${LATEST_VERSION}</version>
-        <scope>runtime</scope>
-    </dependency>
 </dependencies>
 ```
 
-Then, create a configuration class to define the datasource and transaction manager that will be used by the job repository:
-
-```java
-import javax.sql.DataSource;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.jdbc.support.JdbcTransactionManager;
-import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
-
-@Configuration
-public class DataSourceConfiguration {
-
-	@Bean
-	public DataSource dataSource() {
-		return new EmbeddedDatabaseBuilder()
-			.addScript("/org/springframework/batch/core/schema-hsqldb.sql")
-			.build();
-	}
-
-	@Bean
-	public JdbcTransactionManager transactionManager(DataSource dataSource) {
-		return new JdbcTransactionManager(dataSource);
-	}
-
-}
-```
-
-In this tutorial, an embedded [HSQLDB](http://www.hsqldb.org) database is created and initialized with Spring Batch's meta-data tables.
-
-Finally, create a class to define the batch job:
+Then, create a class to define the batch job:
 
 ```java
-import org.springframework.batch.core.Job;
-import org.springframework.batch.core.JobParameters;
-import org.springframework.batch.core.Step;
+import org.springframework.batch.core.job.Job;
+import org.springframework.batch.core.job.parameters.JobParameters;
+import org.springframework.batch.core.launch.JobOperator;
+import org.springframework.batch.core.step.Step;
 import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
 import org.springframework.batch.core.job.builder.JobBuilder;
-import org.springframework.batch.core.launch.JobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.step.builder.StepBuilder;
-import org.springframework.batch.repeat.RepeatStatus;
+import org.springframework.batch.infrastructure.repeat.RepeatStatus;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.jdbc.support.JdbcTransactionManager;
 
 @Configuration
 @EnableBatchProcessing
-@Import(DataSourceConfiguration.class)
 public class HelloWorldJobConfiguration {
 
-	@Bean
-	public Step step(JobRepository jobRepository, JdbcTransactionManager transactionManager) {
-		return new StepBuilder("step", jobRepository).tasklet((contribution, chunkContext) -> {
-			System.out.println("Hello world!");
-			return RepeatStatus.FINISHED;
-		}, transactionManager).build();
-	}
-
-	@Bean
-	public Job job(JobRepository jobRepository, Step step) {
-		return new JobBuilder("job", jobRepository).start(step).build();
-	}
-
-	public static void main(String[] args) throws Exception {
-		ApplicationContext context = new AnnotationConfigApplicationContext(HelloWorldJobConfiguration.class);
-		JobLauncher jobLauncher = context.getBean(JobLauncher.class);
-		Job job = context.getBean(Job.class);
-		jobLauncher.run(job, new JobParameters());
-	}
+    @Bean
+    public Step step(JobRepository jobRepository) {
+        return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
+            System.out.println("Hello world!");
+            return RepeatStatus.FINISHED;
+        }).build();
+    }
+
+    @Bean
+    public Job job(JobRepository jobRepository, Step step) {
+        return new JobBuilder(jobRepository)
+                .start(step)
+                .build();
+    }
+
+    public static void main(String[] args) throws Exception {
+        ApplicationContext context = new AnnotationConfigApplicationContext(HelloWorldJobConfiguration.class);
+        JobOperator jobOperator = context.getBean(JobOperator.class);
+        Job job = context.getBean(Job.class);
+        jobOperator.start(job, new JobParameters());
+    }
 
 }
 ```
@@ -119,16 +82,11 @@ The job in this tutorial is composed of a single step that prints "Hello world!"
 You can now run the `main` method of the `HelloWorldJobConfiguration` class to launch the job. The output should be similar to the following:
 
 ```
-INFO: Finished Spring Batch infrastructure beans configuration in 8 ms.
-INFO: Starting embedded database: url='jdbc:hsqldb:mem:testdb', username='sa'
-INFO: No database type set, using meta data indicating: HSQL
-INFO: No Micrometer observation registry found, defaulting to ObservationRegistry.NOOP
-INFO: No TaskExecutor has been set, defaulting to synchronous executor.
-INFO: Job: [SimpleJob: [name=job]] launched with the following parameters: [{}]
-INFO: Executing step: [step]
+[main] INFO org.springframework.batch.core.launch.support.TaskExecutorJobLauncher -  COMMONS-LOGGING Job: [SimpleJob: [name=job]] launched with the following parameters: [{}]
+[main] INFO org.springframework.batch.core.job.SimpleStepHandler -  COMMONS-LOGGING Executing step: [step]
 Hello world!
-INFO: Step: [step] executed in 10ms
-INFO: Job: [SimpleJob: [name=job]] completed with the following parameters: [{}] and the following status: [COMPLETED] in 25ms
+[main] INFO org.springframework.batch.core.step.AbstractStep -  COMMONS-LOGGING Step: [step] executed in 3ms
+[main] INFO org.springframework.batch.core.launch.support.TaskExecutorJobLauncher -  COMMONS-LOGGING Job: [SimpleJob: [name=job]] completed with the following parameters: [{}] and the following status: [COMPLETED] in 4ms
 ```
 
 ## Getting Started Guide

spring-batch-docs/modules/ROOT/nav.adoc

@@ -51,13 +51,14 @@
 ** xref:spring-batch-integration/namespace-support.adoc[]
 ** xref:spring-batch-integration/launching-jobs-through-messages.adoc[]
 ** xref:spring-batch-integration/available-attributes-of-the-job-launching-gateway.adoc[]
-** xref:spring-batch-integration/sub-elements.adoc[]
+** xref:spring-batch-integration/providing-feedback-with-informational-messages.adoc[Providing Feedback with Informational Messages]
+** xref:spring-batch-integration/asynchronous-processing.adoc[Asynchronous Processors]
+** xref:spring-batch-integration/externelazing-execution.adoc[Externalizing Batch Process Execution]
 * xref:spring-batch-observability.adoc[]
 ** xref:spring-batch-observability/micrometer.adoc[]
 ** xref:spring-batch-observability/jfr.adoc[]
 * Appendices
 ** xref:appendix.adoc[]
 ** xref:schema-appendix.adoc[]
-** xref:transaction-appendix.adoc[]
 ** xref:glossary.adoc[]
 ** xref:faq.adoc[]

spring-batch-docs/modules/ROOT/pages/domain.adoc

@@ -657,3 +657,5 @@ information on configuring a Job in xref:job.adoc[Configuring and Running a Job]
 . You can find more information on configuring a `Step` in
 xref:step.adoc[Configuring a Step].
 
+WARNING: The batch XML namespace is deprecated as of Spring Batch 6.0 and will be removed in version 7.0.
+

spring-batch-docs/modules/ROOT/pages/index.adoc

@@ -7,9 +7,9 @@ The reference documentation is divided into several sections:
 [horizontal]
 xref:spring-batch-intro.adoc[Spring Batch Introduction] :: Background, usage
  scenarios, and general guidelines.
+xref:whatsnew.adoc[What's new in Spring Batch 6.0] :: New features introduced in version 6.0.
 xref:spring-batch-architecture.adoc[Spring Batch Architecture] :: Spring Batch
 architecture, general batch principles, batch processing strategies.
-xref:whatsnew.adoc[What's new in Spring Batch 6.0] :: New features introduced in version 6.0.
 xref:domain.adoc[The Domain Language of Batch] :: Core concepts and abstractions
 of the Batch domain language.
 xref:job.adoc[Configuring and Running a Job] :: Job configuration, execution, and
@@ -23,7 +23,7 @@ xref:scalability.adoc#scalability[Scaling and Parallel Processing] :: Multi-thre
 parallel steps, remote chunking, and partitioning.
 <<repeat.adoc#repeat,Repeat>> :: Completion policies and exception handling of repetitive actions.
 <<retry.adoc#retry,Retry>> :: Retry and backoff policies of retryable operations.
-xref:testing.adoc[Unit Testing] :: Job and Step testing facilities and APIs.
+xref:testing.adoc[Unit and Integration Testing] :: Job and Step testing facilities and APIs.
 xref:common-patterns.adoc#commonPatterns[Common Patterns] :: Common batch processing patterns
 and guidelines.
 xref:spring-batch-integration.adoc[Spring Batch Integration] :: Integration
@@ -38,8 +38,6 @@ xref:appendix.adoc#listOfReadersAndWriters[List of ItemReaders and ItemWriters]
 all provided item readers and writers.
 xref:schema-appendix.adoc#metaDataSchema[Meta-Data Schema] :: Core tables used by the Batch
 domain model.
-xref:transaction-appendix.adoc#transactions[Batch Processing and Transactions] :: Transaction
-boundaries, propagation, and isolation levels used in Spring Batch.
 <<glossary.adoc#glossary,Glossary>> :: Glossary of common terms, concepts, and vocabulary of
 the Batch domain.
 <<faq.adoc#faq,Frequently Asked Questions>> :: Frequently Asked Questions about Spring Batch.

spring-batch-docs/modules/ROOT/pages/job/configuring-infrastructure.adoc

@@ -20,7 +20,6 @@ created, in addition to a number of beans being made available to be autowired:
 
 * `JobRepository`: a bean named `jobRepository`
 * `JobOperator`: a bean named `jobOperator`
-* `JobRegistry`: a bean named `jobRegistry`
 
 Here is an example of how to use the `@EnableBatchProcessing` annotation in a Java configuration class:
 

spring-batch-docs/modules/ROOT/pages/job/configuring-repository.adoc

@@ -6,6 +6,23 @@ of the various persisted domain objects within Spring Batch, such as `JobExecuti
 It is required by many of the major framework features, such as the `JobOperator`,
 `Job`, and `Step`.
 
+== Configuring a Resourceless JobRepository
+
+The simplest implementation of the `JobRepository` interface is the
+`ResourcelessJobRepository`. This implementation does not use or store batch meta-data.
+It is intended for use-cases where restartability is not required and where the execution context
+is not involved in any way (like sharing data between steps through the execution context,
+or partitioned steps where partitions meta-data is shared between the manager and workers through
+the execution context, etc). This implementation holds the minimal state to run a single job
+(ie 1 job instance + 1 job execution + N step executions). This is suitable for one-time jobs
+executed in their own JVM. This job repository works with transactional steps as well as non-transactional
+steps (in conjunction with `ResourcelessTransactionManager`).
+
+IMPORTANT: This implementation is *not* thread-safe and should *not* be used in any concurrent environment.
+
+By default, when using `@EnableBatchProcessing` or `DefaultBatchConfiguration`, a `ResourcelessJobRepository`
+is provided for you.
+
 == Configuring a JDBC JobRepository
 
 [tabs]

spring-batch-docs/modules/ROOT/pages/job/running.adoc

@@ -52,11 +52,11 @@ create an `ApplicationContext`. This file
 should contain everything needed to run the complete
 `Job`, including a `JobOperator`, a `JobRepository` and a `JobRegistry` populated with the jobs to operate.
 |`operation`|The name of the operation to execute on the job. Can be one of [`start`, `startNextInstance`, `stop`, `restart`, `abandon`]
-|`jobName` or `jobExecutionId`|Depending on the operation, this can be the name of the job to start or the execution ID of the job to stop, restart or abandon.
+|`jobName` or `jobExecutionId`|Depending on the operation, this can be the name of the job to start or the execution ID of the job to stop, restart, abandon or recover.
 |===============
 
 When starting a job, all arguments after these are considered to be job parameters, are turned into a `JobParameters` object,
-and must be in the format of `name=value`. In the case of stopping, restarting or abandoning a job, the `jobExecutionId` is
+and must be in the format of `name=value,type,identifying`. In the case of stopping, restarting, abandoning or recovering a job, the `jobExecutionId` is
 expected as the 4th argument, and all remaining arguments are ignored.
 
 The following example shows a date passed as a job parameter to a job defined in Java:

spring-batch-docs/modules/ROOT/pages/readers-and-writers/item-reader.adoc

@@ -28,7 +28,7 @@ input operations, as shown in the following interface definition:
 ----
 public interface ItemReader<T> {
 
-    T read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException;
+    T read() throws Exception;
 
 }
 ----

spring-batch-docs/modules/ROOT/pages/retry.adoc

@@ -14,8 +14,6 @@ Examples include remote calls to a web service that fails because of a network g
 
 [NOTE]
 ====
-As of version 2.2.0, the retry functionality was pulled out of Spring Batch.
-It is now part of a new library, https://github.com/spring-projects/spring-retry[Spring Retry].
-As of v6.0, Spring Batch does *not* use Spring Retry to automate retry operations within the framework,
-and is now based on the https://docs.spring.io/spring-framework/reference/7.0/core/resilience.html#resilience-annotations-retryable[retry feature] provided by Spring Framework 7.0.
+As of v6.0, Spring Batch does *not* use https://github.com/spring-projects/spring-retry[Spring Retry] to automate retry operations within the framework,
+and is now based on the https://docs.spring.io/spring-framework/reference/7.0/core/resilience.html[core retry feature] provided by Spring Framework 7.0.
 ====

spring-batch-docs/modules/ROOT/pages/scalability.adoc

@@ -208,7 +208,7 @@ See the section on xref:step/controlling-flow.adoc#split-flows[Split Flows] for
 [[localChunking]]
 == Local Chunking
 
-Local chunking is a new feature that allows you to process chunks of items in parallel, locally within the same JVM using multiple threads.
+Local chunking is a new feature in v6.0 that allows you to process chunks of items in parallel, locally within the same JVM using multiple threads.
 This is particularly useful when you have a large number of items to process and want to take advantage of multi-core processors.
 With local chunking, you can configure a chunk-oriented step to use multiple threads to process chunks of items concurrently.
 Each thread will read, process and write its own chunk of items independently, while the step will manage the overall execution and commit the results.
@@ -292,7 +292,7 @@ message. JMS is the obvious candidate, but other options (such as JavaSpaces) ex
 the grid computing and shared memory product space.
 
 See the section on
-xref:spring-batch-integration/sub-elements.adoc#remote-chunking[Spring Batch Integration - Remote Chunking]
+xref:spring-batch-integration/externelazing-execution.adoc#remote-chunking[Spring Batch Integration - Remote Chunking]
 for more detail.
 
 [[partitioning]]