异常统一处理

最新推荐文章于 2024-02-05 08:00:00 发布

我愿成为你头顶的云

最新推荐文章于 2024-02-05 08:00:00 发布

阅读量229

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/qq_42640067/article/details/111718273

版权

JavaSE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

前言

我们在写代码的时候，对于可能有异常的代码，处理方式有2种，要么将异常在方法中throws抛出去，抛给别人处理。要么就是用try catch块将有问题的代码包起来，自行处理。如果方法中可能会出异常的代码有很多，那么通过以上2种方式处理的结果就是：方法后面跟着一大堆譬如throws aaaException,throwsbbbException,throwscccException…之类的，当然你也可以直接抛一个父类throws Exception将这些都囊括；然后也可能是方法中一大堆的try catch块包围着，有用的高效代码没几行，却全部都是这样重复的处理异常的代码。这样的结果很令人抓狂，那么有没有一种统一处理异常的方式呢，既能有效的处理异常，又能使我们的代码看起来简洁美观？当然是有，可以定义一个统一的异常捕获类来捕获系统可能会出现的异常，来进行统一捕获和处理。

1、异常分类

对于抛出的异常，我们把它分为两种类型：可预知异常和不可预知异常。

（1）可预知异常

可预知异常是程序员在代码中手动抛出本系统定义的特定异常类型，由于是程序员抛出的异常，通常异常信息比较齐全，程序员在抛出时会指定错误代码及错误信息，获取异常信息也比较方便。

对于可预知的异常由程序员在代码中主动抛出，由SpringMVC统一捕获。

（2）不可预知异常

不可预知异常通常是由于系统出现bug、或一些不要抗拒的错误（比如网络中断、服务器宕机等），异常类型为RuntimeException类型（运行时异常）。

对于不可预知的异常（运行时异常）由SpringMVC统一捕获Exception类型的异常。

处理方式：
可预知的异常及不可预知的运行时异常最终会采用统一的信息格式（错误代码+错误信息）来表示，最终也会随请求响应给客户端。

2、异常抛出及处理流程
在这里插入图片描述
说明：

在controller、service、dao中程序员抛出自定义异常，springMVC框架抛出框架异常类型。
统一由异常捕获类捕获异常，并进行处理。
捕获到自定义异常则直接取出错误代码及错误信息，响应给用户。
捕获到非自定义异常类型首先从Map中找该异常类型是否对应具体的错误代码，如果有则取出错误代码和错误信息并响应给用户，如果从Map中找不到异常类型所对应的错误代码则统一为99999错误代码并响应给用户。
将错误代码及错误信息以Json格式响应给用户。

3、处理过程

以上分析了异常的处理流程，那么现在用代码来进行实现。

（1）自定义异常类

首先，应该自定义一个异常类：

/*
 * 自定义异常类
 */
public class CustomException extends RuntimeException{

    private static final long serialVersionUID = 1L;
    
    ResultCode resultCode;//错误代码
    
    //构造方法
    CustomException(ResultCode resultCode) {
        this.resultCode = resultCode;
    }
    
    //获取操作代码
    public ResultCode getreResultCode() {
        return resultCode;
    }

}

对于ResultCode类型，如下：

/*
 * 定义状态码
 */
public interface ResultCode {
    
    boolean success();//是否操作成功
    
    int code();//操作代码
    
    String message();//提示信息
  
}

最终会响应给用户一个ResultCode对象，里面定义了是否操作成功，失败或成功的状态码以及定义的提示信息。

（2）异常抛出类

对于异常的抛出，我们单独定义一个异常的抛出类，里面定义抛出异常的方法：

/*
 * 定义一个异常抛出类
 * 此类用来抛出自定义异常
 */
public class ExceptionCast {
    
    //提供一个静态方法来抛出自定义异常
    public static void cast(ResultCode resultCode) {
        throw new CustomException(resultCode);
    } 

}

（3）异常捕获类

我们统一定义一个异常捕获类，来捕获可预知异常和不可预知异常，这里先捕获可预知异常：

/*
 * 定义统一异常捕获类
 * 此类捕获自定义异常和框架抛出的不可预知异常
 */
