异常的介绍

异常的概念

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理(停止java虚拟机JVM)。

异常的体系

java.lang.Throwable类：是异常和错误的最顶层的父类

异常：在程序出现了异常，是可以解决的，程序解决了异常可以继续执行
-- java.lang.Exception extends Throwable：编译期异常：写代码的时候(编译)出现的异常
-- java.lang.RuntimeException extends Exception：运行期(时)异常：程序运行的时候出现的异常
错误：在程序中出了错误,是不能解决的,必须的修改代码,把错误去掉,才能让程序执行
-- java.lang.Error extends Throwable：错误

异常的产生过程解析

throw 创建异常抛出

throw关键字（重点）

作用：可以[在方法中]抛出指定的异常对象

格式：

修饰符 返回值类型 方法名（参数列表）{
    throw new Exception("异常信息");
    throw new RuntimeException("异常信息");
    throw new XxxxException("异常信息");
 }

注意：

1，throw关键字必须写在方法中使用

2，throw关键字后边创建的对象，必须是Exception或者RuntimeException或者他们的子类对象

3，抛出了编译期异常，就必须处理这个编译异常

抛出了运行期异常，可以不用处理这个异常，最终交给JVM处理（中断）

异常的处理

throws 抛给调用者处理

异常处理的第一种方式，建议练习的时候使用，工作使用不要使用

作用：

方法的内部抛出了异常对象，是一个编译期异常，就必须的处理这个编译期异常对象。可以使用throws关键字把异常对象抛出给方法的调用者来处理，最终可以抛出给JVM处理：JVM会以红色的字体把异常对象相关的信息打印在控制台，中断当前正在执行的程序

弊端：程序产生异常，抛出异常对象给JVM，JVM终止程序，产生异常之后的代码就执行不到了

格式：

修饰符 返回值类型 方法名（参数列表） throws xxxException，...，yyyException {
    throw new xxxException("异常信息");
}

注意：

1，throws关键字必须写在方法声明处

2，一般在方法内部抛出了什么异常对象，就使用throws关键字在方法上声明抛出什么异常对象给方法的调用者处理

a.在方法内部抛出了多个异常对象，就需要使用throws关键字在方法上声明多个异常对象

b.在方法内部抛出了多个异常对象，有子父类关系，在方法上声明父类异常即可

3，调用一个使用throws关键字声明抛出异常的方法，就必须的处理这个异常对象

a.可以使用throws关键字继续声明抛出这个异常对象，最终抛出给JVM处理

b.可以使用try...catch自己手动处理异常

try...catch 手动处理

异常处理的第二种方式，自己手动处理异常，建议工作中使用

作用：

方法的内部抛出了异常对象，是一个编译期异常，我们就必须的处理这个编译期异常对象。调用的方法上声明抛出了异常对象，我们需要处理这个异常对象。可以使用try catch 关键字捕获处理异常，自己定义异常的处理方式

好处：处理了异常之后，程序后续如果有代码，可以继续执行

格式：

        try{
            可能产生异常的代码
        }catch (定义一个异常相关的变量){ 变量的作用就是用来接收程序产生的异常对象
            异常的处理逻辑（想怎么写就怎么写）
        }
        ...
        catch (定义一个异常相关的变量){ 变量的作用就是用来接收程序产生的异常对象
            异常的处理逻辑（想怎么写就怎么写）
        }

注意：

1.try中可能产生什么异常对象，catch中就要定义什么异常变量来接收这个异常对象

2.如果try中产生了异常对象，就会执行catch中异常的处理逻辑，执行完catch中的代码，继续执行try catch后边的代码

3.如果try中没有产生异常对象，就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try catch后边的代码

4.如果try中产生了多个异常对象，就需要定义多个catch来捕获处理这些异常对象

全局统一异常处理

通过 @ControllerAdvice 和 @ExceptionHandler 注解定义全局异常处理

使用方式：

