Java 类org.springframework.util.ErrorHandler 实例源码

/**
 * Invoke the given listener with the given event.
 * @param listener the ApplicationListener to invoke
 * @param event the current event to propagate
 * @since 4.1
 */
@SuppressWarnings({"unchecked", "rawtypes"})
protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        try {
            listener.onApplicationEvent(event);
        }
        catch (Throwable err) {
            errorHandler.handleError(err);
        }
    }
    else {
        listener.onApplicationEvent(event);
    }
}

/**
 * Invoke the given listener with the given event.
 * @param listener the ApplicationListener to invoke
 * @param event the current event to propagate
 * @since 4.1
 */
@SuppressWarnings({"unchecked", "rawtypes"})
protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        try {
            listener.onApplicationEvent(event);
        }
        catch (Throwable err) {
            errorHandler.handleError(err);
        }
    }
    else {
        try {
            listener.onApplicationEvent(event);
        }
        catch (ClassCastException ex) {
            // Possibly a lambda-defined listener which we could not resolve the generic event type for
            LogFactory.getLog(getClass()).debug("Non-matching event type for listener: " + listener, ex);
        }
    }
}

@PostConstruct
public void init() {
  this.actionMonitor = new ActionMonitor();
  this.detectionTasks = new HashMap<>();
  this.taskScheduler = new ThreadPoolTaskScheduler();
  this.taskScheduler.setPoolSize(10);
  this.taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
  this.taskScheduler.setRemoveOnCancelPolicy(true);
  this.taskScheduler.setErrorHandler(
      new ErrorHandler() {
        protected Logger log = LoggerFactory.getLogger(this.getClass());

        @Override
        public void handleError(Throwable t) {
          log.error(t.getMessage(), t);
        }
      });
  this.taskScheduler.initialize();
}

@PostConstruct
public void init() {
  this.actionMonitor = new ActionMonitor();
  this.executionEngine.setActionMonitor(actionMonitor);
  this.taskScheduler = new ThreadPoolTaskScheduler();
  this.taskScheduler.setPoolSize(10);
  this.taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
  this.taskScheduler.setRemoveOnCancelPolicy(true);
  this.taskScheduler.setErrorHandler(
      new ErrorHandler() {
        protected Logger log = LoggerFactory.getLogger(this.getClass());

        @Override
        public void handleError(Throwable t) {
          log.error(t.getMessage(), t);
        }
      });
  this.taskScheduler.initialize();
}

@PostConstruct
public void init() {
  this.actionMonitor = new ActionMonitor();
  this.taskScheduler = new ThreadPoolTaskScheduler();
  this.taskScheduler.setPoolSize(10);
  this.taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
  this.taskScheduler.setRemoveOnCancelPolicy(true);
  this.taskScheduler.setErrorHandler(
      new ErrorHandler() {
        protected Logger log = LoggerFactory.getLogger(this.getClass());

        @Override
        public void handleError(Throwable t) {
          log.error(t.getMessage(), t);
        }
      });
  this.taskScheduler.initialize();
}

/**
 * Create a new DelegatingErrorHandlingRunnable.
 * @param delegate the Runnable implementation to delegate to
 * @param errorHandler the ErrorHandler for handling any exceptions
 */
public DelegatingErrorHandlingRunnable(Runnable delegate, ErrorHandler errorHandler) {
    Assert.notNull(delegate, "Delegate must not be null");
    Assert.notNull(errorHandler, "ErrorHandler must not be null");
    this.delegate = delegate;
    this.errorHandler = errorHandler;
}

/**
 * Decorate the task for error handling. If the provided {@link ErrorHandler}
 * is not {@code null}, it will be used. Otherwise, repeating tasks will have
 * errors suppressed by default whereas one-shot tasks will have errors
 * propagated by default since those errors may be expected through the
 * returned {@link Future}. In both cases, the errors will be logged.
 */