//控制器增强
@ControllerAdvice
public class ExceptionCatch {
    
   //日志对象
    private static final Logger log = LoggerFactory.getLogger(ExceptionCatch.class);
    
    /*
           * 捕获自定义异常
           * 并转成json格式
     */
    @ExceptionHandler(CustomException.class)
    @ResponseBody
    public ResponseResult catchCustomException(CustomException customException) {
        //记录日志
        log.error("catch exception:{}",customException.getreResultCode());
        //获取错误代码
        ResultCode resultCode = customException.getreResultCode();
        return new ResponseResult(resultCode);
    }

}

一般都会用@ControllerAdvice + @ExceptionHandler组合注解的方式来捕获异常。@ControllerAdvice注解进行控制器增强，@ExceptionHandler来捕获哪种类型的异常。

（4）自定义错误代码

一般会用枚举的方式进行定义：

@ToString
public enum TestCode implements ResultCode{
    
    SUCCESS(true,10000,"操作成功！"),
    FAIL(false,11111,"操作失败！"),
    ID_NOT_EXIST(false,20001,"无效ID！"),
    SERVER_ERROR(false,20002,"服务端异常！");
    
    boolean success;//是否成功
    int code;//状态码
    String message;//提示信息
    
    private TestCode(boolean success,int code,String message) {
        this.success = success;
        this.code = code;
        this.message = message;
    }

    @Override
    public boolean success() {
        return success;
    }

    @Override
    public int code() {
        return code;
    }

    @Override
    public String message() {
        return message;
    }

}

（5）测试可预知异常

下面测试一下抛出可预知异常，修改一下以前的代码：

    public ResponseResult delPerson(int id) {
        Optional<Person> optional = personRepository.findById(id);
        if(!optional.isPresent()) {
            //id不存在的话，抛出自定义的异常
            ExceptionCast.cast(TestCode.ID_NOT_EXIST);
        }
        personRepository.deleteById(id);
        return new ResponseResult(TestCode.SUCCESS);
    }

这是删除一条记录的简单方法，在swagger中测试这个接口：
在这里插入图片描述
输入一个不存在的id，然后执行，返回结果：

这是在错误代码中自定义的信息。然后看控制台：

在这里插入图片描述
日志信息也打印出来了，说明这个捕获类对自定义的异常的捕获和处理是成功的。那么接下来测试对于框架抛出的异常的处理。

（6）不可预知异常处理

不止预知异常是框架抛出的，我们在写代码的时候可能哪里稍微不注意就会遇到，为了测试框架抛出的异常，我先把数据表改一下：

在这里插入图片描述
这个name字段以前是允许为null的，现在改成不允许，然后再测一下添加接口：

参数里面是没有name的，也就是说默认为null了，执行，返回结果如下：

返回了一个500的错误，错误信息是看不出哪里有问题的，再看控制台：
在这里插入图片描述

那么通过控制台，知道是什么异常了，异常类型为DataIntegrityViolationException，知道这个异常类型就可以定义了，如下：

    //定义map，配置异常类型对应的错误代码
    private static ImmutableMap<Class<? extends Throwable>, ResultCode> EXCEPTIONS;
    
    //定义map的builder对象，用于构建ImmutableMap
    private static ImmutableMap.Builder<Class<? extends Throwable>, ResultCode> builder = ImmutableMap.builder();
    
    /*
    * 捕获不可预知异常
     */
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseResult catchException(Exception exception) {
        //记录日志
        log.error("catch exception:{}",exception.getMessage());
        //为空时构建map对象
        if(EXCEPTIONS == null) {
            EXCEPTIONS = builder.build();
        }
        //从EXCEPTIONS中获取错误代码
        ResultCode resultCode = EXCEPTIONS.get(exception.getClass());
        //找到则将错误代码响应给客户端
        if(resultCode != null) {
            return new ResponseResult(resultCode);
        }else {
            //找不到，响应服务端错误
            return new ResponseResult(TestCode.SERVER_ERROR);  
        }
    }
    
    //静态代码块中定义添加框架抛出的异常
    static {
        builder.put(DataIntegrityViolationException.class,TestCode.FIELD_IS_NULL);
    }

