所有类 (Spring Batch 4.1.4.RELEASE API)

所有类接口概要类概要枚举概要异常错误概要注释类型概要
类	说明
AbstractApplicationContextFactory	`ApplicationContextFactory` implementation that takes a parent context and a path to the context to create.
AbstractBatchConfiguration	Base `Configuration` class providing common structure for enabling and using Spring Batch.
AbstractCursorItemReader<T>	Abstract base class for any simple item reader that opens a database cursor and continually retrieves the next row in the ResultSet.
AbstractFileItemWriter<T>	Base class for item writers that write data to a file or stream.
AbstractFlowParser
AbstractHibernateQueryProvider<T>	Abstract Hibernate Query Provider to serve as a base class for all Hibernate `Query` providers.
AbstractItemCountingItemStreamItemReader<T>	Abstract superclass for `ItemReader`s that supports restart by storing item count in the `ExecutionContext` (therefore requires item ordering to be preserved between runs).
AbstractItemStreamItemReader<T>	Base class for `ItemReader` implementations.
AbstractItemStreamItemWriter<T>	Base class for `ItemWriter` implementations.
AbstractJdbcBatchMetadataDao	Encapsulates common functionality needed by JDBC batch metadata DAOs - provides jdbcTemplate for subclasses and handles table prefixes.
AbstractJob	Abstract implementation of the `Job` interface.
AbstractJobExplorerFactoryBean	A `FactoryBean` that automates the creation of a `SimpleJobExplorer`.
AbstractJobRepositoryFactoryBean	A `FactoryBean` that automates the creation of a `SimpleJobRepository`.
AbstractJobTests	已过时。 (from 2.1) use `JobLauncherTestUtils` instead
AbstractJpaQueryProvider	Abstract JPA Query Provider to serve as a base class for all JPA `Query` providers.
AbstractLineTokenizer	Abstract class handling common concerns of various `LineTokenizer` implementations such as dealing with names and actual construction of `FieldSet`
AbstractListenerFactoryBean<T>	`FactoryBean` implementation that builds a listener based on the various lifecycle methods or annotations that are provided.
AbstractListenerParser
AbstractMethodInvokingDelegator<T>	Superclass for delegating classes which dynamically call a custom method of injected object.
AbstractMethodInvokingDelegator.InvocationTargetThrowableWrapper	Used to wrap a `Throwable` (not an `Exception`) thrown by a reflectively-invoked delegate.
AbstractNeo4jItemReader<T>	Restartable `ItemReader` that reads objects from the graph database Neo4j via a paging technique.
AbstractPaginatedDataItemReader<T>	A base class that handles basic reading logic based on the paginated semantics of Spring Data's paginated facilities.
AbstractPagingItemReader<T>	Abstract `ItemStreamReader` for to extend when reading database records in a paging fashion.
AbstractPartitionHandler	Base `PartitionHandler` implementation providing common base features.
AbstractSqlPagingQueryProvider	Abstract SQL Paging Query Provider to serve as a base class for all provided SQL paging query providers.
AbstractState
AbstractStep	A `Step` implementation that provides common behavior to subclasses, including registering and calling listeners.
AbstractStepParser	Internal parser for the <step/> elements inside a job.
AbstractTaskletStepBuilder<B extends AbstractTaskletStepBuilder<B>>	Base class for step builders that want to build a `TaskletStep`.
Address
AddressFieldExtractor
AddressFieldSetMapper
AfterChunk	Marks a method to be called after a chunk is executed. Expected signature: void afterChunk(ChunkContext context)
AfterChunkError	Marks a method to be called after a has failed and been marked for rollback. Expected signature: void afterFailedChunk(ChunkContext context)
AfterJob	Marks a method to be called after a `Job` has completed.
AfterProcess	Marks a method to be called after an item is passed to an `ItemProcessor` Expected signature: void afterProcess(T item, S result)
AfterRead	Marks a method to be called after an item is read from an `ItemReader` Expected signature: void afterRead(T item)
AfterStep	Marks a method to be called after a `Step` has completed.
AfterWrite	Marks a method to be called after an item is passed to an `ItemWriter` Expected signature: void afterWrite(`List`<?
AggregateItem<T>	A wrapper type for an item that is used by `AggregateItemReader` to identify the start and end of an aggregate record.
AggregateItemFieldSetMapper<T>	Delegating mapper to convert form a vanilla `FieldSetMapper` to one that returns `AggregateItem` instances for consumption by the `AggregateItemReader`.
AggregateItemReader<T>	An `ItemReader` that delivers a list as its item, storing up objects from the injected `ItemReader` until they are ready to be packed out as a collection.
Alignment
AlwaysSkipItemSkipPolicy	Implementation of the `SkipPolicy` interface that will always return that an item should be skipped.
AmqpItemReader<T>	AMQP `ItemReader` implementation using an `AmqpTemplate` to receive and/or convert messages.
AmqpItemReaderBuilder<T>	A builder implementation for the `AmqpItemReader`
AmqpItemWriter<T>	AMQP `ItemWriter` implementation using an `AmqpTemplate` to send messages.
AmqpItemWriterBuilder<T>	A builder implementation for the `AmqpItemWriter`
AmqpMessageProducer	Simple producer class that sends `String` messages to the configured queue to be processed.
AnnotationMethodResolver	`MethodResolver` implementation that finds a single Method on the given Class that contains the specified annotation type.
ApplicationContextFactory	Factory for the creation of `ApplicationContext`s.
ApplicationContextJobFactory	A `JobFactory` that creates its own `ApplicationContext` and pulls a bean out when asked to create a `Job`.
ArrayFieldSetMapper	A basic array mapper, returning the values backing a fieldset.
AssertFile	This class can be used to assert that two files are the same.
AsynchronousFailureException	Exception indicating that a failure or early completion condition was detected in a remote worker.
AsyncItemProcessor<I,O>	An `ItemProcessor` that delegates to a nested processor and in the background.
AsyncItemWriter<T>
AutomaticJobRegistrar	Loads and unloads `Jobs` when the application context is created and destroyed.
BaseContextListFactoryBean	A simple factory bean that consolidates the list of locations to look for the base context for the JSR-352 functionality
BasicPartitioner	Simple partitioner for demonstration purpose.
BatchArtifactType	Enum to identify batch artifact types.
BatchConfigurationException	Represents an error has occurred in the configuration of base batch infrastructure (creation of a `JobRepository` for example.
BatchConfigurationSelector	Base `Configuration` class providing common structure for enabling and using Spring Batch.
BatchConfigurer	Strategy interface for users to provide as a factory for custom components needed by a Batch system.
BatchIntegrationConfiguration	Base configuration class for Spring Batch Integration factory beans.
BatchIntegrationNamespaceHandler	The namespace handler for the Spring Batch Integration namespace.
BatchletAdapter
BatchletParser	Parser for the <batchlet /> tag defined in JSR-352.
BatchletStep	Special sub class of the `TaskletStep` for use with JSR-352 jobs.
BatchMessageListenerContainer	Message listener container adapted for intercepting the message reception with advice provided through configuration. To enable batching of messages in a single transaction, use the `TransactionInterceptor` and the `RepeatOperationsInterceptor` in the advice chain (with or without a transaction manager set in the base class).
BatchMessageListenerContainer.ContainerDelegate
BatchParser	Parser used to parse the batch.xml file as defined in JSR-352.
BatchPropertyBeanPostProcessor	`BeanPostProcessor` implementation used to inject JSR-352 String properties into batch artifact fields that are marked with the `BatchProperty` annotation.
BatchPropertyContext	Context object to hold parsed JSR-352 batch properties, mapping properties to beans / "batch artifacts".
BatchRetryTemplate	A special purpose retry template that deals specifically with multi-valued stateful retry.
BatchScopeSupport	ScopeSupport.
BatchScopeSupport.Scopifier	Helper class to scan a bean definition hierarchy and force the use of auto-proxy for step scoped beans.
BatchStatus	Enumeration representing the status of an Execution.
BatchTestContextCustomizer	`ContextCustomizer` implementation that adds batch test utility classes (`JobLauncherTestUtils` and `JobRepositoryTestUtils`) as beans in the test context.
BatchTestContextCustomizerFactory	Factory for `BatchTestContextCustomizer`.
BeanDefinitionUtils
BeanFactoryStepLocator	A `StepLocator` implementation that just looks in its enclosing bean factory for components of type `Step`.
BeanPropertyItemSqlParameterSourceProvider<T>	A convenient implementation for providing BeanPropertySqlParameterSource when the item has JavaBean properties that correspond to names used for parameters in the SQL statement.
BeanValidatingItemProcessor<T>	A `ValidatingItemProcessor` that uses the Bean Validation API (JSR-303) to validate items.
BeanWrapperFieldExtractor<T>	This is a field extractor for a java bean.
BeanWrapperFieldSetMapper<T>	`FieldSetMapper` implementation based on bean property paths.
BeforeChunk	Marks a method to be called before a chunk is executed.
BeforeJob	Marks a method to be called before a `Job` is executed, which comes after a `JobExecution` is created and persisted, but before the first `Step` is executed.
BeforeProcess	Marks a method to be called before an item is passed to an `ItemProcessor` Expected signature: void beforeProcess(T item)
BeforeRead	Marks a method to be called before an item is read from an `ItemReader` Expected signature: void beforeRead()
BeforeStep	Marks a method to be called before a `Step` is executed, which comes after a `StepExecution` is created and persisted, but before the first item is read.
BeforeWrite	Marks a method to be called before an item is passed to an `ItemWriter` Expected signature: void beforeWrite(`List`<?
BillingFieldSetMapper
BillingInfo
BillingInfoFieldExtractor
BrokerConfiguration
BufferedReaderFactory	A factory strategy for custom extensions of `BufferedReader` allowing customisation of the standard behaviour of the `java.io` variety.
CallableTaskletAdapter	Adapts a `Callable`<`RepeatStatus`> to the `Tasklet` interface.
CheckpointAlgorithmAdapter	Wrapper for the `CheckpointAlgorithm` to be used via the rest of the framework.
CheckpointSupport	Provides support for JSR-352 checkpointing.
Child
Chunk<W>	Encapsulation of a list of items to be processed and possibly a list of failed items to be skipped.
ChunkContext	Context object for weakly typed data stored for the duration of a chunk (usually a group of items processed together in a transaction).
ChunkElementParser	Internal parser for the <chunk/> element inside a step.
ChunkHandler<T>	Interface for a remote worker in the Remote Chunking pattern.
ChunkListener	Listener interface for the lifecycle of a chunk.
ChunkListenerAdapter	Wrapper class to adapt the `ChunkListener` to a `ChunkListener`.
ChunkListenerSupport	Basic support implementation of `ChunkListener`
ChunkMessageChannelItemWriter<T>
ChunkMonitor	Manage the offset data between the last successful commit and updates made to an input chunk.
ChunkMonitor.ChunkMonitorData
ChunkOrientedTasklet<I>	A `Tasklet` implementing variations on read-process-write item handling.
ChunkParser	Parser for the <chunk /> element as specified in JSR-352.
ChunkProcessor<I>	Interface defined for processing `Chunk`s.
ChunkProcessorChunkHandler<S>	A `ChunkHandler` based on a `ChunkProcessor`.
ChunkProvider<T>	Interface for providing `Chunk`s to be processed, used by the `ChunkOrientedTasklet`
ChunkRequest<T>	Encapsulation of a chunk of items to be processed remotely as part of a step execution.
ChunkResponse	Encapsulates a response to processing a chunk of items, summarising the result as a `StepContribution`.
Classifier	Mark a method as capable of classifying its input to an instance of its output.
ClassifierCompositeItemProcessor<I,O>	Calls one of a collection of ItemProcessors, based on a router pattern implemented through the provided `Classifier`.
ClassifierCompositeItemProcessorBuilder<I,O>	Creates a fully qualified `ClassifierCompositeItemProcessor`.
ClassifierCompositeItemWriter<T>	Calls one of a collection of ItemWriters for each item, based on a router pattern implemented through the provided `Classifier`.
ClassifierCompositeItemWriterBuilder<T>	Creates a fully qualified ClassifierCompositeItemWriter.
ClassPathXmlApplicationContextFactory	已过时。 use `GenericApplicationContextFactory` instead
ClasspathXmlApplicationContextsFactoryBean	A convenient factory for creating a set of `ApplicationContextFactory` components from a set of `resources`.
ClassPathXmlJobRegistry	已过时。 in version 2.1, please us `AutomaticJobRegistrar` instead
ColumnMapItemPreparedStatementSetter	Implementation of the `ItemPreparedStatementSetter` interface that assumes all keys are contained within a `Map` with the column name as the key.
ColumnRangePartitioner	Simple minded partitioner for a range of values of a column in a database table.
CommandLineJobRunner	Basic launcher for starting jobs from the command line.
CommonsLoggingInvalidCustomerLogger
CompletionPolicy	Interface for batch completion policies, to enable batch operations to strategise normal completion conditions.
CompletionPolicySupport	Very simple base class for `CompletionPolicy` implementations.
CompositeChunkListener
CompositeCompletionPolicy	Composite policy that loops through a list of delegate policies and answers calls by a consensus.
CompositeCustomerUpdateLineTokenizer	Composite `LineTokenizer` that delegates the tokenization of a line to one of two potential tokenizers.
CompositeExceptionHandler	Composite `ExceptionHandler` that loops though a list of delegates.
CompositeItemProcessListener<T,S>
CompositeItemProcessor<I,O>	Composite `ItemProcessor` that passes the item through a sequence of injected `ItemTransformer`s (return value of previous transformation is the entry value of the next). Note the user is responsible for injecting a chain of `ItemProcessor`s that conforms to declared input and output types.
CompositeItemProcessorBuilder<I,O>	Creates a fully qualified `CompositeItemProcessorBuilder`.
CompositeItemReadListener<T>
CompositeItemStream	Simple `ItemStream` that delegates to a list of other streams.
CompositeItemWriteListener<S>
CompositeItemWriter<T>	Calls a collection of `ItemWriter`s in fixed-order sequence. The implementation is thread-safe if all delegates are thread-safe.
CompositeItemWriterBuilder<T>	Creates a fully qualified CompositeItemWriter.
CompositeJobExecutionListener
CompositeJobParametersValidator	Composite `JobParametersValidator` that passes the job parameters through a sequence of injected `JobParametersValidator`s
CompositeRepeatListener	Allows a user to register one or more RepeatListeners to be notified on batch events.
CompositeRetryProcessListener	Composite class holding `RetryProcessListener`'s.
CompositeRetryReadListener	Composite class holding `RetryReadListener`'s.
CompositeRetryWriteListener	Composite class holding `RetryWriteListener`'s.
CompositeSkipListener<T,S>
CompositeSkipPolicy
CompositeStepExecutionListener
ConfigurableSystemProcessExitCodeMapper	Maps exit codes to `ExitStatus` according to injected map.
ConversionException
CoreNamespaceHandler
CoreNamespacePostProcessor	Post-process jobs and steps defined using the batch namespace to inject dependencies.
CoreNamespaceUtils	Utility methods used in parsing of the batch core namespace
CountingCompletionPolicy	Abstract base class for policies that need to count the number of occurrences of some event (e.g. an exception type in the context), and terminate based on a limit for the counter.
Customer
Customer	An XML customer.
CustomerCredit
CustomerCreditDao	Interface for writing customer's credit information to output.
CustomerCreditFieldSetMapper
CustomerCreditIncreaseProcessor	Increases customer's credit by a fixed amount.
CustomerCreditItemWriter	Delegates actual writing to a custom DAO.
CustomerCreditRepository
CustomerCreditRowMapper
CustomerCreditUpdatePreparedStatementSetter
CustomerCreditUpdateWriter
CustomerDao
CustomerDebit
CustomerDebitDao	Interface for writing `CustomerDebitDao` object to arbitrary output.
CustomerDebitRowMapper
CustomerFieldExtractor
CustomerFieldSetMapper
CustomerOperation	Enum representing on of 3 possible actions on a customer update: Add, update, or delete
CustomerUpdate	Immutable Value Object representing an update to the customer as stored in the database.
CustomerUpdateFieldSetMapper	`FieldSetMapper` for mapping to a `CustomerUpdate`.
CustomerUpdateProcessor
CustomerUpdateWriter
CustomerUpdateWriter	Transforms Trade to a CustomerDebit and asks DAO delegate to write the result.
DatabaseType	Enum representing a database type, such as DB2 or oracle.
DataFieldMaxValueIncrementerFactory	Factory for creating `DataFieldMaxValueIncrementer` implementations based upon a provided string.
DataSourceConfiguration
DataSourceConfiguration
DataSourceInitializer	Wrapper for a `DataSource` that can run scripts on start up and shut down.
Db2PagingQueryProvider	DB2 implementation of a `PagingQueryProvider` using database specific features.
DecisionParser	Internal parser for the <decision/> elements inside a job.
DecisionState	State that requires a decider to make the status decision.
DecisionStep	Implements a `Step` to follow the rules for a decision state as defined by JSR-352.
DecisionStepFactoryBean	`FactoryBean` for creating a `DecisionStep`.
DefaultBatchConfigurer
DefaultBufferedReaderFactory
DefaultDataFieldMaxValueIncrementerFactory	Default implementation of the `DataFieldMaxValueIncrementerFactory` interface.
DefaultExceptionHandler	Default implementation of `ExceptionHandler` - just re-throws the exception it encounters.
DefaultExecutionContextSerializer	An implementation of the `ExecutionContextSerializer` using the default serialization implementations from Spring (`DefaultSerializer` and `DefaultDeserializer`).
DefaultFieldSet	Default implementation of `FieldSet` using Java using Java primitive and standard types and utilities.
DefaultFieldSetFactory	Default implementation of `FieldSetFactory` with no special knowledge of the `FieldSet` required.
DefaultFragmentEventReader	Default implementation of `FragmentEventReader`
DefaultItemFailureHandler	Default implementation of the `ItemListenerSupport` class that writes all exceptions via commons logging.
DefaultJobKeyGenerator	Default implementation of the `JobKeyGenerator` interface.
DefaultJobLoader	Default implementation of `JobLoader`.
DefaultJobLoader
DefaultJobParametersConverter	Converter for `JobParameters` instances using a simple naming convention for property keys.
DefaultJobParametersExtractor	Simple implementation of `JobParametersExtractor` which pulls parameters with named keys out of the step execution context and the job parameters of the surrounding job.
DefaultJobParametersValidator	Default implementation of `JobParametersValidator`.
DefaultLineMapper<T>	Two-phase `LineMapper` implementation consisting of tokenization of the line into `FieldSet` followed by mapping to item.
DefaultMailErrorHandler	This `MailErrorHandler` implementation simply rethrows the exception it receives.
DefaultPropertyEditorRegistrar	A re-usable `PropertyEditorRegistrar` that can be used wherever one needs to register custom `PropertyEditor` instances with a `PropertyEditorRegistry` (like a bean wrapper, or a type converter).
DefaultRecordSeparatorPolicy	A `RecordSeparatorPolicy` that treats all lines as record endings, as long as they do not have unterminated quotes, and do not end in a continuation marker.
DefaultResultCompletionPolicy	Very simple `CompletionPolicy` that bases its decision on the result of a batch operation.
DefaultStateTransitionComparator	Sorts by decreasing specificity of pattern, based on just counting wildcards (with * taking precedence over ?).
DefaultStepExecutionAggregator	Convenience class for aggregating a set of `StepExecution` instances into a single result.
DelegateStep	Provides a wrapper for an existing `Step`, delegating execution to it, but serving all other operations locally.
DelimitedLineAggregator<T>	A `LineAggregator` implementation that converts an object into a delimited list of strings.
DelimitedLineTokenizer	A `LineTokenizer` implementation that splits the input String on a configurable delimiter.
DerbyPagingQueryProvider	Derby implementation of a `PagingQueryProvider` using standard SQL:2003 windowing functions.
DirectPoller<S>	A `Poller` that uses the callers thread to poll for a result as soon as it is asked for.
DummyItemWriter
DuplicateJobException	Checked exception that indicates a name clash when registering `Job` instances.
DynamicMethodInvocationException	Indicates an error has been encountered while trying to dynamically invoke a method e.g. using `MethodInvoker`.
EnableBatchIntegration	Enable Spring Batch Integration features and provide a base configuration for setting up remote chunking or partitioning infrastructure beans.
EnableBatchProcessing	Enable Spring Batch features and provide a base configuration for setting up batch jobs in an @Configuration class, roughly equivalent to using the `<batch:*>` XML namespace.
EndState	`State` implementation for ending a job if it is in progress and continuing if just starting.
Entity	Batch Domain Entity class.
ExceptionClassifierSkipPolicy	A `SkipPolicy` that depends on an exception classifier to make its decision, and then delegates to the classifier result.
ExceptionElementParser
ExceptionHandler	Handler to allow strategies for re-throwing exceptions.
ExceptionThrowingItemReaderProxy<T>	Hacked `ItemReader` that throws exception on a given record number (useful for testing restart).
ExecutionContext	Object representing a context for an `ItemStream`.
ExecutionContextDao	DAO interface for persisting and retrieving `ExecutionContext`s.
ExecutionContextPromotionListener	This class can be used to automatically promote items from the `StepExecutionContext` to the `JobExecutionContext` at the end of a step.
ExecutionContextSerializer	A composite interface that combines both serialization and deserialization of an execution context into a single implementation.
ExecutionContextTestUtils	Convenience class for accessing `ExecutionContext` values from job and step executions.
ExecutionContextUserSupport	Facilitates assigning names to objects persisting data in `ExecutionContext` and generating keys for `ExecutionContext` based on the name.
ExitCodeMapper	This interface should be implemented when an environment calling the batch framework has specific requirements regarding the operating system process return status.
ExitStatus	Value object used to carry information about the status of a job or step execution.
ExtendedConnectionDataSourceProxy	Implementation of `SmartDataSource` that is capable of keeping a single JDBC Connection which is NOT closed after each use even if `Connection.close()` is called.
ExtractorLineAggregator<T>	An abstract `LineAggregator` implementation that utilizes a `FieldExtractor` to convert the incoming object to an array of its parts.
FatalStepExecutionException
FaultTolerantChunkProcessor<I,O>	FaultTolerant implementation of the `ChunkProcessor` interface, that allows for skipping or retry of items that cause exceptions during writing.
FaultTolerantChunkProvider<I>	FaultTolerant implementation of the `ChunkProcessor` interface, that allows for skipping or retry of items that cause exceptions during reading or processing.
FaultTolerantStepBuilder<I,O>	A step builder for fully fault tolerant chunk-oriented item processing steps.
FaultTolerantStepFactoryBean<T,S>	Factory bean for step that provides options for configuring skip behavior.
FieldExtractor<T>	This class will convert an object to an array of its parts.
FieldSet	Interface used by flat file input sources to encapsulate concerns of converting an array of Strings to Java native types.
FieldSetFactory	Factory interface for creating `FieldSet` instances.
FieldSetMapper<T>	Interface that is used to map data obtained from a `FieldSet` into an object.
FileUtils	Utility methods for files used in batch processing.
FixedLengthTokenizer	Tokenizer used to process data obtained from files with fixed-length format.
FlatFileCustomerCreditDao	Writes customer's credit information in a file.
FlatFileFooterCallback	Callback interface for writing a footer to a file.
FlatFileFormatException	Exception indicating that some type of error has occurred while attempting to parse a line of input into tokens.
FlatFileHeaderCallback	Callback interface for writing a header to a file.
FlatFileItemReader<T>	Restartable `ItemReader` that reads lines from input `FlatFileItemReader.setResource(Resource)`.
FlatFileItemReaderBuilder<T>	A builder implementation for the `FlatFileItemReader`.
FlatFileItemReaderBuilder.DelimitedBuilder<T>	A builder for constructing a `DelimitedLineTokenizer`
FlatFileItemReaderBuilder.FixedLengthBuilder<T>	A builder for constructing a `FixedLengthTokenizer`
FlatFileItemWriter<T>	This class is an item writer that writes data to a file or stream.
FlatFileItemWriterBuilder<T>	A builder implementation for the `FlatFileItemWriter`
FlatFileItemWriterBuilder.DelimitedBuilder<T>	A builder for constructing a `DelimitedLineAggregator`
FlatFileItemWriterBuilder.FormattedBuilder<T>	A builder for constructing a `FormatterLineAggregator`.
FlatFileParseException	Exception thrown when errors are encountered parsing flat files.
Flow
FlowBuilder<Q>	A builder for a flow of steps that can be executed as a job or as part of a job.
FlowBuilder.SplitBuilder<Q>	A builder for building a split state.
FlowBuilder.TransitionBuilder<Q>	A builder for transitions within a flow.
FlowBuilder.UnterminatedFlowBuilder<Q>	A builder for continuing a flow from a decision state.
FlowBuilderException
FlowElementParser	Internal parser for the <flow/> elements inside a job.
FlowExecution
FlowExecutionAggregator	Strategy interface for aggregating `FlowExecution` instances into a single exit status.
FlowExecutionException
FlowExecutionStatus	Represents the status of `FlowExecution`.
FlowExecutor	Context and execution strategy for `FlowJob` to allow it to delegate its execution step by step.
FlowHolder	Convenient interface for components that contain nested flows.
FlowJob	Implementation of the `Job` interface that allows for complex flows of steps, rather than requiring sequential execution.
FlowJobBuilder	A job builder for `FlowJob` instances.
FlowParser	Parses flows as defined in JSR-352.
FlowState	State that delegates to a Flow
FlowStep	A `Step` implementation that delegates to a `Flow`.
FlowStepBuilder	A step builder for `FlowStep` instances.
FlushFailedException	Unchecked exception indicating that an error has occurred while trying to flush a buffer.
FootballExceptionHandler
FooterFieldExtractor
ForceRollbackForWriteSkipException	Fatal exception to be thrown when a rollback must be forced, typically after catching an exception that otherwise would not cause a rollback.
FormatterLineAggregator<T>	A `LineAggregator` implementation which produces a String by aggregating the provided item via the `Formatter` syntax.
FragmentEventReader	Interface for event readers which support treating XML fragments as standalone XML documents by wrapping the fragments with StartDocument and EndDocument events.
FunctionItemProcessor<I,O>	An `ItemProcessor` implementation that delegates to a `Function`
Game
Game
GameFieldSetMapper
GemfireItemWriter<K,V>	An `ItemWriter` that stores items in GemFire
GemfireItemWriterBuilder<K,V>	A builder implementation for the `GemfireItemWriter`
GeneratingTradeItemReader	Generates configurable number of `Trade` items.
GeneratingTradeResettingListener	This listener resets the count of its GeneratingTradeItemReader after the step.
GenericApplicationContextFactory	`ApplicationContextFactory` implementation that takes a parent context and a path to the context to create.
GroupAwareJob	A `Job` that can optionally prepend a group name to another job's name, to make it fit a naming convention for type or origin.
GsonJsonObjectMarshaller<T>	A json object marshaller that uses Google Gson to marshal an object into a json representation.
GsonJsonObjectReader<T>	Implementation of `JsonObjectReader` based on Google Gson.
H2PagingQueryProvider	H2 implementation of a `PagingQueryProvider` using database specific features.
HeaderCopyCallback	Designed to be registered with both `FlatFileItemReader` and `FlatFileItemWriter` and copy header line from input file to output file.
HeaderFieldExtractor
HeaderFieldSetMapper
HibernateAwareCustomerCreditItemWriter	Delegates writing to a custom DAO and flushes + clears hibernate session to fulfill the `ItemWriter` contract.
HibernateCreditDao
HibernateCursorItemReader<T>	`ItemStreamReader` for reading database records built on top of Hibernate.
HibernateCursorItemReaderBuilder<T>	This is a builder for the `HibernateCursorItemReader`.
HibernateItemReaderHelper<T>	Internal shared state helper for hibernate readers managing sessions and queries.
HibernateItemWriter<T>	`ItemWriter` that uses a Hibernate session to save or update entities that are not part of the current Hibernate session.
HibernateItemWriterBuilder<T>	A builder for the `HibernateItemWriter`
HibernateNativeQueryProvider<E>	This query provider creates Hibernate `Query`s from injected native SQL queries.
HibernatePagingItemReader<T>	`ItemReader` for reading database records built on top of Hibernate and reading only up to a fixed number of items at a time.
HibernatePagingItemReaderBuilder<T>	A builder for the `HibernatePagingItemReader`.
HibernateQueryProvider<T>	Interface defining the functionality to be provided for generating queries for use with Hibernate `ItemReader`s or other custom built artifacts.
HippyMethodInvoker	A `MethodInvoker` that is a bit relaxed about its arguments.
HsqlPagingQueryProvider	HSQLDB implementation of a `PagingQueryProvider` using database specific features.
IncorrectLineLengthException	Exception indicating that the line size expected is different from what is expected.
IncorrectTokenCountException	Exception indicating that an incorrect number of tokens have been found while parsing a file.
InfiniteLoopReader	ItemReader implementation that will continually return a new object.
InfiniteLoopWriter	Simple module implementation that will always return true to indicate that processing should continue.
InlineFlowParser
InlineStepParser	Internal parser for the <step/> elements inside a job.
IntArrayPropertyEditor
InvalidCustomerLogger	Interface for logging invalid customers.
ItemCountAware	Marker interface indicating that an item should have the item count set on it.
ItemListenerSupport<I,O>	Basic no-op implementation of the `ItemReadListener`, `ItemProcessListener`, and `ItemWriteListener` interfaces.
ItemPreparedStatementSetter<T>	A convenient strategy for SQL updates, acting effectively as the inverse of `RowMapper`.
ItemProcessListener<T,S>	Listener interface for the processing of an item.
ItemProcessListenerAdapter<T,S>	Wrapper class for `ItemProcessListener`
ItemProcessor<I,O>	Interface for item transformation.
ItemProcessorAdapter<I,O>	Invokes a custom method on a delegate plain old Java object which itself processes an item.
ItemProcessorAdapter<I,O>
ItemReader<T>	Strategy interface for providing the data.
ItemReaderAdapter<T>	Invokes a custom method on a delegate plain old Java object which itself provides an item.
ItemReaderAdapter<T>	Adapter that wraps an `ItemReader` for use by Spring Batch.
ItemReaderException	A base exception class that all exceptions thrown from an `ItemReader` extend.
ItemReadListener<T>	Listener interface around the reading of an item.
ItemReadListenerAdapter<T>	Wrapper class to adapt the `ItemReadListener` to a `ItemReadListener`.
ItemSqlParameterSourceProvider<T>	A convenient strategy for providing SqlParameterSource for named parameter SQL updates.
ItemStream	Marker interface defining a contract for periodically storing state and restoring from that state should an error occur.
ItemStreamException	Exception representing any errors encountered while processing a stream.
ItemStreamReader<T>	Convenience interface that combines `ItemStream` and `ItemReader` .
ItemStreamSupport	Empty method implementation of `ItemStream`.
ItemStreamWriter<T>	Convenience interface that combines `ItemStream` and `ItemWriter` .
ItemWriteListener<S>	Listener interface for the writing of items.
ItemWriteListenerAdapter<S>	Wrapper class to adapt the `ItemWriteListener` to a `ItemWriteListener`.
ItemWriter<T>	Basic interface for generic output operations.
ItemWriterAdapter<T>	Delegates item processing to a custom method - passes the item as an argument for the delegate method.
ItemWriterAdapter<T>	Adapter that wraps an `ItemWriter` for use by Spring Batch.
ItemWriterException	A base exception class that all exceptions thrown from an `ItemWriter` extend.
IteratorItemReader<T>	An `ItemReader` that pulls data from a `Iterator` or `Iterable` using the constructors.
Jackson2ExecutionContextStringSerializer	Implementation that uses Jackson2 to provide (de)serialization.
JacksonJsonObjectMarshaller<T>	A json object marshaller that uses Jackson to marshal an object into a json representation.
JacksonJsonObjectReader<T>	Implementation of `JsonObjectReader` based on Jackson.
JdbcBatchItemWriter<T>	`ItemWriter` that uses the batching features from `NamedParameterJdbcTemplate` to execute a batch of statements for all items provided.
JdbcBatchItemWriterBuilder<T>	A builder implementation for the `JdbcBatchItemWriter`.
JdbcCursorItemReader<T>	Simple item reader implementation that opens a JDBC cursor and continually retrieves the next row in the ResultSet.
JdbcCursorItemReaderBuilder<T>	Builder for the `JdbcCursorItemReader`
JdbcCustomerDao
JdbcCustomerDebitDao	Reduces customer's credit by the provided amount.
JdbcExecutionContextDao	JDBC DAO for `ExecutionContext`.
JdbcGameDao
JdbcJobExecutionDao	JDBC implementation of `JobExecutionDao`.
JdbcJobInstanceDao	JDBC implementation of `JobInstanceDao`.
JdbcPagingItemReader<T>	`ItemReader` for reading database records using JDBC in a paging fashion.
JdbcPagingItemReaderBuilder<T>	This is a builder for the `JdbcPagingItemReader`.
JdbcParameterUtils	Helper methods for SQL statement parameter parsing.
JdbcPlayerDao
JdbcPlayerSummaryDao
JdbcStepExecutionDao	JDBC implementation of `StepExecutionDao`. Allows customization of the tables names used by Spring Batch for step meta data via a prefix property. Uses sequences or tables (via Spring's `DataFieldMaxValueIncrementer` abstraction) to create all primary keys before inserting a new row.
JdbcTradeDao	Writes a Trade object to a database
JmsItemReader<T>	An `ItemReader` for JMS using a `JmsTemplate`.
JmsItemReaderBuilder<T>	Creates a fully qualified JmsItemReader.
JmsItemWriter<T>	An `ItemWriter` for JMS using a `JmsTemplate`.
JmsItemWriterBuilder<T>	Creates a fully qualified JmsItemWriter.
JmsMethodArgumentsKeyGenerator	A `MethodArgumentsKeyGenerator` for JMS
JmsMethodInvocationRecoverer<T>
JmsNewMethodArgumentsIdentifier<T>	A `NewMethodArgumentsIdentifier` for JMS that looks for a message in the arguments and checks its delivery status.
JmsRedeliveredExtractor
Job	Batch domain object representing a job.
JobBuilder	Convenience for building jobs of various kinds.
JobBuilderException
JobBuilderFactory	Convenient factory for a `JobBuilder` which sets the `JobRepository` automatically.
JobBuilderHelper<B extends JobBuilderHelper<B>>	A base class and utility for other job builders providing access to common properties like job repository.
JobBuilderHelper.CommonJobProperties
JobContext	A context object that can be used to interrogate the current `JobExecution` and some of its associated properties using expressions based on bean paths.
JobExecution	Batch domain object representing the execution of a job.
JobExecutionAlreadyRunningException
JobExecutionDao	Data Access Object for job executions.
JobExecutionDecider	Interface allowing for programmatic access to the decision on what the status of a flow should be.
JobExecutionException	Root of exception hierarchy for checked exceptions in job and step execution.
JobExecutionListener	Provide callbacks at specific points in the lifecycle of a `Job`.
JobExecutionListenerParser	Parser for a step listener element.
JobExecutionListenerSupport
JobExecutionNotFailedException	Checked exception to indicate that user asked for a job execution to be resumed when actually it didn't fail.
JobExecutionNotificationPublisher	JMX notification broadcaster
JobExecutionNotRunningException	Execution indicating that a JobExecution that is not currently running has been requested to stop.
JobExecutionNotStoppedException	Checked exception to indicate that user asked for a job execution to be aborted when hasn't been stopped.
JobExplorer	Entry point for browsing executions of running or historical jobs and steps.
JobExplorerFactoryBean	A `FactoryBean` that automates the creation of a `SimpleJobExplorer` using JDBC DAO implementations.
JobFactory	Strategy for creating a single job.
JobFactoryBean	This `FactoryBean` is used by the JSR-352 namespace parser to create `FlowJob` objects.
JobFactoryRegistrationListener	Generic service that can bind and unbind a `JobFactory` in a `JobRegistry`.
JobFlowBuilder
JobFlowExecutor	Implementation of `FlowExecutor` for use in components that need to execute a flow related to a `JobExecution`.
JobInstance	Batch domain object representing a uniquely identifiable job run.
JobInstanceAlreadyCompleteException	An exception indicating an illegal attempt to restart a job that was already completed successfully.
JobInstanceAlreadyExistsException	Checked exception to indicate that a required `Job` is not available.
JobInstanceDao	Data Access Object for job instances.
JobInterruptedException	Exception to indicate the the job has been interrupted.
JobKeyGenerator<T>	Strategy interface for the generation of the key used in identifying unique `JobInstance`.
JobLauncher	Simple interface for controlling jobs, including possible ad-hoc executions, based on different runtime identifiers.
JobLauncherDetails
JobLauncherTestUtils	Utility class for testing batch jobs.
JobLaunchingGateway	The `JobLaunchingGateway` is used to launch Batch Jobs.
JobLaunchingGatewayParser	The parser for the Job-Launching Gateway, which will instantiate a `JobLaunchingGatewayParser`.
JobLaunchingMessageHandler	Message handler which uses strategies to convert a Message into a job and a set of job parameters
JobLaunchRequest	Encapsulation of a `Job` and its `JobParameters` forming a request for a job to be launched.
JobLaunchRequestHandler	Interface for handling a `JobLaunchRequest` and returning a `JobExecution`.
JobListenerAdapter	Wrapper class to adapt the `JobListener` to a `JobExecutionListener`.
JobListenerFactoryBean	This `AbstractListenerFactoryBean` implementation is used to create a `JobExecutionListener`.
JobListenerMetaData	Enumeration for `JobExecutionListener` meta data, which ties together the names of methods, their interfaces, annotation, and expected arguments.
JobLoader
JobLoader
JobLocator	A runtime service locator interface for retrieving job configurations by `name`.
JobOperator	Low level interface for inspecting and controlling jobs with access only to primitive and collection types.
JobParameter	Domain representation of a parameter to a batch job.
JobParameter.ParameterType	Enumeration representing the type of a JobParameter.
JobParameterExecutionContextCopyListener	This class can be used to automatically copy items from the `JobParameters` to the `StepExecutionContext`.
JobParameters	Value object representing runtime parameters to a batch job.
JobParametersBuilder	Helper class for creating `JobParameters`.
JobParametersConverter	A factory for `JobParameters` instances.
JobParametersExtractor	Strategy interface for translating a `StepExecution` into `JobParameters`.
JobParametersIncrementer	Interface for obtaining the next `JobParameters` in a sequence.
JobParametersInvalidException	Exception for `Job` to signal that some `JobParameters` are invalid.
JobParametersNotFoundException	Checked exception to indicate that a required `JobParametersIncrementer` is not available.
JobParametersValidator	Strategy interface for a `Job` to use in validating its parameters for an execution.
JobParser	Parser for the <job/> element in the Batch namespace.
JobParserJobFactoryBean	This `FactoryBean` is used by the batch namespace parser to create `FlowJob` objects.
JobRegistry	A runtime service registry interface for registering job configurations by `name`.
JobRegistryBackgroundJobRunner	Command line launcher for registering jobs with a `JobRegistry`.
JobRegistryBeanPostProcessor	A `BeanPostProcessor` that registers `Job` beans with a `JobRegistry`.
JobRepository	Repository responsible for persistence of batch meta-data entities.
JobRepositoryFactoryBean	A `FactoryBean` that automates the creation of a `SimpleJobRepository` using JDBC DAO implementations which persist batch metadata in database.
JobRepositoryParser	Parser for the <job-repository/> element in the Batch namespace.
JobRepositoryTestUtils	Convenience class for creating and removing `JobExecution` instances from a database.
JobRestartException	An exception indicating an illegal attempt to restart a job.
JobScope	Convenient annotation for job scoped beans that defaults the proxy mode, so that it doesn't have to be specified explicitly on every bean definition.
JobScope	Scope for job context.
JobScopeManager	Convenient aspect to wrap a single threaded job execution, where the implementation of the `Job` is not job scope aware (i.e. not the ones provided by the framework).
JobScopeTestExecutionListener	A `TestExecutionListener` that sets up job-scope context for dependency injection into unit tests.
JobScopeTestUtils	Utility class for creating and manipulating `JobScope` in unit tests.
JobStep	A `Step` that delegates to a `Job` to do its work.
JobStepBuilder	A step builder for `JobStep` instances.
JobSynchronizationManager	Central convenience class for framework use in managing the job scope context.
JpaItemWriter<T>	`ItemWriter` that is using a JPA EntityManagerFactory to merge any Entities that aren't part of the persistence context.
JpaItemWriterBuilder<T>	A builder for the `JpaItemWriter`.
JpaNativeQueryProvider<E>	This query provider creates JPA `Query`s from injected native SQL queries.
JpaPagingItemReader<T>	`ItemReader` for reading database records built on top of JPA.
JpaPagingItemReaderBuilder<T>	Creates a fully qualified JpaPagingItemReader.
JpaQueryProvider	Interface defining the functionality to be provided for generating queries for use with JPA `ItemReader`s or other custom built artifacts.
JsonFileItemWriter<T>	Item writer that writes data in json format to an output file.
JsonFileItemWriterBuilder<T>	Builder for `JsonFileItemWriter`.
JsonItemReader<T>	`ItemStreamReader` implementation that reads Json objects from a `Resource` having the following format:
JsonItemReaderBuilder<T>	A builder for `JsonItemReader`.
JsonLineMapper	Interpret a line as a JSON object and parse it up to a Map.
JsonObjectMarshaller<T>	Strategy interface to marshal an object into a json representation.
JsonObjectReader<T>	Strategy interface for Json readers.
JsonRecordSeparatorPolicy	JSON-based record separator.
JsrAutowiredAnnotationBeanPostProcessor	This class overrides methods in the copied `SpringAutowiredAnnotationBeanPostProcessor` class to check for the `BatchProperty` annotation before processing injection annotations.
JsrBatchletStepBuilder	Extension of the `TaskletStepBuilder` that uses a `BatchletStep` instead of a `TaskletStep`.
JsrBeanDefinitionDocumentReader	`DefaultBeanDefinitionDocumentReader` extension to hook into the pre processing of the provided XML document, ensuring any references to property operators such as jobParameters and jobProperties are resolved prior to loading the context.
JsrBeanScopeBeanFactoryPostProcessor	In order for property resolution to occur correctly within the scope of a JSR-352 batch job, initialization of job level artifacts must occur on the same thread that the job is executing.
JsrBeanScopeBeanFactoryPostProcessor.JobLevelBeanLazyInitializer	Looks for beans that may have dependencies that need to be lazily initialized and configures the corresponding `BeanDefinition` accordingly.
JsrChunkProcessor<I,O>	`ChunkProcessor` implementation that implements JSR-352's chunking pattern (read and process in a loop until the chunk is complete then write).
JsrChunkProvider<T>	A no-op `ChunkProvider`.
JsrDecisionParser	Parser for the <decision /> element as specified in JSR-352.
JsrEndState	`State` implementation for ending a job per JSR-352 rules if it is in progress and continuing if just starting.
JsrExpressionParser	Support class for parsing JSR-352 expressions.
JsrFaultTolerantChunkProcessor<I,O>	Extension of the `JsrChunkProcessor` that adds skip and retry functionality.
JsrFaultTolerantStepBuilder<I,O>	A step builder that extends the `FaultTolerantStepBuilder` to create JSR-352 specific `ChunkProvider` and `ChunkProcessor` supporting both the chunking pattern defined by the spec as well as skip/retry logic.
JsrFlow	Implements JSR-352 specific logic around the execution of a flow.
JsrFlowExecutor	JSR-352 specific `JobFlowExecutor`.
JsrFlowFactoryBean	Extension to the `SimpleFlowFactoryBean` that provides `JsrStepState` implementations for JSR-352 based jobs.
JsrFlowJob	JSR-352 specific extension of the `FlowJob`.
JsrJobContext	Wrapper class to provide the `JobContext` functionality as specified in JSR-352.
JsrJobContextFactoryBean	Provides a single `JobContext` for each thread in a running job.
JsrJobExecution	Wrapper class to adapt the `JobExecution` to a `JobExecution`.
JsrJobListenerFactoryBean	This `FactoryBean` is used by the JSR-352 namespace parser to create `JobExecutionListener` objects.
JsrJobListenerMetaData	Enumeration for `JobListener` meta data, which ties together the names of methods, their interfaces, annotation, and expected arguments.
JsrJobOperator	The entrance for executing batch jobs as defined by JSR-352.
JsrJobOperator.BaseContextHolder	A singleton holder used to lazily bootstrap the base context used in JSR-352.
JsrJobParametersConverter	Provides default conversion methodology for JSR-352's implementation.
JsrJobParser	Parses a <job /> tag as defined in JSR-352.
JsrNamespaceHandler
JsrNamespacePostProcessor
JsrPartitionHandler	Executes a step instance per thread using a `ThreadPoolTaskExecutor` in accordance with JSR-352.
JsrPartitionHandler.PartitionPlanState	Since a `PartitionPlan` could provide dynamic data (different results from run to run), the batch runtime needs to save off the results for restarts.
JsrPartitionStepBuilder	An extension of the `PartitionStepBuilder` that uses `PartitionStep` so that JSR-352 specific semantics are honored.
JsrSampleBatchlet	Sample `Batchlet` implementation.
JsrSampleItemProcessor	Sample `ItemProcessor` implementation.
JsrSampleItemReader	Sample `ItemReader` implementation.
JsrSampleItemWriter	Sample `ItemWriter` implementation.
JsrSampleTasklet	Sample `Tasklet` implementation.
JsrSimpleStepBuilder<I,O>	A step builder that extends the `FaultTolerantStepBuilder` to create JSR-352 specific `ChunkProvider` and `ChunkProcessor` supporting the chunking pattern defined by the spec.
JsrSplitParser	Parses a <split /> element as defined in JSR-352.
JsrSplitState	JSR-352 states that artifacts cannot set the ExitStatus from within a split for a job.
JsrStepContext	Wrapper class to provide the `StepContext` functionality as specified in JSR-352.
JsrStepContextFactoryBean	`FactoryBean` implementation used to create `StepContext` instances within the step scope.
JsrStepExecution	Implementation of the JsrStepExecution as defined in JSR-352.
JsrStepExecutionAggregator	Aggregates `StepExecution`s based on the rules outlined in JSR-352.
JsrStepExecutionSplitter	Provides JSR-352 specific behavior for the splitting of `StepExecution`s.
JsrStepHandler	Extends `SimpleStepHandler` to apply JSR-352 specific logic for whether to start a step.
JsrStepListenerFactoryBean
JsrStepListenerMetaData	Enumeration for the JSR specific `StepListener` meta data, which ties together the names of methods, their interfaces, and expected arguments.
JsrStepState	Extends `StepState` to persist what the last step that was executed was (used in Decisions and restarts).
JsrTestUtils	Provides testing utilities to execute JSR-352 jobs and block until they are complete (since all JSR-352 based jobs are executed asynchronously).
JsrXmlApplicationContext	`GenericApplicationContext` implementation providing JSR-352 related context operations.
JvmSystemExiter	Implementation of the `SystemExiter` interface that calls the standards System.exit method.
KeyGenerator	Interface for defining keys to uniquely identify items.
KeyValueItemWriter<K,V>	A base class to implement any `ItemWriter` that writes to a key value store using a `Converter` to derive a key from an item
LastModifiedResourceComparator	Comparator to sort resources by the file last modified time.
LdifReader	The `LdifReader` is an adaptation of the `FlatFileItemReader` built around an `LdifParser`.
LdifReaderBuilder	Creates a fully qualified LdifReader.
LimitCheckingItemSkipPolicy	`SkipPolicy` that determines whether or not reading should continue based upon how many items have been skipped.
LimitDecider	This decider will return "CONTINUE" until the limit it reached, at which point it will return "COMPLETE".
LineAggregator<T>	Interface used to create string representing object.
LineCallbackHandler	Callback interface for handling a line from file.
LineItem	An XML line-item.
LineItem
LineItemFieldExtractor
LineMapper<T>	Interface for mapping lines (strings) to domain objects typically used to map lines read from a file to domain objects on a per line basis.
LineTokenizer	Interface that is used by framework to split string obtained typically from a file into tokens.
ListableJobLocator	A listable extension of `JobLocator`.
ListenerMetaData	A common interface for listener meta data enumerations.
ListenerParser	Parses the various listeners defined in JSR-352.
ListItemReader<T>	An `ItemReader` that pulls data from a list.
ListItemWriter<T>
ListPreparedStatementSetter	Implementation of the `PreparedStatementSetter` interface that accepts a list of values to be set on a PreparedStatement.
LogAdvice	Wraps calls for 'Processing' methods which output a single Object to write the string representation of the object to the log.
LoggingItemWriter<T>
LogOrRethrowExceptionHandler	Implementation of `ExceptionHandler` based on an `Classifier`.
LogOrRethrowExceptionHandler.Level	Logging levels for the handler.
MailErrorHandler	This class is used to handle errors that occur when email messages are unable to be sent.
MapExecutionContextDao	In-memory implementation of `ExecutionContextDao` backed by maps.
MapJobExecutionDao	In-memory implementation of `JobExecutionDao`.
MapJobExplorerFactoryBean	A `FactoryBean` that automates the creation of a `SimpleJobExplorer` using in-memory DAO implementations.
MapJobInstanceDao	In-memory implementation of `JobInstanceDao`.
MapJobRegistry	Simple, thread-safe, map-based implementation of `JobRegistry`.
MapJobRepositoryFactoryBean	A `FactoryBean` that automates the creation of a `SimpleJobRepository` using non-persistent in-memory DAO implementations.
MappingLdifReader<T>	The `MappingLdifReader` is an adaptation of the `FlatFileItemReader` built around an `LdifParser`.
MappingLdifReaderBuilder<T>	Creates a fully qualified MappingLdifReader.
MapStepExecutionDao	In-memory implementation of `StepExecutionDao`.
MapStepRegistry	Simple map-based implementation of `StepRegistry`.
MasterConfiguration	This configuration class is for the master side of the remote chunking sample.
MasterConfiguration	This configuration class is for the master side of the remote partitioning sample.
MasterConfiguration	This configuration class is for the master side of the remote partitioning sample.
MaxValueFlowExecutionAggregator	Implementation of the `FlowExecutionAggregator` interface that aggregates `FlowExecutionStatus`', using the status with the high precedence as the aggregate status.
MessageChannelPartitionHandler	A `PartitionHandler` that uses `MessageChannel` instances to send instructions to remote workers and receive their responses.
MessageProcessor	Simple `ItemProcessor` implementation to append a "processed on" `Date` to a received message.
MessageSourcePollerInterceptor	A `ChannelInterceptor` that turns a pollable channel into a "pass-thru channel": if a client calls `receive()` on the channel it will delegate to a `MessageSource` to pull the message directly from an external source.
MetaDataInstanceFactory	Convenience methods for creating test instances of `JobExecution`, `JobInstance` and `StepExecution`.
MethodInvoker	A strategy interface for invoking a method.
MethodInvokerMethodInterceptor	`MethodInterceptor` that, given a map of method names and `MethodInvoker`s, will execute all methods tied to a particular method name, with the provided arguments.
MethodInvokerUtils	Utility methods for create MethodInvoker instances.
MethodInvokingTaskletAdapter	A `Tasklet` that wraps a method in a POJO.
MethodResolver	Strategy interface for detecting a single Method on a Class.
MimeMessageItemWriter	A simple `ItemWriter` that can send mail messages.
ModularBatchConfiguration	Base `Configuration` class providing common structure for enabling and using Spring Batch.
MongoItemReader<T>	Restartable `ItemReader` that reads documents from MongoDB via a paging technique.
MongoItemReaderBuilder<T>	A builder implementation for the `MongoItemReader`
MongoItemWriter<T>	A `ItemWriter` implementation that writes to a MongoDB store using an implementation of Spring Data's `MongoOperations`.
MongoItemWriterBuilder<T>	A builder implementation for the `MongoItemWriter`
MulticasterBatchListener<T,S>
MultiResourceItemReader<T>	Reads items from multiple resources sequentially - resource list is given by `MultiResourceItemReader.setResources(Resource[])`, the actual reading is delegated to `MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream)`.
MultiResourceItemReaderBuilder<T>	A builder implementation for the `MultiResourceItemReader`.
MultiResourceItemWriter<T>	Wraps a `ResourceAwareItemWriterItemStream` and creates a new output resource when the count of items written in current resource exceeds `MultiResourceItemWriter.setItemCountLimitPerResource(int)`.
MultiResourceItemWriterBuilder<T>	A builder implementation for the `MultiResourceItemWriter`.
MultiResourcePartitioner	Implementation of `Partitioner` that locates multiple resources and associates their file names with execution context keys.
MySqlPagingQueryProvider	MySQL implementation of a `PagingQueryProvider` using database specific features.
Neo4jItemReader<T>	Extensions of the `AbstractNeo4jItemReader`.
Neo4jItemReaderBuilder<T>	A builder for the `Neo4jItemReader`.
Neo4jItemWriter<T>	A `ItemWriter` implementation that writes to a Neo4j database.
Neo4jItemWriterBuilder<T>	A builder implementation for the `Neo4jItemWriter`
NestedRepeatCallback	Callback that delegates to another callback, via a `RepeatOperations` instance.
NeverSkipItemSkipPolicy	`SkipPolicy` implementation that always returns false, indicating that an item should not be skipped.
NonSkippableProcessException	Fatal exception to be thrown when a process operation could not be skipped.
NonSkippableReadException	Fatal exception to be thrown when a read operation could not be skipped.
NonSkippableWriteException	Fatal exception to be thrown when a process operation could not be skipped.
NonTransientFlatFileException	Exception thrown when errors are encountered with the underlying resource.
NonTransientResourceException	Exception indicating that an error has been encountered doing I/O from a reader, and the exception should be considered fatal.
NoStartEndDocumentStreamWriter	Delegating XMLEventWriter, which ignores start and end document events, but passes through everything else.
NoSuchJobException	Checked exception to indicate that a required `Job` is not available.
NoSuchJobExecutionException	Checked exception to indicate that a required `JobExecution` is not available.
NoSuchJobInstanceException	Exception that signals that the user requested an operation on a non-existent `JobInstance`.
NoSuchObjectException	This exception identifies that a batch domain object is invalid, which is generally caused by an invalid ID.
NoSuchStepException	Exception to signal that a step was requested that is unknown or does not exist.
NoWorkFoundStepExecutionListener	Fails the step if no items have been processed ( item count is 0).
OnProcessError	Marks a method to be called if an exception is thrown by an `ItemProcessor` Expected signature: void onProcessError(T item, `Exception` e)
OnReadError	Marks a method to be called if an exception is thrown by an `ItemReader` Expected signature: void onReadError(`Exception` ex)
OnSkipInProcess	Marks a method to be called when an item is skipped due to an exception thrown in the `ItemProcessor`. Expected signature: void onSkipInProcess(T item, `Throwable` t)
OnSkipInRead	Marks a method to be called when an item is skipped due to an exception thrown in the `ItemReader` Expected signature: void onSkipInRead(`Throwable` t)
OnSkipInWrite	Marks a method to be called when an item is skipped due to an exception thrown in the `ItemWriter`. Expected signature: void onSkipInWrite(S item, `Throwable` t)
OnWriteError	Marks a method to be called if an exception is thrown by an `ItemWriter` Expected signature: void onWriteError(`Exception` exception, `List`<?
OraclePagingQueryProvider	Oracle implementation of a `PagingQueryProvider` using database specific features.
Order	The direction of the sort in an ORDER BY clause.
Order	An XML order.
Order
OrderItemFieldSetMapper
OrderItemReader
OrderLineAggregator	Converts `Order` object to a list of strings.
OrderValidator
OutputFileListener
OutputFileNameListener
PagingQueryProvider	Interface defining the functionality to be provided for generating paging queries for use with Paging Item Readers.
ParseException	Exception indicating that an error has been encountered parsing IO, typically from a file.
PartitionCollectorAdapter	Adapter class used to wrap a `PartitionCollector` so that it can be consumed as a `ChunkListener`.
Partitioner	Central strategy interface for creating input parameters for a partitioned step in the form of `ExecutionContext` instances.
PartitionHandler	Interface defining the responsibilities of controlling the execution of a partitioned `StepExecution`.
PartitionNameProvider	Optional interface for `Partitioner` implementations that need to use a custom naming scheme for partitions.
PartitionParser	Parser for the <partition> element as defined by JSR-352.
PartitionStep	An extension of the `PartitionStep` that provides additional semantics required by JSR-352.
PartitionStep	Implementation of `Step` which partitions the execution and spreads the load using a `PartitionHandler`.
PartitionStepBuilder	Step builder for `PartitionStep` instances.
PassThroughFieldExtractor<T>	`FieldExtractor` that just returns the original item.
PassThroughFieldSetMapper	Pass through `FieldSetMapper` useful for passing a `FieldSet` back directly rather than a mapped object.
PassThroughItemProcessor<T>	Simple `ItemProcessor` that does nothing - simply passes its argument through to the caller.
PassThroughLineAggregator<T>	A `LineAggregator` implementation that simply calls `Object.toString()` on the given object
PassThroughLineMapper	Pass through `LineMapper` useful for passing the original `String` back directly rather than a mapped object.
PatternMatcher<S>
PatternMatchingCompositeLineMapper<T>	A `LineMapper` implementation that stores a mapping of String patterns to delegate `LineTokenizer`s as well as a mapping of String patterns to delegate `FieldSetMapper`s.
PatternMatchingCompositeLineTokenizer	A `LineTokenizer` implementation that stores a mapping of String patterns to delegate `LineTokenizer`s.
PeekableItemReader<T>	A specialisation of `ItemReader` that allows the user to look ahead into the stream of items.
Person
Person
PersonService	Custom class that contains logic that would normally be be contained in `ItemReader` and `ItemWriter`.
PersonWriter
Player
Player
PlayerDao	Interface for writing `Player` objects to arbitrary output.
PlayerDao	Interface for writing `Player` objects to arbitrary output.
PlayerFieldSetMapper
PlayerItemWriter
PlayerSummary	Domain object representing the summary of a given Player's year.
PlayerSummary	Domain object representing the summary of a given Player's year.
PlayerSummaryMapper	RowMapper used to map a ResultSet to a `PlayerSummary`
PlayerSummaryRowMapper	RowMapper used to map a ResultSet to a `PlayerSummary`
Poller<T>	Interface for polling a `Callable` instance provided by the user.
PostgresPagingQueryProvider	Postgres implementation of a `PagingQueryProvider` using database specific features.
ProcessIndicatorItemWrapper<T>	Item wrapper useful in "process indicator" usecase, where input is marked as processed by the processor/writer.
PropertiesConverter	Utility to convert a Properties object to a String and back.
PropertyExtractingDelegatingItemWriter<T>	Delegates processing to a custom method - extracts property values from item object and uses them as arguments for the delegate method.
PropertyParser	Parser for the <properties /> element defined by JSR-352.
Range	A class to represent ranges.
RangeArrayPropertyEditor	Property editor implementation which parses string and creates array of ranges.
ReaderNotOpenException	Exception indicating that an `ItemReader` needed to be opened before read.
RecordCallbackHandler	This interface can be used to operate on skipped records during open in the `LdifReader` and the `MappingLdifReader`.
RecordMapper<T>	This interface should be implemented to map `LdapAttributes` objects to POJOs.
RecordSeparatorPolicy	Policy for text file-based input sources to determine the end of a record, e.g. a record might be a single line, or it might be multiple lines terminated by a semicolon.
RecursiveCollectionLineAggregator<T>	An implementation of `LineAggregator` that concatenates a collection of items of a common type with the system line separator.
ReferenceJobFactory	A `JobFactory` that just keeps a reference to a `Job`.
ReflectionUtils	Provides reflection based utilities for Spring Batch that are not available via Spring Core
RegexLineTokenizer	Line-tokenizer using a regular expression to filter out data (by using matching and non-matching groups).
RemoteChunkHandlerFactoryBean<T>	Convenient factory bean for a chunk handler that also converts an existing chunk-oriented step into a remote chunk master.
RemoteChunkingMasterParser	Parser for the remote-chunking-master namespace element.
RemoteChunkingMasterStepBuilder<I,O>	Builder for a master step in a remote chunking setup.
RemoteChunkingMasterStepBuilderFactory	Convenient factory for a `RemoteChunkingMasterStepBuilder` which sets the `JobRepository` and `PlatformTransactionManager` automatically.
RemoteChunkingSlaveParser	Parser for the remote-chunking-slave namespace element.
RemoteChunkingWorkerBuilder<I,O>	Builder for a worker in a remote chunking setup.
RemotePartitioningMasterStepBuilder	Builder for a master step in a remote partitioning setup.
RemotePartitioningMasterStepBuilderFactory	Convenient factory for a `RemotePartitioningMasterStepBuilder` which sets the `JobRepository`, `JobExplorer`, `BeanFactory` and `PlatformTransactionManager` automatically.
RemotePartitioningWorkerStepBuilder	Builder for a worker step in a remote partitioning setup.
RemotePartitioningWorkerStepBuilderFactory	Convenient factory for a `RemotePartitioningWorkerStepBuilder` which sets the `JobRepository`, `JobExplorer`, `BeanFactory` and `PlatformTransactionManager` automatically.
RemoteStepExecutionAggregator	Convenience class for aggregating a set of `StepExecution` instances when the input comes from remote steps, so the data need to be refreshed from the repository.
RepeatCallback	Callback interface for batch operations.
RepeatContext	Base interface for context which controls the state and completion / termination of a batch step.
RepeatContextCounter	Helper class for policies that need to count the number of occurrences of some event (e.g. an exception type in the context) in the scope of a batch.
RepeatContextSupport
RepeatException
RepeatInternalState	Internal interface for extensions of `RepeatTemplate`.
RepeatInternalStateSupport
RepeatListener	Interface for listeners to the batch process.
RepeatListenerSupport	Empty method implementation of `RepeatListener`.
RepeatOperations	The main interface providing access to batch operations.
RepeatOperationsInterceptor	A `MethodInterceptor` that can be used to automatically repeat calls to a method on a service.
RepeatStatus
RepeatSynchronizationManager	Global variable support for repeat clients.
RepeatTemplate	Simple implementation and base class for batch templates implementing `RepeatOperations`.
RepositoryItemReader<T>	A `ItemReader` that reads records utilizing a `PagingAndSortingRepository`.
RepositoryItemReaderBuilder<T>	A builder implementation for the `RepositoryItemReader`.
RepositoryItemReaderBuilder.RepositoryMethodReference<T>	Establishes a proxy that will capture a the Repository and the associated methodName that will be used by the reader.
RepositoryItemWriter<T>	A `ItemReader` wrapper for a `CrudRepository` from Spring Data.
RepositoryItemWriterBuilder<T>	A builder implementation for the `RepositoryItemWriter`.
RepositoryItemWriterBuilder.RepositoryMethodReference<T>	Establishes a proxy that will capture a the Repository and the associated methodName that will be used by the writer.
ResourceAware	Marker interface indicating that an item should have the Spring `Resource` in which it was read from, set on it.
ResourceAwareItemReaderItemStream<T>	Interface for `ItemReader`s that implement `ItemStream` and read input from `Resource`.
ResourceAwareItemWriterItemStream<T>	Interface for `ItemWriter`s that implement `ItemStream` and write output to `Resource`.
ResourcelessTransactionManager
ResourcesItemReader	`ItemReader` which produces `Resource` instances from an array.
ResourceSuffixCreator	Strategy interface for translating resource index into unique filename suffix.
ResultHolderResultQueue	An implementation of the `ResultQueue` that throttles the number of expected results, limiting it to a maximum at any given time.
RethrowOnThresholdExceptionHandler	Implementation of `ExceptionHandler` that rethrows when exceptions of a given type reach a threshold.
RetryListener	Interface used internally by RetryListener adapters to provide consistent naming.
RetryProcessListenerAdapter	Wrapper class to adapt a `RetryProcessListener` to a `RetryListener`.
RetryReadListenerAdapter	Wrapper class to adapt a `RetryReadListener` to a `RetryListener`.
RetrySampleConfiguration
RetrySampleItemWriter<T>	Simulates temporary output trouble - requires to retry 3 times to pass successfully.
RetryWriteListenerAdapter	Wrapper class to adapt a `RetryWriteListener` to a `RetryListener`.
RunIdIncrementer
RuntimeExceptionTranslator
ScheduledJobParametersFactory
ScriptItemProcessor<I,O>	`ItemProcessor` implementation that passes the current item to process to the provided script.
ScriptItemProcessorBuilder<I,O>	Creates a fully qualified ScriptItemProcessor.
Shipper	An XML shipper.
ShippingFieldSetMapper
ShippingInfo
SimpleBatchConfiguration	Base `Configuration` class providing common structure for enabling and using Spring Batch.
SimpleBinaryBufferedReaderFactory	A `BufferedReaderFactory` useful for reading simple binary (or text) files with no line endings, such as those produced by mainframe copy books.
SimpleChunkProcessor<I,O>	Simple implementation of the `ChunkProcessor` interface that handles basic item writing and processing.
SimpleChunkProvider<I>	Simple implementation of the ChunkProvider interface that does basic chunk providing from an `ItemReader`.
SimpleCompletionPolicy	Policy for terminating a batch after a fixed number of operations.
SimpleFlow	A `Flow` that branches conditionally depending on the exit status of the last `State`.
SimpleFlowFactoryBean	Convenience factory for SimpleFlow instances for use in XML namespace.
SimpleFlowFactoryBean.DelegateState	A State that proxies a delegate and changes its name but leaves its behavior unchanged.
SimpleJob	Simple implementation of `Job` interface providing the ability to run a `JobExecution`.
SimpleJobBuilder
SimpleJobExplorer	Implementation of `JobExplorer` using the injected DAOs.
SimpleJobLauncher	Simple implementation of the `JobLauncher` interface.
SimpleJobOperator	Simple implementation of the JobOperator interface.
SimpleJobRepository	Implementation of `JobRepository` that stores JobInstances, JobExecutions, and StepExecutions using the injected DAOs.
SimpleJvmExitCodeMapper	An implementation of `ExitCodeMapper` that can be configured through a map from batch exit codes (String) to integer results.
SimpleLimitExceptionHandler	Simple implementation of exception handler which looks for given exception types.
SimpleMailMessageItemWriter	A simple `ItemWriter` that can send mail messages.
SimpleMailMessageItemWriterBuilder	Creates a fully qualified SimpleMailMessageItemWriter.
SimpleMessageApplicationEvent
SimpleMethodInvoker	Simple implementation of the `MethodInvoker` interface that invokes a method on an object.
SimpleMetric	Simple implementation of the `Metric` interface as required by JSR-352.
SimplePartitioner	Simplest possible implementation of `Partitioner`.
SimpleRecordSeparatorPolicy	Simplest possible `RecordSeparatorPolicy` - treats all lines as record endings.
SimpleResourceSuffixCreator	Trivial implementation of `ResourceSuffixCreator` that uses the index itself as suffix, separated by dot.
SimpleRetryExceptionHandler	An `ExceptionHandler` that is aware of the retry context so that it can distinguish between a fatal exception and one that can be retried.
SimpleStepBuilder<I,O>	Step builder for simple item processing (chunk oriented) steps.
SimpleStepExecutionSplitter	Generic implementation of `StepExecutionSplitter` that delegates to a `Partitioner` to generate `ExecutionContext` instances.
SimpleStepFactoryBean<T,S>	Most common configuration options for simple steps should be found here.
SimpleStepHandler	Implementation of `StepHandler` that manages repository and restart concerns.
SimpleSystemProcessExitCodeMapper	Simple `SystemProcessExitCodeMapper` implementation that performs following mapping: 0 -> ExitStatus.FINISHED else -> ExitStatus.FAILED
SingleItemPeekableItemReader<T>	A `PeekableItemReader` that allows the user to peek one item ahead.
SingleItemPeekableItemReaderBuilder<T>	Creates a fully qualified SingleItemPeekeableItemReader.
SkipException	Base exception indicating that the skip has failed or caused a failure.
SkipLimitExceededException	Exception indicating that the skip limit for a particular `Step` has been exceeded.
SkipListener<T,S>	Interface for listener to skipped items.
SkipListenerAdapter<T,S>
SkipListenerFailedException	Special exception to indicate a failure in a skip listener.
SkipListenerSupport<T,S>	Basic no-op implementations of all `SkipListener` implementations.
SkipOverflowException
SkippableExceptionDuringProcessSample
SkippableExceptionDuringReadSample
SkippableExceptionDuringWriteSample
SkipPolicy	Policy for determining whether or not some processing should be skipped.
SkipPolicyFailedException	Special exception to indicate a failure in a skip policy.
SkipWrapper<T>	Wrapper for an item and its exception if it failed processing.
SleepingItemProcessor<I>
SleepingTasklet
SpELItemKeyMapper<K,V>	An implementation of `Converter` that uses SpEL to map a Value to a key
SpELMappingGemfireItemWriter<K,V>	A convenient `GemfireItemWriter` implementation that uses a `SpELItemKeyMapper`
SplitParser	Internal parser for the <split/> elements inside a job.
SplitState	A `State` implementation that splits a `Flow` into multiple parallel subflows.
SpringBatchTest	Annotation that can be specified on a test class that runs Spring Batch based tests.
SpringValidator<T>	Adapts the `Validator` interface to `Validator`.
SqlitePagingQueryProvider	SQLite implementation of a `PagingQueryProvider` using database specific features.
SqlPagingQueryProviderFactoryBean	Factory bean for `PagingQueryProvider` interface.
SqlPagingQueryUtils	Utility class that generates the actual SQL statements used by query providers.
SqlServerPagingQueryProvider	SQL Server implementation of a `PagingQueryProvider` using database specific features.
SqlWindowingPagingQueryProvider	Generic Paging Query Provider using standard SQL:2003 windowing functions.
StagingItemListener	Thread-safe database `ItemReader` implementing the process indicator pattern.
StagingItemProcessor<T>	Marks the input row as 'processed'.
StagingItemReader<T>	Thread-safe database `ItemReader` implementing the process indicator pattern.
StagingItemWriter<T>	Database `ItemWriter` implementing the process indicator pattern.
StandaloneStepParser	Internal parser for the <step/> elements for a job.
StartLimitExceededException	Indicates the step's start limit has been exceeded.
State
StateTransition	Value object representing a potential transition from one `State` to another.
StaxEventItemReader<T>	Item reader for reading XML input based on StAX.
StaxEventItemReaderBuilder<T>	A fluent builder for the `StaxEventItemReader`
StaxEventItemWriter<T>	An implementation of `ItemWriter` which uses StAX and `Marshaller` for serializing object to XML.
StaxEventItemWriterBuilder<T>	A builder for the `StaxEventItemWriter`.
StaxUtils	StAX utility methods.
StaxWriterCallback	Callback interface for writing to an XML file - useful e.g. for handling headers and footers.
Step	Batch domain interface representing the configuration of a step.
StepBuilder	Convenient entry point for building all kinds of steps.
StepBuilderException	Utility exception thrown by builders when they encounter unexpected checked exceptions.
StepBuilderFactory	Convenient factory for a `StepBuilder` which sets the `JobRepository` and `PlatformTransactionManager` automatically.
StepBuilderHelper<B extends StepBuilderHelper<B>>	A base class and utility for other step builders providing access to common properties like job repository and transaction manager.
StepBuilderHelper.CommonStepProperties
StepContext	A context object that can be used to interrogate the current `StepExecution` and some of its associated properties using expressions based on bean paths.
StepContextRepeatCallback	Convenient base class for clients who need to do something in a repeat callback inside a `Step`.
StepContribution	Represents a contribution to a `StepExecution`, buffering changes until they can be applied at a chunk boundary.
StepContributionSource	A source of `StepContribution` instances that can be aggregated and used to update an ongoing `StepExecution`.
StepExecution	Batch domain object representation the execution of a step.
StepExecutionAggregator	Strategy for a aggregating step executions, usually when they are the result of partitioned or remote execution.
StepExecutionApplicationEventAdvice	Wraps calls for methods taking `StepExecution` as an argument and publishes notifications in the form of `ApplicationEvent`.
StepExecutionDao
StepExecutionInterceptor	A `ChannelInterceptor` that adds the current `StepExecution` (if there is one) as a header to the message.
StepExecutionListener	Listener interface for the lifecycle of a `Step`.
StepExecutionListenerSupport
StepExecutionRequest	Class encapsulating information required to request a step execution in a remote partitioning setup.
StepExecutionRequestHandler	A `MessageEndpoint` that can handle a `StepExecutionRequest` and return a `StepExecution` as the result.
StepExecutionSimpleCompletionPolicy	A `CompletionPolicy` that picks up a commit interval from `JobParameters` by listening to the start of a step.
StepExecutionSplitter	Strategy interface for generating input contexts for a partitioned step execution independent from the fabric they are going to run on.
StepFactoryBean<I,O>	This `FactoryBean` is used by the JSR-352 namespace parser to create `Step` objects.
StepHandler	Strategy interface for handling a `Step` on behalf of a `Job`.
StepHolder	Interface for holders of a `Step` as a convenience for callers who need access to the underlying instance.
StepInterruptionPolicy	Strategy interface for an interruption policy.
StepListener	Marker interface that acts as a parent to all step domain listeners, such as: `StepExecutionListener`, `ChunkListener`, `ItemReadListener` and `ItemWriteListener`
StepListenerAdapter	Wrapper class to adapt the `StepListener` to a `StepExecutionListener`.
StepListenerFactoryBean	This `AbstractListenerFactoryBean` implementation is used to create a `StepListener`.
StepListenerFailedException	Exception to indicate a problem in a step listener.
StepListenerMetaData	Enumeration for `StepListener` meta data, which ties together the names of methods, their interfaces, annotation, and expected arguments.
StepListenerParser	Parser for a step listener element.
StepListenerSupport<T,S>	Basic no-op implementations of all `StepListener` interfaces.
StepLocator	Interface for locating a `Step` instance by name.
StepLocatorStepFactoryBean	Convenience factory for `Step` instances given a `StepLocator`.
StepParser	Parser for the <step /> element defined by JSR-352.
StepParserStepFactoryBean<I,O>	This `FactoryBean` is used by the batch namespace parser to create `Step` objects.
StepRegistry	Registry keeping track of all the `Step` defined in a `Job`.
StepRunner	Utility class for executing steps outside of a `Job`.
StepScope	Convenient annotation for step scoped beans that defaults the proxy mode, so that it doesn't have to be specified explicitly on every bean definition.
StepScope	Scope for step context.
StepScopeManager	Convenient aspect to wrap a single threaded step execution, where the implementation of the `Step` is not step scope aware (i.e. not the ones provided by the framework).
StepScopeTestExecutionListener	A `TestExecutionListener` that sets up step-scope context for dependency injection into unit tests.
StepScopeTestUtils	Utility class for creating and manipulating `StepScope` in unit tests.
StepState	`State` implementation that delegates to a `FlowExecutor` to execute the specified `Step`.
StepSynchronizationManager	Central convenience class for framework use in managing the step scope context.
StoppableTasklet	An extension to the `Tasklet` interface to allow users to add logic for stopping a tasklet.
StoredProcedureItemReader<T>	Item reader implementation that executes a stored procedure and then reads the returned cursor and continually retrieves the next row in the `ResultSet`.
StoredProcedureItemReaderBuilder<T>	A fluent builder API for the configuration of a `StoredProcedureItemReader`.
SuffixRecordSeparatorPolicy	A `RecordSeparatorPolicy` that looks for an exact match for a String at the end of a line (e.g. a semicolon).
SummaryFooterCallback	Writes summary info in the footer of a file.
SybasePagingQueryProvider	Sybase implementation of a `PagingQueryProvider` using database specific features.
SynchronizationManagerSupport<E,C>	Central convenience class for framework use in managing the scope context.
SynchronizedAttributeAccessor	An `AttributeAccessor` that synchronizes on a mutex (not this) before modifying or accessing the underlying attributes.
SynchronizedItemStreamReader<T>	This is a simple ItemStreamReader decorator with a synchronized ItemReader.read() method - which makes a non-thread-safe ItemReader thread-safe.
SynchronizedItemStreamReaderBuilder<T>	Creates a fully qualified SynchronizedItemStreamReader.
SystemCommandException	Exception indicating failed execution of system command.
SystemCommandTasklet	`Tasklet` that executes a system command.
SystemExiter	Interface for exiting the JVM.
SystemProcessExitCodeMapper	Maps the exit code of a system process to ExitStatus value returned by a system command.
SystemPropertyInitializer	Helper class that sets up a System property with a default value.
TaskExecutorPartitionHandler	A `PartitionHandler` that uses a `TaskExecutor` to execute the partitioned `Step` locally in multiple threads.
TaskExecutorRepeatTemplate	Provides `RepeatOperations` support including interceptors that can be used to modify or monitor the behaviour at run time. This implementation is sufficient to be used to configure transactional behaviour for each item by making the `RepeatCallback` transactional, or for the whole batch by making the execute method transactional (but only then if the task executor is synchronous). This class is thread-safe if its collaborators are thread-safe (interceptors, terminationPolicy, callback).
Tasklet	Strategy for processing in a step.
TaskletParser	Parse a tasklet element for a step.
TaskletStep	Simple implementation of executing the step as a call to a `Tasklet`, possibly repeated, and each call surrounded by a transaction.
TaskletStepBuilder	Builder for tasklet step based on a custom tasklet (not item oriented).
TestMailErrorHandler	This handler prints out failed messages with their exceptions.
TestMailSender
ThreadLocalClassloaderBeanPostProcessor	After the `BeanFactory` is created, this post processor will evaluate to see if any of the beans referenced from a job definition (as defined by JSR-352) point to class names instead of bean names.
ThreadStepInterruptionPolicy	Policy that checks the current thread to see if it has been interrupted.
ThrottleLimitResultQueue<T>	An implementation of the `ResultQueue` that throttles the number of expected results, limiting it to a maximum at any given time.
TimeoutTerminationPolicy	Termination policy that times out after a fixed period.
TopLevelFlowParser
TopLevelJobListenerParser	Parse <job-listener/> elements in the batch namespace.
TopLevelStepListenerParser	Parse <step-listener/> elements in the batch namespace.
TopLevelStepParser	Parser for the <step/> top level element in the Batch namespace.
Trade
TradeDao	Interface for writing a Trade object to an arbitrary output.
TradeFieldSetMapper
TradeProcessor	Processes the Trade - throwing validation errors if necessary.
TradeRowMapper
TradeValidator
TradeWriter	Delegates the actual writing to custom DAO delegate.
TransactionAwareBufferedWriter	Wrapper for a `FileChannel` that delays actually writing to or closing the buffer if a transaction is active.
TransactionAwareProxyFactory<T>	Factory for transaction aware objects (like lists, sets, maps).
UncheckedTransactionException	Convenience wrapper for a checked exception so that it can cause a rollback and be extracted afterwards.
UnclosedElementCollectingEventWriter	Delegating XMLEventWriter, which collects the QNames of elements that were opened but not closed.
UnexpectedInputException	Used to signal an unexpected end of an input or message stream.
UnexpectedJobExecutionException	Indicates to the framework that a critical error has occurred and processing should immediately stop.
UnopenedElementClosingEventWriter	Delegating XMLEventWriter, which writes EndElement events that match a given collection of QNames directly to the underlying java.io.Writer instead of to the delegate XMLEventWriter.
User
UserMailItemProcessor
ValidatingItemProcessor<T>	Simple implementation of `ItemProcessor` that validates input and returns it without modifications.
ValidationException	This exception should be thrown when there are validation errors.
ValidationSampleConfiguration
Validator<T>	Interface used to validate objects.
WorkerConfiguration	This configuration class is for the worker side of the remote chunking sample.
WorkerConfiguration	This configuration class is for the worker side of the remote partitioning sample.
WorkerConfiguration	This configuration class is for the worker side of the remote partitioning sample.
WriteFailedException	Unchecked exception indicating that an error has occurred while trying to clear a buffer on a rollback.
WriterNotOpenException	Exception indicating that an `ItemWriter` needed to be opened before being written to.
XStreamExecutionContextStringSerializer	已过时。 Due to the incompatibilities between current Jettison versions and XStream versions, this serializer is deprecated in favor of `Jackson2ExecutionContextStringSerializer`