Example usage for org.springframework.batch.core.step.item Chunk add

Introduction

In this page you can find the example usage for org.springframework.batch.core.step.item Chunk add.

Prototype

public void add(W item) 

Source Link

Document

Add the item to the chunk.

Usage

From source file:org.springframework.batch.core.jsr.step.item.JsrChunkProcessor.java

/**
 * Loops through reading (via {@link #provide(StepContribution, Chunk)} and
 * processing (via {@link #transform(StepContribution, Object)}) until the chunk
 * is complete.  Once the chunk is complete, the results are written (via
 * {@link #persist(StepContribution, Chunk)}.
 *
 * @see ChunkProcessor#process(StepContribution, Chunk)
 * @param contribution a {@link StepContribution}
 * @param chunk a {@link Chunk}/*ww w .  j ava 2s  .co m*/
 */
@Override
public void process(final StepContribution contribution, final Chunk<I> chunk) throws Exception {

    final AtomicInteger filterCount = new AtomicInteger(0);
    final Chunk<O> output = new Chunk<O>();

    repeatTemplate.iterate(new RepeatCallback() {

        @Override
        public RepeatStatus doInIteration(RepeatContext context) throws Exception {
            I item = provide(contribution, chunk);

            if (item != null) {
                contribution.incrementReadCount();
            } else {
                return RepeatStatus.FINISHED;
            }

            O processedItem = transform(contribution, item);

            if (processedItem == null) {
                filterCount.incrementAndGet();
            } else {
                output.add(processedItem);
            }

            return RepeatStatus.CONTINUABLE;
        }
    });

    contribution.incrementFilterCount(filterCount.get());
    if (output.size() > 0) {
        persist(contribution, output);
    }
}

---

From source file:org.springframework.batch.core.step.item.FaultTolerantChunkProcessor.java

@Override
protected Chunk<O> transform(final StepContribution contribution, Chunk<I> inputs) throws Exception {

    Chunk<O> outputs = new Chunk<O>();
    @SuppressWarnings("unchecked")
    final UserData<O> data = (UserData<O>) inputs.getUserData();
    final Chunk<O> cache = data.getOutputs();
    final Iterator<O> cacheIterator = cache.isEmpty() ? null : new ArrayList<O>(cache.getItems()).iterator();
    final AtomicInteger count = new AtomicInteger(0);

    // final int scanLimit = processorTransactional && data.scanning() ? 1 :
    // 0;/*from  w  w  w  .  j  ava  2 s  . c  o  m*/

    for (final Chunk<I>.ChunkIterator iterator = inputs.iterator(); iterator.hasNext();) {

        final I item = iterator.next();

        RetryCallback<O, Exception> retryCallback = new RetryCallback<O, Exception>() {

            @Override
            public O doWithRetry(RetryContext context) throws Exception {
                O output = null;
                try {
                    count.incrementAndGet();
                    O cached = (cacheIterator != null && cacheIterator.hasNext()) ? cacheIterator.next() : null;
                    if (cached != null && !processorTransactional) {
                        output = cached;
                    } else {
                        output = doProcess(item);
                        if (output == null) {
                            data.incrementFilterCount();
                        } else if (!processorTransactional && !data.scanning()) {
                            cache.add(output);
                        }
                    }
                } catch (Exception e) {
                    if (rollbackClassifier.classify(e)) {
                        // Default is to rollback unless the classifier
                        // allows us to continue
                        throw e;
                    } else if (shouldSkip(itemProcessSkipPolicy, e, contribution.getStepSkipCount())) {
                        // If we are not re-throwing then we should check if
                        // this is skippable
                        contribution.incrementProcessSkipCount();
                        logger.debug("Skipping after failed process with no rollback", e);
                        // If not re-throwing then the listener will not be
                        // called in next chunk.
                        callProcessSkipListener(item, e);
                    } else {
                        // If it's not skippable that's an error in
                        // configuration - it doesn't make sense to not roll
                        // back if we are also not allowed to skip
                        throw new NonSkippableProcessException(
                                "Non-skippable exception in processor.  Make sure any exceptions that do not cause a rollback are skippable.",
                                e);
                    }
                }
                if (output == null) {
                    // No need to re-process filtered items
                    iterator.remove();
                }
                return output;
            }

        };

        RecoveryCallback<O> recoveryCallback = new RecoveryCallback<O>() {

            @Override
            public O recover(RetryContext context) throws Exception {
                Throwable e = context.getLastThrowable();
                if (shouldSkip(itemProcessSkipPolicy, e, contribution.getStepSkipCount())) {
                    iterator.remove(e);
                    contribution.incrementProcessSkipCount();
                    logger.debug("Skipping after failed process", e);
                    return null;
                } else {
                    if (rollbackClassifier.classify(e)) {
                        // Default is to rollback unless the classifier
                        // allows us to continue
                        throw new RetryException("Non-skippable exception in recoverer while processing", e);
                    }
                    iterator.remove(e);
                    return null;
                }
            }

        };

        O output = batchRetryTemplate.execute(retryCallback, recoveryCallback,
                new DefaultRetryState(getInputKey(item), rollbackClassifier));
        if (output != null) {
            outputs.add(output);
        }

        /*
         * We only want to process the first item if there is a scan for a
         * failed item.
         */
        if (data.scanning()) {
            while (cacheIterator != null && cacheIterator.hasNext()) {
                outputs.add(cacheIterator.next());
            }
            // Only process the first item if scanning
            break;
        }
    }

    return outputs;

}

---

From source file:org.springframework.batch.core.step.item.SimpleChunkProvider.java

@Override
public Chunk<I> provide(final StepContribution contribution) throws Exception {

    final Chunk<I> inputs = new Chunk<I>();
    repeatOperations.iterate(new RepeatCallback() {

        @Override/*from   w w w  .  j a v a2 s.c o  m*/
        public RepeatStatus doInIteration(final RepeatContext context) throws Exception {
            I item = null;
            try {
                item = read(contribution, inputs);
            } catch (SkipOverflowException e) {
                // read() tells us about an excess of skips by throwing an
                // exception
                return RepeatStatus.FINISHED;
            }
            if (item == null) {
                inputs.setEnd();
                return RepeatStatus.FINISHED;
            }
            inputs.add(item);
            contribution.incrementReadCount();
            return RepeatStatus.CONTINUABLE;
        }

    });

    return inputs;

}

---