Example usage for org.springframework.batch.repeat.support TaskExecutorRepeatTemplate TaskExecutorRepeatTemplate

Introduction

In this page you can find the example usage for org.springframework.batch.repeat.support TaskExecutorRepeatTemplate TaskExecutorRepeatTemplate.

Prototype

TaskExecutorRepeatTemplate

Source Link

Usage

From source file:org.springframework.batch.core.configuration.xml.StepParserStepFactoryBean.java

@SuppressWarnings("serial")
private void configureTaskletStep(TaskletStep ts) {
    configureAbstractStep(ts);/*from w ww. j av a2 s.  c  o  m*/
    if (listeners != null) {
        List<ChunkListener> newListeners = new ArrayList<ChunkListener>();
        for (StepListener listener : listeners) {
            if (listener instanceof ChunkListener) {
                newListeners.add((ChunkListener) listener);
            }
        }
        ts.setChunkListeners(newListeners.toArray(new ChunkListener[0]));
    }
    if (tasklet != null) {
        ts.setTasklet(tasklet);
    }
    if (taskExecutor != null) {
        TaskExecutorRepeatTemplate repeatTemplate = new TaskExecutorRepeatTemplate();
        repeatTemplate.setTaskExecutor(taskExecutor);
        if (throttleLimit != null) {
            repeatTemplate.setThrottleLimit(throttleLimit);
        }
        ts.setStepOperations(repeatTemplate);
    }
    if (transactionManager != null) {
        ts.setTransactionManager(transactionManager);
    }
    if (transactionTimeout != null || propagation != null || isolation != null
            || noRollbackExceptionClasses != null) {
        DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
        if (propagation != null) {
            attribute.setPropagationBehavior(propagation.value());
        }
        if (isolation != null) {
            attribute.setIsolationLevel(isolation.value());
        }
        if (transactionTimeout != null) {
            attribute.setTimeout(transactionTimeout);
        }
        Collection<Class<? extends Throwable>> exceptions = noRollbackExceptionClasses == null
                ? new HashSet<Class<? extends Throwable>>()
                : noRollbackExceptionClasses;
        final BinaryExceptionClassifier classifier = new BinaryExceptionClassifier(exceptions, false);
        ts.setTransactionAttribute(new DefaultTransactionAttribute(attribute) {
            @Override
            public boolean rollbackOn(Throwable ex) {
                return classifier.classify(ex);
            }
        });
    }
}

---

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

/**
 * @param step/*from w  w w  .j  av a 2  s. c  o m*/
 * 
 */
protected void applyConfiguration(TaskletStep step) {

    Assert.state(getItemReader() != null, "ItemReader must be provided");
    Assert.state(getItemWriter() != null || getItemProcessor() != null,
            "ItemWriter or ItemProcessor must be provided");
    Assert.state(transactionManager != null, "TransactionManager must be provided");

    step.setTransactionManager(transactionManager);
    step.setTransactionAttribute(getTransactionAttribute());
    step.setJobRepository(jobRepository);
    step.setStartLimit(startLimit);
    step.setAllowStartIfComplete(allowStartIfComplete);

    registerStreams(step, streams);

    if (chunkOperations == null) {
        RepeatTemplate repeatTemplate = new RepeatTemplate();
        repeatTemplate.setCompletionPolicy(getChunkCompletionPolicy());
        chunkOperations = repeatTemplate;
    }

    if (stepOperations == null) {

        stepOperations = new RepeatTemplate();

        if (taskExecutor != null) {
            TaskExecutorRepeatTemplate repeatTemplate = new TaskExecutorRepeatTemplate();
            repeatTemplate.setTaskExecutor(taskExecutor);
            repeatTemplate.setThrottleLimit(throttleLimit);
            stepOperations = repeatTemplate;
        }

        ((RepeatTemplate) stepOperations).setExceptionHandler(exceptionHandler);

    }

    step.setStepOperations(stepOperations);

    SimpleChunkProvider<T> chunkProvider = configureChunkProvider();

    SimpleChunkProcessor<T, S> chunkProcessor = configureChunkProcessor();

    registerItemListeners(chunkProvider, chunkProcessor);
    registerStepListeners(step, chunkOperations);
    registerStreams(step, itemReader, itemProcessor, itemWriter);

    ChunkOrientedTasklet<T> tasklet = new ChunkOrientedTasklet<T>(chunkProvider, chunkProcessor);
    tasklet.setBuffering(!isReaderTransactionalQueue());

    step.setTasklet(tasklet);

}

