SpringBoot 全局异常处理+策略+反射异常

灰太狼 2021-09-21 04:52 521阅读 0赞

### SpringBoot 全局异常处理+策略+反射异常 ###

*  异常分类处理
 *   *  GlobalBaseExceptionHandler(基础异常)
     *  DataAccessException(持久层异常)
     *  GlobalTokenAccessExceptionHandler (令牌授权异常)
     *  GlobalInvocationTargetExceptionHandler(反射异常 技术点)
     *  反射异常处理逻辑

# 异常分类处理 #

GlobalBaseExceptionHandler(基础异常) 
    DataAccessException(持久层异常)
     GlobalTokenAccessExceptionHandler (令牌授权异常)
     GlobalInvocationTargetExceptionHandler(反射异常)
     ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200320140613231.png)

## GlobalBaseExceptionHandler(基础异常) ##

/**
     *  基础异常抛出
     *  包含 类型转换异常  数组下表越界 文件没有找到 输入输出  空指针  参数校验 自定义异常 除数为零
     *
     *
     */
    
    @Slf4j
    @RestControllerAdvice
    public class GlobalBaseExceptionHandler { 
        /**
         * 所有异常报错
         * TODO  策略处理
         * @param ex
         * @return
         * @throws Exception
         */
    
        /**
         * 类转换异常
         * @param exception
         * @return
         */
        @ExceptionHandler(ClassCastException.class)
        public Result classCastException(ClassCastException exception) { 
            return ResultFactory.of(DefaultResultCode.CLASS_CAST_EXCEPTION,exception.getMessage());
        }
    
        /**
         * 数组下表越界异常
         * @param exception
         * @return
         */
        @ExceptionHandler(ArrayIndexOutOfBoundsException.class)
        public Result arrayIndexOutOfBoundsException(ArrayIndexOutOfBoundsException exception) { 
            return ResultFactory.of(DefaultResultCode.ARR_EXCEPTION,exception.getMessage());
        }
    
        /**
         *
         * @param exception
         * @return
         */
        @ExceptionHandler(FileNotFoundException.class)
        public Result fileNotFoundException(FileNotFoundException exception) { 
            return ResultFactory.of(DefaultResultCode.FILE_NOT_FOUND_EXCEPTION,exception.getMessage());
        }
    
        /**
         * 输入输出流异常
         * @param exception
         * @return
         */
        @ExceptionHandler(IOException.class)
        public Result iOException(IOException exception) { 
            return ResultFactory.of(DefaultResultCode.IO_EXCEPTION,exception.getMessage());
        }
    
        /**
         * 空指针异常
         * @param exception
         * @return
         */
        @ExceptionHandler(NullPointerException.class)
        public Result nullPointerException(NullPointerException exception) { 
            exception.printStackTrace();
            return ResultFactory.of(DefaultResultCode.NULL_EXCEPTION, exception.getMessage());
        }
    
        /**
         * 除数为零
         * @param exception
         * @return
         */
        @ExceptionHandler(ArithmeticException.class)
        public Result arithmeticException(ArithmeticException exception) { 
            return ResultFactory.of(DefaultResultCode.DIVISOR_IS_ZERO_EXCEPTION, exception.getMessage());
        }
        /**
         * 自定义异常
         * @param exception
         * @return
         */
        @ExceptionHandler(CustomException.class)
        public Result customException(CustomException exception) { 
            return ResultFactory.of(DefaultResultCode.DEFAULT_ERROR, exception.getMessage());
        }
    
        /**
         * 对方法参数校验异常处理方法(仅对于表单提交有效，对于以json格式提交将会失效)
         * 如果是表单类型的提交，则spring会采用表单数据的处理类进行处理（进行参数校验错误时会抛出BindException异常）
         */
        @ExceptionHandler(BindException.class)
        public Result handlerBindException(BindException exception) { 
            return handlerNotValidException(exception);
        }
    
        /**
         * 对方法参数校验异常处理方法(前端提交的方式为json格式出现异常时会被该异常类处理)
         * json格式提交时，spring会采用json数据的数据转换器进行处理（进行参数校验时错误是抛出MethodArgumentNotValidException异常）
         */
        @ExceptionHandler(MethodArgumentNotValidException.class)
        public Result handlerArgumentNotValidException(MethodArgumentNotValidException exception) { 
            return handlerNotValidException(exception);
        }
    
        private Result handlerNotValidException(Exception e) { 
            log.debug("begin resolve argument exception");
            BindingResult result;
            if (e instanceof BindException) { 
                BindException exception = (BindException) e;
                result = exception.getBindingResult();
            } else { 
                MethodArgumentNotValidException exception = (MethodArgumentNotValidException) e;
                result = exception.getBindingResult();
            }
    
            Map<String, Object> map = Maps.newHashMap();
            if (result.hasErrors()) { 
                List<FieldError> fieldErrors = result.getFieldErrors();
                fieldErrors.forEach(error -> { 
                    map.put(error.getField(), error.getDefaultMessage());
                });
            }
            return ResultFactory.of(DefaultResultCode.INVALID_PARAMETER, map.toString());
        }
    }

## DataAccessException(持久层异常) ##

