|
||||||||||
| 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.LineTokenizer implementations
such as dealing with names and actual construction of FieldSetExitStatus.
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.ExitStatus with a logical combination of the
continuable flag.
ExitStatus with a logical combination of the
continuable flag, and a concatenation of the descriptions.
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.ExceptionClassifier that has only two classes of exception.ExceptionClassifierSupport.DEFAULT or
BinaryExceptionClassifier.NON_DEFAULT depending on the type of the throwable.
ExceptionClassifierSupport.DEFAULT.
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.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.FragmentEventReaderPropertyEditorRegistrar 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.
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).
ExceptionClassifier signalling that the throwable should be logged at error level.
RetryPolicy that dynamically adapts to one of a set of injected
policies according to the value of the latest exception.ExceptionClassifier implementations.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.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.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.
FieldSet'.
DataFieldMaxValueIncrementer for the provided database type.
Message then returns the JMS message ID.
ExecutionContext.
TaskExecutorRepeatTemplate.setTaskExecutor(TaskExecutor) to generate a result.
RecoveryCallback.
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().
ItemReader interface that allows items to be
identified and tagged by a unique key.RowMapper.ItemReader extend.ItemReaderException based on a message and another exception.
ItemReaderException based on a message.
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.
ItemReader for JMS using a JmsTemplate.ResultSet.absolute(int) if possible, otherwise scroll by
calling ResultSet.next().
ItemTransformer that expects a String[] as input and delegates to
a LineAggregator.ItemReader that pulls data from a list.ExceptionHandler based on an ExceptionClassifier.FieldSet pass it to the caller.
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.
RetryContextCache.MapRetryContextCache with default capacity.
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.BackOffPolicy that performs a no-op and as such all
retry operation in a given set proceed one after the other with no pause.NoWorkFoundException based on a message.
NoWorkFoundException based on a message and another exception.
Sleeper implementation that just waits on a local Object.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.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.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.
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.RepeatOperations.ExitStatus.
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.LineAggregator.
CENTER, RIGHT, LEFT.
BackOffPolicy.
CompletionPolicy.
custom editors to register.
ItemWriter property.
ItemTransformer to use on single items,
that are not Strings.
ItemWriter.
ResultSet.
ExceptionClassifier used by this handler.
ExceptionClassifier used by this handler.
RetryCallback.
ResultSet object.
ResultSet object.
FieldSetCreator.
HibernateOperations property.
ItemPreparedStatementSetter.
JdbcOperations.
JdbcTemplate to be used.
RowMapper to be used to map a result set to keys.
RowMapper to be used to map each key to an object.
LineAggregator.
ResultSet object can contain to the given number.
NewItemIdentifier.
BeanWrapperFieldSetMapper.mapLine(FieldSet).
Statement object to execute to the given number of
seconds.
RecordSeparatorPolicy.
ItemRecoverer to use if the retry is
exhausted.
RepeatOperations.
RetryPolicy.
ExecutionContext during the ItemStream call to
update.
ExecutionContext during the ItemStream call to
update.
ExecutionContext.
Sleeper strategy.
Sleeper strategy.
SqlMapClientTemplate to use for this input source.
CompletionPolicy.
RetryPolicy.canRetry(RetryContext),
i.e.
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.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.BackOffPolicy implementations that maintain no
state across invocations.ItemWriter which uses StAX and
EventWriterSerializer for serializing object to XML.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).RetryPolicy that allows a retry only if it hasn't timed out.TimeoutTerminationPolicy with the specified timeout
value (in milliseconds).
line.
line.
UnexpectedInputException based on a message.
UnexpectedInputException based on a message and another exception.
Unmarshaller.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 | |||||||||