这些内容在ExceptionCatch类中添加就行了，ExceptionCatch中完整的代码如下：

/*
 * 定义统一异常捕获类
 * 此类捕获自定义异常和框架抛出的不可预知异常
 */
//控制器增强
@ControllerAdvice
public class ExceptionCatch {
    
    //日志对象
    private static final Logger log = LoggerFactory.getLogger(ExceptionCatch.class);
    
    //定义map，配置异常类型对应的错误代码
    private static ImmutableMap<Class<? extends Throwable>, ResultCode> EXCEPTIONS;
    
    //定义map的builder对象，用于构建ImmutableMap
    private static ImmutableMap.Builder<Class<? extends Throwable>, ResultCode> builder = ImmutableMap.builder();
    
    
    /*
           * 捕获自定义异常
           * 并转成json格式
     */
    @ExceptionHandler(CustomException.class)
    @ResponseBody
    public ResponseResult catchCustomException(CustomException customException) {
        //记录日志
        log.error("catch exception:{}",customException.getreResultCode());
        //获取错误代码
        ResultCode resultCode = customException.getreResultCode();
        return new ResponseResult(resultCode);
    }
    
    /*
           * 捕获不可预知异常
     */
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseResult catchException(Exception exception) {
        //记录日志
        log.error("catch exception:{}",exception.getMessage());
        //为空时构建map对象
        if(EXCEPTIONS == null) {
            EXCEPTIONS = builder.build();
        }
        //从EXCEPTIONS中获取错误代码
        ResultCode resultCode = EXCEPTIONS.get(exception.getClass());
        //找到则将错误代码响应给客户端
        if(resultCode != null) {
            return new ResponseResult(resultCode);
        }else {
            //找不到，响应服务端错误
            return new ResponseResult(TestCode.SERVER_ERROR);  
        }
    }
    
    //静态代码块中定义添加框架抛出的异常
    static {
        builder.put(DataIntegrityViolationException.class,TestCode.FIELD_IS_NULL);
    }

}

在错误代码中添加：
在这里插入图片描述
然后再测试添加接口，返回类型：

捕获到并且处理了。如果将static代码块中的这行注释掉：

    //静态代码块中定义添加框架抛出的异常
    static {
        //builder.put(DataIntegrityViolationException.class,TestCode.FIELD_IS_NULL);
    }

再测添加接口，返回结果：
在这里插入图片描述
因为在定义的map里没找到，找到的统一报服务端异常，如下：

        //从EXCEPTIONS中获取错误代码
        ResultCode resultCode = EXCEPTIONS.get(exception.getClass());
        //找到则将错误代码响应给客户端
        if(resultCode != null) {
            return new ResponseResult(resultCode);
        }else {
            //找不到，响应服务端错误
            return new ResponseResult(TestCode.SERVER_ERROR);  
        }

所以对于框架抛出的异常，我们要知道其异常类型，然后添加进map里，才可以响应具体定义的信息，如果不知道具体是什么异常，也可以把框架抛出的所有异常响应为统一代码，比如图中的服务端异常。

4、总结

对于异常，可以统一捕获和处理，这样可以自定义异常信息，响应给客户端，在客户端显示出来，那么这样的好处是自定义个性化设置，对于用户的体验非常好，而且使我们的代码更加简洁美观，可扩展性更强。如果是微服务的话，建议在每个微服务中都自定义异常、异常捕获以及错误代码，响应给客户端，在页面中显示出个性化的异常信息，将会使用户对应用的体验好感度上升。

我愿成为你头顶的云

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
异常统一处理

前言我们在写代码的时候，对于可能有异常的代码，处理方式有2种，要么将异常在方法中throws抛出去，抛给别人处理。要么就是用try catch块将有问题的代码包起来，自行处理。如果方法中可能会出异常的代码有很多，那么通过以上2种方式处理的结果就是：方法后面跟着一大堆譬如throws aaaException,throwsbbbException,throwscccException…之类的，当然你也可以直接抛一个父类throws Exception将这些都囊括；然后也可能是方法中一大堆的try catch
复制链接

扫一扫

专栏目录