/**
     *
     * DataAccessException(持久层异常)
     * sql异常 HttpMessageNotReadableException
     */
    @RestControllerAdvice
    public class GlobalDataAccessExceptionHandler { 
    
    
        /**
         * sql异常
         *
         * @param exception
         * @return
         */
        @ExceptionHandler({ BadSqlGrammarException.class, SQLException.class})
        public Result sqlException(Exception exception) { 
            return ResultFactory.of(DefaultResultCode.SQL_EXCEPTION, exception.getMessage());
        }
    
        @ExceptionHandler({ SQLIntegrityConstraintViolationException.class, ConstraintViolationException.class})
        public Result sQLIntegrityConstraintViolationException(Exception exception) { 
            return ResultFactory.of(DefaultResultCode.SQL_INTEGRITY_CONSTRAINT_VIOLATION_EXCEPTION, exception.getMessage());
        }
    
        @ExceptionHandler({ DuplicateKeyException.class})
        public Result duplicateKeyException(DuplicateKeyException exception) { 
            return ResultFactory.of(DefaultResultCode.DUPLICATE_KEY_EXCEPTION, exception.getMessage());
        }
    
        /**
         * HttpMessageNotReadableException
         * @param exception
         * @return
         */
        @ExceptionHandler({ HttpMessageNotReadableException.class})
        public Result httpMessageNotReadableException(HttpMessageNotReadableException exception) { 
            return ResultFactory.of(DefaultResultCode.INVALID_FORMAT_EXCEPTION,exception.getMessage());
        }
    
    
        @ExceptionHandler({ TransactionRequiredException.class})
        public Result transactionRequiredException(TransactionRequiredException exception) { 
            return ResultFactory.of(DefaultResultCode.TRANSACTION_REQUIRED_EXCEPTION,exception.getMessage());
        }
    
    
    }

## GlobalTokenAccessExceptionHandler (令牌授权异常) ##

/**
     *
     * GlobalTokenAccessExceptionHandler(令牌授权异常)
     */
    @RestControllerAdvice
    public class GlobalTokenAccessExceptionHandler { 
    
        /**
         * 未授权
         * @param exception
         * @return
         */
        @ExceptionHandler({ UnauthorizedException.class})
        public Result unauthorizedException(UnauthorizedException exception) { 
            return ResultFactory.of(DefaultResultCode.TOKEN_INVALID,exception.getMessage());
        }
    
        /**
         * 权限错误
         * @param exception
         * @return
         */
        @ExceptionHandler({ ShiroException.class})
        public Result shiroException(ShiroException exception) { 
            return ResultFactory.of(DefaultResultCode.TOKEN_INVALIDATION,exception.getMessage());
        }
    
    }

## GlobalInvocationTargetExceptionHandler(反射异常 技术点) ##

/**
     * 反射异常处理
     */
    @RestControllerAdvice
    public class GlobalInvocationTargetExceptionHandler { 
    
        private GlobalDataAccessExceptionHandler globalDataAccessExceptionHandler;
    
        private GlobalBaseExceptionHandler globalBaseExceptionHandler;
    
        private GlobalTokenAccessExceptionHandler globalTokenAccessExceptionHandler;
    
        @Autowired
        public GlobalInvocationTargetExceptionHandler(GlobalDataAccessExceptionHandler globalDataAccessExceptionHandler, GlobalBaseExceptionHandler globalBaseExceptionHandler, GlobalTokenAccessExceptionHandler globalTokenAccessExceptionHandler) { 
            this.globalDataAccessExceptionHandler = globalDataAccessExceptionHandler;
            this.globalBaseExceptionHandler = globalBaseExceptionHandler;
            this.globalTokenAccessExceptionHandler = globalTokenAccessExceptionHandler;
        }
    
    
        /**
         * 反射调用异常
         *
         * @param exception
         * @return
         */
        @ExceptionHandler({ InvocationTargetException.class})
        public Result invocationTargetException(InvocationTargetException exception) throws IllegalAccessException, InvocationTargetException { 
            Throwable throwable = exception.getTargetException();
            //判断当前异常
            return (Result) chooseThrowableByType(throwable);
    //        // 判断异常case
    //        if (throwable.getCause() instanceof SQLIntegrityConstraintViolationException) { 
    //            return globalDataAccessExceptionHandler.sQLIntegrityConstraintViolationException((Exception) throwable); // } else { // return ResultFactory.of(DefaultResultCode.REFLEX_EXCEPTION, exception.getMessage());
    //        }
        }
    
        public Object chooseThrowableByType(Throwable throwable) throws IllegalAccessException, InvocationTargetException { 
            Field[] fields = GlobalInvocationTargetExceptionHandler.class.getDeclaredFields();
            for (Field field : fields) { 
                field.setAccessible(true);
                Object fieldObj = field.get(this);
                Method[] methods = field.getType().getDeclaredMethods();
                for (Method method : methods) { 
                    ExceptionHandler exceptionHandler=method.getAnnotation(ExceptionHandler.class);
                    if (ObjectUtils.isEmpty(exceptionHandler)) { 
                        continue;
                    }
                    Class clzz = throwable.getClass();
                    for (Class<? extends Throwable> aClass : exceptionHandler.value()) { 
                        if (clzz.isAssignableFrom(aClass)) { 
                            method.setAccessible(true);
                            return (Result) method.invoke(fieldObj, throwable);
                        }
                    }
    
                }
            }
            if (ObjectUtils.isEmpty(throwable.getCause())) { 
                return ResultFactory.of(DefaultResultCode.REFLEX_EXCEPTION, throwable.getMessage());
            } else { 
                return chooseThrowableByType(throwable.getCause());
            }
        }
    
    
    }

## 反射异常处理逻辑 ##

1.首先GlobalInvocationTargetExceptionHandler 类中注入三大基础异常类对象 (使用spring bean注入的方式获取对象)
    2.所有的异常类都继承自Throwable 通过throwable.getCause()可以获取反射异常是由那种异常造成的
    3.递归