All Classes and Interfaces
Class
Description
ApplicationContextFactory implementation that takes a parent context and a path to the context to create.Base
Configuration class providing common structure for enabling and using Spring Batch.
Abstract base class for any simple item reader that opens a database cursor and continually retrieves
the next row in the ResultSet.
Base class for item writers that write data to a file or stream.
Abstract Hibernate Query Provider to serve as a base class for all
Hibernate
Query providers.Abstract superclass for
ItemReaders that supports restart by storing
item count in the ExecutionContext (therefore requires item ordering
to be preserved between runs).Base class for
ItemReader implementations.Base class for
ItemWriter implementations.Encapsulates common functionality needed by JDBC batch metadata DAOs -
provides jdbcTemplate for subclasses and handles table prefixes.
Abstract implementation of the
Job interface.A
FactoryBean that automates the creation of a
SimpleJobExplorer.A
FactoryBean that automates the creation of a
SimpleJobRepository.
Abstract JPA Query Provider to serve as a base class for all JPA
Query providers.Abstract class handling common concerns of various
LineTokenizer
implementations such as dealing with names and actual construction of
FieldSetFactoryBean implementation that builds a listener based on the
various lifecycle methods or annotations that are provided.Superclass for delegating classes which dynamically call a custom method of
injected object.
A base class that handles basic reading logic based on the paginated
semantics of Spring Data's paginated facilities.
Abstract
ItemStreamReader for to extend when
reading database records in a paging fashion.Base
PartitionHandler implementation providing common base
features.Abstract SQL Paging Query Provider to serve as a base class for all provided
SQL paging query providers.
A
Step implementation that provides common behavior to subclasses, including registering and calling
listeners.Internal parser for the <step/> elements inside a job.
Base class for step builders that want to build a
TaskletStep.Marks a method to be called after a chunk is executed.
Expected signature: void afterChunk(ChunkContext context)
Expected signature: void afterChunk(ChunkContext context)
Marks a method to be called after a chunk has failed and been
marked for rollback.
Expected signature: void afterFailedChunk(ChunkContext context)
Expected signature: void afterFailedChunk(ChunkContext context)
Marks a method to be called after a
Job has completed.Marks a method to be called after an item is passed to an
ItemProcessor.Marks a method to be called after an item is read from an
Expected signature: void afterRead(T item)
ItemReader Expected signature: void afterRead(T item)
Marks a method to be called after a
Step has completed.Marks a method to be called after an item is passed to an
ItemWriter.Implementation of the
SkipPolicy interface that
will always return that an item should be skipped.
AMQP
ItemReader implementation using an AmqpTemplate to
receive and/or convert messages.A builder implementation for the
AmqpItemReader
AMQP
ItemWriter implementation using an AmqpTemplate to
send messages.A builder implementation for the
AmqpItemWriterMethodResolver implementation that finds a single Method on the
given Class that contains the specified annotation type.Factory for the creation of
ApplicationContexts.A
JobFactory that creates its own ApplicationContext and
pulls a bean out when asked to create a Job.A basic array mapper, returning the values backing a fieldset.
This class can be used to assert that two files are the same.
Exception indicating that a failure or early completion condition was
detected in a remote worker.
An
ItemProcessor that delegates to a nested processor and in the
background.Loads and unloads
Jobs when the application context is created and destroyed.An
ItemReader that deserializes data from a Resource containing serialized Avro objects.A builder implementation for the
AvroItemReader.An
ItemWriter that serializes data to an WritableResource using Avro.A builder implementation for the
AvroItemWriter.Represents an error has occurred in the configuration of base batch
infrastructure (creation of a
JobRepository
for example.Base
Configuration class providing common structure for enabling and using Spring Batch.Strategy interface for users to provide as a factory for custom components needed by a Batch system.
Base configuration class for Spring Batch Integration factory beans.
The namespace handler for the Spring Batch Integration namespace.
Observation context for batch jobs.
Observation.KeyValuesProvider for BatchJobContext.Observation created around a Job execution.
Central class for batch metrics.
A special purpose retry template that deals specifically with multi-valued
stateful retry.
ScopeSupport.
Helper class to scan a bean definition hierarchy and force the use of
auto-proxy for step scoped beans.
Enumeration representing the status of an execution.
Observation context for batch steps.
Observation created around a step execution.
Observation.KeyValuesProvider for BatchStepContext.ContextCustomizer implementation that adds batch test utility classes
(JobLauncherTestUtils and JobRepositoryTestUtils) as beans in
the test context.Factory for
BatchTestContextCustomizer.A
StepLocator implementation that just looks in its enclosing bean
factory for components of type Step.A convenient implementation for providing BeanPropertySqlParameterSource when the item has JavaBean properties
that correspond to names used for parameters in the SQL statement.
A
ValidatingItemProcessor that uses the Bean Validation API (JSR-303)
to validate items.This is a field extractor for a java bean.
FieldSetMapper implementation based on bean property paths.Marks a method to be called before a chunk is executed.
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.Marks a method to be called before an item is passed to an
Expected signature: void beforeProcess(T item)
ItemProcessor Expected signature: void beforeProcess(T item)
Marks a method to be called before an item is read from an
Expected signature: void beforeRead()
ItemReader Expected signature: void beforeRead()
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.Marks a method to be called before an item is passed to an
ItemWriter.A factory strategy for custom extensions of
BufferedReader allowing
customisation of the standard behaviour of the java.io variety.Encapsulation of a list of items to be processed and possibly a list of
failed items to be skipped.
Context object for weakly typed data stored for the duration of a chunk
(usually a group of items processed together in a transaction).
Internal parser for the <chunk/> element inside a step.
Interface for a remote worker in the Remote Chunking pattern.
Listener interface for the lifecycle of a chunk.
Deprecated.
Manage the offset data between the last successful commit and updates made to
an input chunk.
A
Tasklet implementing variations on read-process-write item
handling.Interface defined for processing
Chunks.A
ChunkHandler based on a ChunkProcessor.Interface for providing
Chunks to be processed, used by the
ChunkOrientedTaskletEncapsulation of a chunk of items to be processed remotely as part of a step
execution.
Encapsulates a response to processing a chunk of items, summarising the result as a
StepContribution.Mark a method as capable of classifying its input to an instance of its
output.
Calls one of a collection of ItemProcessors, based on a router
pattern implemented through the provided
Classifier.Creates a fully qualified
ClassifierCompositeItemProcessor.Calls one of a collection of ItemWriters for each item, based on a router
pattern implemented through the provided
Classifier.Creates a fully qualified ClassifierCompositeItemWriter.
A convenient factory for creating a set of
ApplicationContextFactory
components from a set of resources.Implementation of the
ItemPreparedStatementSetter interface that assumes all
keys are contained within a Map with the column name as the key.
Basic launcher for starting jobs from the command line.
Interface for batch completion policies, to enable batch operations to
strategise normal completion conditions.
Very simple base class for
CompletionPolicy implementations.Composite policy that loops through a list of delegate policies and answers
calls by a consensus.
Composite
ExceptionHandler that loops though a list of delegates.Composite
Note the user is responsible for injecting a chain of
ItemProcessor that passes the item through a sequence of
injected ItemTransformers (return value of previous
transformation is the entry value of the next).Note the user is responsible for injecting a chain of
ItemProcessors
that conforms to declared input and output types.Creates a fully qualified
CompositeItemProcessorBuilder.Simple
ItemStream that delegates to a list of other streams.Calls a collection of
The implementation is thread-safe if all delegates are thread-safe.
ItemWriters in fixed-order sequence.The implementation is thread-safe if all delegates are thread-safe.
Creates a fully qualified CompositeItemWriter.
Composite
JobParametersValidator that passes the job parameters through a sequence of
injected JobParametersValidatorsAllows a user to register one or more RepeatListeners to be notified on batch events.
Maps exit codes to
ExitStatus
according to injected map.Post-process jobs and steps defined using the batch namespace to inject
dependencies.
Utility methods used in parsing of the batch core namespace
Abstract base class for policies that need to count the number of occurrences
of some event (e.g.
Enum representing a database type, such as DB2 or oracle.
Factory for creating
DataFieldMaxValueIncrementer implementations
based upon a provided string.This incrementer uses a
DataFieldMaxValueIncrementer to generate
the sequence of values to use as job instance discriminator.Wrapper for a
DataSource that can run scripts on start up and shut
down.DB2 implementation of a
PagingQueryProvider using
database specific features.Internal parser for the <decision/> elements inside a job.
State that requires a decider to make the status decision.
Default implementation of the
BatchConfigurer.Default
BatchJobKeyValuesProvider implementation.Default
BatchStepTagsProvider implementation.Default implementation of the
DataFieldMaxValueIncrementerFactory
interface.Default implementation of
ExceptionHandler - just re-throws the exception it encounters.An implementation of the
ExecutionContextSerializer using the default
serialization implementations from Spring (DefaultSerializer and
DefaultDeserializer).Default implementation of
FieldSet using Java using Java primitive
and standard types and utilities.Default implementation of
FieldSetFactory with no special knowledge
of the FieldSet required.Default implementation of
FragmentEventReaderDefault implementation of the
ItemListenerSupport class that
writes all exceptions via commons logging.Default implementation of the
JobKeyGenerator interface.Default implementation of
JobLoader.Converter for
JobParameters instances using a simple naming
convention for property keys.Simple implementation of
JobParametersExtractor which pulls
parameters with named keys out of the step execution context and the job
parameters of the surrounding job.Default implementation of
JobParametersValidator.Two-phase
LineMapper implementation consisting of tokenization of the line into FieldSet followed by
mapping to item.This
MailErrorHandler implementation simply rethrows the exception it
receives.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).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.Very simple
CompletionPolicy that bases its decision on the result of
a batch operation.Sorts by decreasing specificity of pattern, based on just counting
wildcards (with * taking precedence over ?).
Convenience class for aggregating a set of
StepExecution instances
into a single result.Provides a wrapper for an existing
Step, delegating execution to it,
but serving all other operations locally.A
LineAggregator implementation that converts an object into a
delimited list of strings.A
LineTokenizer implementation that splits the input String on a
configurable delimiter.Derby implementation of a
PagingQueryProvider using standard SQL:2003 windowing functions.A
Poller that uses the callers thread to poll for a result as soon as
it is asked for.Checked exception that indicates a name clash when registering
Job instances.Indicates an error has been encountered while trying to dynamically invoke a
method e.g.
Enable Spring Batch Integration features and provide a base configuration for
setting up remote chunking or partitioning infrastructure beans.
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.State implementation for ending a job if it is in progress and
continuing if just starting.Batch Domain Entity class.
A
SkipPolicy that depends on an exception classifier to make its
decision, and then delegates to the classifier result.Handler to allow strategies for re-throwing exceptions.
Object representing a context for an
ItemStream.DAO interface for persisting and retrieving
ExecutionContexts.This class can be used to automatically promote items from the
Step
ExecutionContext to the Job ExecutionContext at the
end of a step.A composite interface that combines both serialization and deserialization
of an execution context into a single implementation.
Convenience class for accessing
ExecutionContext values from job and
step executions.Facilitates assigning names to objects persisting data in
ExecutionContext and generating keys for
ExecutionContext based on the name.This interface should be implemented when an environment calling the batch
framework has specific requirements regarding the operating system process
return status.
Value object used to carry information about the status of a
job or step execution.
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.An abstract
LineAggregator implementation that utilizes a
FieldExtractor to convert the incoming object to an array of its
parts.FaultTolerant implementation of the
ChunkProcessor interface, that
allows for skipping or retry of items that cause exceptions during writing.FaultTolerant implementation of the
ChunkProvider interface, that
allows for skipping or retry of items that cause exceptions during reading or
processing.A step builder for fully fault tolerant chunk-oriented item processing steps.
Factory bean for step that provides options for configuring skip behavior.
This class will convert an object to an array of its parts.
Interface used by flat file input sources to encapsulate concerns of
converting an array of Strings to Java native types.
Factory interface for creating
FieldSet instances.Interface that is used to map data obtained from a
FieldSet into an
object.Utility methods for files used in batch processing.
Tokenizer used to process data obtained from files with fixed-length format.
Callback interface for writing a footer to a file.
Exception indicating that some type of error has occurred while
attempting to parse a line of input into tokens.
Callback interface for writing a header to a file.
Restartable
ItemReader that reads lines from input FlatFileItemReader.setResource(Resource).A builder implementation for the
FlatFileItemReader.A builder for constructing a
DelimitedLineTokenizerA builder for constructing a
FixedLengthTokenizerThis class is an item writer that writes data to a file or stream.
A builder implementation for the
FlatFileItemWriterA builder for constructing a
DelimitedLineAggregatorA builder for constructing a
FormatterLineAggregator.Exception thrown when errors are encountered
parsing flat files.
A builder for a flow of steps that can be executed as a job or as part of a job.
A builder for building a split state.
A builder for transitions within a flow.
A builder for continuing a flow from a decision state.
Internal parser for the <flow/> elements inside a job.
Strategy interface for aggregating
FlowExecution instances into a
single exit status.Represents the status of
FlowExecution.Context and execution strategy for
FlowJob to allow it to delegate
its execution step by step.Convenient interface for components that contain nested flows.
Implementation of the
Job interface that allows for complex flows of
steps, rather than requiring sequential execution.A job builder for
FlowJob instances.State that delegates to a Flow
A step builder for
FlowStep instances.Unchecked exception indicating that an error has occurred while trying to flush a buffer.
Fatal exception to be thrown when a rollback must be forced, typically after
catching an exception that otherwise would not cause a rollback.
A
LineAggregator implementation which produces a String by
aggregating the provided item via the Formatter syntax.Interface for event readers which support treating XML fragments as standalone XML documents
by wrapping the fragments with StartDocument and EndDocument events.
An
ItemProcessor implementation that delegates to a FunctionAn
ItemWriter that stores items in GemFireA builder implementation for the
GemfireItemWriterApplicationContextFactory implementation that takes a parent context and a path to the context to create.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.A json object marshaller that uses Google Gson
to marshal an object into a json representation.
Implementation of
JsonObjectReader based on
Google Gson.H2 implementation of a
PagingQueryProvider using database specific features.SAP HANA implementation of a
PagingQueryProvider using database specific features.ItemStreamReader for reading database records built on top of Hibernate.This is a builder for the
HibernateCursorItemReader.Internal shared state helper for hibernate readers managing sessions and
queries.
ItemWriter that uses a Hibernate session to save or update entities
that are not part of the current Hibernate session.A builder for the
HibernateItemWriter
This query provider creates Hibernate
Querys from injected native SQL
queries.ItemReader for reading database records built on top of Hibernate and
reading only up to a fixed number of items at a time.A builder for the
HibernatePagingItemReader.
Interface defining the functionality to be provided for generating queries
for use with Hibernate
ItemReaders or other custom built artifacts.A
MethodInvoker that is a bit relaxed about its arguments.HSQLDB implementation of a
PagingQueryProvider using database specific features.Exception indicating that the line size expected is different from what
is expected.
Exception indicating that an incorrect number of tokens have been found
while parsing a file.
Internal parser for the <step/> elements inside a job.
Marker interface indicating that an item should have the item count set on it.
Basic no-op implementation of the
ItemReadListener,
ItemProcessListener, and ItemWriteListener interfaces.A convenient strategy for SQL updates, acting effectively as the inverse of
RowMapper.Listener interface for the processing of an item.
Interface for item transformation.
Invokes a custom method on a delegate plain old Java object which itself
processes an item.
Strategy interface for providing the data.
Invokes a custom method on a delegate plain old Java object which itself
provides an item.
A base exception class that all exceptions thrown from an
ItemReader extend.Listener interface around the reading of an item.
A convenient strategy for providing SqlParameterSource for named parameter SQL updates.
Marker interface defining a contract for periodically storing state and restoring from that state should an error
occur.
Exception representing any errors encountered while processing a stream.
Convenience interface that combines
ItemStream and ItemReader
.Empty method implementation of
ItemStream.Convenience interface that combines
ItemStream and ItemWriter
.
Listener interface for the writing of items.
Basic interface for generic output operations.
Delegates item processing to a custom method -
passes the item as an argument for the delegate method.
A base exception class that all exceptions thrown from an
ItemWriter extend.Implementation that uses Jackson2 to provide (de)serialization.
A json object marshaller that uses Jackson
to marshal an object into a json representation.
Implementation of
JsonObjectReader based on
Jackson.ItemWriter that uses the batching features from
NamedParameterJdbcTemplate to execute a batch of statements for all items
provided.A builder implementation for the
JdbcBatchItemWriter.
Simple item reader implementation that opens a JDBC cursor and continually retrieves the
next row in the ResultSet.
Builder for the
JdbcCursorItemReaderJDBC DAO for
ExecutionContext.JDBC implementation of
JobExecutionDao.JDBC implementation of
JobInstanceDao.ItemReader for reading database
records using JDBC in a paging fashion.This is a builder for the
JdbcPagingItemReader.Helper methods for SQL statement parameter parsing.
JDBC implementation of
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
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.An
ItemReader for JMS using a JmsTemplate.Creates a fully qualified JmsItemReader.
An
ItemWriter for JMS using a JmsTemplate.Creates a fully qualified JmsItemWriter.
A
MethodArgumentsKeyGenerator for JMSA
NewMethodArgumentsIdentifier for JMS that looks for a message in
the arguments and checks its delivery status.Batch domain object representing a job.
Convenience for building jobs of various kinds.
Convenient factory for a
JobBuilder which sets the JobRepository automatically.A base class and utility for other job builders providing access to common properties like job repository.
A context object that can be used to interrogate the current
JobExecution and some of its associated
properties using expressions
based on bean paths.Batch domain object representing the execution of a job.
Data Access Object for job executions.
Interface allowing for programmatic access to the decision on what the status
of a flow should be.
Root of exception hierarchy for checked exceptions in job and step execution.
Provide callbacks at specific points in the lifecycle of a
Job.Parser for a step listener element.
Deprecated.
as of 5.0, in favor of the default methods on the
JobExecutionListenerChecked exception to indicate that user asked for a job execution to be
resumed when actually it didn't fail.
Checked exception indicating that a JobExecution that is not currently running has
been requested to stop.
Checked exception to indicate that user asked for a job execution to be
aborted when hasn't been stopped.
Entry point for browsing executions of running or historical jobs and steps.
A
FactoryBean that automates the creation of a
SimpleJobExplorer using JDBC DAO implementations.Strategy for creating a single job.
Generic service that can bind and unbind a
JobFactory in a
JobRegistry.Implementation of
FlowExecutor for use in components that need to
execute a flow related to a JobExecution.Batch domain object representing a uniquely identifiable job run.
An exception indicating an illegal attempt to restart a job that was already
completed successfully.
Checked exception to indicate that a required
Job is not
available.Data Access Object for job instances.
Exception to indicate the job has been interrupted.
Strategy interface for the generation of the key used in identifying
unique
JobInstance objects.Simple interface for controlling jobs, including possible ad-hoc executions,
based on different runtime identifiers.
Utility class for testing batch jobs.
The
JobLaunchingGateway is used to launch Batch Jobs.The parser for the Job-Launching Gateway, which will instantiate a
JobLaunchingGatewayParser.Message handler which uses strategies to convert a Message into a job and a set of job parameters
Encapsulation of a
Job and its JobParameters forming a request for a job to be launched.Interface for handling a
JobLaunchRequest and returning a JobExecution.This
AbstractListenerFactoryBean implementation is used to create a
JobExecutionListener.Enumeration for
JobExecutionListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.A runtime service locator interface for retrieving job configurations by
name.Low level interface for inspecting and controlling jobs with access only to
primitive and collection types.
Domain representation of a parameter to a batch job.
Enumeration representing the type of
JobParameter.This class can be used to automatically copy items from the
JobParameters to the Step ExecutionContext.Value object representing runtime parameters to a batch job.
Helper class for creating
JobParameters.A factory for
JobParameters instances.Strategy interface for translating a
StepExecution into
JobParameters.Interface for obtaining the next
JobParameters object in a sequence.Exception for
Job to signal that some JobParameters are
invalid.Checked exception to indicate that a required
JobParametersIncrementer is not
available.Strategy interface for a
Job to use in validating its parameters for
an execution.Parser for the <job/> element in the Batch namespace.
This
FactoryBean is used by the batch namespace parser to create
FlowJob objects.A runtime service registry interface for registering job configurations by
name.
Command line launcher for registering jobs with a
JobRegistry.
Repository responsible for persistence of batch meta-data entities.
A
FactoryBean that automates the creation of a
SimpleJobRepository using JDBC DAO implementations which persist
batch metadata in database.Parser for the <job-repository/> element in the Batch namespace.
Convenience class for creating and removing
JobExecution instances
from a database.An exception indicating an illegal attempt to restart a job.
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.
Scope for job context.
Convenient aspect to wrap a single threaded job execution, where the
implementation of the
Job is not job scope aware (i.e.A
TestExecutionListener that sets up job-scope context for
dependency injection into unit tests.Utility class for creating and manipulating
JobScope in unit tests.A step builder for
JobStep instances.Central convenience class for framework use in managing the job scope
context.
ItemStreamReader implementation based
on JPA Query.getResultStream().Builder for
JpaCursorItemReader.ItemWriter that is using a JPA
EntityManagerFactory to merge any Entities that aren't part of the
persistence context.A builder for the
JpaItemWriter.
This query provider creates JPA named
Querys.
This query provider creates JPA
Querys from injected native SQL
queries.ItemReader for reading database
records built on top of JPA.Creates a fully qualified JpaPagingItemReader.
Interface defining the functionality to be provided for generating queries
for use with JPA
ItemReaders or other custom built artifacts.Item writer that writes data in json format to an output file.
Builder for
JsonFileItemWriter.ItemStreamReader implementation that reads Json objects from a
Resource having the following format:A builder for
JsonItemReader.Interpret a line as a JSON object and parse it up to a Map.
Strategy interface to marshal an object into a json representation.
Strategy interface for Json readers.
JSON-based record separator.
Implementation of the
SystemExiter interface that calls the standards
System.exit method.
An
ItemReader implementation for Apache Kafka.A builder implementation for the
KafkaItemReader.
An
ItemWriter implementation for Apache Kafka using a
KafkaTemplate with default topic configured.A builder implementation for the
KafkaItemWriterInterface for defining keys to uniquely identify items.
A base class to implement any
ItemWriter that writes to a key value store
using a Converter to derive a key from an itemComparator to sort resources by the file last modified time.
Creates a fully qualified LdifReader.
SkipPolicy that determines whether or not reading should continue
based upon how many items have been skipped.Interface used to create string representing object.
Callback interface for handling a line from file.
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.
Interface that is used by framework to split string obtained typically from a
file into tokens.
A listable extension of
JobLocator.A common interface for listener meta data enumerations.
An
ItemReader that pulls data from a list.Implementation of
ExceptionHandler based on an Classifier.Logging levels for the handler.
This class is used to handle errors that occur when email messages are unable
to be sent.
Simple, thread-safe, map-based implementation of
JobRegistry.Creates a fully qualified MappingLdifReader.
Simple map-based implementation of
StepRegistry.Implementation of the
FlowExecutionAggregator interface that aggregates
FlowExecutionStatus', using the status with the high precedence as the
aggregate status.A
PartitionHandler that uses MessageChannel instances to send instructions to remote workers and
receive their responses.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.A strategy interface for invoking a method.
MethodInterceptor that, given a map of method names and
MethodInvokers, will execute all methods tied to a particular method
name, with the provided arguments.Utility methods for create MethodInvoker instances.
A
Tasklet that wraps a method in a POJO.Strategy interface for detecting a single Method on a Class.
A simple
ItemWriter that can send mail messages.Base
Configuration class providing common structure for enabling and using Spring Batch.
Restartable
ItemReader that reads documents from MongoDB
via a paging technique.A builder implementation for the
MongoItemReader
A
ItemWriter implementation that writes to a MongoDB store using an implementation of Spring Data's
MongoOperations.A builder implementation for the
MongoItemWriterReads items from multiple resources sequentially - resource list is given by
MultiResourceItemReader.setResources(Resource[]), the
actual reading is delegated to MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream).A builder implementation for the
MultiResourceItemReader.Wraps a
ResourceAwareItemWriterItemStream and creates a new output
resource when the count of items written in current resource exceeds
MultiResourceItemWriter.setItemCountLimitPerResource(int).A builder implementation for the
MultiResourceItemWriter.Implementation of
Partitioner that locates multiple resources and
associates their file names with execution context keys.MySQL implementation of a
PagingQueryProvider using database specific features.Deprecated.
since 5.0 in favor of the item reader from
https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Deprecated.
since 5.0 in favor of the item reader builder from
https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Deprecated.
since 5.0 in favor of the item writer from
https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Deprecated.
since 5.0 in favor of the item writer builder from
https://github.com/spring-projects/spring-batch-extensions/blob/main/spring-batch-neo4j
Callback that delegates to another callback, via a
RepeatOperations
instance.SkipPolicy implementation that always returns false,
indicating that an item should not be skipped.Fatal exception to be thrown when a process operation could not be skipped.
Fatal exception to be thrown when a read operation could not be skipped.
Fatal exception to be thrown when a process operation could not be skipped.
Exception thrown when errors are encountered with the underlying resource.
Exception indicating that an error has been encountered doing I/O from a
reader, and the exception should be considered fatal.
Delegating XMLEventWriter, which ignores start and end document events,
but passes through everything else.
Checked exception to indicate that a required
Job is not
available.Checked exception to indicate that a required
JobExecution is not
available.Exception that signals that the user requested an operation on a non-existent
JobInstance.This exception identifies that a batch domain object is invalid, which
is generally caused by an invalid ID.
Exception to signal that a step was requested that is unknown or does not
exist.
Fails the step if no items have been processed ( item count is 0).
Marks a method to be called if an exception is thrown by an
ItemProcessor.Marks a method to be called if an exception is thrown by an
ItemReader.Marks a method to be called when an item is skipped due to an exception
thrown in the
Expected signature: void onSkipInProcess(T item,
ItemProcessor.Expected signature: void onSkipInProcess(T item,
Throwable t)Marks a method to be called when an item is skipped due to an exception
thrown in the
ItemReader.Marks a method to be called when an item is skipped due to an exception
thrown in the
Expected signature: void onSkipInWrite(S item,
ItemWriter.Expected signature: void onSkipInWrite(S item,
Throwable t)Marks a method to be called if an exception is thrown by an
ItemWriter.Oracle implementation of a
PagingQueryProvider using
database specific features.The direction of the sort in an ORDER BY clause.
Interface defining the functionality to be provided for generating paging queries for use with Paging
Item Readers.
Exception indicating that an error has been encountered parsing IO, typically from a file.
Central strategy interface for creating input parameters for a partitioned
step in the form of
ExecutionContext instances.Interface defining the responsibilities of controlling the execution of a
partitioned
StepExecution.
Optional interface for
Partitioner implementations that need to use a
custom naming scheme for partitions.Implementation of
Step which partitions the execution and spreads the
load using a PartitionHandler.Step builder for
PartitionStep instances.FieldExtractor that just returns the original item.Pass through
FieldSetMapper useful for passing a FieldSet
back directly rather than a mapped object.Simple
ItemProcessor that does nothing - simply passes its argument
through to the caller.A
LineAggregator implementation that simply calls
Object.toString() on the given objectPass through
LineMapper useful for passing the original
String back directly rather than a mapped object.
A
LineMapper implementation that stores a mapping of String patterns
to delegate LineTokenizers as well as a mapping of String patterns to
delegate FieldSetMappers.A
LineTokenizer implementation that stores a mapping of String
patterns to delegate LineTokenizers.
A specialisation of
ItemReader that allows the user to look ahead
into the stream of items.Interface for polling a
Callable instance provided by the user.Postgres implementation of a
PagingQueryProvider using database specific features.Utility to convert a Properties object to a String and back.
Delegates processing to a custom method - extracts property values from item
object and uses them as arguments for the delegate method.
A class to represent ranges.
Property editor implementation which parses string and creates array of
ranges.
Exception indicating that an
ItemReader needed to be opened before read.This interface can be used to operate on skipped records during open in the
LdifReader and the
MappingLdifReader.This is a
FieldSetMapper that supports Java records mapping
(requires JKD 14 or higher).This interface should be implemented to map
LdapAttributes objects to POJOs.Policy for text file-based input sources to determine the end of a record,
e.g.
An implementation of
LineAggregator that concatenates a collection of
items of a common type with the system line separator.A
JobFactory that just keeps a reference to a Job.Provides reflection based utilities for Spring Batch that are not available
via Spring Core
Line-tokenizer using a regular expression to filter out data (by using matching and non-matching groups).
Convenient factory bean for a chunk handler that also converts an existing chunk-oriented step into a remote chunk
manager.
Parser for the remote-chunking-manager namespace element.
Builder for a manager step in a remote chunking setup.
Convenient factory for a
RemoteChunkingManagerStepBuilder which sets
the JobRepository and PlatformTransactionManager automatically.Builder for a worker in a remote chunking setup.
Parser for the remote-chunking-worker namespace element.
Builder for a manager step in a remote partitioning setup.
Convenient factory for a
RemotePartitioningManagerStepBuilder which sets
the JobRepository, JobExplorer, BeanFactory and
PlatformTransactionManager automatically.Builder for a worker step in a remote partitioning setup.
Convenient factory for a
RemotePartitioningWorkerStepBuilder which sets
the JobRepository, JobExplorer, BeanFactory and
PlatformTransactionManager automatically.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.Callback interface for batch operations.
Base interface for context which controls the state and completion /
termination of a batch step.
Helper class for policies that need to count the number of occurrences of
some event (e.g.
Internal interface for extensions of
RepeatTemplate.Interface for listeners to the batch process.
Deprecated.
as of v5.0 in favor of the default methods in
RepeatListener.The main interface providing access to batch operations.
A
MethodInterceptor that can be used to automatically repeat calls to
a method on a service.Global variable support for repeat clients.
Simple implementation and base class for batch templates implementing
RepeatOperations.
A
ItemReader that reads records utilizing
a PagingAndSortingRepository.A builder implementation for the
RepositoryItemReader.Establishes a proxy that will capture a the Repository and the associated
methodName that will be used by the reader.
A
ItemWriter wrapper for a
CrudRepository from Spring Data.A builder implementation for the
RepositoryItemWriter.Establishes a proxy that will capture a the Repository and the associated
methodName that will be used by the writer.
Marker interface indicating that an item should have the Spring
Resource in which it was read from, set on it.ItemReader which produces Resource instances from an array.Strategy interface for translating resource index into unique filename
suffix.
An implementation of the
ResultQueue that throttles the number of
expected results, limiting it to a maximum at any given time.Implementation of
ExceptionHandler that rethrows when exceptions of a
given type reach a threshold.This incrementer increments a "run.id" parameter of type
Long
from the given job parameters.ItemProcessor implementation that passes the current
item to process to the provided script.Creates a fully qualified ScriptItemProcessor.
Base
Configuration class providing common structure for enabling and using Spring Batch.A
BufferedReaderFactory useful for reading simple binary (or text)
files with no line endings, such as those produced by mainframe copy books.Simple implementation of the
ChunkProcessor interface that handles
basic item writing and processing.Simple implementation of the ChunkProvider interface that does basic chunk
providing from an
ItemReader.Policy for terminating a batch after a fixed number of operations.
Convenience factory for SimpleFlow instances for use in XML namespace.
A State that proxies a delegate and changes its name but leaves its
behavior unchanged.
Simple implementation of
Job interface providing the ability to run a
JobExecution.Implementation of
JobExplorer using the injected DAOs.Simple implementation of the
JobLauncher interface.Simple implementation of the JobOperator interface.
Implementation of
JobRepository that stores job instances,
job executions, and step executions using the injected DAOs.An implementation of
ExitCodeMapper that can be configured through a
map from batch exit codes (String) to integer results.Simple implementation of exception handler which looks for given exception
types.
A simple
ItemWriter that can send mail messages.Creates a fully qualified SimpleMailMessageItemWriter.
Simple implementation of the
MethodInvoker interface that invokes a
method on an object.Simplest possible implementation of
Partitioner.Simplest possible
RecordSeparatorPolicy - treats all lines as record
endings.Trivial implementation of
ResourceSuffixCreator that uses the index
itself as suffix, separated by dot.An
ExceptionHandler that is aware of the retry context so that it can
distinguish between a fatal exception and one that can be retried.Step builder for simple item processing (chunk oriented) steps.
Generic implementation of
StepExecutionSplitter that delegates to a
Partitioner to generate ExecutionContext instances.Most common configuration options for simple steps should be found here.
Implementation of
StepHandler that manages repository and restart
concerns.Simple
SystemProcessExitCodeMapper implementation that performs following mapping:
0 -> ExitStatus.FINISHED
else -> ExitStatus.FAILED
A
PeekableItemReader that allows the user to peek one item ahead.Creates a fully qualified SingleItemPeekeableItemReader.
Base exception indicating that the skip has failed or caused a failure.
Exception indicating that the skip limit for a particular
Step has
been exceeded.Interface for listener to skipped items.
Special exception to indicate a failure in a skip listener.
Deprecated.
as of v5.0 in favor of the default methods in
SkipListener.Policy for determining whether or not some processing should be skipped.
Special exception to indicate a failure in a skip policy.
Wrapper for an item and its exception if it failed processing.
An implementation of
Converter that uses SpEL to map a Value to a keyA convenient
GemfireItemWriter implementation that uses a SpELItemKeyMapperInternal parser for the <split/> elements inside a job.
Annotation that can be specified on a test class that runs Spring Batch based tests.
Adapts the
Validator interface to
Validator.SQLite implementation of a
PagingQueryProvider using database specific
features.Factory bean for
PagingQueryProvider interface.Utility class that generates the actual SQL statements used by query
providers.
SQL Server implementation of a
PagingQueryProvider using
database specific features.Incrementer for SQL Server sequences.
Generic Paging Query Provider using standard SQL:2003 windowing functions.
Internal parser for the <step/> elements for a job.
Indicates the step's start limit has been exceeded.
Value object representing a potential transition from one
State to
another.Item reader for reading XML input based on StAX.
A fluent builder for the
StaxEventItemReaderAn implementation of
ItemWriter which uses StAX and
Marshaller for serializing object to XML.A builder for the
StaxEventItemWriter.Callback interface for writing to an XML file - useful e.g.
Batch domain interface representing the configuration of a step.
Convenient entry point for building all kinds of steps.
Utility exception thrown by builders when they encounter unexpected checked exceptions.
Convenient factory for a
StepBuilder which sets the JobRepository and
PlatformTransactionManager automatically.A base class and utility for other step builders providing access to common properties like job repository and
transaction manager.
A context object that can be used to interrogate the current
StepExecution and some of its associated properties using expressions
based on bean paths.Convenient base class for clients who need to do something in a repeat
callback inside a
Step.Represents a contribution to a
StepExecution, buffering changes until
they can be applied at a chunk boundary.A source of
StepContribution instances that can be aggregated and used to update an ongoing
StepExecution.Batch domain object representation for the execution of a step.
Strategy for a aggregating step executions, usually when they are the result
of partitioned or remote execution.
A
ChannelInterceptor that adds the current StepExecution (if
there is one) as a header to the message.Listener interface for the lifecycle of a
Step.Deprecated.
as of 5.0, in favor of the default methods on the
StepExecutionListenerClass encapsulating information required to request a step execution in
a remote partitioning setup.
A
CompletionPolicy that picks up a commit interval from
JobParameters by listening to the start of a step.Strategy interface for generating input contexts for a partitioned step
execution independent from the fabric they are going to run on.
Interface for holders of a
Step as a convenience for callers who need
access to the underlying instance.Strategy interface for an interruption policy.
Marker interface that acts as a parent to all step
domain listeners, such as:
StepExecutionListener,
ChunkListener, ItemReadListener, and
ItemWriteListenerThis
AbstractListenerFactoryBean implementation is used to create a
StepListener.Exception to indicate a problem in a step listener.
Enumeration for
StepListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.Parser for a step listener element.
Basic no-op implementations of all
StepListener interfaces.Interface for locating a
Step instance by name.Convenience factory for
Step instances given a StepLocator.This
FactoryBean is used by the batch namespace parser to create Step objects.Utility class for executing steps outside of a
Job.
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.
Scope for step context.
Convenient aspect to wrap a single threaded step execution, where the
implementation of the
Step is not step scope aware (i.e.A
TestExecutionListener that sets up step-scope context for
dependency injection into unit tests.Utility class for creating and manipulating
StepScope in unit tests.Central convenience class for framework use in managing the step scope
context.
An extension to the
Tasklet interface to allow users to
add logic for stopping a tasklet.
Item reader implementation that executes a stored procedure and then reads the returned cursor
and continually retrieves the next row in the
ResultSet.A fluent builder API for the configuration of a
StoredProcedureItemReader.A
RecordSeparatorPolicy that looks for an exact match for a String at
the end of a line (e.g.Sybase implementation of a
PagingQueryProvider using
database specific features.Central convenience class for framework use in managing the scope
context.
An
AttributeAccessor that synchronizes on a mutex (not this) before
modifying or accessing the underlying attributes.This is a simple ItemStreamReader decorator with a synchronized ItemReader.read()
method - which makes a non-thread-safe ItemReader thread-safe.
Creates a fully qualified SynchronizedItemStreamReader.
An
ItemStreamWriter decorator with a synchronized
write() method.Creates a fully qualified
SynchronizedItemStreamWriter.Exception indicating failed execution of system command.
Tasklet that executes a system command.Interface for exiting the JVM.
Maps the exit code of a system process to ExitStatus value
returned by a system command.
Helper class that sets up a System property with a default value.
A
PartitionHandler that uses a TaskExecutor to execute the
partitioned Step locally in multiple threads.Provides
This implementation is sufficient to be used to configure transactional behaviour for each item by making the
This class is thread-safe if its collaborators are thread-safe (interceptors, terminationPolicy, callback).
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).
Strategy for processing in a step.
Parse a tasklet element for a step.
Simple implementation of executing the step as a call to a
Tasklet,
possibly repeated, and each call surrounded by a transaction.Builder for tasklet step based on a custom tasklet (not item oriented).
Policy that checks the current thread to see if it has been interrupted.
An implementation of the
ResultQueue that throttles the number of
expected results, limiting it to a maximum at any given time.Termination policy that times out after a fixed period.
Parse <job-listener/> elements in the batch namespace.
Parse <step-listener/> elements in the batch namespace.
Parser for the <step/> top level element in the Batch namespace.
Wrapper for a
FileChannel that delays actually writing to or closing the
buffer if a transaction is active.
Factory for transaction aware objects (like lists, sets, maps).
Convenience wrapper for a checked exception so that it can cause a
rollback and be extracted afterwards.
Delegating XMLEventWriter, which collects the QNames of elements that were opened but not closed.
Used to signal an unexpected end of an input or message stream.
Indicates to the framework that a critical error has occurred and processing
should immediately stop.
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.
Simple implementation of
ItemProcessor that validates input and
returns it without modifications.This exception should be thrown when there are validation errors.
Interface used to validate objects.
Unchecked exception indicating that an error has occurred while trying to
clear a buffer on a rollback.
Exception indicating that an
ItemWriter needed to be opened before being
written to.
ChunkListener