public static DelegatingErrorHandlingRunnable decorateTaskWithErrorHandler(
        Runnable task, ErrorHandler errorHandler, boolean isRepeatingTask) {

    if (task instanceof DelegatingErrorHandlingRunnable) {
        return (DelegatingErrorHandlingRunnable) task;
    }
    ErrorHandler eh = (errorHandler != null ? errorHandler : getDefaultErrorHandler(isRepeatingTask));
    return new DelegatingErrorHandlingRunnable(task, eh);
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    try {
        if (this.enterpriseConcurrentScheduler) {
            return new EnterpriseConcurrentTriggerScheduler().schedule(decorateTask(task, true), trigger);
        }
        else {
            ErrorHandler errorHandler = (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
            return new ReschedulingRunnable(task, trigger, this.scheduledExecutor, errorHandler).schedule();
        }
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + this.scheduledExecutor + "] did not accept task: " + task, ex);
    }
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

/**
 * Create a new DelegatingErrorHandlingRunnable.
 * @param delegate the Runnable implementation to delegate to
 * @param errorHandler the ErrorHandler for handling any exceptions
 */
public DelegatingErrorHandlingRunnable(Runnable delegate, ErrorHandler errorHandler) {
    Assert.notNull(delegate, "Delegate must not be null");
    Assert.notNull(errorHandler, "ErrorHandler must not be null");
    this.delegate = delegate;
    this.errorHandler = errorHandler;
}

/**
 * Decorate the task for error handling. If the provided {@link ErrorHandler}
 * is not {@code null}, it will be used. Otherwise, repeating tasks will have
 * errors suppressed by default whereas one-shot tasks will have errors
 * propagated by default since those errors may be expected through the
 * returned {@link Future}. In both cases, the errors will be logged.
 */
public static DelegatingErrorHandlingRunnable decorateTaskWithErrorHandler(
        Runnable task, ErrorHandler errorHandler, boolean isRepeatingTask) {

    if (task instanceof DelegatingErrorHandlingRunnable) {
        return (DelegatingErrorHandlingRunnable) task;
    }
    ErrorHandler eh = (errorHandler != null ? errorHandler : getDefaultErrorHandler(isRepeatingTask));
    return new DelegatingErrorHandlingRunnable(task, eh);
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    try {
        if (this.enterpriseConcurrentScheduler) {
            return new EnterpriseConcurrentTriggerScheduler().schedule(decorateTask(task, true), trigger);
        }
        else {
            ErrorHandler errorHandler = (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
            return new ReschedulingRunnable(task, trigger, this.scheduledExecutor, errorHandler).schedule();
        }
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + this.scheduledExecutor + "] did not accept task: " + task, ex);
    }
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

/**
 * Invoke the registered ErrorHandler, if any. Log at warn level otherwise.
 * @param ex the uncaught error that arose during JMS processing.
 * @see #setErrorHandler
 */
protected void invokeErrorHandler(Throwable ex) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        errorHandler.handleError(ex);
    }
    else {
        logger.warn("Execution of JMS message listener failed, and no ErrorHandler has been set.", ex);
    }
}

@Test
public void testErrorHandlers() {
    ErrorHandler expected = this.context.getBean("testErrorHandler", ErrorHandler.class);
    ErrorHandler errorHandler1 = getErrorHandler("listener1");
    ErrorHandler errorHandler2 = getErrorHandler("listener2");
    ErrorHandler defaultErrorHandler = getErrorHandler(DefaultMessageListenerContainer.class.getName() + "#0");
    assertSame(expected, errorHandler1);
    assertSame(expected, errorHandler2);
    assertNull(defaultErrorHandler);
}

/**
 * Create a new DelegatingErrorHandlingRunnable.
 * @param delegate the Runnable implementation to delegate to
 * @param errorHandler the ErrorHandler for handling any exceptions
 */
public DelegatingErrorHandlingRunnable(Runnable delegate, ErrorHandler errorHandler) {
    Assert.notNull(delegate, "Delegate must not be null");
    Assert.notNull(errorHandler, "ErrorHandler must not be null");
    this.delegate = delegate;
    this.errorHandler = errorHandler;
}

/**
 * Decorate the task for error handling. If the provided {@link ErrorHandler}
 * is not {@code null}, it will be used. Otherwise, repeating tasks will have
 * errors suppressed by default whereas one-shot tasks will have errors
 * propagated by default since those errors may be expected through the
 * returned {@link Future}. In both cases, the errors will be logged.
 */
