文章目录
一、为什么引入 try-with-resource?
所有被打开的系统资源，比如流、文件或者Socket连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。
当然可以将处理资源关闭的代码写在finally块中。
然而，如果你同时打开了多个资源，那么将会出现噩梦般的场景：
public class Demo {
public static void main(String[] args) {
BufferedInputStream bin = null;
BufferedOutputStream bout = null;
try {
bin = new BufferedInputStream(new FileInputStream(new File("E:\\in.txt")));
bout = new BufferedOutputStream(new FileOutputStream(new File("E:\\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) {
e.printStackTrace();
}
finally {
if (bout != null) {
try {
bout.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
}
关闭资源的代码竟然比业务代码还要多 ！！！
这是因为，我们不仅需要关闭 BufferedInputStream ，还需要保证如果关闭 BufferedInputStream 时出现了异常， BufferedOutputStream 也要能被正确地关闭。所以我们不得不借助finally中嵌套finally大法。
可以想到，打开的资源越多，finally中嵌套的将会越深！！！
所以引入了 Try-with-resourse
Try-with-resourse 语句类似于 Python中 的 with 语句,都是自动释放资源,而不用像传统的 try-catch-finally一样必须使用finally关闭资源,而且当资源释放比较多的时候,会出现嵌套关闭资源的现象.
二、try-with-resource 的使用
现在使用 try-with-resource 对上面的例子进行优化
public class Demo {
public static void main(String[] args) {
try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("E:\\in.txt")));
BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("E:\\out.txt")))) {
int b;
while ((b = bin.read()) != -1) {
bout.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
try-with-resources 声明在 JDK 9 已得到改进。
如果你已经有一个资源是 final 或等效于 final 变量,您可以在 try-with-resources 语句中使用该变量，而无需在 try-with-resources 语句中声明一个新变量。
public class Demo {
public static void main(String[] args) throws FileNotFoundException {
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("E:\\in.txt")));
BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("E:\\out.txt")));
try (bin;bout) {
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) {
Connection connection = new Connection();
try (connection) {
connection.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方法会在运行的时候被执行。
异常屏蔽：
刚才反编译的代码（第23行）多了一个 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() 的代码，这样肯定能够保证真正的流被关闭。