---

From source file:org.springframework.batch.core.step.tasklet.AsyncChunkOrientedStepIntegrationTests.java

@Before
public void init() throws Exception {

    maxActive = dataSource.getMaxActive();
    maxIdle = dataSource.getMaxIdle();//from w w w.ja  v  a  2  s. c  om

    // Force deadlock with batch waiting for DB pool and vice versa
    dataSource.setMaxActive(1);
    dataSource.setMaxIdle(1);

    step = new TaskletStep("stepName");
    step.setJobRepository(jobRepository);
    step.setTransactionManager(transactionManager);

    // Only process one item:
    chunkOperations = new RepeatTemplate();
    chunkOperations.setCompletionPolicy(new SimpleCompletionPolicy(1));

    job = new JobSupport("FOO");

    TaskExecutorRepeatTemplate repeatTemplate = new TaskExecutorRepeatTemplate();
    repeatTemplate.setThrottleLimit(2);
    repeatTemplate.setTaskExecutor(new SimpleAsyncTaskExecutor());
    step.setStepOperations(repeatTemplate);
    step.setTransactionManager(transactionManager);
}

---

From source file:org.springframework.batch.core.step.tasklet.AsyncTaskletStepTests.java

private void setUp() throws Exception {

    step = new TaskletStep("stepName");

    ResourcelessTransactionManager transactionManager = new ResourcelessTransactionManager();
    step.setTransactionManager(transactionManager);

    RepeatTemplate chunkTemplate = new RepeatTemplate();
    chunkTemplate.setCompletionPolicy(new SimpleCompletionPolicy(2));
    step.setTasklet(new TestingChunkOrientedTasklet<String>(new ListItemReader<String>(items), itemProcessor,
            itemWriter, chunkTemplate));

    jobRepository = new JobRepositorySupport();
    step.setJobRepository(jobRepository);

    TaskExecutorRepeatTemplate template = new TaskExecutorRepeatTemplate();
    template.setThrottleLimit(throttleLimit);
    SimpleAsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
    taskExecutor.setConcurrencyLimit(concurrencyLimit);
    template.setTaskExecutor(taskExecutor);
    step.setStepOperations(template);/*from  w  ww. j a  v a2s .  co m*/

    step.registerStream(new ItemStreamSupport() {
        private int count = 0;

        @Override
        public void update(ExecutionContext executionContext) {
            super.update(executionContext);
            executionContext.putInt("counter", count++);
        }
    });

}

---

From source file:org.springframework.batch.repeat.support.TaskExecutorRepeatTemplateBulkAsynchronousTests.java

@Before
public void setUp() {

    template = new TaskExecutorRepeatTemplate();
    TaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
    threadPool.setMaxPoolSize(300);//www.  j a v  a  2s .com
    threadPool.setCorePoolSize(10);
    threadPool.setQueueCapacity(0);
    threadPool.afterPropertiesSet();
    taskExecutor = threadPool;
    template.setTaskExecutor(taskExecutor);
    template.setThrottleLimit(throttleLimit);

    items = Collections.synchronizedList(new ArrayList<String>());

    callback = new RepeatCallback() {

        private volatile AtomicInteger count = new AtomicInteger(0);

        @Override
        public RepeatStatus doInIteration(RepeatContext context) throws Exception {
            int position = count.incrementAndGet();
            String item = position <= total ? "" + position : null;
            items.add("" + item);
            if (item != null) {
                beBusy();
            }
            /*
             * In a multi-threaded task, one of the callbacks can call
             * FINISHED early, while other threads are still working, and
             * would do more work if the callback was called again. (This
             * happens for instance if there is a failure and you want to
             * retry the work.)
             */
            RepeatStatus result = RepeatStatus.continueIf(position != early && item != null);
            if (position == error) {
                throw new RuntimeException("Planned");
            }
            if (!result.isContinuable()) {
                logger.debug("Returning " + result + " for count=" + position);
            }
            return result;
        }
    };

}

---