Spring Boot 异常报告器解析

亦凉 2024-03-16 19:03 7阅读 0赞

> 基于Spring Boot 3.1.0 系列文章
> 
> 1.  [Spring Boot 源码阅读初始化环境搭建][Spring Boot]
> 2.  [Spring Boot 框架整体启动流程详解][Spring Boot 1]
> 3.  [Spring Boot 系统初始化器详解][Spring Boot 2]
> 4.  [Spring Boot 监听器详解][Spring Boot 3]
> 5.  [Spring Boot banner详解][Spring Boot banner]
> 6.  [Spring Boot 属性配置解析][Spring Boot 4]
> 7.  [Spring Boot 属性加载原理解析][Spring Boot 5]
> 8.  [Spring Boot 异常报告器解析][Spring Boot 6]

## 创建自定义异常报告器 ##

FailureAnalysis 是Spring Boot 启动时将异常转化为可读消息的一种方法，系统自定义了很多异常报告器，通过接口也可以自定义异常报告器。

创建一个异常类：

public class MyException extends RuntimeException{
        
    }

创建一个FailureAnalyzer：

public class MyFailureAnalyzer extends AbstractFailureAnalyzer<MyException> {
        
        @Override
        protected FailureAnalysis analyze(Throwable rootFailure, MyException cause) {
        
            String des = "发生自定义异常";
            String action = "由于自定义了一个异常";
            return new FailureAnalysis(des, action, rootFailure);
        }
    }

需要在Spring Boot 启动的时候抛出异常，为了测试，我们在上下文准备的时候抛出自定义异常，添加到demo中的MyApplicationRunListener中。

public void contextPrepared(ConfigurableApplicationContext context) {
        
        System.out.println("在创建和准备ApplicationContext之后，但在加载源之前调用");
        throw new MyException();
    }

启动后就会打印出我们的自定义异常报告器内容：

***************************
    APPLICATION FAILED TO START
    ***************************
    
    Description:
    
    发生自定义异常
    
    Action:
    
    由于自定义了一个异常

## 原理分析 ##

在之前的文章《[Spring Boot 框架整体启动流程详解][Spring Boot 7]》，有讲到过Spring Boot 对异常的处理，如下是Spring Boot 启动时的代码：

public ConfigurableApplicationContext run(String... args) {
        
    		long startTime = System.nanoTime();
    		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    		ConfigurableApplicationContext context = null;
    		configureHeadlessProperty();
    		SpringApplicationRunListeners listeners = getRunListeners(args);
    		listeners.starting(bootstrapContext, this.mainApplicationClass);
    		try {
        
    			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    			Banner printedBanner = printBanner(environment);
    			context = createApplicationContext();
    			context.setApplicationStartup(this.applicationStartup);
    			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    			refreshContext(context);
    			afterRefresh(context, applicationArguments);
    			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
    			if (this.logStartupInfo) {
        
    				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
    			}
    			listeners.started(context, timeTakenToStartup);
    			callRunners(context, applicationArguments);
    		}
    		catch (Throwable ex) {
        
    			if (ex instanceof AbandonedRunException) {
        
    				throw ex;
    			}
    			handleRunFailure(context, ex, listeners);
    			throw new IllegalStateException(ex);
    		}
    		try {
        
    			if (context.isRunning()) {
        
    				Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
    				listeners.ready(context, timeTakenToReady);
    			}
    		}
    		catch (Throwable ex) {
        
    			if (ex instanceof AbandonedRunException) {
        
    				throw ex;
    			}
    			handleRunFailure(context, ex, null);
    			throw new IllegalStateException(ex);
    		}
    		return context;
    	}

通过两个try…catch…包裹，在catch 中判断异常是否是AbandonedRunException类型，是直接抛出异常，否则的话进入`handleRunFailure`中。

> AbandonedRunException 异常 在 Spring Boot 处理AOT相关优化的时候会抛出

private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception,
    		SpringApplicationRunListeners listeners) {
        
    	try {
        
    		try {
        
    		//处理exitCode
    			handleExitCode(context, exception);
    			if (listeners != null) {
        
    			//发送启动失败事件
    				listeners.failed(context, exception);
    			}
    		}
    		finally {
        
    		//获取报告处理器，并处理错误
    			reportFailure(getExceptionReporters(context), exception);
    			if (context != null) {
        
    			//关闭上下文
    				context.close();
    				//移除关闭钩子
    				shutdownHook.deregisterFailedApplicationContext(context);
    			}
    		}
    	}
    	catch (Exception ex) {
        
    		logger.warn("Unable to close ApplicationContext", ex);
    	}
    	//重新抛出异常
    	ReflectionUtils.rethrowRuntimeException(exception);
    }

