Example usage for org.springframework.batch.core.step.item BatchRetryTemplate createState

Introduction

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

Prototype

public static List<RetryState> createState(List<?> keys, Classifier<? super Throwable, Boolean> classifier) 

Source Link

Usage

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

@Override
protected void write(final StepContribution contribution, final Chunk<I> inputs, final Chunk<O> outputs)
        throws Exception {
    @SuppressWarnings("unchecked")
    final UserData<O> data = (UserData<O>) inputs.getUserData();
    final AtomicReference<RetryContext> contextHolder = new AtomicReference<RetryContext>();

    RetryCallback<Object, Exception> retryCallback = new RetryCallback<Object, Exception>() {
        @Override/*w  ww.jav a  2s.  c o m*/
        public Object doWithRetry(RetryContext context) throws Exception {
            contextHolder.set(context);

            if (!data.scanning()) {
                chunkMonitor.setChunkSize(inputs.size());
                try {
                    doWrite(outputs.getItems());
                } catch (Exception e) {
                    if (rollbackClassifier.classify(e)) {
                        throw e;
                    }
                    /*
                     * If the exception is marked as no-rollback, we need to
                     * override that, otherwise there's no way to write the
                     * rest of the chunk or to honour the skip listener
                     * contract.
                     */
                    throw new ForceRollbackForWriteSkipException(
                            "Force rollback on skippable exception so that skipped item can be located.", e);
                }
                contribution.incrementWriteCount(outputs.size());
            } else {
                scan(contribution, inputs, outputs, chunkMonitor, false);
            }
            return null;

        }
    };

    if (!buffering) {

        RecoveryCallback<Object> batchRecoveryCallback = new RecoveryCallback<Object>() {

            @Override
            public Object recover(RetryContext context) throws Exception {

                Throwable e = context.getLastThrowable();
                if (outputs.size() > 1 && !rollbackClassifier.classify(e)) {
                    throw new RetryException("Invalid retry state during write caused by "
                            + "exception that does not classify for rollback: ", e);
                }

                Chunk<I>.ChunkIterator inputIterator = inputs.iterator();
                for (Chunk<O>.ChunkIterator outputIterator = outputs.iterator(); outputIterator.hasNext();) {

                    inputIterator.next();
                    outputIterator.next();

                    checkSkipPolicy(inputIterator, outputIterator, e, contribution, true);
                    if (!rollbackClassifier.classify(e)) {
                        throw new RetryException(
                                "Invalid retry state during recovery caused by exception that does not classify for rollback: ",
                                e);
                    }

                }

                return null;

            }

        };

        batchRetryTemplate.execute(retryCallback, batchRecoveryCallback,
                BatchRetryTemplate.createState(getInputKeys(inputs), rollbackClassifier));

    } else {

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

            @Override
            public Object recover(RetryContext context) throws Exception {
                /*
                 * If the last exception was not skippable we don't need to
                 * do any scanning. We can just bomb out with a retry
                 * exhausted.
                 */
                if (!shouldSkip(itemWriteSkipPolicy, context.getLastThrowable(), -1)) {
                    throw new ExhaustedRetryException(
                            "Retry exhausted after last attempt in recovery path, but exception is not skippable.",
                            context.getLastThrowable());
                }

                inputs.setBusy(true);
                data.scanning(true);
                scan(contribution, inputs, outputs, chunkMonitor, true);
                return null;
            }

        };

        if (logger.isDebugEnabled()) {
            logger.debug("Attempting to write: " + inputs);
        }
        try {
            batchRetryTemplate.execute(retryCallback, recoveryCallback,
                    new DefaultRetryState(inputs, rollbackClassifier));
        } catch (Exception e) {
            RetryContext context = contextHolder.get();
            if (!batchRetryTemplate.canRetry(context)) {
                /*
                 * BATCH-1761: we need advance warning of the scan about to
                 * start in the next transaction, so we can change the
                 * processing behaviour.
                 */
                data.scanning(true);
            }
            throw e;
        }

    }

    callSkipListeners(inputs, outputs);

}

---