Java 异常处理的十个建议

2020-11-12 · 捡田螺的小男孩 · 转载 · · 本文共 742个字,预计阅读需要 3分钟。

转载微信公众号:捡田螺的小男孩

一、尽量不要使用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. }

理由:

  • 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 捕捉的所有可能的异常,如果多个层次都这样捕捉,会丢失原始异常的有效信息哦 log.info(“Exception in test,exception:{}”, e);
  7. }
  8. }

正例:

  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接口的对象,都OK。
  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资源就会被他一直占着,这样别人就没有办法用了,这就造成资源浪费。

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

反例:

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

正例:

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

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

反例:

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

正例:

  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 { obj.method() } catch (NullPointerException e) {...}

正例:

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

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

注意异常的匹配顺序,因为只有第一个匹配到异常的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放前面~