How to use

setChunkSize

method

in

org.springframework.batch.core.step.item.ChunkMonitor

  @Override
  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;
  }
};

@Before
public void setUp() {
  monitor.setItemReader(new ItemReader<String>() {
    @Override
    public String read() throws Exception, UnexpectedInputException, ParseException {
      return "" + (count++);
    }
  });
  monitor.registerItemStream(new ItemStreamSupport() {
    @Override
    public void close() {
      super.close();
      closed = true;
    }
  });
  monitor.setChunkSize(CHUNK_SIZE);
}

  @Override
  @SuppressWarnings({ "unchecked", "rawtypes" })
  public Object doWithRetry(RetryContext context) throws Exception {
    chunkMonitor.setChunkSize(chunk.size());
    try {
      doPersist(contribution, chunk);
    }
    catch (Exception e) {
      if (shouldSkip(skipPolicy, e, contribution.getStepSkipCount())) {
        // Per section 9.2.7 of JSR-352, the SkipListener receives all the items within the chunk 						 
        ((MulticasterBatchListener) getListener()).onSkipInWrite(chunk.getItems(), e);
      } else {
        getListener().onRetryWriteException((List<Object>) chunk.getItems(), 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(chunk.size());
    return null;
  }
};

  @Test
  public void testUpdateWithNoStream() throws Exception {
    monitor = new ChunkMonitor();
    monitor.setItemReader(new ItemReader<String>() {
      @Override
      public String read() throws Exception, UnexpectedInputException, ParseException {
        return "" + (count++);
      }
    });
    monitor.setChunkSize(CHUNK_SIZE);
    monitor.incrementOffset();
    ExecutionContext executionContext = new ExecutionContext();
    monitor.update(executionContext);
    assertEquals(0, executionContext.size());
  }
}

  @Override
  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;
  }
};

  @Override
  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;
  }
};

  @Override
  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;
  }
};

  public Object doWithRetry(RetryContext context) throws Exception {
    if (!inputs.isBusy()) {
      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);
    }
    return null;
  }
};

  @Override
  @SuppressWarnings({ "unchecked", "rawtypes" })
  public Object doWithRetry(RetryContext context) throws Exception {
    chunkMonitor.setChunkSize(chunk.size());
    try {
      doPersist(contribution, chunk);
    }
    catch (Exception e) {
      if (shouldSkip(skipPolicy, e, contribution.getStepSkipCount())) {
        // Per section 9.2.7 of JSR-352, the SkipListener receives all the items within the chunk 						 
        ((MulticasterBatchListener) getListener()).onSkipInWrite(chunk.getItems(), e);
      } else {
        getListener().onRetryWriteException((List<Object>) chunk.getItems(), 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(chunk.size());
    return null;
  }
};

  @Override
  @SuppressWarnings({ "unchecked", "rawtypes" })
  public Object doWithRetry(RetryContext context) throws Exception {
    chunkMonitor.setChunkSize(chunk.size());
    try {
      doPersist(contribution, chunk);
    }
    catch (Exception e) {
      if (shouldSkip(skipPolicy, e, contribution.getStepSkipCount())) {
        // Per section 9.2.7 of JSR-352, the SkipListener receives all the items within the chunk 						 
        ((MulticasterBatchListener) getListener()).onSkipInWrite(chunk.getItems(), e);
      } else {
        getListener().onRetryWriteException((List<Object>) chunk.getItems(), 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(chunk.size());
    return null;
  }
};

  @Override
  @SuppressWarnings({ "unchecked", "rawtypes" })
  public Object doWithRetry(RetryContext context) throws Exception {
    chunkMonitor.setChunkSize(chunk.size());
    try {
      doPersist(contribution, chunk);
    }
    catch (Exception e) {
      if (shouldSkip(skipPolicy, e, contribution.getStepSkipCount())) {
        // Per section 9.2.7 of JSR-352, the SkipListener receives all the items within the chunk 						 
        ((MulticasterBatchListener) getListener()).onSkipInWrite(chunk.getItems(), e);
      } else {
        getListener().onRetryWriteException((List<Object>) chunk.getItems(), 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(chunk.size());
    return null;
  }
};