学习下隔壁的异常处理通关指南

KevinYan

发布于 2023-01-03 16:21:57

2560

发布于 2023-01-03 16:21:57

文章被收录于专栏：网管叨bi叨

本文是我在掘金上作为签约作者发布的第一篇文章，为了不跟我平日在这个公众号上的内容发生冲突，所以选了写 Java 核心基础通关指南这个方向。这样正好也能发挥我平日上班经常要使用这两门后端编程语言的优势，历史原因，以前公司 Java 和 Go 团队还经常争项目...... 后来...

后来不知道咋滴，团队合并了，我就得...有时候做个需求，要改几个项目的代码，这几个项目还不是一定是一个语言写的...

好了不多说了，本篇花了大几千字梳理了下 Java 编程时需要知道的异常处理相关知识，以及各种案例案例。

前言

在理想世界中，程序永远不会出现问题，用户输入的数据永远是正确的，逻辑没有任何问题，选择打开的文件也一定是存在的，内存永远是够用的……！但是现实世界里一旦出现这些问题，如果处理不好，程序就不能正常运行了，导致影响用户体验，用户就有可能再也不使用这个程序了。

出现异常时，对外要给出明确友好的提示消息。对内，程序自己尽量做好补救措施，实在不行了要及时释放占有的资源，以免影响其他线程的任务造成整个程序的崩溃。所以程序的异常处理非常重要。

在一开始入门学习编程的时候，为了快速学习语法点我们写的都是一些符合预期能执行下去的程序，不过在实际开发项目的时候就不能太单纯了，一定要处处小心，多质疑自己写的还有他人的程序，即使是其他三方库的程序也要质疑一下--出错了该怎么办？直接忽视会不会让我在公司就无了？

在程序出错的时候，Java 使用的是异常机制，支持将错误信息封装起来，并让程序跳出正常的处理流程，交给异常处理部分去处理。

说到异常处理，很多人都会想起 Try- Catch语法，下面我们先通过一个简单的代码示例，通过运行和解读这个示例来快速了解一下什么是异常，以及异常处理具有行为习惯。

Try Catch语句

在Java程序中，使用Try Catch语句来进行程序的异常处理，先看下面这个简单的例子，理解一样Try Catch语句的执行流程。

package com.example.learnexception;

