JDK源码——try catch finally异常

2021-08-13 13:37:02

摘要

将详解java中的异常和异常处理机制。异常是大家在开发中常用到的一种工具，用于处理程序异常问的一种手段，本文将详细的介绍JDK中使用try catch等处理异常的原理。

异常类型

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。Java中的所有不正常类都继承于Throwable类。Throwable主要包括两个大类，一个是Error类，另一个是Exception类；

错误：Error类以及他的子类的实例，代表了JVM本身的错误。包括虚拟机错误和线程死锁，一旦Error出现了，程序就彻底的挂了，被称为程序终结者；例如，JVM 内存溢出。一般地，程序不会从错误中恢复。
异常：Exception以及他的子类，代表程序运行时发生的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。Exception主要包括两大类，非检查异常（RuntimeException）和检查异常（其他的一些异常）

非检查异常（unckecked exception）：Error 和 RuntimeException 以及他们的子类。javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try…catch…finally）这样的异常，也可以不处理。对于这些异常，我们应该修正代码，而不是去通过异常处理器处理。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

检查异常（checked exception）：除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

捕获异常

（1）try块：负责捕获异常，一旦try中发现异常，程序的控制权将被移交给catch块中的异常处理程序。【try语句块不可以独立存在，必须与 catch 或者 finally 块同存】

（2）catch块：如何处理？比如发出警告：提示、检查配置、网络连接，记录错误等。执行完catch块之后程序跳出catch块，继续执行后面的代码。【编写catch块的注意事项：多个catch块处理的异常类，要按照先catch子类后catch父类的处理方式，因为会【就近处理】异常（由上自下）。】

（3）finally：最终执行的代码，用于关闭和释放资源。

一次异常捕获

try
{
   //一些会抛出的异常
}catch(ExceptionName e1){
   //处理该异常的代码块
}finally{
   //最终要执行的代码
}

java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。

多次异常捕获

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

try
{
   //一些会抛出的异常
}catch(ExceptionName e1){
   //处理该异常的代码块
}catch(ExceptionName e2){
   //处理该异常的代码块
}catch(ExceptionName e3){
   //处理该异常的代码块
}catch(ExceptionName e4){
   //处理该异常的代码块
}finally{
   //最终要执行的代码
}

如果保护代码中发生异常，异常被抛给第一个 catch 块。

如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。

如果不匹配，它会被传递给第二个 catch 块。

如此，直到异常被捕获或者通过所有的 catch 块。

多重异常处理代码块顺序问题：先子类再父类（顺序不对编译器会提醒错误），finally语句块处理最终将要执行的代码。

throw和throws关键字

java中的异常抛出通常使用throw和throws关键字来实现。

throw----将产生的异常抛出

是抛出异常的一个动作。如果不使用try catch语句去尝试捕获这种异常，或者添加声明，将异常抛出给更上一层的调用者进行处理，则程序将会在这里停止，并不会执行剩下的代码。一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。

public static void main(String[] args) { 
    String s = "abc"; 
    if(s.equals("abc")) { 
      throw new NumberFormatException(); 
    } else { 
      System.out.println(s); 
    } 
    //function(); 
}

运行结果：

Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)

throws 函数声明

throws----声明将要抛出何种类型的异常（声明）。当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理

public static void function() throws NumberFormatException{ 
    String s = "abc"; 
    System.out.println(Double.parseDouble(s)); 
  } 
    
  public static void main(String[] args) { 
    try { 
      function(); 
    } catch (NumberFormatException e) { 
      System.err.println("非数据类型不能转换。"); 
      //e.printStackTrace(); 
    } 
}

throw与throws的比较

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

void doA(int a) throws (Exception1,Exception2,Exception3){
      try{
         ......
 
      }catch(Exception1 e){
       throw e;
      }catch(Exception2 e){
       System.out.println("出错了！");
      }
      if(a!=b)
       throw new Exception3("自定义异常");
}

1.代码块中可能会产生3个异常，(Exception1,Exception2,Exception3)。
2.如果产生Exception1异常，则捕获之后再抛出，由该方法的调用者去处理。
3.如果产生Exception2异常，则该方法自己处理了（即System.out.println("出错了！");）。所以该方法就不会再向外抛出Exception2异常了，void doA() throws Exception1,Exception3 里面的Exception2也就不用写了。因为已经用try-catch语句捕获并处理了。
4.Exception3异常是该方法的某段逻辑出错，程序员自己做了处理，在该段逻辑错误的情况下抛出异常Exception3，则该方法的调用者也要处理此异常。这里用到了自定义异常，该异常下面会由解释。

