springboot多个@ControllerAdvice全局异常处理

部分源码理解及分析

入口是 ExceptionHandlerExceptionResolver.doResolveHandlerMethodException ，这里面主要看 ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception); 方法，源码如下：
getExceptionHandlerMethod：
	protected ServletInvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) {
		Class<?> handlerType = (handlerMethod != null ? handlerMethod.getBeanType() : null);
		if (handlerMethod != null) {
			ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
			if (resolver == null) {
				resolver = new ExceptionHandlerMethodResolver(handlerType);
				this.exceptionHandlerCache.put(handlerType, resolver);
			Method method = resolver.resolveMethod(exception);
			if (method != null) {
				return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
		// 第一遍exceptionHandlerCache不会有值，会走到这个遍历里来
		// exceptionHandlerAdviceCache， 结构为：LinkedHashMap<ControllerAdviceBean,ExceptionHandlerMethodResolver>(),注意是有序的
		for (Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
			if (entry.getKey().isApplicableToBeanType(handlerType)) {
				ExceptionHandlerMethodResolver resolver = entry.getValue();
				// 重点是这个方法，找到处理异常的方法返回，由上面入口执行异常处理
				// 注意是调用的resolver.resolveMethod()，也就是resolver中的属性都能获取到
				// 有个属性是后面要用到的，存储了@ControllerAdvice注解类的所有@ExceptionHandler方法：private final Map<Class<? extends Throwable>, Method> mappedMethods = new ConcurrentHashMap<Class<? extends Throwable>, Method>(16);
				Method method = resolver.resolveMethod(exception);
				// 这里只要method不为空就会返回，可以和前面例子中的顺序问题结合理解
				if (method != null) {
					return new ServletInvocableHandlerMethod(entry.getKey().resolveBean(), method);
		return null;
resolver.resolveMethod：
	public Method resolveMethod(Exception exception) {
		// 这个方法进去看
		Method method = resolveMethodByExceptionType(exception.getClass());
		if (method == null) {
			Throwable cause = exception.getCause();
			if (cause != null) {
				method = resolveMethodByExceptionType(cause.getClass());
		return method;
resolveMethodByExceptionType：
	public Method resolveMethodByExceptionType(Class<? extends Throwable> exceptionType) {
		Method method = this.exceptionLookupCache.get(exceptionType);
		if (method == null) {
			// 这个方法进去看
			method = getMappedMethod(exceptionType);
			this.exceptionLookupCache.put(exceptionType, (method != null ? method : NO_METHOD_FOUND));
		return (method != NO_METHOD_FOUND ? method : null);
getMappedMethod：
	private Method getMappedMethod(Class<? extends Throwable> exceptionType) {
		List<Class<? extends Throwable>> matches = new ArrayList<Class<? extends Throwable>>();
		// 遍历this.mappedMethods.keySet()，是上文中提到的存储了@ControllerAdvice注解类的所有@ExceptionHandler方法
		for (Class<? extends Throwable> mappedException : this.mappedMethods.keySet()) {
			// class1.isAssignableFrom(class2)：一个类Class1和另一个类Class2是否相同 或 Class1是否是Class2的超类或接口
			if (mappedException.isAssignableFrom(exceptionType)) {
				matches.add(mappedException);
		// 如果存在则不会返空，也就是第一遍遍历如果有能处理异常的方法就会返回，不管是相同的异常类处理方法还是对其父类的处理方法
		if (!matches.isEmpty()) {
			// 排序， 如果当前@ControllerAdvice注解类中既存在相同异常类处理又存在父类异常处理，则会将相同异常类处理排在前面。这个排序没有深究，多个父类排序规则不清楚。
			Collections.sort(matches, new ExceptionDepthComparator(exceptionType));
			return this.mappedMethods.get(matches.get(0));
		else {
			return null;
总结：如果有多个@ControllerAdvice注解类，当第一个加载的注解类里有对需要捕获异常的相同类/父类有方法处理，就会使用第一个处理方法。可使用@Order控制加载顺序。
上面处理流程是遍历exceptionHandlerAdviceCache，故来看这个数据来源。
	private void initExceptionHandlerAdviceCache() {
		if (getApplicationContext() == null) {
			return;
		if (logger.isDebugEnabled()) {
			logger.debug("Looking for exception mappings: " + getApplicationContext());
		// 找到有@ControllerAdvice注解的类并排序，可以看到这里决定了上面的处理顺序，但加载排序未仔细看
		List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
		AnnotationAwareOrderComparator.sort(adviceBeans);
		for (ControllerAdviceBean adviceBean : adviceBeans) {
			ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(adviceBean.getBeanType());
			if (resolver.hasExceptionMappings()) {
				this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
				if (logger.isInfoEnabled()) {
					logger.info("Detected @ExceptionHandler methods in " + adviceBean);
			if (ResponseBodyAdvice.class.isAssignableFrom(adviceBean.getBeanType())) {
				this.responseBodyAdvice.add(adviceBean);
				if (logger.isInfoEnabled()) {
					logger.info("Detected ResponseBodyAdvice implementation in " + adviceBean);
个人理解哪个生效就是一个加载顺序的问题。启动类如果有@ComponentScan注解，那么还有其他方法，但没有上述使用@Order方法优雅。
使用basePackageClasses属性，将想要优先加载的包写在前面；
使用excludeFilters属性排除不想要加载的类，该属性使用方式多样，可自行搜索查看。（例： @ComponentScan(excludeFilters = @ComponentScan.Filter( type = FilterType.ASSIGNABLE_TYPE, classes = xx.class))）
关于全局异常处理的运用
全局异常处理代码:
@RestController
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public Result handle(Exception e) {
        log.error("全局异常处理：", e);
        return new Result<>(HttpStatus.INTERNAL_SERVER_ERROR.value(), "服务异常", null);
逻辑代码:
@Service
public class xxxServiceImpl {
    private void xxxFunction(int xxId) {
    // 省略逻辑代码, CustomException为自定义异常, 继承Exception
        throw new CustomException("参数校验未通过");