云锦诚建站，专注安岳网站制作网站设计与营销型网站建设与优化

QQ :532337155
电话：028-86922220
 
安岳网站建设设计

将想法与焦点和您一起共享

Java异常处理的十个建议

 前言

Java异常处理的十个建议，希望对大家有帮助~

成都创新互联是一家专业提供合江企业网站建设,专注与成都网站设计、网站制作、H5高端网站建设、小程序制作等业务。10年已为合江众多企业、政府机构等服务。创新互联专业网站建设公司优惠进行中。

本文已上传github:

https://github.com/whx123/JavaHome

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

反例:

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

正例：

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

理由：

  • printStackTrace()打印出的堆栈日志跟业务代码日志是交错混合在一起的，排查异常日志不太方便。
  • e.printStackTrace()语句产生的字符串记录的是堆栈信息，如果信息太长太多，字符串常量池所在的内存块没有空间了,即内存满了，那么，用户的请求就卡住啦~

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

反例：

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

正例：

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

理由：

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

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

反例：

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

正例：

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

理由：

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

四、记得使用finally关闭流资源或者直接使用try-with-resource

反例：

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

正例1：

需要使用finally关闭流资源，如下

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

正例2：

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

  • 资源是指在程序用完了之后必须要关闭的对象。
  • try-with-resources保证了每个声明了的资源在语句结束的时候会被关闭
  • 什么样的对象才能当做资源使用呢?只要实现了java.lang.AutoCloseable接口或者java.io.Closeable接口的对象，都OK。

 

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

理由：

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

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

反例：

 
 
 
 
    
  
  
  
  
  1. //BizException 是 Exception 的子类 
    2. 
  
  
  
  
  2. public class BizException extends Exception {} 
    3. 
  
  
  
  
  3. //抛出父类Exception 
    4. 
  
  
  
  
  4. public static void test() throws Exception {} 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. try { 
    7. 
  
  
  
  
  7.     test(); //编译错误 
    8. 
  
  
  
  
  8. } catch (BizException e) { //捕获异常子类是没法匹配的哦 
    9. 
  
  
  
  
  9.     log.error(e); 
    10. 
  
  
  
  
  10. } 
    11.

正例：

 
 
 
 
    
  
  
  
  
  1. //抛出子类Exception 
    2. 
  
  
  
  
  2. public static void test() throws BizException {} 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. try { 
    5. 
  
  
  
  
  5.     test(); 
    6. 
  
  
  
  
  6. } catch (Exception e) { 
    7. 
  
  
  
  
  7.     log.error(e); 
    8. 
  
  
  
  
  8. } 
    9.

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

反例：

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

正例：

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

理由：

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

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

反例：

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

正例：

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

理由：

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

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

我们常常会想要在捕获一个异常后抛出另一个异常，并且希望把原始异常的信息保存下来，这被称为异常链。公司的框架提供统一异常处理就用到异常链，我们自定义封装异常，不要丢弃原始异常的信息，否则排查问题就头疼啦

反例：

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

运行结果如下，没有了Throwable cause，不好排查是什么异常了啦

 

正例：

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

 

 

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

反例：

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

正例：

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

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

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

反例：

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

正例：

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

理由：

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

网站标题：Java异常处理的十个建议
链接分享：http://scanyue.cn/article/dppcpgc.html

其他资讯