org.springframework.util.ErrorHandler Java Examples

/**
 * 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);
	}
}
 

@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
@Nullable
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
@Nullable
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);
	}
}
 

/**
 * If a task scheduler has been defined by the application, get it so that
 * bugsnag error handling can be added.
 * <p>
 * Reflection is the simplest way to get and set an error handler
 * because the error handler setter is only defined in the concrete classes,
 * not the TaskScheduler interface.
 *
 * @param taskScheduler the task scheduler
 */
private void configureExistingTaskScheduler(TaskScheduler taskScheduler,
                                            BugsnagScheduledTaskExceptionHandler errorHandler) {
    try {
        Field errorHandlerField =
                taskScheduler.getClass().getDeclaredField("errorHandler");
        errorHandlerField.setAccessible(true);
        Object existingErrorHandler = errorHandlerField.get(taskScheduler);

        // If an error handler has already been defined then make the Bugsnag handler
        // call this afterwards
        if (existingErrorHandler instanceof ErrorHandler) {
            errorHandler.setExistingErrorHandler((ErrorHandler) existingErrorHandler);
        }

        // Add the bugsnag error handler to the scheduler.
        errorHandlerField.set(taskScheduler, errorHandler);
    } catch (Throwable ex) {
        LOGGER.warn("Bugsnag scheduled task exception handler could not be configured");
    }
}
 

public ReschedulingRunnable(
		Runnable delegate, Trigger trigger, ScheduledExecutorService executor, ErrorHandler errorHandler) {

	super(delegate, errorHandler);
	this.trigger = trigger;
	this.executor = executor;
}
 

/**
 * 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()));
}
 

/**
 * 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, @Nullable ErrorHandler errorHandler, boolean isRepeatingTask) {

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

/**
 * 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;
}
 

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

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

/**
 * 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);
	}
}
 

@Override
public <T> Future<T> submit(Callable<T> task) {
	ExecutorService executor = getScheduledExecutor();
	try {
		Callable<T> taskToUse = task;
		ErrorHandler errorHandler = this.errorHandler;
		if (errorHandler != null) {
			taskToUse = new DelegatingErrorHandlingCallable<>(task, errorHandler);
		}
		return executor.submit(taskToUse);
	}
	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);
}
 

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

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

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

@Bean
public ErrorHandler errorHandler() {
    return new ConditionalRejectingErrorHandler(customExceptionStrategy());
}
 

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

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) {
	this.errorHandler = errorHandler;
}
 

/**
 * @see AbstractMessageListenerContainer#setErrorHandler(ErrorHandler)
 */
public void setErrorHandler(ErrorHandler errorHandler) {
	this.errorHandler = errorHandler;
}
 

@Override
public void setErrorHandler(ErrorHandler errorHandler) {
    this.delegate.setErrorHandler(errorHandler);
}
 

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

/**
 * @see AbstractMessageListenerContainer#setErrorHandler(ErrorHandler)
 */
public void setErrorHandler(ErrorHandler errorHandler) {
	this.errorHandler = errorHandler;
}
 

@Bean
public ErrorHandler errorHandler() {
    return new CustomErrorHandler();
}
 

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

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