builder.chunk(commitInterval); builder.chunk(chunkCompletionPolicy); enhanceTaskletStepBuilder(builder); builder.reader(itemReader); builder.writer(itemWriter); builder.processor(itemProcessor); builder.processorNonTransactional(); builder.readerIsTransactionalQueue(); builder.listener(listener); builder.listener(listener); builder.skipPolicy(skipPolicy); builder.skipLimit(skipLimit); for (Class<? extends Throwable> type : skippableExceptionClasses.keySet()) { if (skippableExceptionClasses.get(type)) { builder.skip(type); builder.noSkip(type); builder.listener(listener); builder.retryContextCache(retryContextCache);
faultTolerantBuilder.retryContextCache(retryContextCache); for (SkipListener<T, S> listener : BatchListenerFactoryHelper.<SkipListener<T, S>> getListeners(getListeners(), SkipListener.class)) { faultTolerantBuilder.listener(listener); faultTolerantBuilder.listener(listener); faultTolerantBuilder.skipPolicy(skipPolicy); faultTolerantBuilder.skipLimit(skipLimit); for (Class<? extends Throwable> type : skippableExceptionClasses.keySet()) { if (skippableExceptionClasses.get(type)) { faultTolerantBuilder.skip(type); faultTolerantBuilder.noSkip(type); faultTolerantBuilder.processorNonTransactional(); faultTolerantBuilder.retryContextCache(retryContextCache); faultTolerantBuilder.keyGenerator(keyGenerator); faultTolerantBuilder.retryPolicy(retryPolicy); faultTolerantBuilder.retryLimit(retryLimit); faultTolerantBuilder.backOffPolicy(backOffPolicy); for (Class<? extends Throwable> type : retryableExceptionClasses.keySet()) { if (retryableExceptionClasses.get(type)) { faultTolerantBuilder.retry(type); faultTolerantBuilder.noRetry(type); faultTolerantBuilder.noRollback(type);
@Override @Bean public Step step(){ return stepBuilders.get("step") .listener(listener()) .<String,String>chunk(2) .reader(reader()) .writer(writer()) .faultTolerant() .skipLimit(1) .skip(MySkippableException.class) // ChunkListener registered twice for checking BATCH-2149 .listener((ChunkListener) listener()) .build(); } }
@Bean public Step step1(StepBuilderFactory stepBuilderFactory, ItemReader<String> fakeItemReader, ItemProcessor<String, String> fakeProcessor, ItemWriter<String> fakeItemWriter, ItemProcessListener<String, String> itemProcessListener) { return stepBuilderFactory.get("testStep").<String, String>chunk(10) .reader(fakeItemReader) .processor(fakeProcessor) .writer(fakeItemWriter) .listener(itemProcessListener) .faultTolerant().skipLimit(50).skip(RuntimeException.class) .build(); }
@Test public void testFilterCountOnRetryWithNonTransactionalProcessorWhenSkipInWrite() throws Exception { // Given Step step = stepBuilder .retry(IllegalArgumentException.class) .retryLimit(2) .skipPolicy(skipPolicy) .processorNonTransactional() .build(); // When StepExecution stepExecution = execute(step); // Then assertEquals(TOTAL_ITEMS, stepExecution.getReadCount()); // filter count is expected to be counted on each retry attempt assertEquals(20, stepExecution.getFilterCount()); assertEquals(19, stepExecution.getWriteCount()); assertEquals(1, stepExecution.getWriteSkipCount()); }
@Test public void testSkipReadError() throws Exception{ reader.failCount = 10; Step step = builder.faultTolerant().skip(RuntimeException.class).skipLimit(20).chunk(25).reader(reader).processor(processor).writer(writer).listener((ItemReadListener<String>) listener).build(); runStep(step); assertNotNull(stepExecution); assertEquals(BatchStatus.COMPLETED, stepExecution.getStatus()); assertEquals(25, processor.count); assertEquals(25, writer.results.size()); assertEquals(0, stepExecution.getProcessSkipCount()); assertEquals(25, stepExecution.getReadCount()); assertEquals(1, stepExecution.getReadSkipCount()); assertEquals(1, stepExecution.getSkipCount()); assertEquals(25, stepExecution.getWriteCount()); assertEquals(0, stepExecution.getFilterCount()); assertEquals(0, stepExecution.getWriteSkipCount()); assertEquals(0, stepExecution.getFailureExceptions().size()); assertEquals(25, listener.afterProcess); assertEquals(25, listener.afterRead); assertEquals(1, listener.afterWrite); assertEquals(25, listener.beforeProcess); assertEquals(27, listener.beforeRead); assertEquals(1, listener.beforeWriteCount); assertEquals(0, listener.onProcessError); assertEquals(1, listener.onReadError); assertEquals(0, listener.onWriteError); }
@Bean protected Step step() { return steps.get("step").<Trade, Object> chunk(1).reader(reader()).writer(writer()).faultTolerant() .retry(Exception.class).retryLimit(3).build(); }
@Test public void testRetryReadError() throws Exception{ reader.failCount = 10; Step step = builder.faultTolerant().retry(RuntimeException.class).retryLimit(20).chunk(25).reader(reader).processor(processor).writer(writer).listener((ItemReadListener<String>) listener).build(); runStep(step); assertEquals(BatchStatus.COMPLETED, stepExecution.getStatus()); assertEquals(25, processor.count); assertEquals(25, writer.results.size()); assertEquals(0, stepExecution.getProcessSkipCount()); assertEquals(25, stepExecution.getReadCount()); assertEquals(0, stepExecution.getReadSkipCount()); assertEquals(0, stepExecution.getSkipCount()); assertEquals(25, stepExecution.getWriteCount()); assertEquals(0, stepExecution.getFilterCount()); assertEquals(0, stepExecution.getWriteSkipCount()); assertEquals(0, stepExecution.getFailureExceptions().size()); assertEquals(25, listener.afterProcess); assertEquals(25, listener.afterRead); assertEquals(1, listener.afterWrite); assertEquals(25, listener.beforeProcess); assertEquals(27, listener.beforeRead); assertEquals(1, listener.beforeWriteCount); assertEquals(0, listener.onProcessError); assertEquals(1, listener.onReadError); assertEquals(0, listener.onWriteError); }
@Override public RemoteChunkingMasterStepBuilder<I, O> listener(Object listener) { super.listener(listener); return this; }
@Test public void testFilterCountWithNonTransactionalProcessorWhenSkipInWrite() throws Exception { // Given Step step = stepBuilder .skipPolicy(skipPolicy) .processorNonTransactional() .build(); // When StepExecution stepExecution = execute(step); // Then assertEquals(TOTAL_ITEMS, stepExecution.getReadCount()); assertEquals(10, stepExecution.getFilterCount()); assertEquals(19, stepExecution.getWriteCount()); assertEquals(1, stepExecution.getWriteSkipCount()); }
/** * Build a master {@link TaskletStep}. * * @return the configured master step * @see RemoteChunkHandlerFactoryBean */ public TaskletStep build() { Assert.notNull(this.inputChannel, "An InputChannel must be provided"); Assert.state(this.outputChannel == null || this.messagingTemplate == null, "You must specify either an outputChannel or a messagingTemplate but not both."); // configure messaging template if (this.messagingTemplate == null) { this.messagingTemplate = new MessagingTemplate(); this.messagingTemplate.setDefaultChannel(this.outputChannel); if (this.logger.isDebugEnabled()) { this.logger.debug("No messagingTemplate was provided, using a default one"); } } // configure item writer ChunkMessageChannelItemWriter<O> chunkMessageChannelItemWriter = new ChunkMessageChannelItemWriter<>(); chunkMessageChannelItemWriter.setMessagingOperations(this.messagingTemplate); chunkMessageChannelItemWriter.setMaxWaitTimeouts(this.maxWaitTimeouts); chunkMessageChannelItemWriter.setThrottleLimit(this.throttleLimit); chunkMessageChannelItemWriter.setReplyChannel(this.inputChannel); super.writer(chunkMessageChannelItemWriter); return super.build(); }
@Test public void testFilterCountWithTransactionalProcessorWhenSkipInWrite() throws Exception { // Given Step step = stepBuilder .skipPolicy(skipPolicy) .build(); // When StepExecution stepExecution = execute(step); // Then assertEquals(TOTAL_ITEMS, stepExecution.getReadCount()); assertEquals(10, stepExecution.getFilterCount()); assertEquals(19, stepExecution.getWriteCount()); assertEquals(1, stepExecution.getWriteSkipCount()); }
@Override public RemoteChunkingMasterStepBuilder<I, O> skipLimit(int skipLimit) { super.skipLimit(skipLimit); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> skip(Class<? extends Throwable> type) { super.skip(type); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> retryLimit(int retryLimit) { super.retryLimit(retryLimit); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> retry(Class<? extends Throwable> type) { super.retry(type); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> chunk(int chunkSize) { super.chunk(chunkSize); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> skipPolicy(SkipPolicy skipPolicy) { super.skipPolicy(skipPolicy); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> keyGenerator(KeyGenerator keyGenerator) { super.keyGenerator(keyGenerator); return this; }
@Override public RemoteChunkingMasterStepBuilder<I, O> backOffPolicy(BackOffPolicy backOffPolicy) { super.backOffPolicy(backOffPolicy); return this; }