> exitCode是一个整数值，默认返回0，Spring Boot会将该exitCode传递给System.exit()以作为状态码返回，如下是IDEA中停止Spring Boot 返回的退出码：  
> `进程已结束,退出代码130`

### handleExitCode ###

进入`handleExitCode`，看下是如何处理的：

private void handleExitCode(ConfigurableApplicationContext context, Throwable exception) {
        
    	int exitCode = getExitCodeFromException(context, exception);
    	//exitCode非0
    	if (exitCode != 0) {
        
    		if (context != null) {
        
    		//发送ExitCodeEvent事件
    			context.publishEvent(new ExitCodeEvent(context, exitCode));
    		}
    		//获取当前线程的SpringBootExceptionHandler，SpringBootExceptionHandler用来处理未捕获的异常，实现了UncaughtExceptionHandler接口
    		  handler = getSpringBootExceptionHandler();
    		if (handler != null) {
        
    		//添加exitCode到SpringBootExceptionHandler 中
    			handler.registerExitCode(exitCode);
    		}
    	}
    }
    
    private int getExitCodeFromException(ConfigurableApplicationContext context, Throwable exception) {
        
    //从ExitCodeExceptionMapper实现中获取exitCode
    	int exitCode = getExitCodeFromMappedException(context, exception);
    	if (exitCode == 0) {
        
    	//尝试从ExitCodeGenerator实现获取exitCode
    		exitCode = getExitCodeFromExitCodeGeneratorException(exception);
    	}
    	return exitCode;
    }
    
    private int getExitCodeFromMappedException(ConfigurableApplicationContext context, Throwable exception) {
        
    //判断上下文是否是活动状态，上下文至少刷新过一次，不是就返回0
    	if (context == null || !context.isActive()) {
        
    		return 0;
    	}
    	//用于维护ExitCodeGenerator有序集合的组合器，ExitCodeGenerator 是一个接口，用于获取exitCode
    	ExitCodeGenerators generators = new ExitCodeGenerators();
    	//获取ExitCodeExceptionMapper类型的Bean
    	Collection<ExitCodeExceptionMapper> beans = context.getBeansOfType(ExitCodeExceptionMapper.class).values();
    	//将异常和bean包装成MappedExitCodeGenerator,排序后保存，MappedExitCodeGenerator是ExitCodeGenerator 的一个实现
    	generators.addAll(exception, beans);
    	//会循环ExitCodeGenerators 中的ExitCodeGenerator，ExitCodeGenerator会去获取ExitCodeExceptionMapper的实现，如果有一个exitCode非0则马上返回，否则返回0
    	return generators.getExitCode();
    }
    
    private int getExitCodeFromExitCodeGeneratorException(Throwable exception) {
        
    //没有异常
    	if (exception == null) {
        
    		return 0;
    	}
    	//异常类有实现了ExitCodeGenerator 接口
    	if (exception instanceof ExitCodeGenerator generator) {
        
    		return generator.getExitCode();
    	}
    	//继续寻找
    	return getExitCodeFromExitCodeGeneratorException(exception.getCause());
    }
    
    SpringBootExceptionHandler getSpringBootExceptionHandler() {
        
    //当前线程是主线程
    	if (isMainThread(Thread.currentThread())) {
        
    	//获取当前线程的SpringBootExceptionHandler
    		return SpringBootExceptionHandler.forCurrentThread();
    	}
    	return null;
    }

### listeners.failed ###

在处理完exitCode后，继续执行`listeners.failed(context, exception)`，这里就跟以前一样，循环SpringApplicationRunListener实现

### reportFailure ###

Spring Boot 首先从`spring.factories`获取所有的`SpringBootExceptionReporter`实现，`FailureAnalyzers`是其唯一实现，其用于加载和执行`FailureAnalyzer`  
reportFailure 循环执行获取的SpringBootExceptionReporter，如果发送异常成功，则会向之前的`SpringBootExceptionHandler`中记录，表示该异常已经捕获处理

private void reportFailure(Collection<SpringBootExceptionReporter> exceptionReporters, Throwable failure) {
        
    	try {
        
    		for (SpringBootExceptionReporter reporter : exceptionReporters) {
        
    		//如果异常发送成功
    			if (reporter.reportException(failure)) {
        
    			//记录异常
    				registerLoggedException(failure);
    				return;
    			}
    		}
    	}
    	catch (Throwable ex) {
        
    		// 如果上述操作发生异常，还是会继续执行
    	}
    	//记录error级别日志
    	if (logger.isErrorEnabled()) {
        
    		logger.error("Application run failed", failure);
    		registerLoggedException(failure);
    	}
    }

#### reporter.reportException ####

在reportFailure中，通过reporter.reportException(failure)判断异常是否发送成功，进入代码，由于该Demo 只有一个FailureAnalyzers实现，所以进入到FailureAnalyzers的reportException中：

