5 - 异常处理

目录

1. 总览

1.1 Exception 与 Error

1.2 checked unchecked 异常

1)使用 try-catch 进行捕获

2)使用 throws 关键字抛出

1.3 throw 与 throws

1)throw

2)throws

3)区别

1.4 try-catch-finally

2. try with resources

2.1 try–catch-finally 不足

2.2 解决问题

 3. 异常处理实践

3.1 尽量不要捕获 RuntimeException

3.2 尽量使用 try-with-resource 来关闭资源

3.3 不要捕获  Throwable

3.4 不要省略异常信息的记录

3.5 不要记录了异常又抛出异常

3.6 不要在 finally 块中使用 return

3.7 抛出具体定义的检查性异常而不是 Exception

3.8 捕获具体的子类而不是捕获 Exception 类

3.9 自定义异常时不要丢失堆栈跟踪

3.10 finally 块中不要抛出任何异常

3.11 不要在生产环境中使用 printStackTrace()

3.12 对于不打算处理的异常,直接使用 try-finally,不用 catch

3.13 记住早 throw 晚 catch 原则

3.14 只抛出和方法相关的异常

3.15 切勿在代码中使用异常来进行流程控制

3.16 尽早验证用户输入以在请求处理的早期捕获异常

3.17 一个异常只能包含在一个日志中

3.18 将所有相关信息尽可能地传递给异常

3.19 终止掉被中断线程

3.20 对于重复的 try-catch,使用模板方法


1. 总览

异常是指中断程序正常执行的一个不确定的事件

有了异常处理机制后,程序在发生异常的时候就不会中断,我们可以对异常进行捕获,然后改变程序执行的流程

5 - 异常处理_第1张图片

1.1 Exception 与 Error

Exception 和 Error 都继承了 Throwable 类

NoClassDefFoundError 和 ClassNotFoundException 有什么区别?

都是由于系统运行时找不到要加载的类导致的,但是触发的原因不一样

  • NoClassDefFoundError:程序在编译时可以找到所依赖的类,但是在运行时找不到指定的类文件;原因:可能是 jar 包缺失或者调用了初始化失败的类
  • ClassNotFoundException:当动态加载 Class 对象的时候找不到对应的类时抛出该异常;原因:要加载的类不存在或者类名写错了

Error 的出现,意味着程序出现了严重的问题,而这些问题不应该再交给 Java 的异常处理机制来处理,程序应该直接崩溃掉

Exception 的出现,意味着程序出现了一些在可控范围内的问题,应当采取措施进行挽救

1.2 checked unchecked 异常

checked 异常(检查型异常)在源代码里必须显式地捕获或者抛出,否则编译器会提示你进行相应的操作

unchecked 异常(非检查型异常)就是运行时异常,通常是可以通过编码进行规避的,并不需要显式地捕获或者抛出

1)使用 try-catch 进行捕获

try {
    Class clz = Class.forName("com.itwanger.s41.Demo1");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

注:该方法会将异常的堆栈信息打印到标准的控制台下;如果是生产环境,必须使用日志框架把异常的堆栈信息输出到日志系统中,否则可能没办法跟踪

2)使用 throws 关键字抛出

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class clz = Class.forName("com.itwanger.s41.Demo1");
    }
}

这样做的好处是不需要对异常进行捕获处理,只需要交给 Java 虚拟机来处理即可

坏处就是没法针对这种情况做相应的处理

1.3 throw 与 throws

1)throw

throw 关键字,用于主动地抛出异常

throw new exception_class("error message");

2)throws

throws 与 try-catch 对比

public static void main(String args[]){
    try {
        myMethod1();
    } catch (ArithmeticException e) {
        // 算术异常
    } catch (NullPointerException e) {
        // 空指针异常
    }
}
public static void myMethod1() throws ArithmeticException, NullPointerException{
    // 方法签名上声明异常
}

3)区别

  1. throws 关键字用于声明异常,它的作用和 try-catch 相似;而 throw 关键字用于显式的抛出异常。
  2. throws 关键字后面跟的是异常的名字;而 throw 关键字后面跟的是异常的对象
  3. throws 关键字出现在方法签名上,而 throw 关键字出现在方法体里
  4. throws 关键字在声明异常的时候可以跟多个,用逗号隔开;而 throw 关键字每次只能抛出一个异常

1.4 try-catch-finally

try {
    // 可能发生异常的代码
}catch {
   // 异常处理
}finally {
   // 必须执行的代码
}

finally 块常用来关闭一些连接资源,比如说 socket、数据库链接、IO 输入输出流等

OutputStream osf = new FileOutputStream( "filename" );
OutputStream osb = new BufferedOutputStream(opf);
ObjectOutput op = new ObjectOutputStream(osb);
try{
    output.writeObject(writableObject);
} finally{
    op.close();
}

注:即使 try 块有 return,finally 块也会执行

 当然也存在 不执行 finally 的情况:

  • 死循环
  • 执行了 System.exit() 

