这篇文章给大家分享的是有关spring全局异常拦截器怎么实现的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。

你可能会问，Spring已经自带了全局异常拦截，为什么还要重复造轮子呢？

这是个好问题，我觉得有以下几个原因

装逼

Spring的全局异常拦截只是针对于Spring MVC的接口，对于你的RPC接口就无能为力了

无法定制化

除了写业务代码，我们其实还能干点别的事

我觉得上述理由已经比较充分的解答了为什么要重复造轮子，接下来就来看一下怎么造轮子

造个什么样的轮子？

我觉得全局异常拦截应该有如下特性

使用方便，最好和spring原生的使用方式一致，降低学习成本

能够支持所有接口

调用异常处理器可预期，比如说定义了RuntimeException的处理器和Exception的处理器，如果这个时候抛出NullPointException，这时候要能没有歧义的选择预期的处理器

如何造轮子？

由于现在的应用基本上都是基于spring的，因此我也是基于SpringAop来实现全局异常拦截

首先先定义几个注解

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Componentpublic@interfaceExceptionAdvice{}@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic@interfaceExceptionHandler{Class<?extendsThrowable>[]value();}@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic@interfaceExceptionIntercept{}

@ExceptionAdvice 的作用是标志定义异常处理器的类，方便找到异常处理器

@ExceptionHandler 的作用是标记某个方法是处理异常的，里面的值是能够处理的异常类型

@ExceptionIntercept 的作用是标记需要异常拦截的方法

接下来定义统一返回格式，以便出现错误的时候统一返回

@DatapublicclassBaseResponse<T>{privateIntegercode;privateStringmessage;privateTdata;publicBaseResponse(Integercode,Stringmessage){this.code=code;this.message=message;}}

然后定义一个收集异常处理器的类

publicclassExceptionMethodPool{privateList<ExceptionMethod>methods;privateObjectexcutor;publicExceptionMethodPool(Objectexcutor){this.methods=newArrayList<ExceptionMethod>();this.excutor=excutor;}publicObjectgetExcutor(){returnexcutor;}publicvoidadd(Class<?extendsThrowable>clazz,Methodmethod){methods.add(newExceptionMethod(clazz,method));}//按序查找能够处理该异常的处理器publicMethodobtainMethod(Throwablethrowable){returnmethods.stream().filter(e->e.getClazz().isAssignableFrom(throwable.getClass())).findFirst().orElseThrow(()->newRuntimeException("没有找到对应的异常处理器")).getMethod();}@AllArgsConstructor@GetterclassExceptionMethod{privateClass<?extendsThrowable>clazz;privateMethodmethod;}}

ExceptionMethod 里面有两个属性

clazz：这个代表着能够处理的异常

method：代表着处理异常调用的方法

ExceptionMethodPool 里面按序存放所有异常处理器，excutor是执行这些异常处理器的对象

接下来把所有定义的异常处理器收集起来

@ComponentpublicclassExceptionBeanPostProcessorimplementsBeanPostProcessor{privateExceptionMethodPoolexceptionMethodPool;@AutowiredprivateConfigurableApplicationContextcontext;@OverridepublicObjectpostProcessBeforeInitialization(Objectbean,StringbeanName)throwsBeansException{Class<?>clazz=bean.getClass();ExceptionAdviceadvice=clazz.getAnnotation(ExceptionAdvice.class);if(advice==null)returnbean;if(exceptionMethodPool!=null)thrownewRuntimeException("不允许有两个异常定义类");exceptionMethodPool=newExceptionMethodPool(bean);//保持处理异常方法顺序Arrays.stream(clazz.getDeclaredMethods()).filter(method->method.getAnnotation(ExceptionHandler.class)!=null).forEach(method->{ExceptionHandlerexceptionHandler=method.getAnnotation(ExceptionHandler.class);Arrays.stream(exceptionHandler.value()).forEach(c->exceptionMethodPool.add(c,method));});//注册进spring容器context.getBeanFactory().registerSingleton("exceptionMethodPool",exceptionMethodPool);returnbean;}}

ExceptionBeanPostProcessor 通过实现BeanPostProcessor 接口，在bean初始化之前，把所有异常处理器塞进 ExceptionMethodPool,并把其注册进Spring容器

然后定义异常处理器

@ComponentpublicclassExceptionProcessor{@AutowiredprivateExceptionMethodPoolexceptionMethodPool;publicBaseResponseprocess(Throwablee){return(BaseResponse)FunctionUtil.computeOrGetDefault(()->{Methodmethod=exceptionMethodPool.obtainMethod(e);method.setAccessible(true);returnmethod.invoke(exceptionMethodPool.getExcutor(),e);},newBaseResponse(0,"未知错误"));}}

这里应用了我自己通过函数式编程封装的一些语法糖，有兴趣的可以看下

最后通过AOP进行拦截

@Aspect@ComponentpublicclassExceptionInterceptAop{@AutowiredprivateExceptionProcessorexceptionProcessor;@Pointcut("@annotation(com.example.exception.intercept.ExceptionIntercept)")publicvoidpointcut(){}@Around("pointcut()")publicObjectaround(ProceedingJoinPointpoint){returncomputeAndDealException(()->point.proceed(),e->exceptionProcessor.process(e));}publicstatic<R>RcomputeAndDealException(ThrowExceptionSupplier<R>supplier,Function<Throwable,R>dealFunc){try{returnsupplier.get();}catch(Throwablee){returndealFunc.apply(e);}}@FunctionalInterfacepublicinterfaceThrowExceptionSupplier<T>{Tget()throwsThrowable;}}

到这里代码部分就已经完成了，我们来看下如何使用

@ExceptionAdvicepublicclassExceptionConfig{@ExceptionHandler(value=NullPointerException.class)publicBaseResponseprocess(NullPointerExceptione){returnnewBaseResponse(0,"NPE");}@ExceptionHandler(value=Exception.class)publicBaseResponseprocess(Exceptione){returnnewBaseResponse(0,"Ex");}}@RestControllerpublicclassTestControler{@RequestMapping("/test")@ExceptionInterceptpublicBaseResponsetest(@RequestParam("a")Integera){if(a==1){returnnewBaseResponse(1,a+"");}elseif(a==2){thrownewNullPointerException();}elsethrownewRuntimeException();}}

我们通过@ExceptionAdvice标志定义异常处理器的类，然后通过@ExceptionHandler标注处理异常的方法，方便收集

最后在需要异常拦截的方法上面通过@ExceptionIntercept进行异常拦截

我没有使用Spring那种匹配最近父类的方式寻找匹配的异常处理器，我觉得这种设计是一个败笔，理由如下

代码复杂

不能一眼看出要去调用哪个异常处理器，尤其是定义的异常处理器非常多的时候，要是弄多个定义类就更不好找了，可能要把所有的处理器看完才知道应该调用哪个

出于以上考虑，我只保留了一个异常处理器定义类，并且匹配顺序和方法定义顺序一致，从上到下依次匹配，这样只要找到一个能够处理的处理器，那么就知道了会如何调用

感谢各位的阅读！关于“spring全局异常拦截器怎么实现”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！