public static DelegatingErrorHandlingRunnable decorateTaskWithErrorHandler(
        Runnable task, ErrorHandler errorHandler, boolean isRepeatingTask) {

    if (task instanceof DelegatingErrorHandlingRunnable) {
        return (DelegatingErrorHandlingRunnable) task;
    }
    ErrorHandler eh = (errorHandler != null ? errorHandler : getDefaultErrorHandler(isRepeatingTask));
    return new DelegatingErrorHandlingRunnable(task, eh);
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    try {
        if (this.enterpriseConcurrentScheduler) {
            return new EnterpriseConcurrentTriggerScheduler().schedule(decorateTask(task, true), trigger);
        }
        else {
            ErrorHandler errorHandler = (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
            return new ReschedulingRunnable(task, trigger, this.scheduledExecutor, errorHandler).schedule();
        }
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + this.scheduledExecutor + "] did not accept task: " + task, ex);
    }
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

/**
 * Create a new DelegatingErrorHandlingRunnable.
 * @param delegate the Runnable implementation to delegate to
 * @param errorHandler the ErrorHandler for handling any exceptions
 */
public DelegatingErrorHandlingRunnable(Runnable delegate, ErrorHandler errorHandler) {
    Assert.notNull(delegate, "Delegate must not be null");
    Assert.notNull(errorHandler, "ErrorHandler must not be null");
    this.delegate = delegate;
    this.errorHandler = errorHandler;
}

/**
 * Decorate the task for error handling. If the provided {@link ErrorHandler}
 * is not {@code null}, it will be used. Otherwise, repeating tasks will have
 * errors suppressed by default whereas one-shot tasks will have errors
 * propagated by default since those errors may be expected through the
 * returned {@link Future}. In both cases, the errors will be logged.
 */
public static DelegatingErrorHandlingRunnable decorateTaskWithErrorHandler(
        Runnable task, ErrorHandler errorHandler, boolean isRepeatingTask) {

    if (task instanceof DelegatingErrorHandlingRunnable) {
        return (DelegatingErrorHandlingRunnable) task;
    }
    ErrorHandler eh = (errorHandler != null ? errorHandler : getDefaultErrorHandler(isRepeatingTask));
    return new DelegatingErrorHandlingRunnable(task, eh);
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    try {
        if (this.enterpriseConcurrentScheduler) {
            return new EnterpriseConcurrentTriggerScheduler().schedule(decorateTask(task, true), trigger);
        }
        else {
            ErrorHandler errorHandler = (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
            return new ReschedulingRunnable(task, trigger, this.scheduledExecutor, errorHandler).schedule();
        }
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + this.scheduledExecutor + "] did not accept task: " + task, ex);
    }
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

/**
 * Register the bean for the custom error handler.
 *
 * @return custom error handler
 */
@Bean
@ConditionalOnMissingBean(ErrorHandler.class)
public ErrorHandler errorHandler() {
    return new ConditionalRejectingErrorHandler(
            new DelayedRequeueExceptionStrategy(amqpProperties.getRequeueDelay()));
}

@Bean
@ConditionalOnMissingBean(name = "listenerContainerFactory")
public RabbitListenerContainerFactory<SimpleMessageListenerContainer> listenerContainerFactory(
        final SimpleRabbitListenerContainerFactoryConfigurer configurer, final ErrorHandler errorHandler) {
    final ConfigurableRabbitListenerContainerFactory factory = new ConfigurableRabbitListenerContainerFactory(
            amqpProperties.isMissingQueuesFatal(), amqpProperties.getDeclarationRetries(), errorHandler);
    configurer.configure(factory, rabbitConnectionFactory);
    return factory;
}

@Bean(destroyMethod = "shutdown")
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setErrorHandler(new ErrorHandler() {
        @Override
        public void handleError(Throwable t) {
            LogManager.getLogger().error("error while handling job", t);
        }
    });
    scheduler.initialize();
    return scheduler;
}

/**
 * Create a new DelegatingErrorHandlingRunnable.
 * @param delegate the Runnable implementation to delegate to
 * @param errorHandler the ErrorHandler for handling any exceptions
 */
public DelegatingErrorHandlingRunnable(Runnable delegate, ErrorHandler errorHandler) {
    Assert.notNull(delegate, "Delegate must not be null");
    Assert.notNull(errorHandler, "ErrorHandler must not be null");
    this.delegate = delegate;
    this.errorHandler = errorHandler;
}

/**
 * Decorates the task for error handling. If the provided
 * {@link ErrorHandler} is not null, it will be used. Otherwise,
 * repeating tasks will have errors suppressed by default whereas
 * one-shot tasks will have errors propagated by default since those
 * errors may be expected through the returned {@link Future}. In both
 * cases, the errors will be logged.
 */
public static DelegatingErrorHandlingRunnable decorateTaskWithErrorHandler(
        Runnable task, ErrorHandler errorHandler, boolean isRepeatingTask) {

    if (task instanceof DelegatingErrorHandlingRunnable) {
        return (DelegatingErrorHandlingRunnable) task;
    }
    ErrorHandler eh = errorHandler != null ? errorHandler : getDefaultErrorHandler(isRepeatingTask);
    return new DelegatingErrorHandlingRunnable(task, eh);
}

public ScheduledFuture schedule(Runnable task, Trigger trigger) {
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, this.scheduledExecutor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + this.scheduledExecutor + "] did not accept task: " + task, ex);
    }
}

