All Classes and Interfaces
Class
Description
ApplicationContextFactory
implementation that takes a parent context and a path
to the context to create.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
.FactoryBean
implementation that builds a listener based on the various
lifecycle methods or annotations that are provided.Base
PartitionHandler
implementation providing common base features.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.Factory for the creation of
ApplicationContext
instances.A
JobFactory
that creates its own ApplicationContext
and pulls a bean
out when asked to create a Job
.Loads and unloads
Jobs
when the application context is created and
destroyed.Represents that an error has occurred in the configuration of the base batch
infrastructure (the creation of a
JobRepository
, for example).Observation context for batch jobs.
Observation created around a Job execution.
ObservationConvention
for BatchJobContext
.Central class for batch metrics.
Bean post processor that configures observable batch artifacts (jobs and steps) with
Micrometer's observation registry.
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.
ObservationConvention
for BatchStepContext
.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 a chunk is passed to an
ItemWriter
.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.
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
Chunk
s.Interface for providing
Chunk
s to be processed,
used by the ChunkOrientedTasklet
A convenient factory for creating a set of
ApplicationContextFactory
components
from a set of resources
.
Basic launcher for starting jobs from the command line.
Strategy interface for executing commands.
Composite
JobParametersValidator
that passes the job parameters through a
sequence of injected JobParametersValidator
sMaps 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.
RuntimeHintsRegistrar
for Spring Batch core module.This incrementer uses a
DataFieldMaxValueIncrementer
to generate the sequence
of values to use as job instance discriminator.Internal parser for the <decision/> elements inside a job.
State that requires a decider to make the status decision.
Base
Configuration
class that provides common JDBC-based infrastructure beans
for enabling and using Spring Batch.Default
BatchJobObservationConvention
implementation.Default
BatchStepObservationConvention
implementation.An implementation of the
ExecutionContextSerializer
that produces/consumes
Base64 content.Default 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 that uses a simple naming convention for
converting job parameters.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
.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.Checked exception that indicates a name clash when registering
Job
instances.
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.DAO interface for persisting and retrieving
ExecutionContext
s.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.
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.
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.
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.Fatal exception to be thrown when a rollback must be forced, typically after catching
an exception that otherwise would not cause a rollback.
ApplicationContextFactory
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.Internal parser for the <step/> elements inside a job.
Basic no-op implementation of the
ItemReadListener
,
ItemProcessListener
, and ItemWriteListener
interfaces.Listener interface for the processing of an item.
Listener interface around the reading of an item.
Listener interface for the writing of items.
Implementation that uses Jackson2 to provide (de)serialization.
JDBC DAO for
ExecutionContext
.JDBC implementation of
JobExecutionDao
.JDBC implementation of
JobInstanceDao
.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.Batch domain object representing a job.
Convenience for building jobs of various kinds.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated as of v5.0 and scheduled for removal in v5.2 in favor of using
the
JobBuilder
.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
JobExecutionListener
Checked 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 the executions of running or historical jobs and steps.
A
FactoryBean
that automates the creation of a SimpleJobExplorer
by
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.
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.
Convenient factory bean that creates a transactional proxy around a
JobOperator
.Domain representation of a parameter to a batch job.
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
.Exception to report an error when converting job parameters.
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
.Deprecated, for removal: This API element is subject to removal in a future version.
since 5.0 with no replacement.
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.
An exception indicating an illegal attempt to restart a job.
Convenient annotation for job-scoped beans that defaults the proxy mode, so that it
does not 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 step builder for
JobStep
instances.Central convenience class for framework use in managing the job scope context.
Converter for
JobParameters
instances that uses a JSON naming convention for
converting job parameters.Implementation of the
CommandRunner
interface that calls the standard
Runtime.exec(java.lang.String)
method.Implementation of the
SystemExiter
interface that calls the standards
System.exit method.Interface for defining keys to uniquely identify items.
SkipPolicy
that determines whether or not reading should continue based upon
how many items have been skipped.A listable extension of
JobLocator
.A common interface for listener meta data enumerations.
Simple, thread-safe, map-based implementation of
JobRegistry
.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.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.A
Tasklet
that wraps a method in a POJO.Implementation of
Partitioner
that locates multiple resources and associates
their file names with execution context keys.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.
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
.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.A
JobFactory
that keeps a reference to a Job
.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.This incrementer increments a "run.id" parameter of type
Long
from the given
job parameters.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
.Convenience factory for
SimpleFlow
instances for use in the 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
that uses the injected DAOs.Deprecated, for removal: This API element is subject to removal in a future version.
Since v5.0.0 for removal in v5.2.0.
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.Simplest possible implementation of
Partitioner
.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: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.
Internal parser for the <split/> elements inside a job.
Class that exposes the Spring Batch version.
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.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.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated as of v5.0 and scheduled for removal in v5.2 in favor of using
the
StepBuilder
.A base class and utility for other step builders providing access to common properties
like job repository and listeners.
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.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.
Listener interface for the lifecycle of a
Step
.Deprecated.
as of 5.0, in favor of the default methods on the
StepExecutionListener
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
ItemWriteListener
This
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.
Convenient annotation for step-scoped beans.
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.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.Central convenience class for framework use in managing the scope context.
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.
Implementation of the
JobLauncher
interface based on a TaskExecutor
.A
PartitionHandler
that uses a TaskExecutor
to execute the partitioned
Step
locally in multiple threads.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.
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.
Convenience wrapper for a checked exception so that it can cause a rollback and be
extracted afterwards.
Indicates to the framework that a critical error has occurred and processing should
immediately stop.
ChunkListener