|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
FactoryBean that automates the creation of a
SimpleJobExplorer.FactoryBean that automates the creation of a
SimpleJobRepository.Step implementation that provides common behavior to subclasses,
including registering and calling listeners.StepExecution and its ExecutionContext.
ExitStatus.
StepExecution for the parent JobExecution.
Ordered.
Job has completed.Ordered.
ItemProcessorOrdered.
JobRepository.
JobRepository have been
set.
ItemReaderItemReader.read()
Ordered.
Step has completed.Ordered.
ItemWriterItemWriter.write(java.util.List) If the item is last
in a chunk, this will be called before any transaction is committed, and
before ChunkListener.afterChunk()
Ordered.
FlowExecutionStatuses of the
FlowExecutions into one status.
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.
JobFactory that creates its own ApplicationContext from a
path supplied, and pulls a bean out when asked to create a Job.Job is executed, which comes
after a JobExecution is created and persisted, but before the first
Step is executed.JobExecution from
the current scope.
Ordered.
ItemProcessorOrdered.
ItemReaderItemReader.read()
Ordered.
Step is executed, which comes
after a StepExecution is created and persisted, but before the first
item is read.Ordered.
SimpleCompletionPolicy with a commit interval taken from
the JobParameters.
StepExecution for interrupt checks during
system command execution.
StepExecution from
the current scope.
ItemWriterItemWriter.write(java.util.List)
Ordered.
JobFactory provided and register it with the
JobRegistry.
Callable<ExitStatus> to the
Tasklet interface.JobInterruptedException.
Chunk.ChunkIterator.remove(Exception) method for dynamically removing an
item and adding it to the skips.ChunkListenerTasklet implementing variations on read-process-write item
handling.ListableJobRegistry interface that assumes all
Jobs will be loaded from ClassPathXml resources.StepSynchronizationManager.register(StepExecution)
to ensure that StepSynchronizationManager.getContext() always returns the correct value.
FlowExecution instances by comparing their
statuses.
FlowExecutionStatus instances by comparing
their statuses.
ExitStatus
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.
MethodInvoker using the provided method name to search.
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.JobParameters instances using a simple naming
convention for property keys.Job instances that were
regsistered by this post processor.
PartitionHandler provided.
StepContext lifecycle to ensure that the current
thread has a reference to the context, even if the callback is executed
in a pooled thread.
FlowJob.
JobRepositoryFactoryBean.
Job instances.State implementation for ending a job if it is in progress and
continuing if just starting.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.
ExitStatus.
ExitStatus by invoking a method in the delegate POJO.
ExitStatus using
SystemProcessExitCodeMapper.
ExecutionContexts.XPath.Step
ExecutionContext to the Job ExecutionContext at the
end of a step.RepeatOperations.JobExecution for given JobInstance, sorted
backwards by creation order (so the first element is the most recent).
FlowExecution instances into a
single exit status.FlowJob to allow it to delegate
its execution step by step.FlowJob with null name and no flow (invalid state).
FlowJob with provided name and no flow (invalid state).
FlowParser with the specified name and using the
provided job repository ref.
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.
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).
JobOperator.start(String, String).
JobParameters instance.
JobExecution to have been created for a given
JobInstance.
StepListeners.
MethodInvoker for the method with the provided annotation on the provided object.
MethodInvoker using the provided interface, and string methodname from that interface.
Step from the configuration provided.
FactoryBean.getObject().
AbstractJobRepositoryFactoryBean.getObject().
JobParameters as an easily readable String.
Properties instance.
JobExecutions
with the given job name.
StepExecution from its id.
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.
TransactionAttribute for subclasses
only.
State.
FlowExecutionStatus stored.
TaskExecutor
and wait for all of them to finish before proceeding.
PartitionHandler interface.
JobExecution.
State is an end state.
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.BeanDefinitionParser for
JobExecutionListenersJobExecutionNotRunningException with a message.
FactoryBean that automates the creation of a
SimpleJobExplorer using JDBC DAO implementations.JobFactory in a
JobRegistry.Job and JobParameters.Job is not
available.FactoryBean implementation that builds a JobExecutionListener based on the
various lifecycle methods or annotations that are provided.JobExecutionListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.name.JobParameters.JobParameters instances.JobParameters in a sequence.JobParametersIncrementer is not
available.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.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.JobRegistry.CommandLineJobRunner.
ExecutionContextDao backed by static
maps.JobExecutionDao.FactoryBean that automates the creation of a
SimpleJobExplorer using in-memory DAO implementations.JobInstanceDao.JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using non-persistent in-memory DAO
implementations.ExitStatus already just return that,
otherwise return ExitStatus.COMPLETED.
StepExecutionDao.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.SkipPolicy implementation that always returns false,
indicating that an item should not be skipped.Job is not
available.JobExecution is not
available.JobInstance.ItemProcessorOrdered.
ItemReaderOrdered.
ItemProcessorOrdered.
ItemReaderOrdered.
ItemWriterOrdered.
ItemWriterOrdered.
ExecutionContext instances together with
a unique identifier for each one.
ExecutionContext instances.StepExecution.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.
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.
ExitStatus.
JobExecution.
Job and JobParameters
.
JobParameters.
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.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobExecution instances.
JobExecutionListeners.
JobExplorer.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobInstance instances.
JobLauncher.
JobParametersConverter.
JobParametersConverter.
JobParametersIncrementer.
JobRegistry to use for all the bind and
unbind events.
JobRegistry.
ListableJobRegistry.
JobRepository that is needed to manage the
state of the batch meta domain (jobs, steps, executions) during the life
of a job.
JobRepository.
JobRepository.
JobParameters that will contain a commit interval.
JobLauncher.
StepListeners with the handler.
StepListeners with the handler.
Step.
NumberFormat.
JobParameters.
PartitionHandler.
ApplicationContext.
JobRegistry.
RetryListeners.
Step that will be used to execute the partitioned
StepExecution.
StepExecutionSplitter.
RepeatOperations to use for the outer loop of the batch
processing.
Step.
SystemExiter.
TaskExecutor that is used to farm out step
executions to multiple threads.
TaskExecutor.
Tasklet.
TransactionAttribute.
TransactionAttribute.
PlatformTransactionManager.
PlatformTransactionManager.
PlatformTransactionManager.
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.MethodInvoker interface that invokes a method on an
object.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.
SimpleStepFactoryBean.
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.
FlowParser using the provided job repository ref.
State implementation that splits a Flow into multiple
parallel subflows.JobInstance determined by the
JobParametersIncrementer attached to the specified job.
State to
another.StepContext.StepContext for this
StepExecution.
ContextFactory that provides the current
StepContext as a contxt object.Step.StepExecution, buffering changes until
they can be applied at a chunk boundary.StepExecution instances
into a single result.Step.PreparedStatementSetter interface that also
implements StepExecutionListener and uses JobParameters to
set the parameters on a PreparedStatement.CompletionPolicy that picks up a commit interval from
JobParameters by listening to the start of a step.Step as a convenience for callers who need
access to the underlying instance.StepExecutionListener,
ChunkListener, ItemReadListener and
ItemWriteListenerFactoryBean implementation that builds a StepListener based on the
various lifecycle methods or annotations that are provided.StepListener meta data, which ties together the names
of methods, their interfaces, annotation, and expected arguments.StepListener implementations.Step instance by name.Step is not step scope aware (i.e.State implementation that delegates to a FlowExecutor to
execute the specified Step.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.
StepExecution if necessary.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||