背景：
在Java编程过程中，如果打开了外部资源（文件、数据库连接、网络连接等），我们必须在这些外部资源使用完毕后，手动关闭它们。因为外部资源不由JVM管理，无法享用JVM的垃圾回收机制，如果我们不在编程时确保在正确的时机关闭外部资源，就会导致外部资源泄露，紧接着就会出现文件被异常占用，数据库连接过多导致连接池溢出等诸多很严重的问题。
传统关闭资源方式（一般JDK版本低于1.7）
/**
* 根据路径创建文件，如果路径文件夹不存在，就创建
* @param filePath
* @return
*/
public static File createFileAbsolute(String filePath) throws IOException {
File file = new File(filePath);
File fileParent = file.getParentFile(); if(!fileParent.exists()){
fileParent.mkdirs();
}
file.createNewFile();
return file;
} /**
* 传统写法，JDK1.6
* @param dataStr
* @return
*/
public static long write2FileTradition(String dataStr,String filePath){
long fileSize = 0L;
RandomAccessFile raf = null;
FileChannel fchannel = null;
try {
raf = new RandomAccessFile(createFileAbsolute(filePath),"rw");
fchannel = raf.getChannel(); ByteBuffer buf = ByteBuffer.allocate(); buf.clear();
buf.put(dataStr.getBytes());
buf.flip(); while(buf.hasRemaining()){
fchannel.write(buf);
} fileSize = fchannel.size(); } catch (FileNotFoundException e) {
logger.error("file not found",e);
} catch (IOException e) {
logger.error("IO exception",e);
}finally{
IOUtils.close(fchannel);
IOUtils.close(raf);
}
return fileSize;
}
注意：如果是节点流和处理流，可直接关闭处理流，因为io流使用了装饰模式，所以关闭处理流时，会调用节点流的close()方法。
JDK1.7以后关闭资源的方式
try-with-resource语法（语法糖）
在JDK7以前，Java没有自动关闭外部资源的语法特性，直到JDK7中新增了try-with-resource语法，才实现了这一功能。
那什么是try-with-resource呢？简而言之，当一个外部资源的句柄对象（比如FileInputStream对象）实现了AutoCloseable接口，那么就可以将上面的板式代码简化为如下形式：
/**
* JDK1.7 关闭资源语法糖
*
* @param dataStr
* @param filePath
* @return
*/
public static long write2File(String dataStr, String filePath) {
long fileSize = 0L;
try (
RandomAccessFile raf = new RandomAccessFile(createFileAbsolute(filePath), "rw");
FileChannel fchannel = raf.getChannel()
) {
ByteBuffer buf = ByteBuffer.allocate(1024); buf.clear();
buf.put(dataStr.getBytes());
buf.flip(); while (buf.hasRemaining()) {
fchannel.write(buf);
} fileSize = fchannel.size(); } catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} return fileSize;
}
将外部资源的句柄对象的创建放在try关键字后面的括号中，当这个try-catch代码块执行完毕后，Java会确保外部资源的close方法被调用。
反编译后源码：
public static long write2File(String dataStr, String filePath) {
long fileSize = 0L;
try {
RandomAccessFile raf = new RandomAccessFile(filePath, "rw");
Throwable var5 = null;
try {
FileChannel fchannel = raf.getChannel();
Throwable var7 = null;
try {
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.clear();
buf.put(dataStr.getBytes());
buf.flip();
while(buf.hasRemaining()) {
fchannel.write(buf);
}
fileSize = fchannel.size();
} catch (Throwable var34) {
var7 = var34;
throw var34;
} finally {
if (fchannel != null) {
if (var7 != null) {
try {
fchannel.close();
} catch (Throwable var33) {
var7.addSuppressed(var33);
}
} else {
fchannel.close();
}
}
}
} catch (Throwable var36) {
var5 = var36;
throw var36;
} finally {
if (raf != null) {
if (var5 != null) {
try {
raf.close();
} catch (Throwable var32) {
var5.addSuppressed(var32);
}
} else {
raf.close();
}
}
}
} catch (FileNotFoundException var38) {
logger.error("file not found", var38);
} catch (IOException var39) {
logger.error("IO exception", var39);
}
return fileSize;
}
异常抑制
通过反编译的代码，大家可能注意到代码中有一处对异常的特殊处理：
var2.addSuppressed(var11);
这是try-with-resource语法涉及的另外一个知识点，叫做异常抑制。当对外部资源进行处理（例如读或写）时，如果遭遇了异常，且在随后的关闭外部资源过程中，又遭遇了异常，那么你catch到的将会是对外部资源进行处理时遭遇的异常，关闭资源时遭遇的异常将被“抑制”但不是丢弃，通过异常的getSuppressed方法，可以提取出被抑制的异常。
这里理解一点，就是try块中抛出的异常，在finally也抛出异常时，就会丢失，所以通常在finally不抛异常，而是通过 addSuppressed()方法将异常抑制住。
总结：
1、当一个外部资源的句柄对象实现了AutoCloseable接口，JDK7中便可以利用try-with-resource语法更优雅的关闭资源，消除板式代码。
2、try-with-resource时，如果对外部资源的处理和对外部资源的关闭均遭遇了异常，“关闭异常”将被抑制，“处理异常”将被抛出，但“关闭异常”并没有丢失，而是存放在“处理异常”的被抑制的异常列表中。
参考：
https://www.cnblogs.com/itZhy/p/7636615.html
https://www.cnblogs.com/langtianya/p/5139465.html