Java NIO
一、Java NIO简介
Java NIO（New IO，或称Non Blocking IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
二、Java NIO与传统IO的主要差别
1、传统的IO是面向流的，单向。流类似于水管
2、NIO是面向通道的。通道类似于铁路，只负责连接，传输数据还需要缓冲区（类似火车）
三、缓冲区与通道
Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到IO 设备(例如：文件、套接字)的连接。若需要使用NIO 系统，需要获取用于连接IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。
简而言之，Channel 负责传输，Buffer 负责存储。
1、缓冲区
（1）基本定义
一个用于保存特定基本数据类型的容器，类似于数组。Java NIO中的Buffer主要用于与NIO通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。
由java.nio包定义，根据数据类型不同(boolean 除外) ，有以下Buffer常用子类：
- ByteBuffer
- CharBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
所有这些类都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过如下方法获取一个Buffer 对象，static XxxBuffer allocate(int capacity) : 创建一个容量为capacity 的XxxBuffer 对象。
（2）缓冲区存取数据的两个核心方法
获取Buffer 中的数据
- get() ：读取单个字节
- get(byte[] dst)：批量读取多个字节到dst 中
- get(int index)：读取指定索引位置的字节(不会移动position)
放入数据到缓冲区中
- put(byte b)：将给定单个字节写入缓冲区的当前位置
- put(byte[] src)：将src 中的字节写入缓冲区的当前位置
- put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动position)
（3）Buffer 中的四个核心属性
- 容量(capacity)：表示Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改。
- 限制(limit)：第一个不应该读取或写入的数据的索引，即位于limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
- 位置(position)：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制。
- 标记(mark)与重置(reset)：标记是一个索引，通过Buffer 中的mark() 方法指定Buffer 中一个特定的position，之后可以通过调用reset() 方法恢复到这个position。
标记、位置、限制、容量遵守以下不变式：0<=mark<=position<=limit<=capacity。
（4）Buffer的常用方法
- Buffer clear()：清空缓冲区并返回对缓冲区的引用
- Buffer flip()：将缓冲区的界限设置为当前位置，并将当前位置充值为0
- int capacity()：返回Buffer 的capacity大小
- boolean hasRemaining()：判断缓冲区中是否还有元素
- int limit()：返回Buffer 的界限(limit) 的位置
- Buffer limit(int n)：将设置缓冲区界限为n, 并返回一个具有新limit 的缓冲区对象
- Buffer mark()：对缓冲区设置标记
- int position()：返回缓冲区的当前位置position
- Buffer position(int n)：将设置缓冲区的当前位置为n , 并返回修改后的Buffer 对象
- int remaining()：返回position 和limit 之间的元素个数
- Buffer reset()：将位置position 转到以前设置的mark 所在的位置
- Buffer rewind()：将位置设为为0，取消设置的mark
（5） 非直接与直接缓冲区
非直接缓冲区：出于安全考虑，应用程序不能直接和物理磁盘进行数据交换，而是通过用户地址空间和内核地址空间之间文件拷贝的方式进行文件操作。所以，文件拷贝过程造成了性能的损耗。
直接缓冲区： 应用程序通过对物理内存映射文件进行操作，相当于直接对物理磁盘进行文件操作（相当于快捷方式？）。这样有利又有弊，效率是提升了，但是又带来一些问题：分配销毁资源消耗大、不易控制（程序将数据写到物理内存映射文件后就归操作系统管了）。
其它一些总结
字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则Java 虚拟机会尽最大努力直接在此缓冲区上执行本机I/O 操作。也就是说，在每次调用基础操作系统的一个本机I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
直接字节缓冲区可以通过调用此类的allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
直接字节缓冲区还可以通过FileChannel 的map() 方法将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer。Java 平台的实现有助于通过JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。
字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其isDirect()方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。
2、通道
（1）基本定义
Channel是由java.nio.channels 包定义的，表示IO 源与目标打开的连接。Channel类似于传统的“流”，只不过Channel本身不能直接访问数据，Channel只能与Buffer进行交互。
（2）计算机进行IO操作的方式变化
开始，CPU全权管理所有IO接口。弊端：IO阻塞时CPU不能处理其它事情，效率低下，资源得不到有效利用。
接着， 由内存DMA总线负责处理IO操作。弊端：IO操作频繁时造成DMA总线过多，影响性能。
最后，由通道（Channel）负责IO接口。通道是完全独立的处理器，有自己的命令，附属于CPU，专门用于直接处理IO操作。
（3） Channel接口提供的主要实现类
- FileChannel：用于读取、写入、映射和操作文件的通道。
- DatagramChannel：通过UDP 读写网络中的数据通道。
- SocketChannel：通过TCP 读写网络中的数据。
- ServerSocketChannel：可以监听新进来的TCP 连接，对每一个新进来的连接都会创建一个SocketChannel。
（4）获取通道
方式一， 对支持通道的对象调用getChannel() 方法。支持通道的类如下：
- FileInputStream
- FileOutputStream
- RandomAccessFile
- DatagramSocket
- Socket
- ServerSocket
方式二，使用Files 类的静态方法newByteChannel() 获取字节通道。
方式三，通过通道的静态方法open() 打开并返回指定通道。
（5）通道的数据传输
将Buffer 中数据写入Channel：
从Channel 读取数据到Buffer：
示例代码
// 使用直接缓冲区完成文件的复制(内存映射文件)
@Test
public void test2() throws IOException{
long start = System.currentTimeMillis();
FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
// 内存映射文件
MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
// 直接对缓冲区进行数据的读写操作
byte[] dst = new byte[inMappedBuf.limit()];
inMappedBuf.get(dst);
outMappedBuf.put(dst);
inChannel.close();
outChannel.close();
long end = System.currentTimeMillis();
System.out.println("耗费时间为：" + (end - start));
}（6）分散和聚集
分散读取（Scattering Reads）是指从Channel中读取的数据“分散”到多个Buffer中。
注意：按照缓冲区的顺序，从Channel中读取的数据依次将Buffer填满。
聚集写入（Gathering Writes）是指将多个Buffer中的数据“聚集”到Channel。
注意：按照缓冲区的顺序，写入position和limit之间的数据到Channel。
示例代码
// 分散和聚集
@Test
public void test() throws IOException {
RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
// 1. 获取通道
FileChannel channel1 = raf1.getChannel();
// 2. 分配指定大小的缓冲区
ByteBuffer buf1 = ByteBuffer.allocate(100);
ByteBuffer buf2 = ByteBuffer.allocate(1024);
// 3. 分散读取
ByteBuffer[] bufs = {buf1, buf2};
channel1.read(bufs);
for (ByteBuffer byteBuffer : bufs) {
byteBuffer.flip();
}
System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
System.out.println("-----------------");
System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
// 4. 聚集写入
RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
FileChannel channel2 = raf2.getChannel();
channel2.write(bufs);
}（7） 通道之间的数据传输
- transferFrom()：将数据从源通道传输到其他Channel中
- transferTo()：将数据从源通道传输到其他Channel中
示例代码
// 通道之间的数据传输(直接缓冲区)
@Test
public void testTransfer() throws IOException{
FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
// inChannel.transferTo(0, inChannel.size(), outChannel);
outChannel.transferFrom(inChannel, 0, inChannel.size());
inChannel.close();
outChannel.close();
}（8）字符集
获取所有字符集：Map
- 编码：字符串 -> 字节数组
- 解码：字节数组 -> 字符串
// 字符集
@Test
public void testCharset() throws IOException{
Charset cs1 = Charset.forName("GBK");
// 获取编码器
CharsetEncoder ce = cs1.newEncoder();
// 获取解码器
CharsetDecoder cd = cs1.newDecoder();
CharBuffer cBuf = CharBuffer.allocate(1024);
cBuf.put("Hello周先生！");
cBuf.flip();
// 编码
ByteBuffer bBuf = ce.encode(cBuf);
for (int i = 0; i < 12; i++) {
System.out.println(bBuf.get());
}
// 解码
bBuf.flip();
CharBuffer cBuf2 = cd.decode(bBuf);
System.out.println(cBuf2.toString());
System.out.println("------------------------------------------------------");
Charset cs2 = Charset.forName("GBK");
bBuf.flip();
CharBuffer cBuf3 = cs2.decode(bBuf);
System.out.println(cBuf3.toString());
}四、文件通道
FileChannel的常用方法
- int read(ByteBuffer dst)：从Channel 中读取数据到ByteBuffer
- long read(ByteBuffer[] dsts)：将Channel 中的数据“分散”到ByteBuffer[]
- int write(ByteBuffer src)：将ByteBuffer 中的数据写入到Channel
- long write(ByteBuffer[] srcs)：将ByteBuffer[] 中的数据“聚集”到Channel
- long position()：返回此通道的文件位置
- FileChannel position(long p)：设置此通道的文件位置
- long size()：返回此通道的文件的当前大小
- FileChannel truncate(long s)：将此通道的文件截取为给定大小
- void force(boolean metaData)：强制将所有对此通道的文件更新写入到存储设备中
五、NIO的非阻塞式网络通信
1、阻塞与非阻塞
- 传统的IO 流都是阻塞式的。也就是说，当一个线程调用read() 或write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。
- Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞IO 的空闲时间用于在其他通道上执行IO 操作，所以单独的线程可以管理多个输入和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。
2、选择器
选择器（Selector）是SelectableChannle对象的多路复用器，Selector可以同时监控多个SelectableChannel的IO状况，也就是说，利用Selector可使一个单独的线程管理多个Channel。Selector是非阻塞IO的核心。
（1）结构图
（2）应用
创建Selector：通过调用Selector.open()方法创建一个Selector。
向选择器注册通道：SelectableChannel.register(Selector sel, int ops)。
当调用register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数ops 指定。
可以监听的事件类型（可使用SelectionKey 的四个常量表示）：
- 读: SelectionKey.OP_READ （1）
- 写: SelectionKey.OP_WRITE （4）
- 连接: SelectionKey.OP_CONNECT（8）
- 接收: SelectionKey.OP_ACCEPT （16）
若注册时不止监听一个事件，则可以使用“位或”操作符连接。
SelectionKey：表示SelectableChannel和Selector之间的注册关系。每次向选择器注册通道时就会选择一个事件(选择键)。选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。
- int interestOps()：获取感兴趣事件集合
- int readyOps()：获取通道已经准备就绪的操作的集合
- SelectableChannel channel()：获取注册通道
- Selector selector()：返回选择器
- boolean isReadable()：检测Channal 中读事件是否就绪
- boolean isWritable()：检测Channal 中写事件是否就绪
- booleanisConnectable()：检测Channel 中连接是否就绪
- booleanisAcceptable()：检测Channel 中接收是否就绪
Selector的常用方法
- Set
keys()：所有的SelectionKey 集合。代表注册在该Selector上的Channel - selectedKeys()：被选择的SelectionKey 集合。返回此Selector的已选择键集
- int select()：监控所有注册的Channel，当它们中间有需要处理的IO 操作时，该方法返回，并将对应得的SelectionKey 加入被选择的SelectionKey 集合中，该方法返回这些Channel 的数量
- int select(long timeout)：可以设置超时时长的select() 操作
- int selectNow()：执行一个立即返回的select() 操作，该方法不会阻塞线程
- Selector wakeup()：使一个还未返回的select() 方法立即返回
- void close()：关闭该选择器
3、SocketChannel
Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。
操作步骤：
- 打开SocketChannel
- 读写数据
- 关闭SocketChannel
（1）阻塞式实现
// 客户端
@Test
public void client() throws IOException{
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
ByteBuffer buf = ByteBuffer.allocate(1024);
while(inChannel.read(buf) != -1){
buf.flip();
sChannel.write(buf);
buf.clear();
}
sChannel.shutdownOutput();
// 接收服务端的反馈
int len = 0;
while((len = sChannel.read(buf)) != -1){
buf.flip();
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
inChannel.close();
sChannel.close();
}（2） 非阻塞式实现
// 客户端
@Test
public void client() throws IOException{
// 1. 获取通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
// 2. 切换非阻塞模式
sChannel.configureBlocking(false);
// 3. 分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
// 4. 发送数据给服务端
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
String str = scan.next();
buf.put((new Date().toString() + "\n" + str).getBytes());
buf.flip();
sChannel.write(buf);
buf.clear();
}
// 5. 关闭通道
sChannel.close();
}4、ServerSocketChannel
Java NIO中的ServerSocketChannel是一个可以监听新进来的TCP连接的通道，就像标准IO中的ServerSocket一样。
（1）阻塞式实现
@Test
public void server() throws IOException{
ServerSocketChannel ssChannel = ServerSocketChannel.open();
FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
ssChannel.bind(new InetSocketAddress(9898));
SocketChannel sChannel = ssChannel.accept();
ByteBuffer buf = ByteBuffer.allocate(1024);
while(sChannel.read(buf) != -1){
buf.flip();
outChannel.write(buf);
buf.clear();
}
// 发送反馈给客户端
buf.put("服务端接收数据成功".getBytes());
buf.flip();
sChannel.write(buf);
sChannel.close();
outChannel.close();
ssChannel.close();
}（2）非阻塞式实现
// 服务端
@Test
public void server() throws IOException{
//1. 获取通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 切换非阻塞模式
ssChannel.configureBlocking(false);
//3. 绑定连接
ssChannel.bind(new InetSocketAddress(9898));
//4. 获取选择器
Selector selector = Selector.open();
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
//6. 轮询式的获取选择器上已经“准备就绪”的事件
while(selector.select() > 0){
//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
Iterator it = selector.selectedKeys().iterator();
while(it.hasNext()){
//8. 获取准备“就绪”的是事件
SelectionKey sk = it.next();
//9. 判断具体是什么事件准备就绪
if(sk.isAcceptable()){
//10. 若“接收就绪”，获取客户端连接
SocketChannel sChannel = ssChannel.accept();
//11. 切换非阻塞模式
sChannel.configureBlocking(false);
//12. 将该通道注册到选择器上
sChannel.register(selector, SelectionKey.OP_READ);
}else if(sk.isReadable()){
//13. 获取当前选择器上“读就绪”状态的通道
SocketChannel sChannel = (SocketChannel) sk.channel();
//14. 读取数据
ByteBuffer buf = ByteBuffer.allocate(1024);
int len = 0;
while((len = sChannel.read(buf)) > 0 ){
buf.flip();
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
}
//15. 取消选择键 SelectionKey
it.remove();
}
}
} 5、DatagramChannel
Java NIO中的DatagramChannel是一个能收发UDP包的通道。
操作步骤：
- 打开DatagramChannel
- 接收/发送数据
public class TestNonBlockingNIO {
@Test
public void send() throws IOException{
DatagramChannel dc = DatagramChannel.open();
dc.configureBlocking(false);
ByteBuffer buf = ByteBuffer.allocate(1024);
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
String str = scan.next();
buf.put((new Date().toString() + ":\n" + str).getBytes());
buf.flip();
dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
buf.clear();
}
dc.close();
}
@Test
public void receive() throws IOException{
DatagramChannel dc = DatagramChannel.open();
dc.configureBlocking(false);
dc.bind(new InetSocketAddress(9898));
Selector selector = Selector.open();
dc.register(selector, SelectionKey.OP_READ);
while(selector.select() > 0){
Iterator it = selector.selectedKeys().iterator();
while(it.hasNext()){
SelectionKey sk = it.next();
if(sk.isReadable()){
ByteBuffer buf = ByteBuffer.allocate(1024);
dc.receive(buf);
buf.flip();
System.out.println(new String(buf.array(), 0, buf.limit()));
buf.clear();
}
}
it.remove();
}
}
}
六、管道
Java NIO管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。
1、向管道写数据
2、从管道读取数据
从读取管道的数据，需要访问source通道。
调用source通道的read()方法来读取数据。
七、Java NIO2新增API
更详细请参考https://blog.csdn.net/qq_31142553/article/details/81712716。
随着JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为NIO.2。因为NIO 提供的一些功能，NIO已经成为文件处理中越来越重要的部分。
1、Path与Paths
java.nio.file.Path接口代表一个平台无关的平台路径，描述了目录结构中文件的位置。
Paths提供的get()方法用来获取Path对象，Path.get(String first, String … more)用于将多个字符串串连成路径
Path常用方法：
- boolean endsWith(String path) : 判断是否以path 路径结束
- boolean startsWith(String path) : 判断是否以path 路径开始
- boolean isAbsolute() : 判断是否是绝对路径
- Path getFileName() : 返回与调用Path 对象关联的文件名
- Path getName(int idx) : 返回的指定索引位置idx 的路径名称
- int getNameCount() : 返回Path 根目录后面元素的数量
- Path getParent() ：返回Path对象包含整个路径，不包含Path 对象指定的文件路径
- Path getRoot() ：返回调用Path 对象的根路径
- Path resolve(Path p) :将相对路径解析为绝对路径
- Path toAbsolutePath() : 作为绝对路径返回调用Path 对象
- String toString() ：返回调用Path 对象的字符串表示形式
2、Files
java.nio.file.Files 用于操作文件或目录的工具类。
Files常用方法：
- Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
- PathcreateDirectory(Path path, FileAttribute … attr) : 创建一个目录
- Path createFile(Path path, FileAttribute … arr) : 创建一个文件
- void delete(Path path) : 删除一个文件
- Path move(Path src, Path dest, CopyOption…how) : 将src 移动到dest 位置
- long size(Path path) : 返回path 指定文件的大小
Files常用方法：用于判断
- boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
- boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
- boolean isExecutable(Path path) : 判断是否是可执行文件
- boolean isHidden(Path path) : 判断是否是隐藏文件
- boolean isReadable(Path path) : 判断文件是否可读
- boolean isWritable(Path path) : 判断文件是否可写
- boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
- public static A readAttributes(Path path,Class type,LinkOption... options) : 获取与path 指定的文件相关联的属性
Files常用方法：用于操作内容
- SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式
- DirectoryStream newDirectoryStream(Path path) : 打开path 指定的目录
- InputStream newInputStream(Path path, OpenOption…how):获取InputStream 对象
- OutputStream newOutputStream(Path path, OpenOption…how) : 获取OutputStream 对象
3、自动资源管理
Java 7增加了一个新特性，该特性提供了另外一种管理资源的方式，这种方式能自动关闭文件。这个特性有时被称为自动资源管理(Automatic Resource Management, ARM)，该特性以try 语句的扩展版为基础。自动资源管理主要用于，当不再需要文件（或其他资源）时，可以防止无意中忘记释放它们。
自动资源管理基于try 语句的扩展形式：
try (需要关闭的资源声明) {
// 可能发生异常的语句
} catch (异常类型变量名) {
// 异常的处理语句
} finally{
// 一定执行的语句
// 不需要在这里写资源的关闭
}当try代码块结束时，自动释放资源。因此不需要显示的调用close()方法。该形式也称为“带资源的try 语句”。
注意：
- ①try 语句中声明的资源被隐式声明为final ，资源的作用局限于带资源的try语句。
- ②可以在一条try 语句中管理多个资源，每个资源以“;” 隔开即可。
- ③需要关闭的资源，必须实现了AutoCloseable 接口或其自接口Closeable。
文章相关的代码和文档已上传至我的资源，前往下载。