在spring中手写全局异常拦截器

网友投稿 721 2023-03-11

在spring中手写全局异常-

在spring中手写全局异常-

为什么要重复造轮子

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

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

装逼

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

无法定制化

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

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

造个什么样的轮子?

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

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

能够支持所有接口

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

如何造轮子?

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

首先先定义几个注解

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Component

public @interface ExceptionAdvice {

}

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface ExceptionHandler {

Class extends Throwable>[] value();

}

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documehttp://nted

public @interface ExceptionIntercept {

}

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

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

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

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

@Data

public class BaseResponse {

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 methods;

private Object excutor;

public ExceptionMethodPool(Object excutor) {

this.methods = new ArrayList();

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 ->meVQKXPEFe e.getClazz().isAssignableFrom(throwable.getClass()))

.findFirst()

.orElseThrow(() ->new RuntimeException("没有找到对应的异常处理器"))

.getMethod();

}

@AllArgsConstructor

@Getter

class ExceptionMethod {

private Class extends Throwable> clazz;

private Method method;

}

}

ExceptionMethod 里面有两个属性

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

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

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

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

@Component

public class ExceptionBeanPostProcessor implements BeanPostProcessor {

private ExceptionMethodPool exceptionMethodPool;

@Autowired

private ConfigurableApplicationContext context;

@Override

public 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容器

然后定义异常处理器

@Component

public class ExceptionProcessor {

@Autowired

private 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

@Component

public class ExceptionInterceptAop {

@Autowired

private 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 computeAndDealException(ThrowExceptionSupplier supplier, Function dealFunc) {

try {

return supplier.get();

} catch (Throwable e) {

return dealFunc.apply(e);

}

}

@FunctionalInterface

public interface ThrowExceptionSupplier {

T get() throws Throwable;

}

}

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

@ExceptionAdvice

public 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");

}

}

@RestController

public class TestControler {

@RequestMapping("/test")

@ExceptionIntercept

public 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中手写全局异常-的详细内容,更多关于spring 全局异常拦截的资料请关注我们其它相关文章!

版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。

上一篇:小程序自带直播插件(小程序自带直播插件下载)
下一篇:小程序 页面跳转(小程序页面跳转方式)
相关文章

 发表评论

暂时没有评论,来抢沙发吧~