|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Query providers.ItemReaders that supports restart by storing
item count in the ExecutionContext (therefore requires item ordering
to be preserved between runs).ItemReader implementations.ItemWriter implementations.Query providers.LineTokenizer
implementations such as dealing with names and actual construction of
FieldSetThrowable (not an Exception) thrown by a
reflectively-invoked delegate.ItemReader 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).BufferedReader allowing
customisation of the standard behaviour of the java.io variety.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.
ItemStream, just pass the call on,
otherwise reset the peek cache.
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.
BufferedReader for reading String items from the
provided resource.
SQLQuery from the session provided (preferring
stateless if both are available).
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.MailErrorHandler implementation simply rethrows the exception it
receives.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.Poller that uses the callers thread to poll for a result as soon as
it is asked for.FixedBackOffPolicy.setBackOffPeriod(long).
AbstractItemCountingItemStreamItemReader.doOpen().
AbstractCursorItemReader.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.
EntityManager
FieldSet'.
DataFieldMaxValueIncrementer for the provided database type.
Message then returns the JMS message ID.
ExecutionContextUserSupport.getName() to create a unique key that can be safely used to identify data
stored in 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.
PagingQueryProvider using database specific features.MailException.
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.Querys from injected native SQL
queries.ItemReader for reading database records built on top of Hibernate and
reading only up to a fixed number of items at a time.ItemReaders or other custom built artifacts.MethodInvoker that is a bit relaxed about its arguments.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.ItemStream and ItemWriter
.ItemWriter extend.ItemWriterException based on a message and another exception.
ItemWriterException based on a message.
ItemReader that pulls data from a Iterator or
Iterable using the constructors.Iterator from it.
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.Querys from injected native SQL
queries.ItemReader for reading database
records built on top of JPA.ItemReaders or other custom built artifacts.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.
ItemWriter that can send mail messages.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.NonTransientResourceException based on a message and
another exception.
NonTransientResourceException based on a message.
Sleeper implementation that just waits on a local Object.ExecutionContext.
ItemStream, just pass the call on,
otherwise reset the peek cache.
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.ItemReader.read(), without
affecting the result of ItemReader.read().
ItemStream the state is stored for the next call to
SingleItemPeekableItemReader.update(ExecutionContext).
ItemReader that allows the user to look ahead
into the stream of items.Callable instance provided by the user.PagingQueryProvider using database specific features.Resource instance from
the input, or null if none remain.
ItemReader.read() that just iterates over the
iterator provided.
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.
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.ItemReader which produces Resource instances from an array.ResultQueue that throttles the number of
expected results, limiting it to a maximum at any given time.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.
BufferedReader that will be used to extract lines from the file.
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.
HibernateQueryProvider.
EntityManager for the query to be built.
Classifier used by this handler.
RetryCallback.
ResultSet object.
ResultSet object.
FieldSet instances.
HibernateOperations property.
ItemPreparedStatementSetter.
ItemSqlParameterSourceProvider.
JavaMailSender to be used to send messages in MimeMessageItemWriter.write(List).
LineAggregator.
MailSender to be used to send messages in SimpleMailMessageItemWriter.write(List).
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).
PagingQueryProvider.
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.
Session that can be used as a factory for queries.
JdbcOperations.
Sleeper strategy.
Sleeper strategy.
SqlMapClient for injection purposes.
SqlMapClientTemplate.
StatelessSession that can be used as a factory for
queries.
AbstractItemCountingItemStreamItemReader.open(org.springframework.batch.item.ExecutionContext) if the input resource does not exist.
MultiResourceItemReader.open(org.springframework.batch.item.ExecutionContext) if there are no resources to read.
AbstractItemCountingItemStreamItemReader.open(org.springframework.batch.item.ExecutionContext) if the input resource does not exist.
CompletionPolicy.
RetryCallback.
BufferedReaderFactory useful for reading simple binary (or text)
files with no line endings, such as those produced by mainframe copy books.SimpleLimitExceptionHandler to
set the limit.
SimpleLimitExceptionHandler.
ItemWriter that can send mail messages.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.
PeekableItemReader that allows the user to peek one item ahead.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.ResultSet.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 or closing 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 | |||||||||