System.exit() 与 return 不同,前者是用来退出程序的,后者只是回到了上一级方法调用


2. try with resources

2.1 try–catch-finally 不足

在 Java 7 之前,try–catch-finally 是确保资源会被及时关闭的最佳方法,无论程序是否会抛出异常

public class TrycatchfinallyDecoder {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            String path = TrycatchfinallyDecoder.class.getResource("/a.txt").getFile();
            String decodePath = URLDecoder.decode(path,"utf-8");
            br = new BufferedReader(new FileReader(decodePath));

            String str = null;
            while ((str =br.readLine()) != null) {
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

存在一个严重的隐患:try 与 finally 都有可能抛出 IOException,那么程序的调试任务就变得复杂了起来,因为不确定到底是哪一处出了错误

2.2 解决问题

try-with-resources 可以解决该问题,前提是需要释放的资源(比如 BufferedReader)实现了 AutoCloseable 接口,并提供 close() 方法即可

try (BufferedReader br = new BufferedReader(new FileReader(decodePath));) {
    String str = null;
    while ((str =br.readLine()) != null) {
        System.out.println(str);
    }
} catch (IOException e) {
    e.printStackTrace();
}

把要释放的资源写在 try 后的 () 里,如果有多个资源(BufferedReader 和 PrintWriter)需要释放的话,可以直接在 () 中添加(就像写成员属性定义的语句一样)

try (BufferedReader br = new BufferedReader(new FileReader(decodePath));
     PrintWriter writer = new PrintWriter(new File(writePath))) {
    String str = null;
    while ((str =br.readLine()) != null) {
        writer.print(str);
    }
} catch (IOException e) {
    e.printStackTrace();
}

如果想释放自定义资源的话,只要让它实现 AutoCloseable 接口,并提供 close() 方法即可

public class TrywithresourcesCustom {
    public static void main(String[] args) {
        try (MyResource resource = new MyResource();) {
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyResource implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("关闭自定义资源");
    }
}

本质:编译器主动为 try-with-resources 进行了变身,在 try 中调用了 close() 方法

好处:是不会丢失任何异常


 3. 异常处理实践

异常处理实践经验

3.1 尽量不要捕获 RuntimeException

正例:

if (obj != null) {
  //...
}

反例:

try { 
  obj.method(); 
} catch (NullPointerException e) {
  //...
}

3.2 尽量使用 try-with-resource 来关闭资源

当需要关闭资源时,尽量不要使用 try-catch-finally,禁止在 try 块中直接关闭资源

反例:

public void doNotCloseResourceInTry() {
    FileInputStream inputStream = null;
    try {
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
        inputStream.close();
    } catch (FileNotFoundException e) {
        log.error(e);
    } catch (IOException e) {
        log.error(e);
    }
}

原因:一旦 close()之前发生异常,那么资源就无法关闭

正例:直接使用 try-with-resource

public void automaticallyCloseResource() {
    File file = new File("./tmp.txt");
    try (FileInputStream inputStream = new FileInputStream(file);) {
    } catch (FileNotFoundException e) {
        log.error(e);
    } catch (IOException e) {
        log.error(e);
    }
}

如果资源没有实现 AutoCloseable 接口,就在 finally 块关闭流

public void closeResourceInFinally() {
    FileInputStream inputStream = null;
    try {
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
    } catch (FileNotFoundException e) {
        log.error(e);
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                log.error(e);
            }
        }
    }
}

3.3 不要捕获  Throwable

Throwable 是 exception 和 error 的父类,如果在 catch 子句中捕获了 Throwable,很可能把超出程序处理能力之外的错误也捕获了

反例:

public void doNotCatchThrowable() {
    try {
    } catch (Throwable t) {
        // 不要这样做
    }
}

3.4 不要省略异常信息的记录

需要记录错误信息

public void logAnException() {
    try {
    } catch (NumberFormatException e) {
        log.error("错误发生了: " + e);
    }
}

3.5 不要记录了异常又抛出异常

反例:

public void wrapException(String input) throws MyBusinessException {
    try {
    } catch (NumberFormatException e) {
        throw new MyBusinessException("错误信息描述:", e);
    }
}

3.6 不要在 finally 块中使用 return

try 块中的 return 语句执行成功后,并不会马上返回,而是继续执行 finally 块中的语句,如果 finally 块中也存在 return 语句,那么 try 块中的 return 就将被覆盖。

反例:

private int x = 0;
public int checkReturn() {
    try {
        return ++x;
    } finally {
        return ++x;
    }
}

3.7 抛出具体定义的检查性异常而不是 Exception

反例:

public void foo() throws Exception { //错误方式
}

声明的方法应该尽可能抛出具体的检查性异常

3.8 捕获具体的子类而不是捕获 Exception 类

反例:

try {
   someMethod();
} catch (Exception e) { //错误方式
   LOGGER.error("method has failed", e);
}

如果捕获 Exception 类型的异常,可能会导致以下问题:

