这篇文章给大家分享的是有关spring全局异常拦截器怎么实现的内容。小编觉得挺实用的,因此分享给大家做个参考,一起跟随小编过来看看吧。
你可能会问,Spring已经自带了全局异常拦截,为什么还要重复造轮子呢?
这是个好问题,我觉得有以下几个原因
装逼
Spring的全局异常拦截只是针对于Spring MVC的接口,对于你的RPC接口就无能为力了
无法定制化
除了写业务代码,我们其实还能干点别的事
我觉得上述理由已经比较充分的解答了为什么要重复造轮子,接下来就来看一下怎么造轮子
造个什么样的轮子?
我觉得全局异常拦截应该有如下特性
使用方便,最好和spring原生的使用方式一致,降低学习成本
能够支持所有接口
调用异常处理器可预期,比如说定义了RuntimeException的处理器和Exception的处理器,如果这个时候抛出NullPointException,这时候要能没有歧义的选择预期的处理器
如何造轮子?
由于现在的应用基本上都是基于spring的,因此我也是基于SpringAop来实现全局异常拦截
首先先定义几个注解
@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Componentpublic @interface ExceptionAdvice {} @Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface ExceptionHandler {Class<? extends Throwable>[] value();} @Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface ExceptionIntercept {}
@ExceptionAdvice 的作用是标志定义异常处理器的类,方便找到异常处理器
@ExceptionHandler 的作用是标记某个方法是处理异常的,里面的值是能够处理的异常类型
@ExceptionIntercept 的作用是标记需要异常拦截的方法
接下来定义统一返回格式,以便出现错误的时候统一返回
@Datapublic class BaseResponse<T> {private Integer code;private String message;private T data; public BaseResponse(Integer code, String message) {this.code = code;this.message = message;}}
然后定义一个收集异常处理器的类
public class ExceptionMethodPool {private List<ExceptionMethod> methods;private Object excutor; public ExceptionMethodPool(Object excutor) {this.methods = new ArrayList<ExceptionMethod>();this.excutor = excutor;} public Object getExcutor() {return excutor;} public void add(Class<? extends Throwable> clazz, Method method) {methods.add(new ExceptionMethod(clazz, method));} //按序查找能够处理该异常的处理器public Method obtainMethod(Throwable throwable) {return methods.stream().filter(e -> e.getClazz().isAssignableFrom(throwable.getClass())).findFirst().orElseThrow(() ->new RuntimeException("没有找到对应的异常处理器")).getMethod();} @AllArgsConstructor@Getterclass ExceptionMethod {private Class<? extends Throwable> clazz;private Method method;}}
ExceptionMethod 里面有两个属性
clazz:这个代表着能够处理的异常
method:代表着处理异常调用的方法
ExceptionMethodPool 里面按序存放所有异常处理器,excutor是执行这些异常处理器的对象
接下来把所有定义的异常处理器收集起来
@Componentpublic class ExceptionBeanPostProcessor implements BeanPostProcessor {private ExceptionMethodPool exceptionMethodPool;@Autowiredprivate ConfigurableApplicationContext context; @Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {Class<?> clazz = bean.getClass();ExceptionAdvice advice = clazz.getAnnotation(ExceptionAdvice.class);if (advice == null) return bean;if (exceptionMethodPool != null) throw new RuntimeException("不允许有两个异常定义类");exceptionMethodPool = new ExceptionMethodPool(bean); //保持处理异常方法顺序Arrays.stream(clazz.getDeclaredMethods()).filter(method -> method.getAnnotation(ExceptionHandler.class) != null).forEach(method -> {ExceptionHandler exceptionHandler = method.getAnnotation(ExceptionHandler.class);Arrays.stream(exceptionHandler.value()).forEach(c -> exceptionMethodPool.add(c,method));});//注册进spring容器context.getBeanFactory().registerSingleton("exceptionMethodPool",exceptionMethodPool);return bean;}}
ExceptionBeanPostProcessor 通过实现BeanPostProcessor 接口,在bean初始化之前,把所有异常处理器塞进 ExceptionMethodPool,并把其注册进Spring容器
然后定义异常处理器
@Componentpublic class ExceptionProcessor {@Autowiredprivate ExceptionMethodPool exceptionMethodPool; public BaseResponse process(Throwable e) {return (BaseResponse) FunctionUtil.computeOrGetDefault(() ->{Method method = exceptionMethodPool.obtainMethod(e);method.setAccessible(true);return method.invoke(exceptionMethodPool.getExcutor(),e);},new BaseResponse(0,"未知错误"));}}
这里应用了我自己通过函数式编程封装的一些语法糖,有兴趣的可以看下
最后通过AOP进行拦截
@Aspect@Componentpublic class ExceptionInterceptAop {@Autowiredprivate ExceptionProcessor exceptionProcessor; @Pointcut("@annotation(com.example.exception.intercept.ExceptionIntercept)")public void pointcut() {} @Around("pointcut()")public Object around(ProceedingJoinPoint point) {return computeAndDealException(() -> point.proceed(),e -> exceptionProcessor.process(e));} public static <R> R computeAndDealException(ThrowExceptionSupplier<R> supplier, Function<Throwable, R> dealFunc) {try {return supplier.get();} catch (Throwable e) {return dealFunc.apply(e);}}@FunctionalInterfacepublic interface ThrowExceptionSupplier<T> {T get() throws Throwable;}}
到这里代码部分就已经完成了,我们来看下如何使用
@ExceptionAdvicepublic class ExceptionConfig {@ExceptionHandler(value = NullPointerException.class)public BaseResponse process(NullPointerException e){return new BaseResponse(0,"NPE");} @ExceptionHandler(value = Exception.class)public BaseResponse process(Exception e){return new BaseResponse(0,"Ex");} } @RestControllerpublic class TestControler { @RequestMapping("/test")@ExceptionInterceptpublic BaseResponse test(@RequestParam("a") Integer a){if (a == 1){return new BaseResponse(1,a+"");}else if (a == 2){throw new NullPointerException();}else throw new RuntimeException();}}
我们通过@ExceptionAdvice标志定义异常处理器的类,然后通过@ExceptionHandler标注处理异常的方法,方便收集
最后在需要异常拦截的方法上面通过@ExceptionIntercept进行异常拦截
我没有使用Spring那种匹配最近父类的方式寻找匹配的异常处理器,我觉得这种设计是一个败笔,理由如下
代码复杂
不能一眼看出要去调用哪个异常处理器,尤其是定义的异常处理器非常多的时候,要是弄多个定义类就更不好找了,可能要把所有的处理器看完才知道应该调用哪个
出于以上考虑,我只保留了一个异常处理器定义类,并且匹配顺序和方法定义顺序一致,从上到下依次匹配,这样只要找到一个能够处理的处理器,那么就知道了会如何调用
感谢各位的阅读!关于“spring全局异常拦截器怎么实现”这篇文章就分享到这里了,希望以上内容可以对大家有一定的帮助,让大家可以学到更多知识,如果觉得文章不错,可以把它分享出去让更多的人看到吧!
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。