Java tutorial
/* * Copyright 2013 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.batch.core.jsr.step.item; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.batch.core.StepContribution; import org.springframework.batch.core.StepListener; import org.springframework.batch.core.listener.MulticasterBatchListener; import org.springframework.batch.core.step.item.Chunk; import org.springframework.batch.core.step.item.ChunkProcessor; import org.springframework.batch.item.ItemProcessor; import org.springframework.batch.item.ItemReader; import org.springframework.batch.item.ItemWriter; import org.springframework.batch.repeat.RepeatCallback; import org.springframework.batch.repeat.RepeatContext; import org.springframework.batch.repeat.RepeatOperations; import org.springframework.batch.repeat.RepeatStatus; /** * {@link ChunkProcessor} implementation that implements JSR-352's chunking pattern * (read and process in a loop until the chunk is complete then write). This * implementation is responsible for all three phases of chunk based processing * (reading, processing and writing). * * @author Michael Minella * * @param <I> The input type for the step * @param <O> The output type for the step */ public class JsrChunkProcessor<I, O> implements ChunkProcessor<I> { private final Log logger = LogFactory.getLog(getClass()); private ItemReader<? extends I> itemReader; private final MulticasterBatchListener<I, O> listener = new MulticasterBatchListener<I, O>(); private RepeatOperations repeatTemplate; private ItemProcessor<? super I, ? extends O> itemProcessor; private ItemWriter<? super O> itemWriter; public JsrChunkProcessor() { this(null, null, null, null); } public JsrChunkProcessor(ItemReader<? extends I> reader, ItemProcessor<? super I, ? extends O> processor, ItemWriter<? super O> writer, RepeatOperations repeatTemplate) { this.itemReader = reader; this.itemProcessor = processor; this.itemWriter = writer; this.repeatTemplate = repeatTemplate; } protected MulticasterBatchListener<I, O> getListener() { return listener; } /** * 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} */ @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); } } /** * Register some {@link StepListener}s with the handler. Each will get the * callbacks in the order specified at the correct stage. * * @param listeners list of listeners to be used within this step */ public void setListeners(List<? extends StepListener> listeners) { for (StepListener listener : listeners) { registerListener(listener); } } /** * Register a listener for callbacks at the appropriate stages in a process. * * @param listener a {@link StepListener} */ public void registerListener(StepListener listener) { this.listener.register(listener); } /** * Responsible for the reading portion of the chunking loop. In this implementation, delegates * to {@link #doProvide(StepContribution, Chunk)} * * @param contribution a {@link StepContribution} * @param chunk a {@link Chunk} * @return an item * @throws Exception */ protected I provide(final StepContribution contribution, final Chunk<I> chunk) throws Exception { return doProvide(contribution, chunk); } /** * Implements reading as well as any related listener calls required. * * @param contribution a {@link StepContribution} * @param chunk a {@link Chunk} * @return an item * @throws Exception */ protected final I doProvide(final StepContribution contribution, final Chunk<I> chunk) throws Exception { try { listener.beforeRead(); I item = itemReader.read(); if (item != null) { listener.afterRead(item); } else { chunk.setEnd(); } return item; } catch (Exception e) { if (logger.isDebugEnabled()) { logger.debug(e.getMessage() + " : " + e.getClass().getName()); } listener.onReadError(e); throw e; } } /** * Responsible for the processing portion of the chunking loop. In this implementation, delegates to the * {@link #doTransform(Object)} if a processor is available (returns the item unmodified if it is not) * * @param contribution a {@link StepContribution} * @param item an item * @return a processed item if a processor is present (the unmodified item if it is not) * @throws Exception */ protected O transform(final StepContribution contribution, final I item) throws Exception { if (itemProcessor == null) { @SuppressWarnings("unchecked") O result = (O) item; return result; } return doTransform(item); } /** * Implements processing and all related listener calls. * * @param item the item to be processed * @return the processed item * @throws Exception */ protected final O doTransform(I item) throws Exception { try { listener.beforeProcess(item); O result = itemProcessor.process(item); listener.afterProcess(item, result); return result; } catch (Exception e) { listener.onProcessError(item, e); throw e; } } /** * Responsible for the writing portion of the chunking loop. In this implementation, delegates to the * {{@link #doPersist(StepContribution, Chunk)}. * * @param contribution a {@link StepContribution} * @param chunk a {@link Chunk} * @throws Exception */ protected void persist(final StepContribution contribution, final Chunk<O> chunk) throws Exception { doPersist(contribution, chunk); contribution.incrementWriteCount(chunk.getItems().size()); } /** * Implements writing and all related listener calls * * @param contribution a {@link StepContribution} * @param chunk a {@link Chunk} * @throws Exception */ protected final void doPersist(final StepContribution contribution, final Chunk<O> chunk) throws Exception { try { List<O> items = chunk.getItems(); listener.beforeWrite(items); itemWriter.write(items); listener.afterWrite(items); } catch (Exception e) { listener.onWriteError(e, chunk.getItems()); throw e; } } }