Class 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.
Dave Syer, Robert Kasanicky, Mahmoud Ben Hassine
  • Constructor Details

    • SimpleLimitExceptionHandler

      public SimpleLimitExceptionHandler(int limit)
      Convenience constructor for the SimpleLimitExceptionHandler to set the limit.
      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
      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.
      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
      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.
      Throwable - implementations are free to re-throw the exception
      See Also:
    • setLimit

      public void setLimit(int limit)
      The limit on the given exception type within a single context before it is rethrown.
      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.
      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).
      fatalExceptionClasses - defaults to Error