@@ -117,7 +117,7 @@ public class ExitStatus implements Serializable, Comparable {
*
Codes beginning with FAILED have severity 5
*
Codes beginning with UNKNOWN have severity 6
*
- * Others have severity 7, so custom exit codes always win.
+ * Others have severity 7, so custom exit codes always win.
*
* If the input is null just return this.
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/JobExecution.java b/spring-batch-core/src/main/java/org/springframework/batch/core/JobExecution.java
index 45be8fc33..71b352294 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/JobExecution.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/JobExecution.java
@@ -16,6 +16,8 @@
package org.springframework.batch.core;
+import org.springframework.batch.item.ExecutionContext;
+
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
@@ -28,8 +30,6 @@ import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
-import org.springframework.batch.item.ExecutionContext;
-
/**
* Batch domain object representing the execution of a job.
*
@@ -333,7 +333,7 @@ public class JobExecution extends Entity {
* Return all failure causing exceptions for this JobExecution, including
* step executions.
*
- * @return List containing all exceptions causing failure for
+ * @return List<Throwable> containing all exceptions causing failure for
* this JobExecution.
*/
public synchronized List getAllFailureExceptions() {
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/JobParametersBuilder.java b/spring-batch-core/src/main/java/org/springframework/batch/core/JobParametersBuilder.java
index 6939f6625..bedee3b52 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/JobParametersBuilder.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/JobParametersBuilder.java
@@ -16,21 +16,21 @@
package org.springframework.batch.core;
+import org.springframework.util.Assert;
+
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
-import org.springframework.util.Assert;
-
/**
* Helper class for creating {@link JobParameters}. Useful because all
* {@link JobParameter} objects are immutable, and must be instantiated separately
* to ensure typesafety. Once created, it can be used in the
* same was a java.lang.StringBuilder (except, order is irrelevant), by adding
* various parameter types and creating a valid {@link JobParameters} once
- * finished.
- *
+ * finished.
+ *
* Using the identifying flag indicates if the parameter will be used
* in the identification of a JobInstance. That flag defaults to true.
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/Step.java b/spring-batch-core/src/main/java/org/springframework/batch/core/Step.java
index df0d61096..c5e83e4b8 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/Step.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/Step.java
@@ -42,7 +42,7 @@ public interface Step {
/**
* Process the step and assign progress and status meta information to the {@link StepExecution} provided. The
* {@link Step} is responsible for setting the meta information and also saving it if required by the
- * implementation.
+ * implementation.
*
* It is not safe to re-use an instance of {@link Step} to process multiple concurrent executions.
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunk.java b/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunk.java
index 2a0366f59..003a8b21e 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunk.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunk.java
@@ -15,17 +15,17 @@
*/
package org.springframework.batch.core.annotation;
+import org.springframework.batch.core.ChunkListener;
+import org.springframework.batch.core.scope.context.ChunkContext;
+
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.springframework.batch.core.ChunkListener;
-import org.springframework.batch.core.scope.context.ChunkContext;
-
/**
* Marks a method to be called after a chunk is executed.
- *
+ *
* Expected signature: void afterChunk(ChunkContext context)
*
* @author Lucas Ward
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunkError.java b/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunkError.java
index eba8a66a2..a8ef5fce5 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunkError.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/annotation/AfterChunkError.java
@@ -15,18 +15,18 @@
*/
package org.springframework.batch.core.annotation;
+import org.springframework.batch.core.ChunkListener;
+import org.springframework.batch.core.scope.context.ChunkContext;
+
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.springframework.batch.core.ChunkListener;
-import org.springframework.batch.core.scope.context.ChunkContext;
-
/**
* Marks a method to be called after a has failed and been
* marked for rollback.
- *
+ *
* Expected signature: void afterFailedChunk(ChunkContext context)
*
* @author Michael Minella
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.java b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.java
index 662197c0c..cedf8cc83 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.java
@@ -33,7 +33,7 @@ import java.lang.annotation.Target;
/**
*
* Enable Spring Batch features and provide a base configuration for setting up batch jobs in an @Configuration
- * class, roughly equivalent to using the {@code } XML namespace.
+ * class, roughly equivalent to using the {@code } XML namespace.
*
*
* @Configuration
@@ -134,8 +134,6 @@ import java.lang.annotation.Target;
* especially if a {@link BatchConfigurer} is provided, because cyclic configuration dependencies are otherwise likely
* to develop.
*
- *
- *
*
* For reference, the first example above can be compared to the following Spring XML configuration:
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/StepScope.java b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/StepScope.java
index b95c4c129..19e66489e 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/StepScope.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/StepScope.java
@@ -15,13 +15,13 @@
*/
package org.springframework.batch.core.configuration.annotation;
+import org.springframework.context.annotation.Scope;
+import org.springframework.context.annotation.ScopedProxyMode;
+
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
-import org.springframework.context.annotation.Scope;
-import org.springframework.context.annotation.ScopedProxyMode;
-
/**
*
* Convenient annotation for step scoped beans that defaults the proxy mode, so that it doesn't have to be specified
@@ -42,7 +42,7 @@ import org.springframework.context.annotation.ScopedProxyMode;
*
* @author Dave Syer
*
- * @Since 2.2
+ * @since 2.2
*
*/
@Scope(value = "step", proxyMode = ScopedProxyMode.TARGET_CLASS)
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/support/DefaultJobLoader.java b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/support/DefaultJobLoader.java
index 260618e28..bfec62a1b 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/support/DefaultJobLoader.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/support/DefaultJobLoader.java
@@ -15,12 +15,6 @@
*/
package org.springframework.batch.core.configuration.support;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.batch.core.Job;
@@ -36,6 +30,12 @@ import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.util.Assert;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
/**
* Default implementation of {@link JobLoader}. Uses a {@link JobRegistry} to
* manage a population of loaded jobs and clears them up when asked. An optional
@@ -208,7 +208,7 @@ public class DefaultJobLoader implements JobLoader, InitializingBean {
/**
* Returns all the {@link Step} instances defined by the specified {@link StepLocator}.
- *
+ *
* The specified jobApplicationContext is used to collect additional steps that
* are not exposed by the step locator
*
@@ -238,7 +238,7 @@ public class DefaultJobLoader implements JobLoader, InitializingBean {
/**
* Registers the specified {@link Job} defined in the specified {@link ConfigurableApplicationContext}.
- *
+ *
* Makes sure to update the {@link StepRegistry} if it is available.
*
* @param context the context in which the job is defined
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/xml/StepParserStepFactoryBean.java b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/xml/StepParserStepFactoryBean.java
index d4d9b7fda..5e08682d4 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/xml/StepParserStepFactoryBean.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/xml/StepParserStepFactoryBean.java
@@ -961,11 +961,11 @@ public class StepParserStepFactoryBean implements FactoryBean, BeanN
/**
* Public setter for the capacity of the cache in the retry policy. If more items than this fail without being
* skipped or recovered an exception will be thrown. This is to guard against inadvertent infinite loops generated
- * by item identity problems.
- *
+ * by item identity problems.
+ *
* The default value should be high enough and more for most purposes. To breach the limit in a single-threaded step
* typically you have to have this many failures in a single transaction. Defaults to the value in the
- * {@link MapRetryContextCache}.
+ * {@link MapRetryContextCache}.
*
* @param cacheCapacity the cache capacity to set (greater than 0 else ignored)
*/
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/converter/DefaultJobParametersConverter.java b/spring-batch-core/src/main/java/org/springframework/batch/core/converter/DefaultJobParametersConverter.java
index a40d84547..1a2d953a7 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/converter/DefaultJobParametersConverter.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/converter/DefaultJobParametersConverter.java
@@ -15,6 +15,13 @@
*/
package org.springframework.batch.core.converter;
+import org.springframework.batch.core.JobInstance;
+import org.springframework.batch.core.JobParameter;
+import org.springframework.batch.core.JobParameter.ParameterType;
+import org.springframework.batch.core.JobParameters;
+import org.springframework.batch.core.JobParametersBuilder;
+import org.springframework.util.StringUtils;
+
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.NumberFormat;
@@ -27,13 +34,6 @@ import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
-import org.springframework.batch.core.JobInstance;
-import org.springframework.batch.core.JobParameter;
-import org.springframework.batch.core.JobParameter.ParameterType;
-import org.springframework.batch.core.JobParameters;
-import org.springframework.batch.core.JobParametersBuilder;
-import org.springframework.util.StringUtils;
-
/**
* Converter for {@link JobParameters} instances using a simple naming
* convention for property keys. Key names that are prefixed with a - are
@@ -50,7 +50,7 @@ import org.springframework.util.StringUtils;
* The literal values are converted to the correct type using the default Spring
* strategies, augmented if necessary by the custom editors provided.
*
- *
+ *
*
* If you need to be able to parse and format local-specific dates and numbers,
* you can inject formatters ({@link #setDateFormat(DateFormat)} and
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/job/flow/support/DefaultStateTransitionComparator.java b/spring-batch-core/src/main/java/org/springframework/batch/core/job/flow/support/DefaultStateTransitionComparator.java
index 10c636b3a..d4b6dc874 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/job/flow/support/DefaultStateTransitionComparator.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/job/flow/support/DefaultStateTransitionComparator.java
@@ -15,15 +15,15 @@
*/
package org.springframework.batch.core.job.flow.support;
-import java.util.Comparator;
-
import org.springframework.util.StringUtils;
+import java.util.Comparator;
+
/**
* Sorts by decreasing specificity of pattern, based on just counting
* wildcards (with * taking precedence over ?). If wildcard counts are equal
* then falls back to alphabetic comparison. Hence * > foo* > ??? >
- * fo? > foo.
+ * fo? > foo.
*
* @see Comparator
* @author Michael Minella
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/jsr/configuration/support/SpringAutowiredAnnotationBeanPostProcessor.java b/spring-batch-core/src/main/java/org/springframework/batch/core/jsr/configuration/support/SpringAutowiredAnnotationBeanPostProcessor.java
index 6f161b085..5b85b7f20 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/jsr/configuration/support/SpringAutowiredAnnotationBeanPostProcessor.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/jsr/configuration/support/SpringAutowiredAnnotationBeanPostProcessor.java
@@ -67,9 +67,11 @@ import org.springframework.util.ReflectionUtils;
*
This class is considered a quick work around and needs to be refactored / removed.
*
*
The in addition to making this class package private, the following methods were modified to be protected:
- *
findAutowiringMetadata(Class> clazz)
- *
buildAutowiringMetadata(Class> clazz)
+ *
+ *
findAutowiringMetadata(Class<?> clazz)
+ *
buildAutowiringMetadata(Class<?> clazz)
*
findAutowiredAnnotation(AccessibleObject ao)
+ *
*/
class SpringAutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/launch/JobOperator.java b/spring-batch-core/src/main/java/org/springframework/batch/core/launch/JobOperator.java
index 129203c47..e71d1df1d 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/launch/JobOperator.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/launch/JobOperator.java
@@ -15,10 +15,6 @@
*/
package org.springframework.batch.core.launch;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobInstance;
@@ -31,6 +27,10 @@ import org.springframework.batch.core.repository.JobExecutionAlreadyRunningExcep
import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
import org.springframework.batch.core.repository.JobRestartException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
/**
* Low level interface for inspecting and controlling jobs with access only to
* primitive and collection types. Suitable for a command-line client (e.g. that
@@ -130,8 +130,8 @@ public interface JobOperator {
* {@link JobParametersIncrementer} attached to the specified job. If the
* previous instance is still in a failed state, this method should still
* create a new instance and run it with different parameters (as long as
- * the {@link JobParametersIncrementer} is working).
- *
+ * the {@link JobParametersIncrementer} is working).
+ *
*
* The last three exception described below should be extremely unlikely,
* but cannot be ruled out entirely. It points to some other thread or
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/CommandLineJobRunner.java b/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/CommandLineJobRunner.java
index 1091218e6..a63c8a7c1 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/CommandLineJobRunner.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/CommandLineJobRunner.java
@@ -15,19 +15,6 @@
*/
package org.springframework.batch.core.launch.support;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-import java.util.Set;
-
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.batch.core.BatchStatus;
@@ -58,6 +45,19 @@ import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
/**
*
* Basic launcher for starting jobs from the command line. In general, it is
@@ -101,11 +101,12 @@ import org.springframework.util.StringUtils;
*
jobParameters: 0 to many parameters that will be used to launch a job
* specified in the form of key=value pairs.
*
- *
*
*
* If the -next option is used the parameters on the command line
@@ -135,18 +135,18 @@ import org.springframework.util.StringUtils;
* {@link JobParameters} using a {@link JobParametersConverter} from the
* application context (if there is one, or a
* {@link DefaultJobParametersConverter} otherwise). Below is an example
- * arguments list: "
+ * arguments list: "
* Once arguments have been successfully parsed, autowiring will be used to set
- * various dependencies. The {@JobLauncher} for example, will be
+ * various dependencies. The {@link JobLauncher} for example, will be
* loaded this way. If none is contained in the bean factory (it searches by
* type) then a {@link BeanDefinitionStoreException} will be thrown. The same
* exception will also be thrown if there is more than one present. Assuming the
@@ -502,11 +502,11 @@ public class CommandLineJobRunner {
* such contexts. No exception are thrown from this method, rather
* exceptions are logged and an integer returned through the exit status in
* a {@link JvmSystemExiter} (which can be overridden by defining one in the
- * Spring context).
+ * Spring context).
* Parameters can be provided in the form key=value, and will be converted
* using the injected {@link JobParametersConverter}.
*
- * @param args
+ * @param args
*
*
-restart: (optional) if the job has failed or stopped and the most
* should be restarted. If specified then the jobIdentifier parameter can be
@@ -520,6 +520,7 @@ public class CommandLineJobRunner {
*
jobParameters: 0 to many parameters that will be used to launch a
* job.
*
+ *
* The options (-restart, -next) can occur anywhere in the
* command line.
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/SimpleJobLauncher.java b/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/SimpleJobLauncher.java
index 39ea3ae4e..fbafc04a9 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/SimpleJobLauncher.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/launch/support/SimpleJobLauncher.java
@@ -53,7 +53,7 @@ import org.springframework.util.Assert;
* Repository can reliably recreate it.
*
* @author Lucas Ward
- * @Author Dave Syer
+ * @author Dave Syer
* @author Will Schipp
* @author Michael Minella
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/partition/StepExecutionSplitter.java b/spring-batch-core/src/main/java/org/springframework/batch/core/partition/StepExecutionSplitter.java
index da70b143e..c1b1cd8f9 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/partition/StepExecutionSplitter.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/partition/StepExecutionSplitter.java
@@ -16,12 +16,12 @@
package org.springframework.batch.core.partition;
-import java.util.Set;
-
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionException;
import org.springframework.batch.core.StepExecution;
+import java.util.Set;
+
/**
* Strategy interface for generating input contexts for a partitioned step
* execution independent from the fabric they are going to run on.
@@ -44,8 +44,8 @@ public interface StepExecutionSplitter {
* executable instances with the same parent {@link JobExecution}. The grid
* size will be treated as a hint for the size of the collection to be
* returned. It may or may not correspond to the physical size of an
- * execution grid.
- *
+ * execution grid.
+ *
*
* On a restart clients of the {@link StepExecutionSplitter} should expect
* it to reconstitute the state of the last failed execution and only return
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/partition/support/TaskExecutorPartitionHandler.java b/spring-batch-core/src/main/java/org/springframework/batch/core/partition/support/TaskExecutorPartitionHandler.java
index 083274862..549e8af4c 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/partition/support/TaskExecutorPartitionHandler.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/partition/support/TaskExecutorPartitionHandler.java
@@ -16,12 +16,6 @@
package org.springframework.batch.core.partition.support;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-import java.util.concurrent.FutureTask;
-
import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.Step;
@@ -35,12 +29,18 @@ import org.springframework.core.task.TaskExecutor;
import org.springframework.core.task.TaskRejectedException;
import org.springframework.util.Assert;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+
/**
* A {@link PartitionHandler} that uses a {@link TaskExecutor} to execute the
* partitioned {@link Step} locally in multiple threads. This can be an
* effective approach for scaling batch steps that are IO intensive, like
* directory and filesystem scanning and copying.
- *
+ *
* By default, the thread pool is synchronous.
*
* @author Sebastien Gerard
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/repository/JobRepository.java b/spring-batch-core/src/main/java/org/springframework/batch/core/repository/JobRepository.java
index d4d48a448..cef28dbfe 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/repository/JobRepository.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/repository/JobRepository.java
@@ -16,8 +16,6 @@
package org.springframework.batch.core.repository;
-import java.util.Collection;
-
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobInstance;
@@ -29,6 +27,8 @@ import org.springframework.batch.core.repository.dao.JobInstanceDao;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.transaction.annotation.Isolation;
+import java.util.Collection;
+
/**
*
* Repository responsible for persistence of batch meta-data entities.
@@ -100,7 +100,7 @@ public interface JobRepository {
* support the higher isolation levels).
*
*
- * @param jobName the name of the job that is to be executed
+ * @param jobName the name of the job that is to be executed
*
* @param jobParameters the runtime parameters for the job
*
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/repository/dao/JdbcStepExecutionDao.java b/spring-batch-core/src/main/java/org/springframework/batch/core/repository/dao/JdbcStepExecutionDao.java
index 42c9a347e..2ffcf03ab 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/repository/dao/JdbcStepExecutionDao.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/repository/dao/JdbcStepExecutionDao.java
@@ -16,17 +16,6 @@
package org.springframework.batch.core.repository.dao;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.sql.Types;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.batch.core.BatchStatus;
@@ -40,18 +29,29 @@ import org.springframework.jdbc.core.simple.ParameterizedRowMapper;
import org.springframework.jdbc.support.incrementer.DataFieldMaxValueIncrementer;
import org.springframework.util.Assert;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
/**
- * JDBC implementation of {@link StepExecutionDao}.
+ * JDBC implementation of {@link StepExecutionDao}.
*
* Allows customization of the tables names used by Spring Batch for step meta
- * data via a prefix property.
+ * data via a prefix property.
*
* Uses sequences or tables (via Spring's {@link DataFieldMaxValueIncrementer}
* abstraction) to create all primary keys before inserting a new row. All
* objects are checked to ensure all fields to be stored are not null. If any
* are found to be null, an IllegalArgumentException will be thrown. This could
* be left to JdbcTemplate, however, the exception will be fairly vague, and
- * fails to highlight which field caused the exception.
+ * fails to highlight which field caused the exception.
*
* @author Lucas Ward
* @author Dave Syer
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/scope/JobScope.java b/spring-batch-core/src/main/java/org/springframework/batch/core/scope/JobScope.java
index c7cdd33e9..c34034e1a 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/scope/JobScope.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/scope/JobScope.java
@@ -28,8 +28,8 @@ import org.springframework.beans.factory.config.Scope;
* Scope for job context. Objects in this scope use the Spring container as an
* object factory, so there is only one instance of such a bean per executing
* job. All objects in this scope are <aop:scoped-proxy/> (no need to
- * decorate the bean definitions).
- *
+ * decorate the bean definitions).
+ *
*
* In addition, support is provided for late binding of references accessible
* from the {@link JobContext} using #{..} placeholders. Using this feature,
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/scope/StepScope.java b/spring-batch-core/src/main/java/org/springframework/batch/core/scope/StepScope.java
index b1f933358..423f018ce 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/scope/StepScope.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/scope/StepScope.java
@@ -28,8 +28,8 @@ import org.springframework.beans.factory.config.Scope;
* Scope for step context. Objects in this scope use the Spring container as an
* object factory, so there is only one instance of such a bean per executing
* step. All objects in this scope are <aop:scoped-proxy/> (no need to
- * decorate the bean definitions).
- *
+ * decorate the bean definitions).
+ *
*
* In addition, support is provided for late binding of references accessible
* from the {@link StepContext} using #{..} placeholders. Using this feature,
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/step/factory/FaultTolerantStepFactoryBean.java b/spring-batch-core/src/main/java/org/springframework/batch/core/step/factory/FaultTolerantStepFactoryBean.java
index 566847214..1e66a6ec1 100755
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/step/factory/FaultTolerantStepFactoryBean.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/step/factory/FaultTolerantStepFactoryBean.java
@@ -109,11 +109,11 @@ public class FaultTolerantStepFactoryBean extends SimpleStepFactoryBean
+ * by item identity problems.
*
* The default value should be high enough and more for most purposes. To breach the limit in a single-threaded step
* typically you have to have this many failures in a single transaction. Defaults to the value in the
- * {@link MapRetryContextCache}.
+ * {@link MapRetryContextCache}.
*
* This property is ignored if the {@link #setRetryContextCache(RetryContextCache)} is set directly.
*
@@ -186,7 +186,7 @@ public class FaultTolerantStepFactoryBean extends SimpleStepFactoryBean
+ *
* Defaults to all no exception.
*
* @param exceptionClasses defaults to Exception
@@ -199,7 +199,7 @@ public class FaultTolerantStepFactoryBean extends SimpleStepFactoryBean
+ *
* Defaults is empty.
*
* @param noRollbackExceptionClasses the exception classes to set
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipLimitExceededException.java b/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipLimitExceededException.java
index e20b2d6ee..fa278dd32 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipLimitExceededException.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipLimitExceededException.java
@@ -17,7 +17,7 @@ package org.springframework.batch.core.step.skip;
/**
- * Exception indicating that the skip limit for a particular {@Step} has
+ * Exception indicating that the skip limit for a particular {@link org.springframework.batch.core.Step} has
* been exceeded.
*
* @author Ben Hale
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipPolicy.java b/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipPolicy.java
index c14e34edd..c0f43768a 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipPolicy.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/step/skip/SkipPolicy.java
@@ -26,9 +26,9 @@ public interface SkipPolicy {
/**
* Returns true or false, indicating whether or not processing should
* continue with the given throwable. Clients may use
- * skipCount<0 to probe for exception types that are skippable,
+ * {@code skipCount<0} to probe for exception types that are skippable,
* so implementations should be able to handle gracefully the case where
- * skipCount<0. Implementations should avoid throwing any
+ * {@code skipCount<0}. Implementations should avoid throwing any
* undeclared exceptions.
*
* @param t exception encountered while reading
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/SimpleSystemProcessExitCodeMapper.java b/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/SimpleSystemProcessExitCodeMapper.java
index ba27551f9..55c7b4ab7 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/SimpleSystemProcessExitCodeMapper.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/SimpleSystemProcessExitCodeMapper.java
@@ -21,8 +21,8 @@ import org.springframework.batch.core.ExitStatus;
/**
* Simple {@link SystemProcessExitCodeMapper} implementation that performs following mapping:
*
- * 0 -> ExitStatus.FINISHED
- * else -> ExitStatus.FAILED
+ * 0 -> ExitStatus.FINISHED
+ * else -> ExitStatus.FAILED
*
* @author Robert Kasanicky
*/
diff --git a/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/TaskletStep.java b/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/TaskletStep.java
index be8e58180..096570916 100644
--- a/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/TaskletStep.java
+++ b/spring-batch-core/src/main/java/org/springframework/batch/core/step/tasklet/TaskletStep.java
@@ -15,8 +15,6 @@
*/
package org.springframework.batch.core.step.tasklet;
-import java.util.concurrent.Semaphore;
-
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.batch.core.BatchStatus;
@@ -53,13 +51,15 @@ import org.springframework.transaction.support.TransactionSynchronizationManager
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.Assert;
+import java.util.concurrent.Semaphore;
+
/**
* Simple implementation of executing the step as a call to a {@link Tasklet},
* possibly repeated, and each call surrounded by a transaction. The structure
* is therefore that of a loop with transaction boundary inside the loop. The
* loop is controlled by the step operations (
- * {@link #setStepOperations(RepeatOperations)}).
- *
+ * {@link #setStepOperations(RepeatOperations)}).
+ *
*
* Clients can use interceptors in the step operations to intercept or listen to
* the iteration on a step-wide basis, for instance to get a callback when the
@@ -233,7 +233,7 @@ public class TaskletStep extends AbstractStep {
* given an up to date {@link BatchStatus}, and the {@link JobRepository} is
* used to store the result. Various reporting information are also added to
* the current context governing the step execution, which would normally be
- * available to the caller through the step's {@link ExecutionContext}.
+ * available to the caller through the step's {@link ExecutionContext}.
*
* @throws JobInterruptedException if the step or a chunk is interrupted
* @throws RuntimeException if there is an exception during a chunk
diff --git a/spring-batch-core/src/site/apt/changelog.apt b/spring-batch-core/src/site/apt/changelog.apt
deleted file mode 100644
index 18947ba75..000000000
--- a/spring-batch-core/src/site/apt/changelog.apt
+++ /dev/null
@@ -1,8 +0,0 @@
-Changelog: Spring Batch Core
-
-* 1.0-M2
-
-** 2007/07/12
-
- * No-one uses this file: we should just switch to auto-generated changelogs?
-
diff --git a/spring-batch-core/src/site/apt/executable.apt b/spring-batch-core/src/site/apt/executable.apt
deleted file mode 100644
index ec70e9936..000000000
--- a/spring-batch-core/src/site/apt/executable.apt
+++ /dev/null
@@ -1,38 +0,0 @@
-
- Tried to create an executable jar with this:
-
-+---
-
-
-
- org.apache.maven.plugins
- maven-jar-plugin
-
-
-
- org.springframework.batch.container.bootstrap.BatchCommandLineLauncher
- true
-
-
-
-
-
-
-+---
-
- But the resulting MANIFEST.MF is rubbish. Look at the classpath
- (where did that come from)?
-
-+---
-Manifest-Version: 1.0
-Archiver-Version: Plexus Archiver
-Created-By: Apache Maven
-Built-By: dsyer
-Build-Jdk: 1.5.0_09
-Main-Class: org.springframework.batch.container.bootstrap.BatchCommand
- LineLauncher
-Class-Path: spring-2.1-m2.jar commons-logging-1.1.jar log4j-1.2.12.jar
- dom4j-1.6.1.jar commons-lang-2.1.jar spring-batch-infrastructure-1.0
- -m2-SNAPSHOT.jar antlr-2.7.6.jar commons-collections-2.1.1.jar hibern
- ate-3.2.3.ga.jar spring-mock-2.1-m2.jar ehcache-1.2.3.jar
-+---
diff --git a/spring-batch-core/src/site/apt/glossary.apt b/spring-batch-core/src/site/apt/glossary.apt
deleted file mode 100644
index 1b2e1aac5..000000000
--- a/spring-batch-core/src/site/apt/glossary.apt
+++ /dev/null
@@ -1,46 +0,0 @@
- ------
- Glossary
- ------
- Wayne Lund
- ------
- May 2007
-
-
- [[1]]<>: An accumulation of business transactions over time.
-
- [[2]]<>: Term used to designate batch as an application style in its own right similar to online, Web or SOA. It has standard elements of input, validation, transformation of information to business model, business processing and output. In addition, it requires monitoring at a macro level.
-
- [[3]]<>: The handling of a batch of many business transactions that have accumulated over a period of time (e.g. an hour, day, week, month, or year). It is the application of a process, or set of processes, to many data entities or objects in a repetitive and predictable fashion with either no manual element, or a separate manual element for error processing.
-
- [[4]]<>: The time frame within which a batch job must complete. This can be constrained by other systems coming online, other dependent jobs needing to execute or other factors specific to the batch environment.
-
- [[5]]<>: It is the main batch task or Unit of Work controller. It initializes the module, and controls the transaction environment based on commit interval setting, etc.
-
- [[6]]<>: The main application program created by application developer to process the business logic for each LUW.
-
- [[7]]<>: Job Types describe application of jobs for particular type of processing. Common areas are interface processing (typically flat files), forms processing (either for online pdf generation or print formats), report processing. s
-
- [[8]]<>: A driving query identifies the set of work for a job to do; the job then breaks that work into individual units of work. For instance, identify all financial transactions that have a status of "pending transmission" and send them to our partner system. The driving query returns a set of record IDs to process; each record ID then becomes a unit of work. A driving query may involve a join (if the criteria for selection falls across two or more tables) or it may work with a single table.
-
- [[9]]<>: A batch job iterates through a driving query (or another input source such as a file) to perform the set of work that the job must accomplish. Each iteration of work performed is a unit of work.
-
- [[10]]<>: A set of LUWs constitute a commit interval.
-
- [[11]]<>: Splitting a job into multiple threads where each thread is responsible for a subset of the overall data to be processed. The threads of execution may be within the same JVM or they may span JVMs in a clustered environment that supports workload balancing.
-
- [[12]]<>: A table that holds temporary data while it is being processed.
-
- [[13]]<>: - a job that can be executed again and will assume the same identity as when run initially. In othewords, it is has the same job instance id.
-
- [[14]]Rerunnable - a job that is restartable and manages it's own state in terms of previous run's record processing. Note>>: Rerunnable is tied to the driving query. If the query can be formed so that it will limit the processed rows when the job is restarted than re-runnable = true. Often times a condition is added to the where statement to limit the rows returned by the driving query with something like "and processedFlag != true".
-
----------------------------------------------------------------------
-Note: If its false the architecture assumes responsibility for tracking which rows have been processed. There is a default strategy for tracking the last record processed by partition. Most batch jobs only have one partition. The option is only valid for a restartable job. The reason being is that we have to persist the restart data which is only available on a restartable job.
-
-In DSL it is the following:
- StartOver ::= restartable = false. Restartable ::= true | false
- If (Restartable)
- re-runnable ::= true | false
-
-We don't persist restart information for a non-restartable job. As you can see, it doesn't make sense. Rerunnable has always confused the best of us.
-----------------------------------------------------------------------------
diff --git a/spring-batch-core/src/site/apt/index.apt b/spring-batch-core/src/site/apt/index.apt
deleted file mode 100644
index 626f7c58f..000000000
--- a/spring-batch-core/src/site/apt/index.apt
+++ /dev/null
@@ -1,77 +0,0 @@
- ------
- Spring Batch Core
- ------
- Dave Syer
- ------
- August 2007
-
-Overview of the Spring Batch Core
-
- The Spring Batch Core Domain consists of an API for launching,
- monitoring and managing batch jobs.
-
-[images/core-domain-overview.png] The Spring Batch Core Domain with
-dependencies to infrastructure indicated schematically.
-
- The figure above shows the central parts of the core domain and its
- main touch points with the batch application develepor (<<>>
- and <<>>). To launch a job there is a <<>>
- interface that can be used to simplify the launching for dumb
- clients like JMX or a command line.
-
- A <<>> is composed of a list of <<>>s, each of which is
- executed in turn by the <<>>. The <<>> is a central
- strategy in the Spring Batch Core. Implementations of <<>>
- are responsible for sharing the work out, but in ways that the
- configuration doesn't need to be aware of. For instance, the same
- or very similar <<>> configuration might be used in a simple
- in-process sequential executor, or in a multi-threaded
- implementation, or one that delegates to remote calls to a
- distributed system.
-
-[images/core-domain-extended.png] The Spring Batch Core Domain
-extended to include the datababase entities and identifier strategy.
-
- A <<>> can be re-used to create multiple job
- instances and this is reflected in the figure above showing an
- extended picture of the core domain. When a <<>>
- is launched it first checks to see if a job with
- the same <<>> was already executed. We expect one of
- the following outcomes, depending on the <<>>:
-
- * If the job was not previously launched then it can be created
- and executed. A new <<>> is created and stored in a
- repository (usually a database). A new <<>> is also
- created to track the progress of this particular execution.
-
- * If the job was previously launched and failed the <<>> is
- responsible for indicating whether it believes it is restartable
- (is a restart legal and expected). There is a flag for this
- purpose on the <<>>. If the there was a previous failure -
- maybe the operator has fixed some bad input and wants to run it
- again - then we might want to restart the previous job.
-
- If the job was previously launched with teh same
- <<>> and completed successfully, then it is an
- error to restart it. An ad-hoc request needs to be distinguished
- from previous runs by adding a unique job parameter. In either
- case a new <<>> is created and stored to monitor
- this execution of the <<>>.
-
-Overview of the Spring Batch Launch Environment
-
- The diagram below provides an overview of the high level components, technical services, and basic operations required by a batch architecture. This architecture framework is a blueprint that has been proven through decades of implementations on the last several generations of platforms (COBOL/Mainframe, C++/Unix, and now Java/anywhere). Simple Batch provides a physical implementation of the layers, components and technical services commonly found in robust, maintainable systems used to address the creation of simple to complex batch applications, with the infrastructure and extensions to address very complex processing needs. The materials below will walk through the details of the diagram.
-
-[images/spring-batch-reference-model.png] Simple Batch Launch Environment high level flow and interaction of the architecture.
-
-* Tiers
-
- The application style is organized into four logical tiers, which include Run, Job, Application, and Data tiers. The primary goal for organizing an application according to the tiers is to embed what is known as "separation of concerns" within the system. Effective separation of concerns results in reducing the impact of change to the system.
-
- * <> The Run Tier is concerned with the scheduling and launching of the application. A vendor product is typically used in this tier to allow time-based and interdependent scheduling of batch jobs as well as providing parallel processing capabilities.
-
- * <> The Job Tier is responsible for the overall execution of a batch job. It sequentially executes batch steps, ensuring that all steps are in the correct state and all appropriate policies are enforced.
-
- * <> The Application Tier contains components required to execute the program. It contains specific modules that address the required batch functionality and enforces policies around a module execution (e.g., commit intervals, capture of statistics, etc.)
-
- * <> The Data Tier provides the integration with the physical data sources that might include databases, files, or queues. <>: In some cases the Job tier can be completely missing and in other cases one job script can start several batch job instances.
diff --git a/spring-batch-core/src/site/apt/introduction.apt b/spring-batch-core/src/site/apt/introduction.apt
deleted file mode 100644
index 44b7a3764..000000000
--- a/spring-batch-core/src/site/apt/introduction.apt
+++ /dev/null
@@ -1,201 +0,0 @@
- ------
- Batch Processing Strategy
- ------
- Scott Wintermute
- ------
- May 2007
-
-Batch Processing Strategy
-
- To help design and implement batch systems, basic batch application building blocks and patterns should be provided to the designers and programmers in form of sample structure charts and code shells. When starting to design a batch job, the business logic should be decomposed into a series of steps which can be implemented using the following standard building blocks:
-
- * Conversion Applications: For each type of file supplied by or generated to an external system, a conversion application will need to be created to convert the transaction records supplied into a standard format required for processing. This type of batch application can partly or entirely consist of translation utility modules (see Basic Batch Services).
-
- * Validation Applications: Validation applications ensure that all input/output records are correct and consistent. Validation is typically based on file headers and trailers, checksums and validation algorithms as well as record level cross-checks.
-
- * Extract Applications: An application that reads a set of records from a database or input file, selects records based on predefined rules, and writes the records to an output file.
-
- * Extract/Update Applications: An application that reads records from a database or an input file, and makes changes to a database or an output file driven by the data found in each input record.
-
- * Processing and Updating Applications: An application that performs processing on input transactions from an extract or a validation application. The processing will usually involve reading a database to obtain data required for processing, potentially updating the database and creating records for output processing.
-
- * Output/Format Applications: Applications reading an input file, restructures data from this record according to a standard format, and produces an output file for printing or transmission to another program or system.
-
- <>
-
- Additionally a basic application shell should be provided for business logic that cannot be built using the previously mentioned building blocks.
-
- In addition to the main building blocks, each application may use one or more of standard utility steps, such as:
-
- * Sort - A Program that reads an input file and produces an output file where records have been re-sequenced according to a sort key field in the records. Sorts are usually performed by standard system utilities.
-
- * Split - A program that reads a single input file, and writes each record to one of several output files based on a field value. Splits can be tailored or performed by parameter-driven standard system utilities.
-
- * Merge - A program that reads records from multiple input files and produces one output file with combined data from the input files. Merges can be tailored or performed by parameter-driven standard system utilities.
-
- Batch applications can additionally be categorized by their input source:
-
- * Database-driven applications are driven by rows or values retrieved from the database.
-
- * File-driven applications are driven by records or values retrieved from a file
-
- The foundation of any batch system is the processing strategy. Factors affecting the selection of the strategy include estimated batch system volume, concurrency with on-line or with another batch systems, available batch windows etc. Also with more enterprises wanting to be up and running 24x7, leaving no obvious batch windows.
-
- Typical processing options for batch are:
-
- * Normal processing in a batch window during off-line
-
- * Concurrent batch / on-line processing
-
- * Parallel processing of many different batch runs or jobs at the same time
-
- * Streaming i.e. processing of many instances of the same job at the same time
-
- * A combination of these
-
- The order in the list above reflects the implementation complexity, processing in a batch window being the easiest and streaming the most complex to implement.
-
- Some or all of these options may be supported by a commercial scheduler.
-
- In the following section these processing options will be discussed in more detail. It is important to notice that the commit and locking strategy adopted by batch processes will be dependent on the type of processing performed and as a rule of thumb, the on-line locking should use the same principles. Therefore a batch architecture cannot be simply an afterthought when designing an overall architecture.
-
- The locking strategy can use only normal database locks, or an additional custom locking service can be implemented in the architecture. The locking service would track database locking (for example by storing the necessary information in a dedicated db-table) and give or deny permissions to the application programs requesting a db operation. Retry logic could also be implemented by this architecture to avoid aborting a batch job in case of a lock situation.
-
- <<1. Normal processing in a batch window>>
- For simple batch processes running in a separate batch window, where the data being updated is not required by on-line users or other batch processes, concurrency is not an issue and a single commit can be done at the end of the batch run.
-
- In most cases a more robust approach is more appropriate. A thing to keep in mind is that batch systems have a tendency to grow as time goes by, both in terms of complexity and the data volumes they will handle. If no locking strategy is in place and the system still relies on a single commit point, modifying the batch programs can be painful. Therefore, even with the simplest batch systems, consider the need for commit logic depicted in the [Restart/Recovery section|Restart & Recovery] as well as the information concerning the more complex cases below.
-
- <<2. Concurrent batch / on-line processing>>
- Batch applications processing data that can simultaneously be updated by on-line users, should not lock any data (either in the database or in files) which could be required by on-line users for more than a few seconds. Also updates should be committed to the database at the end of every few transaction. This minimizes the portion of data that is unavailable to other processes and the elapsed time the data is unavailable.
-
- Another option to minimize physical locking is to have a logical row-level locking implemented using either an Optimistic Locking Pattern or a Pessimistic Locking Pattern.
-
- * Optimistic locking assumes a low likelihood of record contention. It typically means inserting a timestamp column in each database table used concurrently by both batch and on-line processing. When an application fetches a row for processing, it also fetches the timestamp. As the application then tries to update the processed row, the update uses the original timestamp in the WHERE clause. If the timestamp matches, the data and the timestamp will be updated successfully. If the timestamp does not match, this indicates that another application has updated the same row between the fetch and the update attempt and therefore the update cannot be performed.
-
- * Pessimistic locking is any locking strategy that assumes there is a high likelihood of record contention and therefore either a physical or logical lock needs to be obtained at retrieval time. One type of pessimistic logical locking uses a dedicated lock-column in the database table. When an application retrieves the row for update, it sets a flag in the lock column. With the flag in place, other applications attempting to retrieve the same row will logically fail. When the application that set the flag updates the row, it also clears the flag, enabling the row to be retrieved by other applications. Please note, that the integrity of data must be maintained also between the initial fetch and the setting of the flag, for example by using db locks (e.g.,SELECT FOR UPDATE). Note also that this method suffers from the same downside as physical locking except that it is somewhat easier to manage building a time-out mechanism that will get the lock released if the user goes to lunch while the record is locked.
-
- These patterns are not necessarily suitable for batch processing, but they might be used for concurrent batch and on-line processing for example in cases where the database doesn't support row-level locking. As a general rule, optimistic locking is more suitable for on-line applications, while pessimistic locking is more suitable for batch applications. Whenever logical locking is used, the same scheme must be used for all applications accessing data entities protected by logical locks.
-
- Note that both of these solutions only address locking a single record. Often we may need to lock a logically related group of records. With physical locks, you have to manage these very carefully in order to avoid potential deadlocks. With logical locks, it is usually best to build a logical lock manager that understands the logical record groups you want to protect and can ensure that locks are coherent and non-deadlocking. This logical lock manager usually uses its own tables for lock management, contention reporting, time-out mechanism, etc.
-
- <<3. Parallel Processing>>
- Parallel processing allows multiple batch runs / jobs to run in parallel to minimize the total elapsed batch processing time. This is not a problem as long as the jobs are not sharing the same files, db-tables or index spaces. If they do, this service should be implemented using partitioned data. Another option is to build an architecture module for maintaining interdependencies using a control table. A control table should contain a row for each shared resource and whether it is in use by an application or not. The batch architecture (Control Program Tasklet) or the application in a parallel job would then retrieve information from that table to determine if it can get access to the resource it needs or not.
-
- If the data access is not a problem, parallel processing can be implemented in a mainframe environment using parallel job classes, in order to ensure adequate CPU time for all the processes. In an environment other than the mainframe, a similar solution can be put in place with for example threads. The solution has to be robust enough to ensure time slices for all the running processes.
-
- Other key issues in parallel processing include load balancing and the availability of general system resources such as files, database buffer pools etc. Also note that the control table itself can easily become a critical resource.
-
- <<4. Partitioning>>
- Using partitioning allows multiple versions of large batch applications to run in concurrent. The purpose of this is to reduce the elapsed time required to process long batch jobs. Processes which can be successfully partitioned are those where the input file can be split and/or the main database tables partitioned to allow the application to run against different sets of data.
-
- In addition, processes which are partitioned must be designed to only process their assigned data set. A partitioning architecture has to be closely tied to the database design and the database partitioning strategy. Please note, that the database partitioning doesn't necessarily mean physical partitioning of the database, although in most cases this is advisable. The following picture illustrates the partitioning approach:!app_style_batch_processing.png|align=center!
-
- The architecture should be flexible enough to allow dynamic configuration of the number of partitions. Both automatic and user controlled configuration should be considered. Automatic configuration may be based on parameters such as the input file size and/or the number of input records.
-
- <<4.1 Streaming Approaches>>
- The following lists some of the possible streaming approaches. Selecting a streaming approach has to be done on a case-by-case basis.
-
- <1. Fixed and Even Break-Up of Record Set>
-
- This involves breaking the input record set into an even number of portions (e.g. 10, where each portion will have exactly 1/10th of the entire record set). Each portion is then processed by one instance of the batch/extract application.
-
- In order to use this approach, preprocessing will be required to split the recordset up. The result of this split will be a lower and upper bound placement number which can be used as input to the batch/extract application in order to restrict its processing to its portion alone.
-
- Preprocessing could be a large overhead as it has to calculate and determine the bounds of each portion of the record set.
-
- <2. Breakup by a Key Column>
-
- This involves breaking up the input record set by a key column such as a location code, and assigning data from each key to a batch instance. In order to achieve this, column values can either be
-
- <3. Assigned to a batch instance via a streaming table (see below for details).>
-
- <4. Assigned to a batch instance by a portion of the value (e.g. values 0000-0999, 1000 - 1999, etc.)>
-
- Under option 1, addition of new values will mean a manual reconfiguration of the batch/extract to ensure that the new value is added to a particular instance.
-
- Under option 2, this will ensure that all values are covered via an instance of the batch job. However, the number of values processed by one instance is dependent on the distribution of column values (i.e. there may be a large number of locations in the 0000-0999 range, and few in the 1000-1999 range). Under this option, the data range should be designed with streaming in mind.
-
- Under both options, the optimal even distribution of records to batch instances cannot be realized. There is no dynamic configuration of the number of batch instances used.
-
- <5. Breakup by Views>
-
- This approach is basically breakup by a key column, but on the database level. It involves breaking up the recordset into views. These views will be used by each instance of the batch application during its processing. The breakup will be done by grouping the data.
-
- With this option, each instance of a batch application will have to be configured to hit a particular view (instead of the master table). Also, with the addition of new data values, this new group of data will have to be included into a view. There is no dynamic configuration capability, as a change in the number of instances will result in a change to the views.
-
- <6. Addition of a Processing Indicator>
-
- This involves the addition of a new column to the input table, which acts as an indicator. As a preprocessing step, all indicators would be marked to non-processed. During the record fetch stage of the batch application, records are read on the condition that that record is marked non-processed, and once they are read (with lock), they are marked processing. When that record is completed, the indicator is updated to either complete or error. Many instances of a batch application can be started without an change, as the additional column ensures that a record is only processed once.
-
- With this option, I/O on the table increased dynamically. In the case of a updating batch application, this impact is reduced, as a write will have to occur anyway.
-
- <7. Extract Table to a Flat File>
-
- This involves the extraction of the table into a file. This file can then be split into multiple segments and used as input to the batch instances.
-
- With this option, the additional overhead of extracting the table into a file, and splitting it, may cancel out the effect of multi-streaming. Dynamic configuration can be achieved via changing the file splitting script.
-
- <8. Use of a Hashing Column>
-
- This scheme involves the addition of a hash column (key/index) to the database tables used to retrieve the driver record. This hash column will have an indicator to determine which instance of the batch application will process this particular row. For example, if there are three batch instances to be started, then an indicator of 'A' will mark that row for processing by instance 1, an indicator of 'B' will mark that row for processing by instance 2, etc.
-
- The procedure used to retrieve the records would then have an additional WHERE clause to select all rows marked by a particular indicator. The inserts in this table would involve the addition of the marker field, which would be defaulted to one of the instances (e.g. 'A').
-
- A simple batch application would be used to update the indicators such as to redistribute the load between the different instances. When a sufficiently large number of new rows have been added, this batch can be run (anytime, except in the batch window) to redistribute the new rows to other instances.
-
- Additional instances of the batch application only require the running of the batch application as above to redistribute the indicators to cater for a new number of instances.
-
-
- 4.2 Database and Application design Principles
-
- An architecture that supports multi-streamed applications which run against partitioned database tables using the key column approach, should include a central streaming repository for storing streaming parameters. This provides flexibility and ensures maintainability. The repository will generally consist of a single table known as the streaming table.
-
- Information stored in the streaming table will be static and in general should be maintained by the DBA. The table should consist of one row of information for each stream of a multi-streamed application. The table should have a similar layout to the following table:
-
- {center}
- || Streaming Table ||
- | Program ID Code
- Stream Number (Logical ID of the stream)
- Low Value of the db key column for this stream
- High Value of the db key column for this stream |
- {center}
-
- On program start-up the program id and stream number should be passed to the application from the architecture (Control Processing Tasklet). These variables are used to read the streaming table, to determine what range of data the application is to process (if a key column approach is used). In addition the stream number must be used throughout the processing to:
-
- * Add to the output files/database updates in order for the merge process to work properly
-
- * Report normal processing to the batch log and any errors that occur during execution to the architecture error handler
-
- 4.3 Minimizing Deadlocks
- When applications run in parallel or streamed, contention in database resources and deadlocks may occur. It is critical that the database design team eliminates potential contention situations as far as possible as part of the database design.
-
- Also ensure that the database index tables are designed with deadlock prevention and performance in mind.
-
- Deadlocks or hot spots often occur in administration or architecture tables such as log tables, control tables, lock tables etc.. The implications of these should be taken into account as well. A realistic stress test is crucial for identifying the possible bottlenecks in the architecture.
-
- To minimize the impact of conflicts on data, the architecture should provide services such as wait-and-retry intervals when attaching to a database or when encountering a deadlock. This means a built-in mechanism to react to certain database return codes and instead of issuing an immediate error handling, waiting a predetermined amount of time and retrying the database operation.
-
- 4.4 Parameter Passing and Validation
-
- The streaming architecture should be relatively transparent to application developers. The architecture should perform all tasks associated with running the application in a streamed mode i.e.
-
- * Retrieve streaming parameters before application start-up
-
- * Validate streaming parameters before application start-up
-
- * Pass parameters to application at start-up
-
- The validation should include checks to ensure that:
-
- * the application has sufficient streams to cover the whole data range
-
- * there are no gaps between streams
-
- If the database is partitioned, some additional validation may be necessary to ensure that a single stream does not span database partitions.
-
- Also the architecture should take into consideration the consolidation of streams. Key questions include:
-
- * Must all the streams be finished before going into the next job step?
-
- * What happens if one of the streams aborts?
diff --git a/spring-batch-core/src/site/apt/outline.apt b/spring-batch-core/src/site/apt/outline.apt
deleted file mode 100644
index d500ed334..000000000
--- a/spring-batch-core/src/site/apt/outline.apt
+++ /dev/null
@@ -1,124 +0,0 @@
- ------------------------------------------
- The Spring Batch - Reference Documentation
- ----------------------------------------
- Wayne Lund, Waseem Malik, Lucas Ward, Scott Wintermute,
- Kerry O'Brien, Tomi Vanek
- -------------------------------------------
- May 2007
-
-Preface
-
-*1. {{{./introduction.html}Spring Container Batch Processing}}
-
- *1.1. Overview
-
- *1.2 Usage Scenarios
-
-*2. {{{./overview.html}Architecture Overview}}
-
- **2.1. Introduction to Architecture Layers
-
- **2.2. Batch Applications
-
- **2.3 Container Application layer
-
- **2.4 Container Support Layer
-
- **2.5 The Container Core Layer
-
- **2.6 Using the Spring-batch infrastructure
-
- *2.6.1 Infrastructure Provided I/O Support
-
- *2.6.2 Infrastucture Provided Base Services
-
- *2.7. Batch Execution Container Configurations
-
- *2.7.1. Single VM Simple Batch Execution Container - One Job, One Step, One Partition
-
- *2.7.2. Single VM Multi-threaded Batch Execution Container Configuration - One Job, One Step, Multiple Partitions
-
- *2.7.3 Batch Execution Container Hosted in J2EE Container - managed environment
-
-
-*3. Core Batch Services
-
- *3.1. Launching Batch Jobs
-
- *3.2. Mapping Batch Error Codes to Launch Client Error Codes
-
- *3.2.1. Returning error codes to Enterprise Schedulers with command line interfaces
-
- *3.2.2. Web Request - returning error codes to "On-Demand Batch Requests"
-
- *3.3. Job Services
-
- *3.3.1. Step Configuration
-
- *3.3.2. Job Status Service
-
- *3.3.3. Job Status
-
- *3.3.4. Job Statistics
-
- *3.4. Step Services
-
- *3.4.1. Step Execution
-
- *3.4.2. Restart Services
-
- *3.4.3. Skip Services
-
- *3.4.5. Step Statistics
-
- *3.5. Data Providers - Operations, Templates and Convenience Callbacks
-
- *3.5.1. Wrapping input sources
-
- *3.5.2. Validation of input
-
- *3.5.3. Delimited File Data Providers
-
- *3.5.4. Fixed Position File Data Providers
-
- *3.5.5. XML File Data Providers
-
- *3.5.6. SQL Input Source Data Provider
-
- *3.6. Transaction Management
-
- *3.6.1. Transaction Synchronization with non-transactional resources
-
- *3.7. Partitioning Batch Jobs
-
- *3.7.1. Partitioning Strategies
-
- *3.7.2. Partitioning Job Steps
-
- *3.7.3. Partition Status
-
- *3.7.4. Partition Statistics
-
- *3.7.5. Handling Exceptions within partitions
-
-*4. [Batch in a J2EE Container]
-
-*5. [Testing Batch Jobs]
-
- *5.1. Unit Testing & Mock Objects Provided by the Framework
-
- *5.2. Integration Testing
-
- *5.3. Performance Testing Batch Jobs
-
-*6. {{{samples.html}Practical Examples for Spring Batch}}
-
- *6.1. Sample Applications|Spring Reference-Application Job-Map
-
- *6.2. Running the Sample Batch Applications
-
-*7. [INCUB:Batch XML Schema]
-
-*8. {{{./glossary.html}Glossary}}
-
-
diff --git a/spring-batch-core/src/site/apt/overview.apt b/spring-batch-core/src/site/apt/overview.apt
deleted file mode 100644
index 2edcc8b03..000000000
--- a/spring-batch-core/src/site/apt/overview.apt
+++ /dev/null
@@ -1,145 +0,0 @@
- ------
- Architecture Overview
- ------
- Wayne Lund
- ------
- May 2007
-
-2. Architecture Overview
-
-
-*2.1 Introduction
-
- This chapter covers the overall spring batch architecture. The Spring Container Archtiecture is made up of five logical layers; 1) the Batch Application, 2) the Batch Application Layer, 3) the batch core layer, and 4) the batch infrastucture layer.
-
-*----------*----------------*------------+
-|Provided By | Layer | Description
-*----------*----------------*------------*
-| Application Developer | Batch Application | This is where the application writes their batch jobs and modules. |
-*----------*----------------*------------*
-| Spring Batch Execution Container | Container Application Layer | Allows for extending and overwriting of the batch support layer for custom requirements. Facilities implemented in this layer could migrate down to Batch Support Layer. This is also the layer to add the project specific jars required by job types (e.g. reporting jars like Crystal, Brio, etc, form generation jars like Central Pro or Adobe, etc). |
-*----------*----------------*------------*
-| Spring Batch Execution Container | Container Support Layer | Provides default implementations of batch core services including I/O, Restart, Partitioning, Statistics, and configurations |
-*----------*----------------*------------*
-| Spring Batch Execution Container | Container Core Layer | Enables configuration, Common Services & Interfaces, management |
-*----------*----------------*------------*
-| Spring Batch Infrastructure | Batch-Infrastructure | Provides IO support, Batch style transactions, advanced exception handling, batch-template, batch-retry |
-*----------*----------------*------------*
-
- [Figure 2.0] - Batch Architecture Layers
-
- The batch architecture is modeled after a container architecture, meaning that there are managed resources essential to high performance batch architectures that are configured through a spring context. The following sections will provide a quick review of each layer and their role in the batch architecture.
-
-*2.2 Batch Applications
-
-*2.3 Container Application Layer
-
-*2.4 Container Support Layer
-
- The batch support layer provides default implementations for all interfaces, interceptors, advice and other core batch services. Figure 2.3.1 illustrates the following logical packages. !Batch Support.png!
-Although physically they break out into many more than depicted, logically you can think of the groupings in the following manner:
-* I/O Support packages
-* Restart Support
-* Lifecycle Support packages
-* DAO support layer
-
- **2.4.1 I/O Support Packages
-
- The I/O related packages are currently the richest packages in the batch architecture. They are modeled after Spring Patterns of Operations and Templates. For example, you'll see FlatFileInputOperations accompanied with a FlatFileInputTemplate. The FlatFileInputTemplate is wired up with a File Descriptor, which contains a Record Descriptor along with various other properties. With the File and Record Descriptors the InputTemplate supports a callback method that allows for the mapping of a record into an object. This support applies to fixed length records, delimited records and XML records. To further simplify this a DefaultFlatFileDataProvider is supplied an input template, which contains the field and record descriptions, along with a line mapper that knows how to map the line to an object. The next() operation on a record simply needs to readAndMap(lineMapper) a record. This pattern is used over again for XML and SQL input for simple mapping of input records to objects.
-
- In addition to declarative descriptions of the records that can be re-used by multiple batch jobs, the I/O facilities also support configurable validation strategies. The two currently supported are Apache Commons Validator and Spring's VALang.
-
- **2.4.2 Restart Support
-
- The Restart Support provides implementations for a few common restart strategies that will be discussed further in the respective section. The following are provided out-of-the-box:
- * IDList Restart Strategy - a strategy that supports a batch application where the application does not have a "process" flag and needs the batch architecture to track which records have been processed. This is not the ideal scenario.
- * Last Processed Restart Strategy - when the record can be identified through a where and order by only the last record(s) processed needs to be saved for restart.
- * No Restart Strategy - some batch jobs simply can't support restart. When they are re-run they are considered to be a new instance of a batch job.
- * Sql Restart Strategy - \[need some additional javadoc for this strategy\].
-
- **2.4.3 Lifecycle Support
-
-*2.5. The Container Core Layer
-
- The Batch Core interfaces and services are illiustrated in a simplied view of a package diagram. There are roughly seven logical packages:
- * Core Spring Extensions
- * Core Batch Advice
- * Core Batch Configuration
- * Core Batch Repository
- * Core Batch Tasklet
- \\ !Batch Core.png!
- [Figure 2.5] Batch Core Layer
-
- In the actual physical packaging there are a few more packages but the above illistration serves as an overview of the logical services that the batch container provides. The following sections will provide an introduction into each set of core batch facilities.
-
- **2.5.1 Core Spring Extensions
-
- The Core Spring extensions provide the scaffolding for a batch container. This includes facilities for managing the batch architecture in terms of launching, suspending and stopping batch jobs. There is house keeping that goes on, especially in concurrent batch jobs, related to ensuring that batch jobs quiese properly. The lifecycle management provides services for the proper initialization and subsequent shutdown of batch resources and services. The batch architecture is flexible in terms of how batch jobs may be launched. For example, batch jobs can be started via JMX facilities, scripts from the command line that launch a Java VM. It can also support launching batch jobs through web services or http. There are no restrictions. Finally, there are standard batch error codes. These error codes can be exposed to external utilities, like Schedulers, to ensure that batch jobs expose the status of jobs to an operational environment. This is especially important in the batch context where the modus operandi is headless, meaning unattended operation.
-
- **2.5.2 Core Batch Advice
-
- Core Batch Advice is an inventory of the type of advice that batch architectures will inject during the runtime of a batch application. These are defined as a set of extensible interfaces, with a number of default implementations in the support layer that provide some of the most common types of advice. Partition Advice is helpful with large datasets that need to be "chunked" up and run concurrently for better through put. Resource Advice is helpful for registering interest in transactional information so that file locations can be kept in sync with information processed within a transaction. In addition, the resource is associated with the correct step context and its associated configuration properties. Skip advice is applied for records that the module is unable to process. Restart Advice is helpful for Restartable jobs where for advising the job on how to restart. There is considerable variability on how restart can occur. For example, a job may be marking records as "processed" and the restart advice will advise the process with query that restarts the job at the last successfully processed record. Finally, Statistics are vital in operational environments to report on records processed, records skipped and total number of records read. In addition, certain batch jobs lend themselves to custom reporting to expose additional business level information like the number of trades processed or cases opened, etc.
-
- **2.5.3 Core Batch Configuration
-
- Batch configuration is considerably different from online web applications or SOA based applications. The Core Batch Configuration provides a place for configuring runtime properties related to the batch application style. This includes the ability to add Commit Policy. In a batch style application it is often advantageous to keep the commit interval as high as possible when processing Logical Units of Work. Whereas in an online web application with declarative transaction the transaction scope would be at the entrance to a business service, a batch transaction scope may include many logical units of work before a transaction commit is executed. A Start Policy allows a configuration to tell the batch job whether it is Restartable, and if so, what type of restart to initiate. Some jobs are not restartable and care should be taken to ensure that information is not applied multiple times when the business rules do not allow for it. Exception policies deal with what to do when exceptions occur. This impacts logging policies and exception handling. The architecture defines a common set of exceptions that projects can apply handlers to like processing errors, validation errors, parsing errors, missing configuration parameters, etc.
-
- **2.5.4 Container Repository
-
- This is an internal package for storing the state of a batch job and any associated partition and step status.
-
- **2.5.5 Core Batch Tasklet
-
- The core batch module is where control is handed off to the application. There are a number of patterns that have been observed in processing batch data. Spring Core Batch Tasklet implements the most common patterns and provides and extension point for additional Tasklet processing implementations. The basic idea of module provides the facilities for reading and processing data. The simplest implementation of Tasklet, the ReadProcessTasklet, handles both the input and output of data within one class. An alternative implementation, the DataProviderProcessTasklet, provides functionality for 'split processing'. This type of processing is characterized by separating the reading and processing of batch data into two seperate classes: DataProvider and TaskletProcessor. The DataProvider class provides a solid means for reusablility and enforces good architecture practices. Because an object \*must\* be returned by the DataProider to continue processing, (Returning null indicates processing should end) a developer is forced to read in all relevant data, place it into domain or value objects, and return the object. The TaskletProcessor will then use this object within the business logic and final output.
-
-2.6 Container's Use of batch infrastructure
-
- **2.6.1 Infrastructure Provided I/O
-
- The I/O core interfaces and implementations provide facilities for simplifying the extraction of data from I/O sources like files and database tables. The key concepts are FieldDescriptors and FieldSets along with appropriate CallBack Handlers. These are modeled after common spring operations and templates like JdbcTemplate. Through the use of LineMappers a developer needs only to describe a record format and write the appropriate callback method that maps the parsed record into an object of their choice. These can either be true POJO objects or Value Objects (structures) that are subsequently available for the module to processs. The interface for Field Descriptors also allows for a level of validation through the use of Spring's VALang or Apache's Common Validator.
-
- **2.6.2 Core Batch Interceptors & Interceptor Services
-
- * Batch Operations & Batch Template
-
- Interceptors and the associated services are the key to how advise is applied in the batch architecture. The interceptors are Point Cuts in the batch lifecycle that allow the injection of advise. The shared lifecycle behavior abstracted through the BatchLifeCycleInterceptor defineds three methods; init, onError and finalize. All subclasses of LifeCycleInterceptor define default behavior for these three methods. The JobLifecycleInterceptor further exposes the methods beforeJob(), beforeStep(), afterJob(), and afterStep() allowing hooks into the lifecycle for specific advise. The Batch Architecture provides default implementations for all lifecycle point cuts, or interception points. The Tasklet Interceptor, in addition to the standard lifecycle methods, implements logic around beforeLuw(), afterLuw(), commitIntervalStarted() and commitIntervalCompleted(). Having well defined lifecycle interception points allows for the easy insertion of custom advice into the batch runtime environment.
-
-2.7 Batch Esecution Container Configurations
-
- In addition to core facilities for configuring or wiring together jobs and steps with required resources, policies, and interceptors, spring batch allows considerable flexibility in how scalability is achieved. More options for scalability will be available in the future. The important key for scalability in Java is the recognition that there is a limit to what one JVM may scale up to in terms of number of threads, managed resources, memory configuration, etc. The spring batch architecture allows for the configuration of simple batch jobs where one VM and one process is sufficient to do perform the work within a batch window all the way through many threads distributed within a cluster of JEE servers. The figure below illistrates the scalability spectrum.
-
- This is not to be understood as the only way to scale batch jobs as there are many factors. For example, other federated java architectures hold potential like Teracotta or Gigaspaces although there is no current implementation for these distributed models in the current batch architecture.
- !scalability-model.png!
- [Figure 2.3.1] - Scalability Model
-
-*2.7.1. Single VM Simple Batch Execution Container - One Job, One Step, One Partition
-
- The simplest configuration is one job with with step and hence, one implied partition. Implied means that there is nothing for the developer to consider because the default number of partitions is one. There is typically one input source and one output source in this simple configuration. See the Simple Tasklet Job for an example of what this configuration looks like. A simple configuration still typically configures a datasource context, the batch configuration for describing the Job, Step, along with the associated configured policies, field descriptors, and line mappers. !SimpleTradeConfiguration.jpg!
- [Figure 2.3.1] Simple Container Configuration
-
- The details of this configuration will be covered thoroughly in subsequent sections of the document but for now it should be understood that Job, the Step, the input template, the file descriptor with its associated line mapper, and the output (e.g. the TradeWriter).
-
-*2.3.2. Single VM Multi-threaded Batch Execution Container Configuration - One Job, One Step, Multiple Partitions
-
- In a Single JVM using partitioning a multi-threaded execution is supported. \[This is still work in progress\]
-
-*2.3.3. Batch Execution Container Hosted in J2EE Container - managed environment
-
- The J2EE container model has fallen under fire over the past few years for many valid reasons. There are some things that the J2EE container do very well though that projects should consider when planning for scalability with batch architectures. Commercial and open source containers like WebSphere, BEA and JBOSS typically:
-
- * manage datasources effectively along with attendent services like prepared statement caching.
-
- * manage transactions effectively including many configurable properties for long lived transactions.
-
- * manage thread pools more effectively.
-
- * supply robust implementations of JTA, a requirement when batch jobs output to multiple XA resources like JMS and JDBC.
-
- * manage distribution effectively including domains, clusters and cells
-
- * provide robust JMX management for configuring, managing and administering distributed applications.
-
- * workload management facilities (clusters) provided by J2EE vendors
-
- Projects are encouraged to deploy batch applications with the simplest configuration possible, but when federated JVMs are a requirement to process volumes of data within a batch window, batch-in-container provides an effective way of distributing the processing. Spring Batch supports this through a simple change in configuration. \[Work in progress on the exact implementation - being released as part of M2\].
-
diff --git a/spring-batch-core/src/site/resources/images/core-domain-extended.png b/spring-batch-core/src/site/resources/images/core-domain-extended.png
deleted file mode 100644
index 4ac1358c43e7ad81953894322f59cafa9d27d54e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 7587
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
UHOcnQCK>#@qOPk}rb2-J3mqMhTmS$7
diff --git a/spring-batch-core/src/site/resources/images/core-domain-overview.png b/spring-batch-core/src/site/resources/images/core-domain-overview.png
deleted file mode 100644
index ced0330ab5e36e3fc626fc3ad193fc2d30259612..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 8417
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
diff --git a/spring-batch-core/src/site/resources/images/spring-batch-reference-model.png b/spring-batch-core/src/site/resources/images/spring-batch-reference-model.png
deleted file mode 100644
index 39d963a7573b610a7a03096c13e12d3e0027b8b4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 37973
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