  • 难以识别和定位异常:如果捕获 Exception 类型的异常,可能会捕获到一些不应该被处理的异常,从而导致程序难以识别和定位异常
  • 难以调试和排错:如果捕获 Exception 类型的异常,可能会使得调试和排错变得更加困难,因为无法确定具体的异常类型和异常发生的原因

正例:应该尽可能地捕获具体的子类

try {
    // 读取数据的代码
} catch (FileNotFoundException e) {
    // 处理文件未找到异常的代码
} catch (IOException e) {
    // 处理输入输出异常的代码
}

3.9 自定义异常时不要丢失堆栈跟踪

不要破坏原始异常的堆栈跟踪

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

    @Override
    public void printStackTrace() {
        System.err.println("MyException:");
        super.printStackTrace();
    }
}

3.10 finally 块中不要抛出任何异常

try {
  someMethod();  //Throws exceptionOne
} finally {
  cleanUp();    //如果finally还抛出异常,那么exceptionOne将永远丢失
}

如果在 finally 块中抛出异常,可能会导致原始异常被掩盖

一旦 cleanup 抛出异常,someMethod 中的异常将会被覆盖

3.11 不要在生产环境中使用 printStackTrace()

它可能会导致以下问题:

  • printStackTrace() 方法将异常的堆栈跟踪信息输出到标准错误流中,这可能会暴露敏感信息,如文件路径、用户名、密码等。
  • printStackTrace() 方法会将堆栈跟踪信息输出到标准错误流中,这可能会影响程序的性能和稳定性。在高并发的生产环境中,大量的异常堆栈跟踪信息可能会导致系统崩溃或出现意外的行为。
  • 由于生产环境中往往是多线程、分布式的复杂系统,printStackTrace() 方法输出的堆栈跟踪信息可能并不完整或准确。

在生产环境中,应该使用日志系统来记录异常信息,日志系统可以将异常信息记录到文件或数据库中,而不会暴露敏感信息,也不会影响程序的性能和稳定性

// 可以使用 logback 记录异常信息,如下所示:
try {
    // some code
} catch (Exception e) {
    logger.error("An error occurred: ", e);
}

3.12 对于不打算处理的异常,直接使用 try-finally,不用 catch

try {
  method1();  // 会调用 Method 2
} finally {
  cleanUp();    //do cleanup here
}

3.13 记住早 throw 晚 catch 原则

在代码中尽可能早地抛出异常,以便在异常发生时能够及时地处理异常

在 catch 块中尽可能晚地捕获异常,以便在捕获异常时能够获得更多的上下文信息,从而更好地处理异常

3.14 只抛出和方法相关的异常

public class Demo {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("The result is: " + result);
        } catch (ArithmeticException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("Division by zero");
        }
        return a / b;
    }
}

只抛出了和方法相关的异常 ArithmeticException,这可以使代码更加清晰和易于维护

3.15 切勿在代码中使用异常来进行流程控制

使用异常来进行流程控制会导致代码的可读性、可维护性和性能出现问题

应该使用其他合适的控制结构来管理程序的流程

虽然是可以实现逻辑的,但是要避免这样使用

public class Demo {
    public static void main(String[] args) {
        String input = "1,2,3,a,5";
        String[] values = input.split(",");
        for (String value : values) {
            try {
                int num = Integer.parseInt(value);
                System.out.println(num);
            } catch (NumberFormatException e) {
                System.err.println(value + " is not a valid number");
            }
        }
    }
}

3.16 尽早验证用户输入以在请求处理的早期捕获异常

用 JDBC 的方式往数据库插入数据,那么最好是先 validate 再 insert

3.17 一个异常只能包含在一个日志中

反例:

log.debug("Using cache sector A");
log.debug("Using retry sector B");

在单线程环境中,这样看起来没什么问题,但如果在多线程环境中,这两行紧挨着的代码中间可能会输出很多其他的内容,导致问题查起来会很难

正例:

LOGGER.debug("Using cache sector A, using retry sector B");

3.18 将所有相关信息尽可能地传递给异常

有用的异常消息和堆栈跟踪非常重要

应该尽量把 String message, Throwable cause 异常信息和堆栈都输出

3.19 终止掉被中断线程

正例:

while (true) {
  try {
    Thread.sleep(100000);
  } catch (InterruptedException e) {
    break;
  }
}
doSomethingCool();

3.20 对于重复的 try-catch,使用模板方法

在尝试关闭数据库连接时的异常处理时使用模板方法:

class DBUtil{
    public static void closeConnection(Connection conn){
        try{
            conn.close();
        } catch(Exception ex){
            //Log Exception - Cannot close connection
        }
    }
}

public void dataAccessCode() {
    Connection conn = null;
    try{
        conn = getConnection();
        ....
    } finally{
        DBUtil.closeConnection(conn);
    }
}

你可能感兴趣的:(Java基础,python,开发语言)