public ScheduledFuture schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

@Test
public void testErrorHandlers() {
    ErrorHandler expected = this.context.getBean("testErrorHandler", ErrorHandler.class);
    ErrorHandler errorHandler1 = getErrorHandler("listener1");
    ErrorHandler errorHandler2 = getErrorHandler("listener2");
    ErrorHandler defaultErrorHandler = getErrorHandler(DefaultMessageListenerContainer.class.getName() + "#0");
    assertSame(expected, errorHandler1);
    assertSame(expected, errorHandler2);
    assertNull(defaultErrorHandler);
}

/**
 * 实例化一个可重复调度的可运行任务。
 * 
 * @param delegate
 * @param trigger
 * @param executor
 * @param errorHandler
 */
public ReschedulingRunnable(Runnable delegate, Trigger trigger,
        ScheduledExecutorService executor, ErrorHandler errorHandler) {
    // 实例化一个"能捕获任何异常或错误的Runnable包装器"
    super(delegate, errorHandler);

    this.trigger = trigger;
    this.executor = executor;
}

@Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

/**
 * メッセージ受信側で例外が発生した場合に
 * リトライ対象例外は警告ログ、リトライ対象外例外はエラーログを出力する{@link ErrorHandler}のインスタンスを生成し、
 * インスタンスをDIコンテナに登録します。
 * @return {@link LoggingErrorHandler}のインスタンス
 */
@Bean
public ErrorHandler errorHandler() {
    LoggingErrorHandler handler = new LoggingErrorHandler();
    handler.setRetryableExceptions(exceptionMapping());
    return handler;
}

private SimpleMessageListenerContainer container() {
    SimpleMessageListenerContainer c = new SimpleMessageListenerContainer(ctx.getBean(ConnectionFactory.class));
    c.setConnectionFactory(ctx.getBean(ConnectionFactory.class));
    c.setErrorHandler(ctx.getBean(ErrorHandler.class));
    c.setAdviceChain(ctx.getBean(Advice[].class));
    return c;
}

public ReschedulingRunnable(Runnable delegate, Trigger trigger, ScheduledExecutorService executor, ErrorHandler errorHandler) {
    super(delegate, errorHandler);
    this.trigger = trigger;
    this.executor = executor;
}

/**
 * Provide an {@link ErrorHandler} strategy.
 */
public void setErrorHandler(ErrorHandler errorHandler) {
    Assert.notNull(errorHandler, "'errorHandler' must not be null");
    this.errorHandler = errorHandler;
}

/**
 * Set a custom {@link ErrorHandler} strategy.
 */
public void setErrorHandler(ErrorHandler errorHandler) {
    Assert.notNull(errorHandler, "'errorHandler' must not be null");
    this.errorHandler = errorHandler;
}

public DelegatingErrorHandlingCallable(Callable<V> delegate, ErrorHandler errorHandler) {
    this.delegate = delegate;
    this.errorHandler = errorHandler;
}

/**
 * Provide an {@link ErrorHandler} strategy.
 */
public void setErrorHandler(ErrorHandler errorHandler) {
    this.errorHandler = errorHandler;
}