深入理解Java基础之try-with-resource语法糖

湛蓝之海

这篇文章主要介绍了深入理解Java基础之try-with-resource语法糖,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
背景
众所周知，所有被打开的系统资源，比如流、文件或者socket连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。
在java的江湖中，存在着一种名为finally的功夫，它可以保证当你习武走火入魔之时，还可以做一些自救的操作。在远古时代，处理资源关闭的代码通常写在finally块中。然而，如果你同时打开了多个资源，那么将会出现噩梦般的场景：

public class demo {
  public static void main(string[] args) {
  bufferedinputstream bin = null;
  bufferedoutputstream bout = null;
  try {
    bin = new bufferedinputstream(new fileinputstream(new file("test.txt")));
    bout = new bufferedoutputstream(new fileoutputstream(new file("out.txt")));
    int b;
    while ((b = bin.read()) != -1) {
    bout.write(b);
    }
  }
  catch (ioexception e) {
    e.printstacktrace();
  }
  finally {
    if (bin != null) {
    try {
      bin.close();
    }
    catch (ioexception e) {
      throw e;
    }
    finally {
      if (bout != null) {
      try {
        bout.close();
      }
      catch (ioexception e) {
        throw e;
      }
      }
    }
    }
  }
  }
}

oh my god！！！ 关闭资源的代码竟然比业务代码还要多 ！！！这是因为，我们不仅需要关闭 bufferedinputstream ，还需要保证如果关闭 bufferedinputstream 时出现了异常， bufferedoutputstream 也要能被正确地关闭。所以我们不得不借助finally中嵌套finally大法。可以想到，打开的资源越多，finally中嵌套的将会越深！！！
java 1.7中新增的try-with-resource语法糖来打开资源，而无需码农们自己书写资源来关闭代码。再也不用担心我把手写断掉了！我们用try-with-resource来改写刚才的例子：

public class trywithresource {
  public static void main(string[] args) {
  try (bufferedinputstream bin = new bufferedinputstream(new fileinputstream(new file("test.txt")));
     bufferedoutputstream bout = new bufferedoutputstream(new fileoutputstream(new file("out.txt")))) {
    int b;
    while ((b = bin.read()) != -1) {
    bout.write(b);
    }
  }
  catch (ioexception e) {
    e.printstacktrace();
  }
  }
}

动手实践
为了能够配合try-with-resource，资源必须实现 autoclosable 接口。该接口的实现类需要重写 close 方法：

public class connection implements autocloseable {
  public void senddata() {
  system.out.println("正在发送数据");
  }
  @override
  public void close() throws exception {
  system.out.println("正在关闭连接");
  }
}

调用类：

public class trywithresource {
  public static void main(string[] args) {
  try (connection conn = new connection()) {
    conn.senddata();
  }
  catch (exception e) {
    e.printstacktrace();
  }
  }
}

运行后输出结果：

正在发送数据
正在关闭连接

原理
那么这个是怎么做到的呢？我相信聪明的你们一定已经猜到了，其实，这一切都是编译器大神搞的鬼。我们反编译刚才例子的class文件：

package com.codersm.trywithresource;
 
public class trywithresource {
  public trywithresource() {
  }
 
  public static void main(string[] args) {
  try {
    connection conn = new connection();
    throwable var2 = null;
 
    try {
    conn.senddata();
    } catch (throwable var12) {
    var2 = var12;
    throw var12;
    } finally {
    if (conn != null) {
      if (var2 != null) {
      try {
        conn.close();
      } catch (throwable var11) {
        var2.addsuppressed(var11);
      }
      } else {
      conn.close();
      }
    }
 
    }
  } catch (exception var14) {
    var14.printstacktrace();
  }
 
  }
}

看到没，在第15~27行，编译器自动帮我们生成了finally块，并且在里面调用了资源的close方法，所以例子中的close方法会在运行的时候被执行。
异常屏蔽
细心的你们肯定又发现了，刚才反编译的代码（第21行）比远古时代写的代码多了一个 addsuppressed 。为了了解这段代码的用意，我们稍微修改一下刚才的例子：我们将刚才的代码改回远古时代手动关闭异常的方式，并且在 senddata 和 close 方法中抛出异常：

public class connection implements autocloseable {
  public void senddata() throws exception {
  throw new exception("send data");
  }
  @override
  public void close() throws exception {
  throw new myexception("close");
  }
}

修改main方法：