public boolean reportException(Throwable failure) {
        
    //循环调用加载的FailureAnalyzer实现的analyze方法
    	FailureAnalysis analysis = analyze(failure, this.analyzers);
    	//加载FailureAnalysisReporter实现，组装具体错误信息，并打印日志
    	return report(analysis);
    }

`this.analyzers`在`FailureAnalyzers`创建的时候已经将`FailureAnalyzer`实现从`spring.factories`中加载  
下面的代码将循环调用加载的FailureAnalyzer实现的analyze方法，返回一个包装了`异常描述、发生异常的动作、原始异常` 信息的对象

private FailureAnalysis analyze(Throwable failure, List<FailureAnalyzer> analyzers) {
        
    	for (FailureAnalyzer analyzer : analyzers) {
        
    		try {
        
    			FailureAnalysis analysis = analyzer.analyze(failure);
    			if (analysis != null) {
        
    				return analysis;
    			}
    		}
    		catch (Throwable ex) {
        
    			logger.trace(LogMessage.format("FailureAnalyzer %s failed", analyzer), ex);
    		}
    	}
    	return null;
    }

此处Spring Boot 建议自定义的FailureAnalyzer 通过继承`AbstractFailureAnalyzer`来实现，Spring Boot 自带的FailureAnalyzer确实也是这样的，但是你也可以直接实现FailureAnalyzer 接口。AbstractFailureAnalyzer中会筛选出需要关注的异常，而直接实现FailureAnalyzer 接口，需要自行在方法中处理。  
随后将返回的FailureAnalysis实现通过FailureAnalysisReporter组装打印到客户端

private boolean report(FailureAnalysis analysis) {
        
    //FailureAnalysisReporter也是从spring.factories中加载，可见也可以自定义
    	List<FailureAnalysisReporter> reporters = this.springFactoriesLoader.load(FailureAnalysisReporter.class);
    	if (analysis == null || reporters.isEmpty()) {
        
    		return false;
    	}
    	for (FailureAnalysisReporter reporter : reporters) {
        
    		reporter.report(analysis);
    	}
    	return true;
    }

在该Demo中，只有一个FailureAnalysisReporter实例`LoggingFailureAnalysisReporter`

public void report(FailureAnalysis failureAnalysis) {
        
    //如果是debug级别，则会打印堆栈信息
    	if (logger.isDebugEnabled()) {
        
    		logger.debug("Application failed to start due to an exception", failureAnalysis.getCause());
    	}
    	//如果是error级别，还会打印组装好的错误信息
    	if (logger.isErrorEnabled()) {
        
    		logger.error(buildMessage(failureAnalysis));
    	}
    }
    
    private String buildMessage(FailureAnalysis failureAnalysis) {
        
    	StringBuilder builder = new StringBuilder();
    	builder.append(String.format("%n%n"));
    	builder.append(String.format("***************************%n"));
    	builder.append(String.format("APPLICATION FAILED TO START%n"));
    	builder.append(String.format("***************************%n%n"));
    	builder.append(String.format("Description:%n%n"));
    	builder.append(String.format("%s%n", failureAnalysis.getDescription()));
    	if (StringUtils.hasText(failureAnalysis.getAction())) {
        
    		builder.append(String.format("%nAction:%n%n"));
    		builder.append(String.format("%s%n", failureAnalysis.getAction()));
    	}
    	return builder.toString();
    }

#### 关闭上下文、移除钩子 ####

context.close() 如果上下文不为空，则关闭上下文，并且移除关闭钩子。  
shutdownHook.deregisterFailedApplicationContext(context) 用来将之前在SpringApplicationShutdownHook 钩子中注册的上下文移除。  
SpringApplicationShutdownHook 是Spring Boot 定义的关闭钩子，用来优雅关机。

## 总结 ##

![在这里插入图片描述][5c054fc419264f22bd963d3d5b8e4423.jpeg]

[Spring Boot]: https://itsaysay.blog.csdn.net/article/details/129665897
[Spring Boot 1]: https://itsaysay.blog.csdn.net/article/details/130981611
[Spring Boot 2]: https://itsaysay.blog.csdn.net/article/details/131034991
[Spring Boot 3]: https://itsaysay.blog.csdn.net/article/details/131073017
[Spring Boot banner]: https://itsaysay.blog.csdn.net/article/details/131116036
[Spring Boot 4]: https://itsaysay.blog.csdn.net/article/details/131178566
[Spring Boot 5]: https://itsaysay.blog.csdn.net/article/details/131205549
[Spring Boot 6]: https://itsaysay.blog.csdn.net/article/details/131242002
[Spring Boot 7]: https://itsaysay.blog.csdn.net/article/details/130981611?spm=1001.2014.3001.5502
[5c054fc419264f22bd963d3d5b8e4423.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5f152b0b31934375ad71aa2698099e30.png