public class ExceptionFirstExpression {
    public static void main(String[] args) {
        try {
            int[] arr = new int[1];
            arr[1] = 9;
        } catch (Exception ex) {

            int abc = 999;
            ex.printStackTrace();
        }

        try {
            String str = "";
            str.substring(9, 10);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        System.out.println("程序执行结束");

    }
}

在解读上面的程序执行结果前，先了解一下依靠 try catch 语句做异常处理的执行流程。

在 try 语句中如果发生了不符合正确预期的异常情况（Exception），那么程序的执行流程会跳转到 catch 语句中。
Java会将异常相关信息封装在一个异常类的实例中，上面 catch 代码块中 ex 变量就是指向这个异常实例的引用。
处理异常最简单的方法，就是调用异常实例的printStackTrace方法将异常信息打印出来输出到控制台或者日志。
当 catch 块内的语句执行完毕后，程序会继续向下顺序执行。

上面的程序有两个tray catch 块，可以看到两个try块中的语句都有问题，第一个是数组索引越界（数组长度为1索引只有0），第二个是字符串索引的越界。他们都会导致程序抛出异常，我们执行程序看一下结果：

java.lang.ArrayIndexOutOfBoundsException: 1
 at com.qsc.ebao.insureplan.controller.front.ExceptionFirstExpression.main(ExceptionFirstExpression.java:7)
java.lang.StringIndexOutOfBoundsException: String index out of range: 10
 at java.lang.String.substring(String.java:1963)
 at com.qsc.ebao.insureplan.controller.front.ExceptionFirstExpression.main(ExceptionFirstExpression.java:16)
程序执行结束

可以看到程序仍然执行到了最后，不过在两个catch 语句分别捕获了java.lang.ArrayIndexOutOfBoundsException 和 java.lang.StringIndexOutOfBoundsException 两个异常，并把他们的实例赋值给了 ex 。在例程的catch块的异常处理中用，则是用 ex.printStackTrace 打印出了异常明细和导致异常的调用栈。

因为正常捕获到异常并进行了处理，所以上面的例程仍然能平稳执行到最后。

了解了 try catch 语句的执行流程后，我们再来深入地看一下关于异常实例所代表的异常（Exception）在 Java 中的所拥有的体系。

异常的分类

Java中的异常由 Throwable 类及其子类来描述。Throwable类是Java异常类型的顶层父类，一个对象只有是 Throwable 类或者其子类的实例，它才是一个异常对象，才能被Java的异常处理机制识别。

Java 提供的系统异常有很多，我们还可以自定义异常，不过 Java 的异常分类中我们只需要记住几个关键的分类即可，不必所有异常类的行为全都得背一遍。

下图是一个异常类族的层级图。

Throwable 有两个直接子类，Error类和Exception类

Error类表示系统的内部错误和资源耗尽错误，这些错误发生于虚拟机自身、或者发生在虚拟机试图执行应用时，这些异常在应用程序的控制和处理能力之外，一旦发生，Java 虚拟机一般会选择线程终止。
Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。其中 RuntimeException 和其子类为运行时异常（Runtime Exception），即非检查异常（Unchecked exception）；而 Exception 的其它子类为非运行时异常，即受检查异常（Checked Exception）。

上面异常类族的分级，其实都不用刻意记，搞不清楚的时候可以回来这里再复习一下。对我们写程序真正有影响，需要我们牢记的是上面描述里提到的非检查异常和受检查异常，这是根据 Java 对异常的处理要求进行的分类。

非检查异常（Unchecked Exception）：Error 和 RuntimeException 以及他们的子类都属于非检查异常。Java 不强制一定要在程序里用 try catch 或者 throws 处理这类异常。这样的异常发生的原因多半是代码写的有问题。比如除数为 0 错误 ArithmeticException，强制类型转换错误 ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。
受检查异常（Checked Exception）：除了上面描述的非检查异常以外，其他异常类都属于受检查异常。Java 强制要求在程序的方法中通过 try catch 语句捕获处理它，或者是用 throws 语句抛出它给外层，否则编译不会通过。这类异常一般是由程序的运行环境导致的。程序可能被运行在各种未知的环境下，且无法干预用户如何使用我们编写的程序，于是程序就应该为这样的异常做好处理准备。如SQLException, IOException, ClassNotFoundException 等。

下面的例程执行try块中的程序时会抛出 ClassNotFoundException，它是受检查异常，如果不用try catch 处理或者声明要抛出这个异常，是不能通过编译的。

package com.example.learnexception;

public class MustChecked {
    // 这里的throws和try catch 选其一即可， try catch 后 throws 也就没机会执行了。
    public static void main(String[] args) throws ClassNotFoundException  {
        try {
            Class clazz = Class.forName("com.example.learnexception.MustCheckedAbc");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这个示例程序里，其实我们已经了解了Java程序的方法里遇到异常情况跑出异常的语法，下面我们把抛出异常的使用场景再好好分析一下。

抛出异常

抛出异常，分为抛出方法内使用的其他包产生的异常（re-throw）--即不处理，再往外抛，交给上层处理。以及抛出自己代码的异常。

可以使用 throws 关键字在方法上声明方法可能会抛出的异常，抛出的异常类型可以是实际异常的父类或者本身。throws 关键字可以声明抛出多个类型的异常，用逗号分开就可以。

public class ThrowIt {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class clazz = Class.forName("abc");
        clazz.getField("");
    }

}

上面是声明了方法可能会抛出 ClassNotFoundException 和 NoSuchFieldException 异常。

我们也可以自己创建一个异常然后抛出去，在代码里主动抛出异常，要使用 throw 语句（注意是单数形式，不要和方法声明上的throws搞混了）

package com.example.learnexception;

public class NewAndThrowIt {

    public static void causeException() throws Exception {
  int a = 1;
        if (a < 10) {
            throw new Exception("Custome Exception");
        }
    }

    public static void causeRuntimeException() throws RuntimeException {
        // 可以创建一个unchecked exception，然后用throw语句抛出去
        // 这时候，方法定义里可以有，也可以没有throws语句
        throw new RuntimeException("");
    }

}

方法 causeException 创建了一个 checked exception 实例，然后用 throw 关键字扔出去，这时候就需要方法声明里用 throws 明确声明方法会抛出的异常类型。
方法 causeRuntimeException 创建一个unchecked exception，然后用throw关键字扔出去，这时候，方法声明里可以有，也可以没有throws语句。

在定义接口时，也可以在接口方法声明上加上 throws 语句，限制实现类如果抛出异常的话，必须抛出 throws 声明的类或者其子类。

public interface IntfaceWithEx {

    void methodWithEx() throws Exception;

}

异常的传递和异常链

现实世界里，用Java开发的程序是由一个个类组成的，类的功能由一个个方法来实现，所以一个功能是靠着方法的层层调用实现的，在异常处理时最基本的 ex.printStackTrace() 就是输出产生异常时方法的调用栈--即可以理解为事发现场。

Java 的异常也是在方法调用栈上传递的，要么沿着方法调用栈一路往上层方法上抛，最终无人处理造成当前线程异常退出，要么被调用栈中的某个方法 Catch 住。

在异常处理中比较常见的场景是，比如底层 IO 出现异常，我们的程序有可能会 Catch 住这个异常再根据自己的需要抛出新异常，如果这时只是简单地 throw 出创建的新异常，势必会导致原有的异常信息丢失，那么如何保持整个异常的链路呢？在 Throwable 及其子类的重载构造方法中都可以接受一个 Throwable 类型的 cause 参数

public class Exception extends Throwable {
    
 public Exception(String message) {
        super(message);
    }
    
    public Exception(String message, Throwable cause) {
        super(message, cause);
    }
    
    ......
}

public class Throwable implements Serializable {
    
    ......
    public synchronized Throwable getCause() {
        return (cause==this ? null : cause);
    }   
}

该参数代表原有的异常，通过 getCause ()就可以获取该原始异常信息。通过这种方法可以保持整个异常链的连续性。

自定义异常

在写应用程序时经常会需要定义一些自己需要的异常。异常最重要的信息是三块：类型、错误信息和调用栈。

异常类型，在catch、throws 、throw 这些关键字出现的地方都会进行异常类型的判断
错误信息，描述了异常的详细信息。
调用栈，出现异常时的调用栈，调用栈是由异常的基类 Throwable 帮助封装的，不需要程序员开发人员人为进行干预。

下面是一个自定义的异常类 UserException，仿照Excption类的重载构造方法，我们也给它定义了三个重载构造方法。

package com.example.learnexception.exceptions;

public class UserException extends Exception {

    public UserException() {
    }

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

    public UserException(String message, Throwable cause) {
        super(message, cause);
    }

    public UserException(Throwable cause) {
        super(cause);
    }
}

构造方法里的 Throwable 类型的参数 cause 在上节异常链里已经提过，表示导致当前这个异常的异常。比如在创建User时，由于数据库网络问题导致了创建失败，那么在抛出 UserException 异常的时候就可以把数据库 IO 异常作为 cause 传给UserException的构造方法创建 UserException 异常实例。

下面是一个使用我们自定义异常 UserException 的示例程序

package com.example.learnexception;

import com.example.learnexception.exceptions.UserException;

public class ExCaller {

    public void callThrowException() throws UserException {
        // 可以在这里catch异常，然后封装成自己的异常，并增加相应的异常描述
        System.out.println("ExCaller.callThrowException开始");
        try {
            Class.forName("com.example.TestForException");
        } catch (ClassNotFoundException ex) {
            throw new UserException("there's something wrong", ex);
        }
        System.out.println("ExCaller.callThrowException 方法调用结束");
    }

}

上面的例程我们在方法里创建一个 TestForException 类的实例，因为不存在这个类，所以try 块里会抛出 ClassNotFoundException 异常，在catch里我们捕获了这个异常，封装成自己的异常，并增加了相应的异常描述。

package com.example.learnexception;

import com.example.learnexception.exceptions.UserException;

public class CallExceptionAppMain {
    public static void main(String[] args) {
        ExCaller caller = new ExCaller();
        try {
            caller.callThrowException();
        } catch (UserException ex) {
            ex.printStackTrace();
        }
    }
}

catch 语句是根据异常类型匹配来捕捉相应类型的异常的。如果类型不匹配，catch语句是不会执行的，异常会继续抛出。

也就是说，如果使用 catch (Throwable) 会捕捉到所有的异常，包括Error，但是建议 catch 的范围尽量精准，不要用范围太大的异常类父类，比如 Exception 在 catch 时就尽量少用，实在不行也最多只捕捉 Exception 类型的异常就行了，不要使用 Throwable 。

注意：

如果 catch 一个其实并没有可能被抛出的受检查异常，Java程序会报错，因为 Java明确的知道这个类型的异常不会发生。
如果 catch 一个非检查异常，Java程序不会报错。
如果throws一个其实并没有被抛出的checked exception或者unchecked exception，Java程序不会报错。

掌握了自定义异常后，让我们在回到Try-Catch语法上，上面我们一直用的其实不是这个语法的完全态，让我们再下一节仔细说说。

Try Catch Finally

try catch 语句的形式可以扩展成try catch finally 的形式。下面通过一个示例程序，了解一下，加了 finally 之后的作用。

package com.example.learnexception;

public class TryCatchFinallyAppMain {

    private static int VAL = 0;

    public static void main(String[] args) {
        System.out.println(withFinally());
        System.out.println(VAL);
    }

    private static int withFinally() {
        int len = 0;
        try {
            String s = null;
            return s.length();
        } catch (Exception ex) {
            // 异常的处理：在有返回值的情况下，返回一个特殊的值，代表情况不对，有异常
            len = -1;
            System.out.println("执行catch里的return语句");
            return len;
        } finally {
            // 可以认为finally语句会在方法返回后，后面的方法开始前，会在return语句后
            // 无论是因为return结束还是因为异常结束，finally语句都会执行
            System.out.println("执行finally语句");
            // finally里最好不要有return语句
//            return -2;

            // finally里给前面 return 表达式里的变量值赋值没用
            len = -2;

            VAL = 999;
            System.out.println("finally语句执行完毕");
        }
    }


}

不管是否有异常产生，finally块中代码都会执行，无论是因为 return 结束还是因为异常结束，finally语句都会在方法退出后执行。
finally是在 return 后面的表达式运算后执行的，所以函数返回值是在 finally 执行前确定的。无论finally 中的代码怎么样，返回的值都不会改变，仍然是之前return语句中保存的值，所以我们不要再 finally 的代码块里尝试修改要 return 给调用者的返回值。
再有一点还要注意，finally中最好不要包含return，否则程序会提前退出，返回值不再是 try 或 catch 中保存的返回值。

其实 finally 因为其最后必定执行的特点，特别适合于关闭文件、网络IO等释放程序占用资源的操作，不过因为还是有可能会被人为忘记，所以 Java 又在 1.7 版本引入了新语法，避免遗忘释放资源。

可自动回收资源的 Try 语句

和网络、文件等资源相关的异常处理起来比较繁杂，尤其是在处理多个资源的时候，比如读取文件内容再通过网络发送出去，在文件资源操作和网络资源操作的时候都可能出错（文件找不到，权限不对，网络连接不上等等）这种情况下就要需要在 finally 块中把资源主动关闭。但有可能会被遗漏，所以后来 java 1.7 就有了 try-with-resources ---支持自动关闭资源的 try 语句。

那怎么让 try 语句自动帮助我们关闭异常呢？首先这个资源要能支持自动关闭，Java 里只要实现了 AutoCloseable 接口的类的实例，就会被认为是一个可被自动关闭的资源。

package com.example.learnexception;

import java.io.IOException;

public class AutoClosableTestResource implements AutoCloseable {

    private String resourceName;
    private int counter;

    public AutoClosableTestResource(String resName) {
        this.resourceName = resName;
    }

    // read 方法会随便的读取出数据，或者抛出IOException
    public String read() throws IOException {
        counter++;
        if (Math.random() > 0.1) {
            return "You got lucky to read from " + resourceName + " for " + counter + " times...";
        } else {
            throw new IOException("resource不存在哦");
        }
    }

    @Override
    public void close() throws Exception {
        System.out.println("资源释放了:" + resourceName);
    }
}

到时候 try 语句就会帮助我们自动调用 close 方法释放掉资源。接下来看怎么在 try-with-resources 语法里使用这个资源。

package com.example.learnexception;

public class TryWithResource {
    public static void main(String[] args) {
        try (
                AutoClosableTestResource res1 = new AutoClosableTestResource("res1");
                AutoClosableTestResource res2 = new AutoClosableTestResource("res2")
        ) {
            while (true) {
                System.out.println(res1.read());
                System.out.println(res2.read());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

跟常规的try catch语句相比，try 后的小括号里创建可以自动关闭的资源，这里创建的资源能被 try 代码块里的代码使用，等出现异常或者正常退出的时候就会帮我们释放掉这里的资源。

我们执行以下上面的例程，可以看到以输出。

You got lucky to read from res1 for 1 times...
You got lucky to read from res2 for 1 times...
You got lucky to read from res1 for 2 times...
You got lucky to read from res2 for 2 times...
资源释放了:res2
资源释放了:res1
java.io.IOException: resource不存在哦
 at com.example.learnexception.AutoClosableTestResource.read(AutoClosableTestResource.java:20)
    at com.example.learnexception.TryWithResource.main(TryWithResource.java:10)

try 后面括号里创建的资源，在程序退出前都被释放了。我们后面再写与资源操作有关的代码时，尽量都使用这种形式，日常咱们开发能接触到的资源也都已经实现了 AutoCloseable，支持被自动关闭。

总结

本篇文章，把 Java 的异常处理的知识点以及实际开发中的应用盘点了一遍，内容比较多，建议看完文章理解就行，不用非得全部记住，需要重点关注的知识点在文章里已经做重点说明，后面实际开发项目时，也可以多拿这篇内容做参考，提升我们自己的开发体验，毕竟我一直觉得工作中写代码，就跟开卷考试一样，哈哈，你觉得呢！

你在公司里平时工作时要用几门开发语言呢，会不会有自己写串的时候呢？评论里来分享一下吧，我前两天就因为写了两周 Java，Go项目 API 接口JSON字段始终加上去不起作用，查半天，发现字段给小写了。。。

- END -

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2022-10-28，如有侵权请联系 cloudcommunity@tencent.com 删除

java

本文分享自网管叨bi叨微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

java

登录后参与评论

0 条评论

热度