|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Job interface.FactoryBean that automates the creation of a
SimpleJobExplorer.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.Step implementation that provides common behavior to subclasses,
including registering and calling listeners.StepExecution and its ExecutionContext.
Date parameter for the given key.
ExitStatus.
JobParameter for the given key.
StepExecution for the parent JobExecution.
Ordered.
Job has completed.Ordered.
ItemProcessor ItemProcessor.process(Object) returns.
Ordered.
JobRepository.
JobRepository have been
set.
ItemReader ItemReader.read()
Ordered.
Step has completed.Ordered.
ItemWriter List<? extends S> items)ItemWriter.write(java.util.List) This will be
called before any transaction is committed, and before
ChunkListener.afterChunk()
Ordered.
FlowExecutionStatuses of the
FlowExecutions into one status.
StepExecution.
StepExecution
delegating to the delegate aggregator once the input has been refreshed
from the JobExplorer.
SkipPolicy interface that
will always return that an item should be skipped.ExitStatus with a logical combination of the exit
code, and a concatenation of the descriptions.
ApplicationContexts.JobFactory that creates its own ApplicationContext and
pulls a bean out when asked to create a Job.Jobs when the application context is created
and destroyed.Job is executed, which comes
after a JobExecution is created and persisted, but before the first
Step is executed.Ordered.
ItemProcessor ItemProcessor.process(Object).
Ordered.
ItemReader ItemReader.read()
Ordered.
Step is executed, which comes
after a StepExecution is created and persisted, but before the first
item is read.Ordered.
JobParameters to the Step
ExecutionContext, if not already present.
SimpleCompletionPolicy with a commit interval taken from
the JobParameters.
StepExecution for interrupt checks during
system command execution.
StepExecution from
the current scope.
ItemWriter List<? extends S> items)ItemWriter.write(java.util.List)
Ordered.
JobFactory provided and register it with the
JobRegistry.
Callable<RepeatStatus> to the Tasklet
interface.JobInterruptedException.
#remove(Exception)
method for dynamically removing an item and adding it to the skips.ChunkListenerTasklet implementing variations on read-process-write item
handling.Chunks.Chunks to be processed, used by the
ChunkOrientedTaskletApplicationContextFactory implementation that takes a parent context
and a path to the context to create.ApplicationContextFactory
components from a set of resources.AutomaticJobRegistrar insteadStepSynchronizationManager.register(StepExecution)
to ensure that StepSynchronizationManager.getContext() always returns the correct value.
FlowExecution instances by comparing their
statuses.
FlowExecutionStatus instances by comparing
their statuses.
JobParametersValidator that passes the job parameters through a sequence of
injected JobParametersValidatorsExitStatus
according to injected map.ChunkProcessor.
ChunkProvider.
ApplicationContext from the provided path.
BundleContext and the enclosing Spring
ApplicationContext as a parent context.
StateTransition specification.
StateTransition specification.
ApplicationContext from the factory provided and pull
out a bean with the name given during initialization.
JobExecution for a given Job and
JobParameters.
BeanDefinition for a target
wrapped in a placeholder tarrget source, able to defer binding of
placeholders until the bean is used.
StateTransition specification with a wildcard
pattern that matches all outcomes.
StateTransition specification from one State
to another (by name).
StepContribution.
JobExecution.
ItemListenerSupport class that
writes all exceptions via commons logging.JobLoader.JobParameters instances using a simple naming
convention for property keys.JobParametersExtractor which pulls
parameters with named keys out of the step execution context and the job
parameters of the surrounding job.JobParametersValidator.StepExecution instances
into a single result.Job instances that were regsistered by this
post processor.
PartitionHandler provided.
JobLauncher to
prevent duplicate executions.
StepContext lifecycle.
FlowJob.
JobRepositoryFactoryBean
.
Job instances.State implementation for ending a job if it is in progress and
continuing if just starting.SkipPolicy that depends on an exception classifier to make its
decision, and then delegates to the classifier result.AbstractJob.doExecute(JobExecution).
JobExecution and update the meta information like status
and statistics as necessary.
AbstractStep.open(ExecutionContext)), execution
logic (AbstractStep.doExecute(StepExecution)) and resource closing (
AbstractStep.close(ExecutionContext)).
StepExecution provided.
RepeatStatus.
ExitStatus by invoking a method in the delegate POJO.
ExitStatus using
SystemProcessExitCodeMapper.
ExecutionContexts.Step
ExecutionContext to the Job ExecutionContext at the
end of a step.ChunkProcessor interface, that
allows for skipping or retry of items that cause exceptions during writing.ChunkProcessor interface, that
allows for skipping or retry of items that cause exceptions during reading or
processing.JobExecution for given JobInstance, sorted
backwards by creation order (so the first element is the most recent).
FlowExecution instances into a
single exit status.FlowExecution.FlowJob to allow it to delegate
its execution step by step.Job interface that allows for complex flows of
steps, rather than requiring sequential execution.FlowJob with null name and no flow (invalid state).
FlowJob with provided name and no flow (invalid state).
XPath.Step implementation that delegates to a Flow.FlowStep that sets the flow and of the step
explicitly.
CommandLineJobRunner as it exits.
ExceptionHandler.
ExecutionContext for this execution.
ExecutionContext for this execution
JobExecutions associated with a particular
JobInstance, in reverse order of creation (and therefore usually
of execution).
ItemProcessor for subclasses to use
ItemReader for subclasses to use.
ItemWriter for subclasses to use
Job at runtime.
JobExecution by its id.
JobInstance values in descending order of creation (and
therefore usually of first execution).
JobInstances for a given job name, in
reverse order of creation (and therefore usually of first execution).
JobInstance names (sorted
alphabetically).
JobOperator.start(String, String).
JobParameters instance.
JobExecution.
JobRepository without
a cast.
JobExecution to have been created for a given
JobInstance.
JobExecutionListener interfaces.
StepListener interfaces.
StepListeners.
ApplicationContextFactory from each resource provided
in ClasspathXmlApplicationContextsFactoryBean.setResources(Resource[]).
Step from the configuration provided.
ApplicationContextFactory.
FactoryBean.getObject().
AbstractJobRepositoryFactoryBean.getObject().
JobParameters as an easily readable String.
Properties instance.
JobExecutions
with the given job name.
StepExecution by its id and parent
JobExecution id.
StepExecution from its id.
StepExecution that is active in this context.
StepExecution instances belonging to the
JobExecution with the supplied id, giving details of status,
start and end times etc.
JobExecution with the supplied id, giving details
of status, start and end times etc.
TaskExecutor available to subclasses
TransactionAttribute for subclasses only.
TransactionAttribute for subclasses only.
Job that can optionally prepend a group name to another job's name,
to make it fit a naming convention for type or origin.Job with the delegate and no group name.
Job with the given group name and delegate.
State.
FlowExecutionStatus stored.
TaskExecutor
and wait for all of them to finish before proceeding.
PartitionHandler interface.
JobExecution.
InlineFlowParser with the specified name and using the
provided job repository ref.
State is an end state.
JobExecutionListener.
StepListener.
JobExecution indicates that it is running.
Step should not be
treated as thread safe.
JobExecution indicates that it has been signalled to
stop.
ItemReadListener,
ItemProcessListener, and ItemWriteListener interfaces.ExecutionContext.JobExecutionDao.JobInstanceDao.StepExecutionDao.DataFieldMaxValueIncrementer
abstraction) to create all primary keys before inserting a new row.JobExecutionException with a generic message.
JobExecutionException with a generic message and a
cause.
Job.JobExecutionNotRunningException with a message.
FactoryBean that automates the creation of a
SimpleJobExplorer using JDBC DAO implementations.JobFactory in a
JobRegistry.FlowExecutor for use in components that need to
execute a flow related to a JobExecution.Job and JobParameters.Job is not
available.AbstractListenerFactoryBean implementation is used to create a
JobExecutionListener.JobExecutionListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.name.JobParameters to the Step ExecutionContext.JobParameters.JobParameters instances.StepExecution into
JobParameters.JobParameters in a sequence.Job to signal that some JobParameters are
invalid.JobParametersIncrementer is not
available.Job to use in validating its parameters for
an execution.name.JobRegistry.BeanPostProcessor that registers Job beans with a
JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using JDBC DAO implementations which persist
batch metadata in database.Step that delegates to a Job to do its work.SystemExiter interface that calls the standards
System.exit method.SkipPolicy that determines whether or not reading should continue
based upon how many items have been skipped.JobLocator.PreparedStatementSetter interface that accepts
a list of values to be set on a PreparedStatement.CommandLineJobRunner.
ExecutionContextDao backed by maps.JobExecutionDao.FactoryBean that automates the creation of a
SimpleJobExplorer using in-memory DAO implementations.MapJobRepositoryFactoryBean
as a source of Dao instances.
MapJobRepositoryFactoryBean.
JobInstanceDao.JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using non-persistent in-memory DAO
implementations.ResourcelessTransactionManager.
ExitStatus already just return that,
otherwise return ExitStatus.COMPLETED.
StepExecutionDao.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.Tasklet that wraps a method in a POJO.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.Job is not
available.JobExecution is not
available.JobInstance.Job found therein.
ItemProcessor Exception e)ItemProcessor.process(Object).
Ordered.
ItemReader Exception ex)Ordered.
ItemProcessor.Throwable t)Ordered.
ItemReader Throwable t)Ordered.
ItemWriter.Throwable t)Ordered.
ItemWriter Exception exception,
List<? extends S> items)Ordered.
ApplicationContextFactory that can be used to load a context from an
XML location in a bundle.ExecutionContext.
ExecutionContext instances together with
a unique identifier for each one.
ExecutionContext instances.StepExecution.Partitioner implementations that need to use a
custom naming scheme for partitions.Step which partitions the execution and spreads the
load using a PartitionHandler.TargetSource that lazily initializes its target, replacing bean
definition properties dynamically if they are marked as placeholders.Job then register it.
SystemExiter so it can be adjusted before
dependency injection.
SimpleChunkProvider.doRead().
JobFactory that just keeps a reference to a Job.Job at runtime.
StepSynchronizationManager.close() call in a finally block to ensure that the correct
context is available in the enclosing block.
JobExecutionListener
callbacks.
ItemStream for callbacks to the stream
interface.
StepExecution instances
when the input comes from remote steps, so the data need to be refreshed from
the repository.ExitStatus.
JobExecution.
Job and JobParameters
.
JobParameters.
events come from the expected source.
BackOffPolicy.
Step when it is created.
BundleContext for creating a job application context
later.
Callable.
CompletionPolicy applying to the chunk
level.
DataSource.
DataSource.
ExceptionHandler.
ExecutionContext for this execution
ExecutionContext for this execution
ExitCodeMapper.
ExitStatus for this contribution.
StepExecutionSplitter in the
TaskExecutorPartitionHandler.handle(StepExecutionSplitter, StepExecution) method, instructing
it how many StepExecution instances are required, ideally.
StepInterruptionPolicy.
true tasklet will attempt to interrupt the thread
executing the system command if SystemCommandTasklet.setTimeout(long) has been
exceeded or user interrupts the job.
Job to delegate to in this step.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobExecution instances.
JobExecutionListeners.
JobExplorer.
JobExplorer.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobInstance instances.
JobLauncher.
JobLauncher is required to be able to run the enclosed
Job.
JobLocator to find a job to run.
JobParametersConverter.
JobParametersConverter.
JobParametersExtractor is used to extract
JobParametersExtractor from the StepExecution to run the
Job.
JobParametersIncrementer.
JobRegistry to use for jobs created.
JobRegistry to use for all the bind and
unbind events.
JobRegistry.
ListableJobLocator.
JobRepository that is needed to manage the
state of the batch meta domain (jobs, steps, executions) during the life
of a job.
JobRepository.
JobRepository.
KeyGenerator to use to identify failed items across rollback.
KeyGenerator to use to identify failed items across rollback.
ExecutionContext.
JobParameters that will contain a commit interval.
JobLauncher.
StepListeners with the handler.
StepListeners with the handler.
Step.
ExecutionContext instances.
NumberFormat.
Partitioner that will be used to generate step execution meta
data for the target step.
PartitionHandler which can send out step executions for remote
processing and bring back the results.
ItemProcessor is transactional (defaults to
true).
ApplicationContext.
ClassPathXmlApplicationContextFactory.
RetryListeners.
SHORT_CONTEXT.
SkipPolicy that determines the outcome of an exception when
processing an item.
Step that will be used to execute the partitioned
StepExecution.
StepExecutionAggregator that can aggregate step executions when
they come back from the handler.
StepExecutionSplitter.
RepeatOperations to use for the outer loop of the batch
processing.
Step.
ExecutionContext.
SystemExiter.
TaskExecutor that is used to farm out step
executions to multiple threads.
TaskExecutor.
Tasklet.
TransactionAttribute.
PlatformTransactionManager.
PlatformTransactionManager.
PlatformTransactionManager.
ChunkProcessor interface that handles
basic item writing and processing.ItemReader.Flow that branches conditionally depending on the exit status of
the last State.Job interface providing the ability to run a
JobExecution.JobExplorer using the injected DAOs.JobLauncher interface.JobRepository that stores JobInstances,
JobExecutions, and StepExecutions using the injected DAOs.ExitCodeMapper that can be configured through a
map from batch exit codes (String) to integer results.Partitioner.ExceptionHandler that is aware of the retry context so that it can
distinguish between a fatal exception and one that can be retried.StepExecutionSplitter that delegates to a
Partitioner to generate ExecutionContext instances.SimpleStepExecutionSplitter from its mandatory
properties.
SimpleStepExecutionSplitter.SimpleStepExecutionSplitter(JobRepository, boolean, String, Partitioner) instead
SimpleStepFactoryBean.
StepHandler that manages repository and restart
concerns.SystemProcessExitCodeMapper implementation that performs following mapping:
0 -> ExitStatus.FINISHED
else -> ExitStatus.FAILEDSkipListener implementations.StepExecution into a set of parallel
executable instances with the same parent JobExecution.
InlineFlowParser using the provided job repository
ref.
State implementation that splits a Flow into multiple
parallel subflows.JobLoader.
JobInstance determined by the
JobParametersIncrementer attached to the specified job.
State to
another.StepExecution and some of its associated properties using expressions
based on bean paths.StepContext for this
StepExecution.
ContextFactory that provides the current
StepContext as a context object.Step.StepExecution, buffering changes until
they can be applied at a chunk boundary.Step.CompletionPolicy that picks up a commit interval from
JobParameters by listening to the start of a step.Step on behalf of a Job.Step as a convenience for callers who need
access to the underlying instance.StepExecutionListener,
ChunkListener, ItemReadListener and
ItemWriteListenerAbstractListenerFactoryBean implementation is used to create a
StepListener.StepListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.StepListener interfaces.Step instance by name.Step is not step scope aware (i.e.State implementation that delegates to a FlowExecutor to
execute the specified Step.JobLoader.clear().
JobExecution to stop.
JobExecution with the supplied id.
Tasklet that executes a system command.PartitionHandler that uses a TaskExecutor to execute the
partitioned Step locally in multiple threads.Tasklet,
possibly repeated, and each call surrounded by a transaction.CompletionPolicy if set, otherwise
returns the value of StepExecutionSimpleCompletionPolicy.setKeyName(String).
JobFactory provided and unregister it with the
JobRegistry.
Job.
JobExecution (but not its ExecutionContext).
StepExecution (but not its ExecutionContext).
ExecutionContexts of the given
StepExecution.
ExecutionContext of the given
JobExecution.
JobExecution.
SimpleChunkProcessor.doWrite(List) method and
increments the write count in the contribution.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||