|
||||||||||
| 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.
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.
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 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.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 XPath.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<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.Chunks.Chunks to be processed, used by the
ChunkOrientedTaskletApplicationContextFactory implementation that takes a parent context and a path
to the context to create.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.
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.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.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).
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.
JobExecutionListener interfaces.
StepListener interfaces.
StepListeners.
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.
TaskExecutor available to subclasses
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.
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.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 XPath.Step ExecutionContext.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.PreparedStatementSetter interface that accepts
a list of values to be set on a PreparedStatement.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.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.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.
ExecutionContext.
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.
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.
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.
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.
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 context object.Step.StepExecution, buffering changes until
they can be applied at a chunk boundary.StepExecution instances
into a single result.Step.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
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 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.
SimpleChunkProcessor.doWrite(List) method and
increments the write count in the contribution.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||