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
Chunks.Interface for providing
Chunks to be processed,
used by the ChunkOrientedTaskletA 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 JobParametersValidatorsMaps 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
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.
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
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 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 MethodInvokers,
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
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.
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