Package org.springframework.batch.repeat.exception

# Class SimpleLimitExceptionHandler

java.lang.Object
org.springframework.batch.repeat.exception.SimpleLimitExceptionHandler

All Implemented Interfaces:
  `ExceptionHandler`, `org.springframework.beans.factory.InitializingBean`

public class SimpleLimitExceptionHandler extends Object implements ExceptionHandler, org.springframework.beans.factory.InitializingBean
Simple implementation of exception handler which looks for given exception types. If one of the types is found then a counter is incremented and the limit is checked to determine if it has been exceeded and the Throwable should be re-thrown. Also allows to specify list of 'fatal' exceptions that are never subject to counting, but are immediately re-thrown. The fatal list has higher priority so the two lists needn't be exclusive.

Author:
  Dave Syer, Robert Kasanicky

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `SimpleLimitExceptionHandler()`
  Default constructor for the `SimpleLimitExceptionHandler`.
  `SimpleLimitExceptionHandler(int limit)`
  Convenience constructor for the `SimpleLimitExceptionHandler` to set the limit.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `afterPropertiesSet()`
  Apply the provided properties to create a delegate handler.
  `void`
  `handleException(RepeatContext context, Throwable throwable)`
  Rethrows only if the limit is breached for this context on the exception type specified.
  `void`
  `setExceptionClasses(Collection<Class<? extends Throwable>> classes)`
  Setter for the exception classes that this handler counts.
  `void`
  `setFatalExceptionClasses(Collection<Class<? extends Throwable>> fatalExceptionClasses)`
  Setter for the exception classes that shouldn't be counted, but rethrown immediately.
  `void`
  `setLimit(int limit)`
  The limit on the given exception type within a single context before it is rethrown.
  `void`
  `setUseParent(boolean useParent)`
  Flag to indicate the exception counters should be shared between sibling contexts in a nested batch (i.e.

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

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

- ## Constructor Details

  - ### SimpleLimitExceptionHandler

    public SimpleLimitExceptionHandler(int limit)
    Convenience constructor for the `SimpleLimitExceptionHandler` to set the limit.
    Parameters:
      `limit` - the limit

  - ### SimpleLimitExceptionHandler

    public SimpleLimitExceptionHandler()
    Default constructor for the `SimpleLimitExceptionHandler`.

- ## Method Details

  - ### afterPropertiesSet

    public void afterPropertiesSet() throws Exception
    Apply the provided properties to create a delegate handler.
    Specified by:
      `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`
    Throws:
      `Exception`
    See Also:
      - `InitializingBean.afterPropertiesSet()`

  - ### setUseParent

    public void setUseParent(boolean useParent)
    Flag to indicate the exception counters should be shared between sibling contexts in a nested batch (i.e. inner loop). Default is false. Set this flag to true if you want to count exceptions for the whole (outer) loop in a typical container.
    Parameters:
      `useParent` - true if the parent context should be used to store the counters.

  - ### handleException

    public void handleException(RepeatContext context, Throwable throwable) throws Throwable
    Rethrows only if the limit is breached for this context on the exception type specified.
    Specified by:
      `handleException` in interface `ExceptionHandler`
    Parameters:
      `context` - the current `RepeatContext`. Can be used to store state (via attributes), for example to count the number of occurrences of a particular exception type and implement a threshold policy.
      `throwable` - an exception.
    Throws:
      `Throwable` - implementations are free to re-throw the exception
    See Also:
      - `setExceptionClasses(Collection)`
      - `setLimit(int)`
      - `ExceptionHandler.handleException(org.springframework.batch.repeat.RepeatContext, Throwable)`

  - ### setLimit

    public void setLimit(int limit)
    The limit on the given exception type within a single context before it is rethrown.
    Parameters:
      `limit` - the limit

  - ### setExceptionClasses

    public void setExceptionClasses(Collection<Class<? extends Throwable>> classes)
    Setter for the exception classes that this handler counts. Defaults to `Exception`. If more exceptionClasses are specified handler uses single counter that is incremented when one of the recognized exception exceptionClasses is handled.
    Parameters:
      `classes` - exceptionClasses

  - ### setFatalExceptionClasses

    public void setFatalExceptionClasses(Collection<Class<? extends Throwable>> fatalExceptionClasses)
    Setter for the exception classes that shouldn't be counted, but rethrown immediately. This list has higher priority than `setExceptionClasses(Collection)`.
    Parameters:
      `fatalExceptionClasses` - defaults to `Error`