public class trywithresource {
  public static void main(string[] args) {
  try {
    test();
  }
  catch (exception e) {
    e.printstacktrace();
  }
  }
  private static void test() throws exception {
  connection conn = null;
  try {
    conn = new connection();
    conn.senddata();
  }
  finally {
    if (conn != null) {
    conn.close();
    }
  }
  }
}

运行之后我们发现：

basic.exception.myexception: close
 at basic.exception.connection.close(connection.java:10)
 at basic.exception.trywithresource.test(trywithresource.java:82)
 at basic.exception.trywithresource.main(trywithresource.java:7)
 ......

好的，问题来了，由于我们一次只能抛出一个异常，所以在最上层看到的是最后一个抛出的异常——也就是 close 方法抛出的 myexception ，而 senddata 抛出的 exception 被忽略了。这就是所谓的异常屏蔽。由于异常信息的丢失，异常屏蔽可能会导致某些bug变得极其难以发现，程序员们不得不加班加点地找bug，如此毒瘤，怎能不除！幸好，为了解决这个问题，从java 1.7开始，大佬们为 throwable 类新增了 addsuppressed 方法，支持将一个异常附加到另一个异常身上，从而避免异常屏蔽。那么被屏蔽的异常信息会通过怎样的格式输出呢？我们再运行一遍刚才用try-with-resource包裹的main方法：

java.lang.exception: send data
 
 at basic.exception.connection.senddata(connection.java:5)
 at basic.exception.trywithresource.main(trywithresource.java:14)
 ......
 suppressed: basic.exception.myexception: close
 at basic.exception.connection.close(connection.java:10)
 at basic.exception.trywithresource.main(trywithresource.java:15)
 ... 5 more

可以看到，异常信息中多了一个 suppressed 的提示，告诉我们这个异常其实由两个异常组成， myexception 是被suppressed的异常。可喜可贺！
注意事项
在使用try-with-resource的过程中，一定需要了解资源的 close 方法内部的实现逻辑。否则还是可能会导致资源泄露。
举个例子，在java bio中采用了大量的装饰器模式。当调用装饰器的 close 方法时，本质上是调用了装饰器内部包裹的流的 close 方法。比如：

public class trywithresource {
  public static void main(string[] args) {
  try (fileinputstream fin = new fileinputstream(new file("input.txt"));
    gzipoutputstream out = new gzipoutputstream(new fileoutputstream(new file("out.txt")))) {
    byte[] buffer = new byte[4096];
    int read;
    while ((read = fin.read(buffer)) != -1) {
    out.write(buffer, 0, read);
    }
  }
  catch (ioexception e) {
    e.printstacktrace();
  }
  }
}

在上述代码中，我们从 fileinputstream 中读取字节，并且写入到 gzipoutputstream 中。 gzipoutputstream 实际上是 fileoutputstream 的装饰器。由于try-with-resource的特性，实际编译之后的代码会在后面带上finally代码块，并且在里面调用fin.close()方法和out.close()方法。我们再来看 gzipoutputstream 类的close方法：

public void close() throws ioexception {
  if (!closed) {
  finish();
  if (usesdefaultdeflater)
    def.end();
  out.close();
  closed = true;
  }
}

我们可以看到，out变量实际上代表的是被装饰的 fileoutputstream 类。在调用out变量的 close 方法之前， gzipoutputstream 还做了 finish 操作，该操作还会继续往 fileoutputstream 中写压缩信息，此时如果出现异常，则会 out.close() 方法被略过，然而这个才是最底层的资源关闭方法。正确的做法是应该在try-with-resource中单独声明最底层的资源，保证对应的 close 方法一定能够被调用。在刚才的例子中，我们需要单独声明每个 fileinputstream 以及 fileoutputstream ：

public class trywithresource {
  public static void main(string[] args) {
  try (fileinputstream fin = new fileinputstream(new file("input.txt"));
    fileoutputstream fout = new fileoutputstream(new file("out.txt"));
    gzipoutputstream out = new gzipoutputstream(fout)) {
    byte[] buffer = new byte[4096];
    int read;
    while ((read = fin.read(buffer)) != -1) {
    out.write(buffer, 0, read);
    }
  }
  catch (ioexception e) {
    e.printstacktrace();
  }
  }
}

由于编译器会自动生成 fout.close() 的代码，这样肯定能够保证真正的流被关闭。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持CodeAE代码之家。
原文链接：https://juejin.im/post/5c62ba79f265da2de660e91e