JAVA异常分类和自定义异常定义

偏执的太偏执、 2022-04-27 17:40 519阅读 0赞

异常概念：

1、如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出方法。在这种情况下 会抛出一个封装了错误信息的对象。此时，这个方法会立刻退出同时不返回任何值。另外，调用 这个方法的其他代码也无法继续执行，异常处理机制会将代码执行交给异常处理器。

2、Throwable 是 Java 语言中所有错误或异常的超类。下一层分为 Error 和 Exception

Error

1. Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果 出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。

Exception（RuntimeException、CheckedException）

2. Exception 又 有 两 个 分 支 ， 一 个 是 运 行 时 异 常 RuntimeException ， 一 个 是 CheckedException。

RuntimeException 如 ： NullPointerException 、 ClassCastException ； 一 个 是 检 查 异 常 CheckedException，如 I/O 错误导致的 IOException、SQLException。 RuntimeException 是 那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException，那么一 定是程序员的错误

检查异常 CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强 制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一 般包括几个方面：

1》 试图在文件尾部读取数据

2》 试图打开一个错误格式的 URL

3》 试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在

3、Throw 和 throws 的区别：

位置不同

1》 throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的 是异常对象。

功能不同：

2》throws 用来声明异常，让调用者只知道该功能可能出现的问题，可以给出预先的处理方 式；throw 抛出具体的问题对象，执行到 throw，功能就已经结束了，跳转到调用者，并 将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语 句，因为执行不到。

3》throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常， 执行 throw 则一定抛出了某种异常对象。 两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异 常，真正的处理异常由函数的上层调用处理。

看图理解：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70][]

4、上面介绍了异常的一些概念，下面介绍如何自定义异常，并且异常如何统一格式响应出去

自定义异常以及统一异常格式响应出去很简单，分为以下几步：
    
    （1）首先自定义一个异常类（2）再写一个全局异常捕获类（3）再封装一个通用响应对象，完成以上3步就ok了
    
    具体实现方法往下看：

1》自定义异常首先要先自己新建一个异常类继承运行时异常RuntimeException ，然后再定义一个异常码和消息的枚举类配合使用，代码如下：

