JDK7 引入了 try-with-resources，为资源关闭提供了更为方便简洁的方法。以一段简单的 BIO 服务端代码为例，使用传统方式关闭资源：
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
InputStream inputStream = null;
try {
serverSocket = new ServerSocket(3000);
while (true) {
socket = serverSocket.accept();
inputStream = socket.getInputStream();
byte[] bytes = new byte[5];
int count = inputStream.read(bytes);
while (count != -1) {
for (int index = 0; index < count; index++) {
System.out.print((char) bytes[index]);
}
count = inputStream.read(bytes);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
serverSocket.close();
socket.close();
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
可见，为确保资源正确关闭，需要在 finall 中再嵌入 try，打开的资源越多，嵌套也越多，最终可能会出现关闭资源的代码比业务代码还要多的情况。另外，传统方式还存在异常屏蔽的问题。在上例故意制造一个错误，将监听端口号改为 -1，运行服务端时提示如下：
Exception in thread "main" java.lang.NullPointerException
at com.example.TraditionalTry.main(TraditionalTry.java:32)
该异常指出 finally 块的 serverSocket.close(); 发出空指针异常，并没有指出问题真正所在代码行，即 serverSocket = new ServerSocket(-1);，不利于问题的定位和排查。
为解决上述问题，使用 try-with-resources 改写上例，不仅使代码简洁清晰，而且不会出现异常屏蔽的情况，能够准确指示错误所在：
public static void main(String[] args) throws Exception {
try (ServerSocket serverSocket = new ServerSocket(3000)) {
while (true) {
try (Socket socket = serverSocket.accept()) {
try (InputStream inputStream = socket.getInputStream()) {
byte[] bytes = new byte[5];
int count = inputStream.read(bytes);
while (count != -1) {
for (int index = 0; index < count; index++) {
System.out.print((char) bytes[index]);
}
count = inputStream.read(bytes);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
为进一步验证上述写法，创建两个实现 AutoCloseable 接口的简单资源类。覆盖后的 close() 方法，在提示关闭信息后均发出异常；Outer 类额外有一个提示信息后也会发出异常的 show() 方法：
注：能够使用 try-with-resources 关闭资源的类，必须实现 AutoCloseable 接口。
class Outer implements AutoCloseable {
public void show() {
System.out.println("show is running!");
throw new RuntimeException("Outer show Exception!");
}
@Override
public void close() throws Exception {
System.out.println("Outer close!");
throw new RuntimeException("Outer close Exception!");
}
}
class Inner implements AutoCloseable {
@Override
public void close() throws Exception {
System.out.println("Inner close!");
throw new RuntimeException("Inner close Exception!");
}
}
调用：
public static void main(String[] args) {
try (Outer outer = new Outer()) {
try (Inner inner = new Inner()) {
System.out.println("other code...");
outer.show();
}
} catch (Exception e) {
e.printStackTrace();
}
}
输出如下。可见资源都已经关闭，被屏蔽的异常也已经显示出来：
other code...
show is running!
Inner close!
Outer close!
java.lang.RuntimeException: Outer show Exception!
at com.example.Outer.show(TestTryResources.java:20)
at com.example.TestTryResources.main(TestTryResources.java:8)
Suppressed: java.lang.RuntimeException: Inner close Exception!
at com.example.Inner.close(TestTryResources.java:35)
at com.example.TestTryResources.main(TestTryResources.java:6)
Suppressed: java.lang.RuntimeException: Outer close Exception!
at com.example.Outer.close(TestTryResources.java:26)
at com.example.TestTryResources.main(TestTryResources.java:5)
关于 try-with-resources 的底层实现原理，可以看看编译后的 class 文件：
public static void main(String[] args) {
try {
Outer outer = new Outer();
try {
Inner inner = new Inner();
try {
System.out.println("other code...");
outer.show();
} catch (Throwable var7) {
try {
inner.close();
} catch (Throwable var6) {
var7.addSuppressed(var6);
}
throw var7;
}
inner.close();
} catch (Throwable var8) {
try {
outer.close();
} catch (Throwable var5) {
var8.addSuppressed(var5);
}
throw var8;
}
outer.close();
} catch (Exception var9) {
var9.printStackTrace();
}
}
和传统关闭资源操作的实现原理一样，编译器生成了 finally 代码块，并在其中调用了 close 方法，除此之外，还多调用了一个 addSuppressed 方法来处理异常屏蔽。