@ControllerAdvice 注解：异常监听。标注在 java 类上
定义一个异常处理方法
- @ExceptionHandler 注解：标注在方法上
  - value 属性：指定当前异常处理器处理的异常类型
@ControllerAdvice 注解 + @ResponseBody 注解可以合并成组合注解 @RestControllerAdvice

/**
* 全局异常处理器
*/
@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
 
    /**
     * 异常处理
     */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public DataResult exceptionHandler(Exception e) {
        log.error("GlobalExceptionHandler.exceptionHandler , 异常信息",e);
        return DataResult.fail(e.getMessage());
    }
 
    /**
     * 业务异常
     */
    @ResponseBody
    @ExceptionHandler(value = BplCommonException.class)
    public DataResult bplCommonExceptionHandler(BplCommonException e) {
        log.warn("",e);
        return DataResult.fail(e.getMessage());
    }
 
    /**
     * 处理所有RequestBody注解参数验证异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public DataResult handleMethodArgumentNotValidException(MethodArgumentNotValidException e){
        log.warn(e.getMessage());
        return DataResult.fail(e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
    }
 
    /**
     * 处理所有RequestParam注解数据验证异常
     */
    @ExceptionHandler(BindException.class)
    public DataResult handleBindException(BindException ex) {
        FieldError fieldError = ex.getBindingResult().getFieldError();
        log.warn("必填校验异常:{}({})", fieldError.getDefaultMessage(),fieldError.getField());
        return DataResult.fail(ex.getBindingResult().getAllErrors().get(0).getDefaultMessage());
    }
}

finally 关键字

作用：

finally关键字里边定义的代码，无论程序是否有异常，都会执行。工作中一般用于资源释放(IO)

格式：

try{
    可能产生异常的代码
}catch(定义一个异常相关的变量 ){
    异常的处理逻辑(想怎么写就怎么写)
}
...
catch(定义一个异常相关的变量 ){
    异常的处理逻辑(想怎么写就怎么写)
}finally{
    无论程序是否有异常,都会执行的代码
}

注意：

1，finally不能单独使用，必须和try一起使用

2，如果try中出现了异常，会先执行catch中异常的处理逻辑，再执行finally中定义的代码。执行完毕finally中的代码，会继续执行try catch finally之后的代码

3，如果try没有异常，执行完try中的代码，再执行finally中定义的代码。执行完毕finally中的代码，会继续执行try catch finally之后的代码

Throwable类中定义的异常处理逻辑

仅供参考，我们可以使用，也可以自己定义异常的处理逻辑

Throwable类中成员方法：

// JVM处理异常对象，把异常对象打印在控制台，默认调用的就是此方法
void printStackTrace()
// 返回此 throwable 的简短描述
String getMessage()
// 返回此 throwable 的详细消息字符串
String toString()

Exception类继承了Throwable，所以Exception所有的子类都可以使用这三个方法

注意事项

运行期异常

运行期异常被抛出可以不处理，默认会交给JVM处理==>中断。
即不捕获（不使用try catch来捕获处理异常）也不声明抛出（不使用throws声明抛出异常对象）
运行时异常，我们处理没有意义，处理了也是为了让后续代码可以继续执行，但是运行时异常本身还是存在的。
比如如果使用数组，超出了数组索引的使用范围，就算我们使用try catch处理了运行时异常。实际上数组还是越界的，没有从根本上解决问题。这时候我们应该修改代码，不让数组的索引越界

子父类异常的处理

如果父类的方法抛出了多个异常，
子类重写父类方法时，子类可以抛出和父类方法相同的异常
子类重写父类方法时，抛出父类异常的子类
子类重写父类方法时，可以不抛出异常
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常
若此时子类产生异常，只能捕获处理，不能声明抛出

重点：子类重写父类方法，父类方法异常什么样，子类和父类一样就可以了，无需考虑异常问题

多个异常的捕获处理