注意：如果某个方法调用了抛出异常的方法，那么必须添加try catch语句去尝试捕获这种异常，或者添加声明，将异常抛出给更上一层的调用者进行处理

自定义异常

为什么要使用自定义异常，有什么好处？

1.我们在工作的时候，项目是分模块或者分功能开发的 ,基本不会你一个人开发一整个项目，使用自定义异常类就统一了对外异常展示的方式。
2.有时候我们遇到某些校验或者问题时，需要直接结束掉当前的请求，这时便可以通过抛出自定义异常来结束，如果你项目中使用了SpringMVC比较新的版本的话有控制器增强，可以通过@ControllerAdvice注解写一个控制器增强类来拦截自定义的异常并响应给前端相应的信息。
3.自定义异常可以在我们项目中某些特殊的业务逻辑时抛出异常，比如"中性".equals(sex)，性别等于中性时我们要抛出异常，而Java是不会有这种异常的。系统中有些错误是符合Java语法的，但不符合我们项目的业务逻辑。

怎么使用自定义异常？

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

package com.zhuangxiaoyan.JDK;

public class MyException extends Exception {
     /**
     * 错误编码
     */
    private String errorCode;

    public MyException(){}
    
    /**
     * 构造一个基本异常.
     *
     * @param message
     *        信息描述
     */
    public MyException(String message){
        super(message);
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }
}

package com.zhuangxiaoyan.JDK;

public class Main {
    public static void main(String[] args) {
      // TODO Auto-generated method stub
      String[] sexs = {"男性","女性","中性"};
      for(int i = 0; i < sexs.length; i++){
         if("中性".equals(sexs[i])){
            try {
                throw new MyException("不存在中性的人！");
            } catch (MyException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
         }else{
             System.out.println(sexs[i]);
         }
       } 
    }
}

finally块和return

首先一个不容易理解的事实：在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行。

public static void main(String[] args)
{
    int re = bar();
    System.out.println(re);
}
private static int bar() 
{
    try{
        return 5;
    } finally{
        System.out.println("finally");
    }
}
/*输出：
finally5
*/

也就是说：try…catch…finally中的return 只要能执行，就都执行了，他们共同向同一个内存地址（假设地址是0×80）写入返回值，后执行的将覆盖先执行的数据，而真正被调用者取的返回值就是最后一次写入的。那么，按照这个思想，下面的这个例子也就不难理解了。

finally中的return 会覆盖 try 或者catch中的返回值。

public static void main(String[] args){
    int result;

    result  =  foo();
    System.out.println(result);     /2

    result = bar();
    System.out.println(result);    /2
}

@SuppressWarnings("finally")
public static int foo(){
    trz{
        int a = 5 / 0;
    } catch (Exception e){
        return 1;
    } finally{
        return 2;
    }

}

@SuppressWarnings("finally")
public static int bar(){
    try {
        return 1;
    }finally {
        return 2;
    }
}

finally中的return会抑制（消灭）前面try或者catch块中的异常

class TestException{
    public static void main(String[] args){
        int result;
        try{
            result = foo();
            System.out.println(result);           //输出100
        } catch (Exception e){
            System.out.println(e.getMessage());    //没有捕获到异常
        }
 
        try{
            result  = bar();
            System.out.println(result);           //输出100
        } catch (Exception e){
            System.out.println(e.getMessage());    //没有捕获到异常
        }
    }
 
    //catch中的异常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception{
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我将被忽略，因为下面的finally中使用了return");
        }finally {
            return 100;
        }
    }
 
    //try中的异常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception{
        try {
            int a = 5/0;
            return 1;
        }finally {
            return 100;
        }
    }
}

finally中的异常会覆盖（消灭）前面try或者catch中的异常

class TestException{
    public static void main(String[] args){
        int result;
        try{
            result = foo();
        } catch (Exception e){
            System.out.println(e.getMessage());    //输出：我是finaly中的Exception
        }
 
        try{
            result  = bar();
        } catch (Exception e){
            System.out.println(e.getMessage());    //输出：我是finaly中的Exception
        }
    }
 
    //catch中的异常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception{
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我将被忽略，因为下面的finally中抛出了新的异常");
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
    }
 
    //try中的异常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception{
        try {
            int a = 5/0;
            return 1;
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
    }
}

上面的3个例子都异于常人的编码思维，因此我建议：

不要在fianlly中使用return。
不要在finally中抛出异常。
减轻finally的任务，不要在finally中做一些其它的事情，finally块仅仅用来释放资源是最合适的。
将尽量将所有的return写在函数的最后面，而不是try … catch … finally中。

