在spring中手写全局异常拦截器
为什么要重复造轮子
你可能会问，Spring已经自带了全局异常拦截，为什么还要重复造轮子呢？
这是个好问题，我觉得有以下几个原因
- 装逼
- Spring的全局异常拦截只是针对于SpringMVC的接口，对于你的RPC接口就无能为力了
- 无法定制化
- 除了写业务代码，我们其实还能干点别的事
我觉得上述理由已经比较充分的解答了为什么要重复造轮子，接下来就来看一下怎么造轮子
造个什么样的轮子？
我觉得全局异常拦截应该有如下特性
- 使用方便，最好和spring原生的使用方式一致，降低学习成本
- 能够支持所有接口
- 调用异常处理器可预期，比如说定义了RuntimeException的处理器和Exception的处理器，如果这个时候抛出NullPointException，这时候要能没有歧义的选择预期的处理器
如何造轮子？
由于现在的应用基本上都是基于spring的，因此我也是基于SpringAop来实现全局异常拦截
首先先定义几个注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public@interfaceExceptionAdvice{
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public@interfaceExceptionHandler{
Class[]value();
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public@interfaceExceptionIntercept{
}
@ExceptionAdvice的作用是标志定义异常处理器的类，方便找到异常处理器
@ExceptionHandler的作用是标记某个方法是处理异常的，里面的值是能够处理的异常类型
@ExceptionIntercept的作用是标记需要异常拦截的方法
接下来定义统一返回格式，以便出现错误的时候统一返回
@Data publicclassBaseResponse{ privateIntegercode; privateStringmessage; privateTdata; publicBaseResponse(Integercode,Stringmessage){ this.code=code; this.message=message; } }
然后定义一个收集异常处理器的类
publicclassExceptionMethodPool{
privateListmethods;
privateObjectexcutor;
publicExceptionMethodPool(Objectexcutor){
this.methods=newArrayList();
this.excutor=excutor;
}
publicObjectgetExcutor(){
returnexcutor;
}
publicvoidadd(Classclazz,Methodmethod){
methods.add(newExceptionMethod(clazz,method));
}
//按序查找能够处理该异常的处理器
publicMethodobtainMethod(Throwablethrowable){
returnmethods
.stream()
.filter(e->e.getClazz().isAssignableFrom(throwable.getClass()))
.findFirst()
.orElseThrow(()->newRuntimeException("没有找到对应的异常处理器"))
.getMethod();
}
@AllArgsConstructor
@Getter
classExceptionMethod{
privateClassclazz;
privateMethodmethod;
}
}
ExceptionMethod里面有两个属性
- clazz：这个代表着能够处理的异常
- method：代表着处理异常调用的方法
ExceptionMethodPool里面按序存放所有异常处理器，excutor是执行这些异常处理器的对象
接下来把所有定义的异常处理器收集起来
@Component
publicclassExceptionBeanPostProcessorimplementsBeanPostProcessor{
privateExceptionMethodPoolexceptionMethodPool;
@Autowired
privateConfigurableApplicationContextcontext;
@Override
publicObjectpostProcessBeforeInitialization(Objectbean,StringbeanName)throwsBeansException{
Classclazz=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容器
然后定义异常处理器
@Component
publicclassExceptionProcessor{
@Autowired
privateExceptionMethodPoolexceptionMethodPool;
publicBaseResponseprocess(Throwablee){
return(BaseResponse)FunctionUtil.computeOrGetDefault(()->{
Methodmethod=exceptionMethodPool.obtainMethod(e);
method.setAccessible(true);
returnmethod.invoke(exceptionMethodPool.getExcutor(),e);
},newBaseResponse(0,"未知错误"));
}
}
这里应用了我自己通过函数式编程封装的一些语法糖，有兴趣的可以看下
最后通过AOP进行拦截
@Aspect
@Component
publicclassExceptionInterceptAop{
@Autowired
privateExceptionProcessorexceptionProcessor;
@Pointcut("@annotation(com.example.exception.intercept.ExceptionIntercept)")
publicvoidpointcut(){
}
@Around("pointcut()")
publicObjectaround(ProceedingJoinPointpoint){
returncomputeAndDealException(()->point.proceed(),
e->exceptionProcessor.process(e));
}
publicstaticRcomputeAndDealException(ThrowExceptionSuppliersupplier,FunctiondealFunc){
try{
returnsupplier.get();
}catch(Throwablee){
returndealFunc.apply(e);
}
}
@FunctionalInterface
publicinterfaceThrowExceptionSupplier{
Tget()throwsThrowable;
}
}
到这里代码部分就已经完成了，我们来看下如何使用
@ExceptionAdvice
publicclassExceptionConfig{
@ExceptionHandler(value=NullPointerException.class)
publicBaseResponseprocess(NullPointerExceptione){
returnnewBaseResponse(0,"NPE");
}
@ExceptionHandler(value=Exception.class)
publicBaseResponseprocess(Exceptione){
returnnewBaseResponse(0,"Ex");
}
}
@RestController
publicclassTestControler{
@RequestMapping("/test")
@ExceptionIntercept
publicBaseResponsetest(@RequestParam("a")Integera){
if(a==1){
returnnewBaseResponse(1,a+"");
}
elseif(a==2){
thrownewNullPointerException();
}
elsethrownewRuntimeException();
}
}
我们通过@ExceptionAdvice标志定义异常处理器的类，然后通过@ExceptionHandler标注处理异常的方法，方便收集
最后在需要异常拦截的方法上面通过@ExceptionIntercept进行异常拦截
我没有使用Spring那种匹配最近父类的方式寻找匹配的异常处理器，我觉得这种设计是一个败笔，理由如下
- 代码复杂
- 不能一眼看出要去调用哪个异常处理器，尤其是定义的异常处理器非常多的时候，要是弄多个定义类就更不好找了，可能要把所有的处理器看完才知道应该调用哪个
出于以上考虑，我只保留了一个异常处理器定义类，并且匹配顺序和方法定义顺序一致，从上到下依次匹配，这样只要找到一个能够处理的处理器，那么就知道了会如何调用
原创不易，如果觉得对你有帮助，麻烦点个赞！
我会不定期分享一些有意思的技术，点个关注不迷路-。-
以上就是在spring中手写全局异常拦截器的详细内容，更多关于spring全局异常拦截的资料请关注毛票票其它相关文章！