Java 异常处理

一、尽量不要使用e.printStackTrace()处理而是使用log打印。

反例:

  1. try{
  2.   // do what you want  
  3. }catch(Exception e){
  4.   e.printStackTrace();
  5. }

正例：

  1. try{
  2.   // do what you want  
  3. }catch(Exception e){
  4.   log.info("程序异常啦,{}",e);
  5. }

理由：

  • e.printStackTrace()打印出的堆栈日志跟业务代码日志是交错混合在一起的，排查异常日志不太方便。

  • e.printStackTrace()语句产生的字符串记录的是堆栈信息，如果信息太长太多，字符串常量池所在的内存块没有空间了,即内存满了，那么，用户的请求就卡住了

    二、catch了异常，但是没有打印出具体的exception，无法更好定位问题

    反例：

    1. try{
    2. // do what you want  
    3. }catch(Exception e){
    4. log.info("程序异常啦");
    5. }

    正例：

    1. try{
    2. // do what you want  
    3. }catch(Exception e){
    4. log.info("程序异常啦，{}",e);
    5. }

    理由：

  • 反例中，并没有把exception出来，到时候排查问题就不好查了啦，到底是SQl写错的异常还是IO异常，还是其他呢？所以应该把exception打印到日志中。

    三、不要用一个Exception捕捉所有可能的异常

    反例：

    1. public void test(){
    2.   try{
    3.       //…抛出 IOException 的代码调用
    4.       //…抛出 SQLException 的代码调用
    5.   }catch(Exception e){
    6.       //用基类 Exception 捕捉的所有可能的异常，如果多个层次都这样捕捉，会丢失原始异常的有效信息哦
    7.       log.info(“Exception in test,exception:{}”, e);
    8.   }
    9. }

    正例：

    1. public void test(){
    2.   try{
    3.       //…抛出 IOException 的代码调用
    4.       //…抛出 SQLException 的代码调用
    5.   }catch(IOException e){
    6.       //仅仅捕捉 IOException
    7.       log.info(“IOException in test,exception:{}”, e);
    8.   }catch(SQLException e){
    9.       //仅仅捕捉 SQLException
    10.       log.info(“SQLException in test,exception:{}”, e);
    11.   }
    12. }

    理由：

  • 用基类 Exception 捕捉的所有可能的异常，如果多个层次都这样捕捉，会丢失原始异常的有效信息。

    四、在Finally块中关闭流资源或者直接使用try-with-resource

    反例：

    1. FileInputStream fdIn = null;
    2. try {
    3.   fdIn = new FileInputStream(new File("/jay.txt"));
    4.   //在这里关闭流资源？有没有问题呢？如果发生异常了呢？
    5.   fdIn.close();
    6. } catch (FileNotFoundException e) {
    7.   log.error(e);
    8. } catch (IOException e) {
    9.   log.error(e);
    10. }

    正例1：
    需要使用finally关闭流资源，如下

    1. FileInputStream fdIn = null;
    2. try {
    3.   fdIn = new FileInputStream(new File("/jay.txt"));
    4. } catch (FileNotFoundException e) {
    5.   log.error(e);
    6. } catch (IOException e) {
    7.   log.error(e);
    8. }finally {
    9.   try {
    10.       if (fdIn != null) {
    11.           fdIn.close();
    12.       }
    13.   } catch (IOException e) {
    14.       log.error(e);
    15.   }
    16. }

    正例2：
    当然，也可以使用JDK7的新特性try-with-resource来处理，它是Java7提供的一个新功能，它用于自动资源管理。

  • 资源是指在程序用完了之后必须要关闭的对象。

  • try-with-resources保证了每个声明了的资源在语句结束的时候会被关闭

  • 什么样的对象才能当做资源使用呢？只要实现了java.lang.AutoCloseable接口或者java.io.Closeable接口的对象就可以。

    1. try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
    2.   // use resources   
    3. } catch (FileNotFoundException e) {
    4.   log.error(e);
    5. } catch (IOException e) {
    6.   log.error(e);
    7. }

    理由：

  • 如果不使用finally或者try-with-resource，当程序发生异常，IO资源流没关闭，那么这个IO资源就会被他一直占着，这样别人就没有办法用了，这就造成资源浪费。

    五、捕获异常与抛出异常必须是完全匹配，或者捕获异常是抛异常的父类

    反例： ```java //BizException 是 Exception 的子类 public class BizException extends Exception {} //抛出父类Exception public static void test() throws Exception {}

try { test(); //编译错误 } catch (BizException e) { //捕获异常子类是没法匹配的哦 log.error(e); }

  1. **正例：**
  2. ```java
  3. //抛出子类Exception
  4. public static void test() throws BizException {}
  6. try {
  7.     test();
  8. } catch (Exception e) {
  9.     log.error(e);
  10. }

六、捕获到的异常，不能忽略它，至少打点日志

反例：

  1. public static void testIgnoreException() throws Exception {
  2.     try {       
  3.         // 搞事情
  4.     } catch (Exception e) {     //一般不会有这个异常
  6.     }
  7. }