Spring异常处理 ExceptionHandler的使用

通常一个web程序在运行过程中，由于用户的操作不当，或者程序的bug，有大量需要处理的异常。其中有些异常是需要暴露给用户的，比如登陆超时，权限不足等等。可以通过弹出提示信息的方式告诉用户出了什么错误。而这就表示在程序中需要一个机制，去处理这些异常，将程序的异常转换为用户可读的异常。而且最重要的，是要将这个机制统一，提供统一的异常处理。

使用加强Controller做全局异常处理

@ExceptionHandler注解。当一个Controller中有方法加了@ExceptionHandler之后，这个Controller其他方法中没有捕获的异常就会以参数的形式传入加了@ExceptionHandler注解的那个方法中。首先需要为自己的系统设计一个自定义的异常类，通过它来传递状态码。

/** Created by xjl.
 * 自定义异常
 */
public class SystemException extends RuntimeException{
    private String code;//状态码
    public SystemException(String message, String code) {
        super(message);
        this.code = code;
    }
    public String getCode() {
        return code;
    }
}

所谓加强Controller就是@ControllerAdvice注解，有这个注解的类中的方法的某些注解会应用到所有的Controller里，其中就包括@ExceptionHandler注解。于是可以写一个全局的异常处理类：

/**
 * Created by xjl 2021/11/26.
 * 全局异常处理，捕获所有Controller中抛出的异常。
 */
@ControllerAdvice
public class GlobalExceptionHandler {
   //处理自定义的异常
   @ExceptionHandler(SystemException.class) 
   @ResponseBody
   @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
   public Object customHandler(SystemException e){
      e.printStackTrace();
      return WebResult.buildResult().status(e.getCode()).msg(e.getMessage());
   }
   //其他未处理的异常
   @ExceptionHandler(Exception.class)
   @ResponseBody
   @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
   public Object exceptionHandler(Exception e){
      e.printStackTrace();
      return WebResult.buildResult().status(Config.FAIL).msg("系统错误");
   }
}

这个类中只处理了两个异常，但是已经满足了大部分需要，如果还有需要特殊处理的地方，可以再加上处理的方法就行了。如此，我们现在的Controller中的方法就可以很简洁了，比如处理登陆的逻辑就可以这样简单的写：

/**
 * Created by xjl on 2021/11/26
 * 账号
 */
@RestController
@RequestMapping("passport")
public class PassportController {
    PassportService passportService;
        @RequestMapping("login")
    public Object doLogin(HttpSession session, String username, String password){
        User user = passportService.doLogin(username, password);
        session.setAttribute("user", user);
        return WebResult.buildResult().redirectUrl("/student/index");
    }
}

而在passprotService的doLogin方法中，可能会抛出用户名或密码错误等异常，然后就会交由GlobalExceptionHandler去处理，直接返回异常信息给前端，然后前端也不需要关心是否返回了异常，因为这些都已经定义好了。

一个异常在其中流转的过程为：

比如doLogin方法抛出了自定义异常，其code为：FAIL，message为：用户名或密码错误，由于在controller的方法中没有捕获这个异常，所以会将异常抛给GlobalExceptionHandler，然后GlobalExceptionHandler通过WebResult将状态码和提示信息返回给前端，前端通过默认的处理函数，弹框提示用户“用户名或密码错误”。而对于这样的一次交互，我们根本不用编写异常处理部分的逻辑。

码农公寓

JDK源码——try catch finally异常

摘要

异常类型

捕获异常

一次异常捕获

多次异常捕获

throw和throws关键字

throw----将产生的异常抛出

throws 函数声明

throw与throws的比较

自定义异常

为什么要使用自定义异常，有什么好处？

怎么使用自定义异常？

finally块和return

finally中的return 会覆盖 try 或者catch中的返回值。

finally中的return会抑制（消灭）前面try或者catch块中的异常

finally中的异常会覆盖（消灭）前面try或者catch中的异常

Spring异常处理 ExceptionHandler的使用

使用加强Controller做全局异常处理

博文参考

码农公寓

摘要

异常类型

捕获异常

一次异常捕获

多次异常捕获

throw和throws关键字

throw----将产生的异常抛出

throws 函数声明

throw与throws的比较

自定义异常

为什么要使用自定义异常，有什么好处？

怎么使用自定义异常？

finally块和return

finally中的return 会覆盖 try 或者catch中的返回值。

finally中的return会抑制（消灭）前面try或者catch块中的异常

finally中的异常会覆盖（消灭）前面try或者catch中的异常

Spring异常处理 ExceptionHandler的使用

使用加强Controller做全局异常处理

博文参考

相关文章