自定义异常类：
    /**
     * 自定义异常类格式
     * @date 2019-06-10 10:09
     */
    
    public class TestException extends RuntimeException{
    
        private String code;
    
        public TestException(String code) {
            this.code = code;
        }
    
        public TestException(String code, Object message) {
            super(message.toString());
            this.code = code;
        }
    
        public String getCode() {
            return this.code;
        }
    
    
    }
    
    
    异常枚举类：
    public enum ActivityException {
    
    
        PARAMETER_ERROR("10100", "系统异常，入参错误"),
    
        GET_ACTIVITY_LIST("10000", "系统异常，查询活动列表异常"),
    
        private String code;
        private String message;
    
        ActivityException(String code, String message) {
            this.code = code;
            this.message = message;
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
    }

2》自定义异常好了之后使用的时候就可以new 一个自定义的异常抛出去了比如：throw new TestException("枚举code","枚举message");但是只有这些还不够，上面仅仅是把自己想要响应的异常定义出来了，那怎么统一格式响应给前端呢？那就需要全局异常捕获，捕获到自定义的异常然后封装成自己想要的格式，响应格式可以按自己需求封装异常code、message、path、time等

全局异常捕获类：
    
    /**
     * 全局异常捕获类(作用是异常信息统一格式输出)
     * @date 2019-06-10 10:25
     */
    @RestControllerAdvice//切面注解不能少
    public class TestResponseBodyAdvice {
        private static final Logger log = LoggerFactory.getLogger(TestResponseBodyAdvice.class);
    
        public TestResponseBodyAdvice() {
        }
    
        /**
         * 全局异常Exception捕获类
         * @param e
         * @return
         */
        @ExceptionHandler({Exception.class})
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
        public Response uniteExceptionHandler(Exception e) {
            log.error("系统异常", e);
            return Response.builderFail("999", "error");
        }
    
        /**
         * 全局自定义异常TestException捕获类
         * @param e
         * @return
         */
        @ExceptionHandler({TestException.class})
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)//响应状态码500
        public Response businessExceptionHandler(TestException e) {
            log.error(e.getCode(), e.getMessage());
            log.error("系统异常", e);
            return Response.builderFail(e.getCode(), e.getMessage());
        }
    
    
        /**
         *  Dto字段属性校验全局异常类
         * 用法：
         *  @ApiModelProperty(value = "规则模板名称")
         *  @NotNull
         *  @Length(max = 50, message = "名称不得超过50" ,groups = {InsertGroup.class, UpdateGroup.class})
         *  private String templateName;
         *  controller中参数加@Valid注解即可
         */
        @ExceptionHandler({MethodArgumentNotValidException.class})
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
        public Response uniteExceptionHandler(org.springframework.web.bind.MethodArgumentNotValidException e) {
            log.error("系统异常", e);
            return Response.builderFail("999", e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
        }
    
    }

可能还需要封装一个统一响应对象

@ApiModel("通用响应对象")
    @JsonSerialize(
            include = JsonSerialize.Inclusion.NON_NULL
    )
    public class Response<T> implements Serializable {
        private static final long serialVersionUID = -4505655308965878999L;
        private static final String successCode = "0";
        @ApiModelProperty("返回的业务对象")
        private T data;
        @ApiModelProperty(
                value = "错误代码，0--成功，其他失败",
                example = "0"
        )
        private String code = "0";
        @ApiModelProperty(
                value = "返回信息描述",
                example = "success"
        )
        private Object msg = "success";
    
        private Response() {
        }
    
        private Response success(T data) {
            this.data = data;
            return this;
        }
    
        private Response fail(String code, Object msg) {
            this.code = code;
            this.msg = msg;
            return this;
        }
    
        public static Response builderSuccess(Object o) {
            return (new Response()).success(o);
        }
    
        public static Response builderFail(String code, Object msg) {
            return (new Response()).fail(code, msg);
        }
    
        public T getData() {
            return this.data;
        }
    
        public String getCode() {
            return this.code;
        }
    
        public Object getMsg() {
            return this.msg;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public void setMsg(Object msg) {
            this.msg = msg;
        }
    
        @Override
        public boolean equals(Object o) {
            if (o == this) {
                return true;
            } else if (!(o instanceof Response)) {
                return false;
            } else {
                Response<?> other = (Response)o;
                if (!other.canEqual(this)) {
                    return false;
                } else {
                    label47: {
                        Object this$data = this.getData();
                        Object other$data = other.getData();
                        if (this$data == null) {
                            if (other$data == null) {
                                break label47;
                            }
                        } else if (this$data.equals(other$data)) {
                            break label47;
                        }
    
                        return false;
                    }
    
                    Object this$code = this.getCode();
                    Object other$code = other.getCode();
                    if (this$code == null) {
                        if (other$code != null) {
                            return false;
                        }
                    } else if (!this$code.equals(other$code)) {
                        return false;
                    }
    
                    Object this$msg = this.getMsg();
                    Object other$msg = other.getMsg();
                    if (this$msg == null) {
                        if (other$msg != null) {
                            return false;
                        }
                    } else if (!this$msg.equals(other$msg)) {
                        return false;
                    }
    
                    return true;
                }
            }
        }
    
        protected boolean canEqual(Object other) {
            return other instanceof Response;
        }
    
    //    @Override
    //    public int hashCode() {
            int PRIME = true;
    //        int result = 1;
    //        Object $data = this.getData();
    //        int result = result * 59 + ($data == null ? 43 : $data.hashCode());
    //        Object $code = this.getCode();
    //        result = result * 59 + ($code == null ? 43 : $code.hashCode());
    //        Object $msg = this.getMsg();
    //        result = result * 59 + ($msg == null ? 43 : $msg.hashCode());
    //        return result;
    //    }
    
        @Override
        public String toString() {
            return "Response(data=" + this.getData() + ", code=" + this.getCode() + ", msg=" + this.getMsg() + ")";
        }
    }

5、这样有自定义的异常类，还有全局统一异常捕获类，在运行出错的时候程序要抛出自定义异常，全局异常捕获会自动捕获自定义的异常然后取出异常里面的信息再封装成响应实体对象响应出去，以此达到统一异常响应

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70]: /images/20220121/bb7d790b07eb4afe82d73b2d9a4ce7f2.png