多个异常分别处理
一个异常使用一个try catch处理
多个异常一次捕获，多次处理
格式：
```
try{
    ...
}catch(xxxException e){
    ...
    e.printStackTrace();
}catch(xxxException e){
    ...
    e.printStackTrace();
}
```
好处：
简化代码，只写一个try就可以了
每个catch中都可以写不同的异常处理逻辑
注意:
一个try多个catch这种写法，catch中定义的异常变量，不能是下边定义异常变量的父类
多个异常一次捕获一次处理
格式：
```
try{
    ...
}catch(Exception e){
    ...
    e.printStackTrace();
}
```
好处：格式简单
弊端：无论try中有多少种异常产生，只能在catch中写一种异常的处理逻辑

自定义异常类

java给我们提供的异常类不够我们使用，就需要我们自己定义一些异常相关的类

注意:

1.自定义异常类名，一般都是以Exception结尾，说明这就是一个异常相关的的类（见名知意）

2.自定义异常类

a.继承Exception：自定义异常就是一个编译期异常

使用：如果在方法中抛出了编译期异常，那么我们就必须的处理这个异常，有两种处理方式

1）使用throws关键字在方法上继续声明抛出这个异常对象，让方法调用者处理，最终抛出给JVM（中断）

2）使用try catch自己捕获处理异常对象

b.继承RuntimeException：自定义异常就是一个运行期（时）异常

使用：如果在方法中抛出了运行期异常，我们无需处理，默认交给JVM处理（中断）

自定义编译异常类

public class BaseException extends Exception{
    public BaseException() {
    }

    public BaseException(String message) {
        super(message);
    }
}

自定义运行期异常类

运行期异常类

/**
 * 自定义通用运行期异常
 */
public class BaseRuntimeException extends RuntimeException{
    static final long serialVersionUID = -3387516993124229952L;

    private String code;

    public BaseRuntimeException() {
    }

    public BaseRuntimeException(String message) {
        super(message);
    }

    public BaseRuntimeException(String code, String message) {
        super(message);
        this.code = code;
    }

    public BaseRuntimeException(String message, Throwable e) {
        super(message, e);
    }

    public BaseRuntimeException(Throwable e) {
        super(e);
    }

    public BaseRuntimeException(BaseResponseEnum responseEnum) {
        this(responseEnum.getCode(), responseEnum.getMsg());
    }
}

异常信息码枚举类

import org.assertj.core.util.Preconditions;

/**
 * 异常信息码复用枚举类
 */
public class BaseResponseEnum {

    final private String code;
    final private String msg;

    public BaseResponseEnum(String code, String msg){
        Preconditions.checkNotNull(code);
        Preconditions.checkNotNull(msg);

        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public static final BaseResponseEnum SUCCESS =
            new BaseResponseEnum("000000", "sucess");

    public static final BaseResponseEnum FAILURE =
            new BaseResponseEnum("999999", "系统繁忙，请稍后再试");

    public static final BaseResponseEnum BUS_CUSTOMER_ERROR =
            new BaseResponseEnum("910000", "业务处理异常");

    public static final BaseResponseEnum ILLEGAL_REQUEST =
            new BaseResponseEnum("920000", "非法请求");
}

拓展

Objects类中requireNonNull方法

java.util.Objects：操作对象的工具类

// 判断传递的对象是否为null
static <T> T requireNonNull(T obj)
static <T> T requireNonNull(T obj, String message)
/*    如果传递的对象是null，方法内部就会抛出空指针异常
    如果传递的对象不是null，则方法内部会返回这个对象 */
   
// 方法的源码:
public static <T> T requireNonNull(T obj) {
    if (obj == null){
        throw new NullPointerException();
    }
    return obj;
}

public static <T> T requireNonNull(T obj, String message) {
    if (obj == null){
        throw new NullPointerException(message);
    }
    return obj;
}

java 异常（Exception）概述及基本处理