|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
ItemReaders that supports restart by storing
item count in the ExecutionContext (therefore requires item ordering
to be preserved between runs).ItemReader implementations.ItemWriter implementations.LineTokenizer
implementations such as dealing with names and actual construction of
FieldSetItemReader for to extend when reading database records in a paging
fashion.FieldExtractor and
then aggregate them.
RetryPolicy that always permits a retry.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.Classifier with easy configuration options for
mapping from one arbitrary type of object to another via a pattern matcher.FieldSetMapper implementation based on bean property paths.Classifier for exceptions that has only two classes (true and
false).Classifier interface.Classifier from the delegate provided.
Classifier from the delegate provided.
Classifier.Classifier implementations.PatternMatchingClassifier.setPatternMap(Map).
RepeatOperations implementations.
RepeatOperations implementations.
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.ItemProcessor that passes the item through a sequence of
injected ItemTransformers (return value of previous
transformation is the entry value of the next).ItemProcessor
s that conforms to declared input and output types.ItemStream that delegates to a list of other streams.ItemWriters in fixed-order sequence.RetryPolicy that composes a list of other policies and delegates
calls to them in order.sql.
BeanPropertySqlParameterSource based on values from
the provided item.
SqlParameterSource based on values from
the provided item.
DataFieldMaxValueIncrementer implementations
based upon a provided string.PagingQueryProvider using
database specific features.DataFieldMaxValueIncrementerFactory
interface.ExceptionHandler - just re-throws the exception it encounters.FieldSet using Java using Java primitive
and standard types and utilities.FieldSetFactory with no special knowledge
of the FieldSet required.FragmentEventReaderLineMapper implementation consisting of tokenization of the
line into FieldSet followed by mapping to item.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.DefaultRetryState representing the state for a new retry
attempt.
LineAggregator implementation that converts an object into a
delimited list of strings.LineTokenizer implementation that splits the input String on a
configurable delimiter.DelimitedLineTokenizer class for the common case where the delimiter is a
comma.
DelimitedLineTokenizer class.
PagingQueryProvider using standard SQL:2003 windowing functions.FixedBackOffPolicy.setBackOffPeriod(long).
AbstractItemCountingItemStreamItemReader.doOpen().
HibernateCursorItemReader.setQueryString(String).
JdbcCursorItemReader.setSql(String) query.
JdbcCursorItemReader.setVerifyCursorPosition(boolean) is true.
line.
line.
RetryPolicy that dynamically adapts to one of a set of injected
policies according to the value of the latest exception.RetryCallback with the configured retry
semantics.
RetryCallback with a fallback on exhausted
retry to the RecoveryCallback.
ItemStream.ExecutionContext and generating keys for ExecutionContext
based on the name.BackOffPolicy that increases the back off period
for each retry attempt in a given set using the
exponential function.SmartDataSource that is capable of keeping a single
JDBC Connection which is NOT closed after each use even if
Connection.close() is called.LineAggregator implementation that utilizes a
FieldExtractor to convert the incoming object to an array of its
parts.FieldSet instances.FieldSet into an
object.BackOffPolicy that pauses for a fixed period of
time before continuing.FlatFileFormatException based on a message.
FlatFileFormatException based on a message and another exception.
ItemReader that reads lines from input
FlatFileItemReader.setResource(Resource).FlushFailedException based on a message and another exception.
FlushFailedException based on a message.
LineAggregator implementation which produces a String by
aggregating the provided item via the Formatter syntax.RetryContext.
FieldSet'.
DataFieldMaxValueIncrementer for the provided database type.
Message then returns the JMS message ID.
ExecutionContext.
MethodInvoker for the method with the provided annotation
on the provided object.
MethodInvoker using the provided method name to search.
MethodInvoker using the provided interface, and method
name from that interface.
MethodInvoker for the delegate from a single public
method.
TaskExecutorRepeatTemplate.setTaskExecutor(TaskExecutor) to generate a result.
PagingQueryProvider instance using the provided properties
and appropriate for the given database type.
PagingQueryProvider.
ItemReader for reading database records built on top of Hibernate.ItemWriter that uses a Hibernate session to save or update entities
that are not part of the current Hibernate session.PagingQueryProvider using database specific features.ItemWriter that uses the batching features from
SqlMapClientTemplate to execute a batch of statements for all items
provided.IbatisBatchItemWriter.write(List) is called inside a transaction.ItemReader for reading database
records using iBATIS in a paging fashion.String value from column with given '
name.
DataSource if necessary.
RepeatOperations.
AbstractMethodInvokingDelegator.setArguments(Object[]).
Connection
true, otherwise
delegate to CompletionPolicySupport.isComplete(RepeatContext).
RepeatStatus indicating
completion.
CompletionPolicy.
CompletionPolicy.
RetryContext.setExhaustedOnly().
RowMapper.ItemReader extend.ItemReaderException based on a message and another exception.
ItemReaderException based on a message.
ItemStream and ItemReader
.ItemStream.ItemWriter extend.ItemWriterException based on a message and another exception.
ItemWriterException based on a message.
ItemWriter that uses the batching features from
SimpleJdbcTemplate to execute a batch of statements for all items
provided.ItemReader for reading database records using JDBC in a paging
fashion.ItemReader for JMS using a JmsTemplate.ItemWriter for JMS using a JmsTemplate.MethodArgumentsKeyGenerator for JMSNewMethodArgumentsIdentifier for JMS that looks for a message in
the arguments and checks its delivery status.ItemWriter that is using a JPA
EntityManagerFactory to merge any Entities that aren't part of the
persistence context.ItemReader for reading database records built on top of JPA.ResultSet.absolute(int) if possible, otherwise scroll by
calling ResultSet.next().
ItemReader that pulls data from a list.ExceptionHandler based on an Classifier.FieldSet 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.
MultiResourceItemReader.setResources(Resource[]), the actual reading is delegated to
MultiResourceItemReader.setDelegate(ResourceAwareItemReaderItemStream).ResourceAwareItemWriterItemStream and creates a new output
resource when the count of items written in current resource exceeds
MultiResourceItemWriter.setItemCountLimitPerResource(int).PagingQueryProvider using database specific features.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.Sleeper implementation that just waits on a local Object.ExecutionContext.
RetryPolicy having checked in the cache for an
existing value if the state is not null.
PagingQueryProvider using
database specific features.ParseException based on a message and another exception.
ParseException based on a message.
FieldExtractor that just returns the original item.FieldSetMapper useful for passing a FieldSet
back directly rather than a mapped object.ItemProcessor that does nothing - simply passes its argument
through to the caller.LineAggregator implementation that simply calls
Object.toString() on the given objectLineMapper useful for passing the original
String back directly rather than a mapped object.PatternMatcher with a map of patterns to values
Classifier that maps from String patterns with wildcards to a set
of values of a given type.LineMapper implementation that stores a mapping of String patterns
to delegate LineTokenizers as well as a mapping of String patterns to
delegate FieldSetMappers.LineTokenizer implementation that stores a mapping of String
patterns to delegate LineTokenizers.PagingQueryProvider using database specific features.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'.
LineAggregator that concatenates a collection of
items of a common type with the system line separator.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.
RepeatContextCounter.
RepeatContextSupport.
RepeatTemplate.RepeatListener.MethodInterceptor that can be used to automatically repeat calls to
a method on a service.RepeatOperations.ItemReaders that implement ItemStream and read
input from Resource.ItemWriters that implement ItemStream and write
output to Resource.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.BackOffPolicy.
CompletionPolicy.
custom editors to register.
DateFormat to use for parsing numbers.
DateFormat to use for parsing numbers.
Classifier annotation on a method in the supplied delegate and use that
to create a Classifier from the parameter type to the return
type.
LineAggregator to use on single items, that
are not Strings.
ResultSet.
Classifier used by this handler.
RetryCallback.
ResultSet object.
ResultSet object.
ResultSet object.
FieldSet instances.
HibernateOperations property.
ItemPreparedStatementSetter.
ItemSqlParameterSourceProvider.
LineAggregator.
ResultSet object can contain to the given number.
ExecutionContext.
NewMethodArgumentsIdentifier.
NumberFormat to use for parsing numbers.
NumberFormat to use for parsing numbers.
BeanWrapperFieldSetMapper.mapFieldSet(FieldSet).
Statement object to execute to the given number of seconds.
MethodInvocationRecoverer to use if the retry is
exhausted.
RepeatOperations.
RetryContextCache.
RetryPolicy.
ExecutionContext during the ItemStream call to
update.
ExecutionContext during the ItemStream call to
update.
ExecutionContext.
JdbcOperations.
Sleeper strategy.
Sleeper strategy.
SqlMapClient for injection purposes.
SqlMapClientTemplate.
AbstractItemCountingItemStreamItemReader.open(org.springframework.batch.item.ExecutionContext) if the
input resource does not exist.
AbstractItemCountingItemStreamItemReader.open(org.springframework.batch.item.ExecutionContext) if the
input resource does not exist.
CompletionPolicy.
RetryCallback.
SimpleLimitExceptionHandler to
set the limit.
SimpleLimitExceptionHandler.
MethodInvoker interface that invokes a
method on an object.RecordSeparatorPolicy - treats all lines as record
endings.ResourceSuffixCreator that uses the index
itself as suffix, separated by dot.SimpleRetryPolicy with the default number of retry
attempts.
SimpleRetryPolicy with the specified number of retry
attempts, and default exceptions to retry.
RetryContextCache.SoftReferenceMapRetryContextCache with default capacity.
Validator interface to
Validator.PagingQueryProvider interface.PagingQueryProvider using
database specific features.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
Marshaller for serializing object to XML.Classifier for a parameterised object type based on a map.SubclassClassifier with null default value.
SubclassClassifier with supplied default value.
SubclassClassifier with supplied default value.
RecordSeparatorPolicy that looks for an exact match for a String at
the end of a line (e.g.PagingQueryProvider using
database specific features.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).ResultQueue that throttles the number of
expected results, limiting it to a maximum at any given time.RetryPolicy that allows a retry only if it hasn't timed out.TimeoutTerminationPolicy with the specified timeout
value (in milliseconds).
line.
line.
Writer that delays actually writing to the buffer if a
transaction is active.UnexpectedInputException based on a message.
UnexpectedInputException based on a message and another exception.
ExecutionContext.
ExecutionContext provider for the contributions
registered under the given key.
CompletionPolicy.
ItemProcessor that validates input and
returns it without modifications.ValidationException based on a message and another exception.
ValidationException based on a message.
ItemWriter instances according to their
classification by the Classifier.
XMLEventWriter.
WriteFailedException based on a message and another
exception.
WriteFailedException based on a message.
Writer.
Writer.
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 | |||||||||