org.springframework.batch.core.step.skip

## Class LimitCheckingItemSkipPolicy

- java.lang.Object
- - org.springframework.batch.core.step.skip.LimitCheckingItemSkipPolicy

- All Implemented Interfaces:
    SkipPolicy

      public class LimitCheckingItemSkipPolicy
      extends java.lang.Object
      implements SkipPolicy

  `SkipPolicy` that determines whether or not reading should continue based upon how many items have been skipped. This is extremely useful behavior, as it allows you to skip records, but will throw a `SkipLimitExceededException` if a set limit has been exceeded. For example, it is generally advisable to skip `FlatFileParseException`s, however, if the vast majority of records are causing exceptions, the file is likely bad.

  Furthermore, it is also likely that you only want to skip certain exceptions. `FlatFileParseException` is a good example of an exception you will likely want to skip, but a `FileNotFoundException` should cause immediate termination of the `Step`. A `Classifier` is used to determine whether a particular exception is skippable or not.

  Author:
    Ben Hale, Lucas Ward, Robert Kasanicky, Dave Syer, Dan Garrette

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `LimitCheckingItemSkipPolicy()` Convenience constructor that assumes all exception types are fatal.
    `LimitCheckingItemSkipPolicy(int skipLimit, org.springframework.classify.Classifier<java.lang.Throwable,java.lang.Boolean> skippableExceptionClassifier)`
    `LimitCheckingItemSkipPolicy(int skipLimit, java.util.Map<java.lang.Class<? extends java.lang.Throwable>,java.lang.Boolean> skippableExceptions)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `setSkipLimit(int skipLimit)` The absolute number of skips (of skippable exceptions) that can be tolerated before a failure.
    `void` | `setSkippableExceptionClassifier(org.springframework.classify.Classifier<java.lang.Throwable,java.lang.Boolean> skippableExceptionClassifier)` The classifier that will be used to decide on skippability.
    `void` | `setSkippableExceptionMap(java.util.Map<java.lang.Class<? extends java.lang.Throwable>,java.lang.Boolean> skippableExceptions)` Set up the classifier through a convenient map from throwable class to boolean (true if skippable).
    `boolean` | `shouldSkip(java.lang.Throwable t, int skipCount)` Given the provided exception and skip count, determine whether or not processing should continue for the given exception.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### LimitCheckingItemSkipPolicy

          public LimitCheckingItemSkipPolicy()

      Convenience constructor that assumes all exception types are fatal.

    - #### LimitCheckingItemSkipPolicy

          public LimitCheckingItemSkipPolicy(int skipLimit,
                                             java.util.Map<java.lang.Class<? extends java.lang.Throwable>,java.lang.Boolean> skippableExceptions)

      Parameters:
        `skipLimit` - the number of skippable exceptions that are allowed to be skipped
        `skippableExceptions` - exception classes that can be skipped (non-critical)

    - #### LimitCheckingItemSkipPolicy

          public LimitCheckingItemSkipPolicy(int skipLimit,
                                             org.springframework.classify.Classifier<java.lang.Throwable,java.lang.Boolean> skippableExceptionClassifier)

      Parameters:
        `skipLimit` - the number of skippable exceptions that are allowed to be skipped
        `skippableExceptionClassifier` - exception classifier for those that can be skipped (non-critical)

  - ### Method Detail

    - #### setSkipLimit

          public void setSkipLimit(int skipLimit)

      The absolute number of skips (of skippable exceptions) that can be tolerated before a failure.
      Parameters:
        `skipLimit` - the skip limit to set

    - #### setSkippableExceptionClassifier

          public void setSkippableExceptionClassifier(org.springframework.classify.Classifier<java.lang.Throwable,java.lang.Boolean> skippableExceptionClassifier)

      The classifier that will be used to decide on skippability. If an exception classifies as "true" then it is skippable, and otherwise not.
      Parameters:
        `skippableExceptionClassifier` - the skippableExceptionClassifier to set

    - #### setSkippableExceptionMap

          public void setSkippableExceptionMap(java.util.Map<java.lang.Class<? extends java.lang.Throwable>,java.lang.Boolean> skippableExceptions)

      Set up the classifier through a convenient map from throwable class to boolean (true if skippable).
      Parameters:
        `skippableExceptions` - the skippable exceptions to set

    - #### shouldSkip

          public boolean shouldSkip(java.lang.Throwable t,
                                    int skipCount)

      Given the provided exception and skip count, determine whether or not processing should continue for the given exception. If the exception is not classified as skippable in the classifier, false will be returned. If the exception is classified as skippable and `StepExecution` skipCount is greater than the skipLimit, then a `SkipLimitExceededException` will be thrown.
      Specified by:
        `shouldSkip` in interface `SkipPolicy`
      Parameters:
        `t` - exception encountered while reading
        `skipCount` - currently running count of skips
      Returns:
        true if processing should continue, false otherwise.