正例：

  1. public static void testIgnoreException() {
  2.     try {
  3.         // 搞事情
  4.     } catch (Exception e) {     //一般不会有这个异常
  5.         log.error("这个异常不应该在这里出现的,{}",e); 
  6.     }
  7. }

理由：

  • 虽然一个正常情况都不会发生的异常，但是如果捕获到它，就不要忽略，至少打个日志。

    七、注意异常对代码层次结构的侵染（早发现早处理）

    反例：

    1. public UserInfo queryUserInfoByUserId(Long userid) throw SQLException {
    2.   //根据用户Id查询数据库
    3. }

    正例：

    1. public UserInfo queryUserInfoByUserId(Long userid) {
    2.   try{
    3.       //根据用户Id查询数据库
    4.   }catch(SQLException e){
    5.       log.error("查询数据库异常啦，{}",e);
    6.   }finally{
    7.       //关闭连接，清理资源
    8.   }
    9. }

    理由：

  • 项目中一般都会把代码分 Action、Service、Dao 等不同的层次结构，如果是DAO层处理的异常尽早处理，如果往上 throw SQLException，上层代码就还是要try catch处理，这就污染代码了。

    八、自定义封装异常，不要丢弃原始异常的信息Throwable cause

    经常会想要在捕获一个异常后抛出另一个异常，并且希望把原始异常的信息保存下来，这被称为异常链。框架提供统一异常处理就用到异常链，自定义封装异常，不要丢弃原始异常的信息，否则排查问题就比较困难了。
    反例：

    1. public class TestChainException {
    2.   public void readFile() throws MyException{
    3.       try {
    4.           InputStream is = new FileInputStream("jay.txt");
    5.           Scanner in = new Scanner(is);
    6.           while (in.hasNext()) {
    7.               System.out.println(in.next());
    8.           }
    9.       } catch (FileNotFoundException e) {
    10.           //e 保存异常信息
    11.           throw new MyException("文件在哪里呢");
    12.       }
    13.   }
    14.   public void invokeReadFile() throws MyException{
    15.       try {
    16.           readFile();
    17.       } catch (MyException e) {
    18.           //e 保存异常信息
    19.           throw new MyException("文件找不到");
    20.       }
    21.   }
    22.   public static void main(String[] args) {
    23.       TestChainException t = new TestChainException();
    24.       try {
    25.           t.invokeReadFile();
    26.       } catch (MyException e) {
    27.           e.printStackTrace();
    28.       }
    29.   }
    30. }
    31. //MyException 构造器
    32. public MyException(String message) {
    33.   super(message);
    34. }

    没有了Throwable cause，不好排查是什么异常了
    正例：

    1. public class TestChainException {
    2.   public void readFile() throws MyException{
    3.       try {
    4.           InputStream is = new FileInputStream("jay.txt");
    5.           Scanner in = new Scanner(is);
    6.           while (in.hasNext()) {
    7.               System.out.println(in.next());
    8.           }
    9.       } catch (FileNotFoundException e) {
    10.           //e 保存异常信息
    11.           throw new MyException("文件在哪里呢", e);
    12.       }
    13.   }
    14.   public void invokeReadFile() throws MyException{
    15.       try {
    16.           readFile();
    17.       } catch (MyException e) {
    18.           //e 保存异常信息
    19.           throw new MyException("文件找不到", e);
    20.       }
    21.   }
    22.   public static void main(String[] args) {
    23.       TestChainException t = new TestChainException();
    24.       try {
    25.           t.invokeReadFile();
    26.       } catch (MyException e) {
    27.           e.printStackTrace();
    28.       }
    29.   }
    30. }
    31. //MyException 构造器
    32. public MyException(String message, Throwable cause) {
    33.   super(message, cause);
    34. }

    九、运行时异常RuntimeException ，不应该通过catch 的方式来处理，而是先预检查，比如：NullPointerException处理

    反例：

    1. try {
    2.     obj.method() 
    3. } catch (NullPointerException e) {
    4.   ...
    5. }

    正例：

    1. if (obj != null){
    2.  ...
    3. }

    十、注意异常匹配的顺序，优先捕获具体的异常

    注意异常的匹配顺序，因为只有第一个匹配到异常的catch块才会被执行。如果希望看到，是NumberFormatException异常，就抛出NumberFormatException，如果是IllegalArgumentException就抛出IllegalArgumentException。
    反例：

    1. try {
    2.   doSomething("test exception");
    3. } catch (IllegalArgumentException e) {       
    4.   log.error(e);
    5. } catch (NumberFormatException e) {
    6.   log.error(e);
    7. }

    正例：

    1. try {
    2.   doSomething("test exception");
    3. } catch (NumberFormatException e) {       
    4.   log.error(e);
    5. } catch (IllegalArgumentException e) {
    6.   log.error(e);
    7. }

    理由：

  • 因为NumberFormatException是IllegalArgumentException 的子类，反例中，不管是哪个异常，都会匹配到IllegalArgumentException，就不会再往下执行，因此不知道是否是NumberFormatException。所以需要优先捕获具体的异常，把NumberFormatException放前面。