|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
ItemReaders which use item buffering to
support reset/rollback.ItemReader implementations.ItemReader implementations.ItemWriter implementations.ItemWriter that allows for base classes to only implement
the AbstractItemWriter.flush() and AbstractItemWriter.clear() methods if they need it.FactoryBean that automates the creation of a
SimpleJobRepository.LineTokenizer implementations
such as dealing with names and actual construction of FieldSetStep implementation that provides common behavior to subclasses,
including registering and calling listeners.ItemOrientedStep.ExitStatus.
Ordered.
Ordered.
JobRepository have been set.
ItemReader.read()
Ordered.
Ordered.
ItemWriter.write(Object) If the item is last in a
chunk, this will be called before any transaction is committed, and
before ChunkListener.afterChunk()
Ordered.
ItemReader that delivers a list as its item, storing up objects
from the injected ItemReader until they are ready to be packed out
as a collection.RetryPolicy that always permits a retry.ItemSkipPolicy interface that
will always return that an item should be skipped.ExitStatus with a logical combination of the
continuable flag.
ExitStatus with a logical combination of the
continuable flag, and a concatenation of the descriptions.
SkipLimitStepFactoryBean.setSkipLimit(int) value to configure item handler and
and exception handler.
AsynchronousFailureException based on a message and
another exception.
AsynchronousFailureException based on a message.
exp(backOffContext.expSeed)'.
StatelessBackOffPolicy.doBackOff() method without passing on
the BackOffContext argument which is not needed for stateless
implementations.
BackOffPolicy was interrupted, most likely by an
InterruptedException during a call to Thread.sleep(long).retry operation.ItemWriter that uses the batching features from
PreparedStatement if available and can take some rudimentary steps to
locate a failure during a flush, and identify the items that failed.FieldSetMapper implementation based on bean property paths.JobExecution from
the current scope.
Ordered.
ItemReader.read()
Ordered.
Ordered.
StepExecution that will
be needed to create a file name.
SimpleCompletionPolicy with a commit interval taken from
the JobParameters.
StepExecution from
the current scope.
ItemWriter.write(Object)
Ordered.
ExceptionClassifier that has only two classes of exception.JobInterruptedException.
ChunkListenerExceptionClassifierSupport.DEFAULT or
BinaryExceptionClassifier.NON_DEFAULT depending on the type of the throwable.
ExceptionClassifierSupport.DEFAULT.
JobFactory that creates its own ApplicationContext from a
path supplied, and pulls a bean out when asked to create a Job.ItemWriter.
ItemWriter.clear()
RepeatOperations implementations.
RepeatOperations implementations.
ItemWriter.clear()ClearFailedException based on a message and another exception.
ClearFailedException based on a message.
MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream) reader
and reset instance variable values.
ItemPreparedStatementSetter interface that assumes all
keys are contained within a Map with the column name as the key.CompletionPolicy implementations.ExceptionHandler that loops though a list of delegates.ItemStream that delegates to a list of other streams.ItemTransformer that passes the item through a sequence
of injected ItemTransformers (return value of previous transformation
is the entry value of the next).RetryPolicy that composes a list of other policies and delegates
calls to them in order.ClassPathXmlApplicationContext from the path provided
and pull out a bean with the name given during initialization.
JobExecution for a given Job and
JobParameters.
JobExecution based on the passed in Job and
JobParameters.
StepContribution.
DataFieldMaxValueIncrementer implementations
based upon a provided string.ExceptionClassifier signalling that the throwable should be logged at debug level.
DataFieldMaxValueIncrementerFactory
interface.ExceptionHandler - just re-throws the exception it encounters.FieldSet using Java using Java primitive
and standard types and utilities.FragmentEventReaderItemListenerSupport class that
writes all exceptions via commons logging.JobParameters instances using a simple naming
convention for property keys.PropertyEditorRegistrar that can be used wherever one
needs to register custom PropertyEditor instances with a
PropertyEditorRegistry (like a bean wrapper, or a type converter).RecordSeparatorPolicy that treats all lines as record endings, as
long as they do not have unterminated quotes, and do not end in a
continuation marker.CompletionPolicy that bases its decision on the result of
a batch operation.ItemReader.ItemWriter.DelimitedLineTokenizer class for the common case where the delimiter is a
comma.
DelimitedLineTokenizer class.
Job instances that were
regsistered by this post processor.
FixedBackOffPolicy.setBackOffPeriod(long).
AbstractTransactionalResourceItemWriter.clear().
AbstractBufferedItemReaderItemStream.doOpen().
AbstractTransactionalResourceItemWriter.flush().
HibernateCursorItemReader.setQueryString(String).
JdbcCursorItemReader.setSql(String) query.
ItemTransformerItemWriter.setItemTransformer(ItemTransformer).
JdbcCursorItemReader.setVerifyCursorPosition(boolean) is true.
FlatFileItemReader.setLineTokenizer(LineTokenizer) and maps to domain object using
FlatFileItemReader.setFieldSetMapper(FieldSetMapper).
line.
line.
AbstractTransactionalResourceItemWriter.write(Object).
Job instances.ExceptionClassifier signalling that the throwable should be logged at error level.
ItemReader with hard-coded input data.ItemWriter which only logs data it receives.RetryPolicy that dynamically adapts to one of a set of injected
policies according to the value of the latest exception.ExceptionClassifier implementations.JobExecution and update the meta information like status
and statistics as necessary.
Step.
AbstractStep.open(ExecutionContext)), execution
logic (AbstractStep.doExecute(StepExecution)) and resource closing (AbstractStep.close(ExecutionContext)).
StepExecution provided.
Step, which is unnatural to
separate into read-(transform)-write phases.
ExitStatus by invoking a method in the delegate POJO.
RetryCallback with the configured retry
semantics.
ItemStream.ExecutionContext and generating keys for ExecutionContext
based on the name.RepeatOperations.BackOffPolicy that increases the back off period
for each retry attempt in a given set using the
exponential function.FieldSet.FieldSet into an
object.Job with a single step which just pumps messages
from a file into a channel.ExecutionContext for the given JobExecution.
ExecutionContext for the given StepExecution.
BackOffPolicy that pauses for a fixed period of
time before continuing.LineAggregator implementation which produces line by aggregating provided
strings into columns with fixed length.FlatFileFormatException based on a message.
FlatFileFormatException based on a message and another exception.
ItemReader, that reads lines from text file,
tokenizes them to structured tuples (FieldSets) instances and maps
the FieldSets to domain objects.ItemWriter.
ChunkHandler.
ItemWriter.flush()
ItemWriter.flush()FlushFailedException based on a message and another exception.
FlushFailedException based on a message.
RetryContext.
ExceptionClassifier.classify(Throwable) with null argument.
ExceptionClassifierSupport.classify(Throwable) with argument null.
ExceptionHandler.
ExecutionContext for this execution
ExecutionContext for this execution
FieldSet'.
DataFieldMaxValueIncrementer for the provided database type.
ItemReader for subclasses to use.
ItemWriter for subclasses to use
Job at runtime.
JobParameters instance.
Resource to its URL
representation and load that into a job parameter.
Message then returns the JMS message ID.
ExecutionContext.
StepListeners.
TaskExecutorRepeatTemplate.setTaskExecutor(TaskExecutor) to generate a result.
Step from the configuration provided.
Job that can process a flat file or XML file into
messages.
AbstractJobRepositoryFactoryBean.getObject().
Job.
Properties instance.
RecoveryCallback.
TransactionAttribute for subclasses only.
SimpleItemHandler.read(StepContribution) and if not null
pass the item to SimpleItemHandler.write(Object, StepContribution).
ItemWriter that is aware of the Hibernate session and can take some
responsibilities to do with chunk boundaries away from a less smart
ItemWriter (the delegate).ItemReader for reading database records built on top of Hibernate.DrivingQueryItemReader that maps keys to objects.KeyCollector based on iBATIS ORM framework.String value from column with given 'name.
RepeatOperations.
true if exit status is not continuable, otherwise
delegate to CompletionPolicySupport.isComplete(RepeatContext).
ExitStatus indicating
completion.
CompletionPolicy.
CompletionPolicy.
RetryContext.setExhaustedOnly().
JobExecution indicates that it is running.
Step should not be
treated as thread safe.
JobExecution indicates that it has been signalled to
stop.
ItemReader interface that allows items to be
identified and tagged by a unique key.ItemWriteListener and
ItemReadListener interfaces.RowMapper.ItemReader extend.ItemReaderException based on a message and another exception.
ItemReaderException based on a message.
ItemHandler that implements skip behavior.ItemStream.ItemTransformer
before it is written to output by ItemWriter.ItemWriter extend.ItemWriterException based on a message and another exception.
ItemWriterException based on a message.
JobExecutionDao.JobInstanceDao.StepExecutionDao.DataFieldMaxValueIncrementer
abstraction) to create all primary keys before inserting a new row.ItemReader for JMS using a JmsTemplate.JobExecutionException with a generic message.
JobExecutionException with a generic message and a
cause.
Job.Job and JobParameters.Job and its JobParameters forming a
request for a job to be launched.name.JobParameters.JobParameters instances.name.BeanPostProcessor that registers Job beans
with a JobRegistry.JobExecution and StepExecutions.FactoryBean that automates the creation of a
SimpleJobRepository using JDBC DAO implementations which persist
batch metadata in database.ResultSet.absolute(int) if possible, otherwise scroll by
calling ResultSet.next().
SystemExiter interface that calls the standards
System.exit method.ItemSkipPolicy that determines whether or not reading should continue
based upon how many items have been skipped.ItemTransformer that expects a String[] as input and delegates to
a LineAggregator.JobRegistry.ItemReader that pulls data from a list.ExceptionHandler based on an ExceptionClassifier.CommandLineJobRunner.
FieldSet pass it to the caller.
JobExecutionDao.JobInstanceDao.JobRegistry.FactoryBean that automates the creation of a
SimpleJobRepository using non-persistent in-memory DAO
implementations.DefaultFieldSet to an object retrieved from the enclosing Spring
context, or to a new instance of the required type if no prototype is
available.
FieldSet into an object.
ExitStatus already just return that,
otherwise return ExitStatus.FINISHED.
RetryContextCache.MapRetryContextCache with default capacity.
StepExecutionDao.ItemReader.
ItemStream is used in a
single-threaded environment.
ItemStream is used in a
single-threaded environment.
ItemStream is used in a
single-threaded environment.
ItemReader fails to mark its current state for future retry.MarkFailedException based on a message.
MarkFailedException based on a message and another exception.
Marshaller object.KeyCollector interface that works for
composite keys.MultiResourceItemReader.setResources(Resource[]), the actual reading is delegated to
MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream).RepeatOperations instance.RetryPolicy that allows the first attempt but never permits a
retry.ItemSkipPolicy implementation that always returns false,
indicating that an item should not be skipped.BackOffPolicy that performs a no-op and as such all
retry operation in a given set proceed one after the other with no pause.Job is not
available.NoWorkFoundException based on a message.
NoWorkFoundException based on a message and another exception.
Sleeper implementation that just waits on a local Object.Ordered.
Ordered.
ExitStatus.and(ExitStatus).
Ordered.
Ordered.
Ordered.
Ordered.
Ordered.
ExecutionContext.
RecoveryRetryCallback.
ParseException based on a message and another exception.
ParseException based on a message.
FieldSetMapper useful for passing a FieldSet
back directly rather than a mapped object.Job then register it.
RecordSeparatorPolicy.
String value at 'index'.
BigDecimal value at index 'index'.
BigDecimal value from column with given 'name.
BigDecimal value at index 'index',
returning the supplied defaultValue if the trimmed string
value at index 'index' is blank.
BigDecimal value from column with given 'name,
returning the supplied defaultValue if the trimmed string
value at index 'index' is blank.
boolean' value at index 'index'.
boolean' value from column with given 'name'.
boolean' value at index 'index'.
boolean' value from column with given 'name'.
byte' value at index 'index'.
byte' value from column with given 'name'.
char' value at index 'index'.
char' value from column with given 'name'.
java.util.Date value in default format at
designated column index.
java.sql.Date value in given format from column
with given name.
java.util.Date value in default format at
designated column index.
java.sql.Date value in given format from column
with given name.
double' value at index 'index'.
double' value from column with given 'name.
ItemReader needed to be opened before read.ReaderNotOpenException based on a message.
ReaderNotOpenException based on a message and another exception.
float' value at index 'index'.
float' value from column with given 'name.
int' value at index 'index'.
int' value from column with given 'name'.
int' value at index 'index',
using the supplied defaultValue if the field value is
blank.
int' value from column with given 'name',
using the supplied defaultValue if the field value is
blank.
long' value at index 'index'.
long' value from column with given 'name'.
long' value at index 'index',
using the supplied defaultValue if the field value is
blank.
long' value from column with given 'name',
using the supplied defaultValue if the field value is
blank.
String value at index 'index' including
trailing whitespace (don't trim).
String value from column with given 'name'
including trailing whitespace (don't trim).
short' value at index 'index'.
short' value from column with given 'name'.
String value at index 'index'.
String value from column with given 'name'.
RetryPolicy that detects an RecoveryRetryCallback when it
opens a new context, and uses it to make sure the item is in place for later
decisions about how to retry or backoff.RetryCallback that knows about and caches an item, and attempts to
process it using a delegate RetryCallback.ItemTransformer that treats its argument
specially if it is an array or collection.JobFactory that just keeps a reference to a Job.Job at runtime.
ItemStream as one of the interesting providers under
the provided key.
RepeatOperations implementations to ensure that
RepeatSynchronizationManager.getContext() always returns the correct value.
RetryOperations implementations to ensure that
RetrySynchronizationManager.getContext() always returns the correct value.
JobExecutionListener
callbacks.
ItemStream for callbacks to the stream
interface.
RetryContext, and
also increment the retry count if the throwable is non-null.RetryPolicy implementations should use this method when they
register the throwable.
RecoveryCallbackRetryPolicy.canRetry(RetryContext) is false then take remedial action (if
implemented by subclasses), and remove the current item from the history.
RepeatContextCounter.
RepeatContextSupport.
RepeatListener.MethodInterceptor that can be used to automatically repeat calls to
a method on a service.Step implementations allowing registration of
listeners and also direct injection of the RepeatOperations needed at
step and chunk level.RepeatOperations.ExitStatus.
ItemReader.
ItemReader fails to reset its state based on the previous mark.ResetFailedException based on a message.
ResetFailedException based on a message and another exception.
ItemReaders that implement ItemStream and read
input from Resource.ExceptionClassifier signalling that the throwable should be rethrown.
ExceptionHandler that rethrows when exceptions of a
given type reach a threshold.RetryOperations.RetryContext instances.RetryListener.RetryOperations to
execute operations with configurable retry behaviour.MethodInterceptor that can be used to automatically retry calls to
a method on a service if it fails.RetryPolicy is responsible for allocating and managing resources
needed by RetryOperations.Job and JobParameters.
JobParameters.
JobExecution.
StepExecution.
ExecutionContext of the given JobExecution.
ExecutionContext of the given StepExecution.
ExecutionContext of the given StepExecution.
LineAggregator.
CENTER, RIGHT, LEFT.
BackOffPolicy.
BackOffPolicy.
Step when it is created.
CompletionPolicy applying to the chunk
level.
RepeatOperations to use for the inner loop of the batch
processing.
RepeatOperations to use for the inner loop of the batch
processing.
CompletionPolicy.
custom editors to register.
DataSource.
ItemWriter property.
ItemTransformer to use on single items,
that are not Strings.
ItemWriter.
ResultSet.
ExceptionClassifier used by this handler.
ExceptionClassifier used by this handler.
ExceptionHandler.
ExecutionContext for this execution
ExecutionContext for this execution
RetryCallback.
ExitCodeMapper.
ResultSet object.
ResultSet object.
FieldSetCreator.
HibernateOperations property.
StepInterruptionPolicy.
ItemHandler.
ItemKeyGenerator.
ItemKeyGenerator.
ItemPreparedStatementSetter.
ItemReader.
JdbcOperations.
JdbcTemplate to be used.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobExecution instances.
JobExecutionListeners.
DataFieldMaxValueIncrementer to be used when
generating primary keys for JobInstance instances.
JobParametersConverter.
JobParametersConverter used to translate
JobParameters into Properties.
JobRegistry.
JobRepository that is needed to manage the
state of the batch meta domain (jobs, steps, executions) during the life
of a job.
JobRepository.
JobRepository.
JobRepository.
JobRepository that is needed to manage the
state of the batch meta domain (jobs, steps, executions) during the life
of a job.
RowMapper to be used to map a result set to keys.
RowMapper to be used to map each key to an object.
JobParameters that will contain a commit interval.
JobLauncher.
JobLauncher.
LineAggregator.
Step.
ResultSet object can contain to the given number.
NewItemIdentifier.
NumberFormat.
JobParameters.
BeanWrapperFieldSetMapper.mapLine(FieldSet).
Statement object to execute to the given number of
seconds.
RecordSeparatorPolicy.
ItemRecoverer to use if the retry is
exhausted.
RepeatOperations.
RetryListeners.
RetryPolicy.
ExecutionContext during the ItemStream call to
update.
ExecutionContext during the ItemStream call to
update.
ExecutionContext.
SkipListeners with the handler.
Sleeper strategy.
Sleeper strategy.
SqlMapClientTemplate to use for this input source.
Step.
AbstractStep.setStepExecutionListeners(StepExecutionListener[]) instead
RepeatOperations to use for the outer loop of the batch
processing.
RepeatOperations to use for the outer loop of the batch
processing.
Step.
SystemExiter.
TaskExecutor.
Tasklet.
CompletionPolicy.
TransactionAttribute.
TransactionAttribute.
PlatformTransactionManager.
PlatformTransactionManager.
PlatformTransactionManager.
PlatformTransactionManager.
RetryPolicy.canRetry(RetryContext),
i.e.
ItemHandler with no skipping or
recovering.JobExecution.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.SimpleLimitExceptionHandler to
set the limit.
SimpleLimitExceptionHandler.
RecordSeparatorPolicy - treats all lines as record
endings.SimpleRetryPolicy with the default number of retry
attempts.
SimpleRetryPolicy with the specified number of retry
attempts, and default exceptions to retry.
KeyCollector implementation that only works for a single column key.SkipListener implementations.Validator interface to
Validator.RepeatContextSupport and return it.
CompletionPolicy.
BackOffContext configured
with the 'expSeed' and 'increment' values.
null'.
MethodInterceptor that can be used to automatically retry calls to
a method on a service if it fails.SkipLimitStepFactoryBean in version 1.1.0.BackOffPolicy implementations that maintain no
state across invocations.ItemWriter which uses StAX and
EventWriterSerializer for serializing object to XML.StepExecution, buffering changes
until they can be applied at a chunk boundary.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.StepExecutionSynchronizer to return based on the
availabilty of Java 5 or Backport Concurrent.StepExecutionListener,
ChunkListener, ItemReadListener and
ItemWriteListenerStepListener implementations.JobExecution to stop.
RecordSeparatorPolicy that looks for an exact match for a String at
the end of a line (e.g.AttributeAccessor that synchronizes on a mutex (not this) before
modifying or accessing the underlying attributes.RepeatOperations support including interceptors that can be
used to modify or monitor the behaviour at run time.RepeatCallback transactional,
or for the whole batch by making the execute method transactional (but only
then if the task executor is synchronous).Tasklet.execute()
method, developers should consider implementing StepExecutionListener and
check the StepExecution.isTerminateOnly() value for long lasting
processes to enable prompt termination of processing on user request.ItemReader and
ItemWriter interfaces then (typically extending or composing provided
implementations).Tasklet that wraps a method in a POJO.Step that executes a Tasklet directly.Step for executing a Tasklet
RetryPolicy that allows a retry only if it hasn't timed out.TimeoutTerminationPolicy with the specified timeout
value (in milliseconds).
line.
line.
StepExecutionResourceProxy.setFilePattern(String).
CompletionPolicy if set, otherwise
returns the value of StepExecutionSimpleCompletionPolicy.setKeyName(String).
UnexpectedInputException based on a message.
UnexpectedInputException based on a message and another exception.
Unmarshaller.Job.
ExecutionContext.
ExecutionContext provider for the contributions
registered under the given key.
CompletionPolicy.
DelegatingItemReader that provides for
validation before returning input.ValidationException based on a message and another exception.
ValidationException based on a message.
ExceptionClassifier signalling that the throwable should be logged at warn level.
DelegatingItemWriter.doProcess(Object) and then writes the result to the
delegate ItemWriter.
ItemWriter needed to be opened before being
written to..WriterNotOpenException based on a message.
WriterNotOpenException based on a message and another exception.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||