Java NIO之通道Channel
1、前提
通道式（Channel）是java.nio的第二个主要创新。通道既不是一个扩展也不是一项增强，而是全新的、极好的Java I/O示例，提供与I/O服务的直接连接。Channel用于在字节缓冲区和位于通道另一侧的实体（通常是一个文件或套接字）之间有效地传输数据。通常情况下，通道与操作系统的文件描述符（FileDescriptor）和文件句柄（FileHandler）有着一对一的关系。虽然通道比文件描述符更广义，但开发者经常使用到的多数通道都是连接到开放的文件描述符的。Channel类提供维持平台独立性所需的抽象过程，不然仍然会模拟现代操作系统本身的I/O性能。
通道是一种途径，借助该途径，可以用最小的总开销来访问操作系统本身的I/O服务。缓冲区则是通道内部用来发送和接收数据的端点，如下图：
2、通道接口
public interface Channel extends Closeable {
/**
* Tells whether or not this channel is open.
*/
public boolean isOpen();
/**
* Closes this channel.
*/
public void close() throws IOException;
}
Channel 经常翻译为通道，类似 IO 中的流，用于读取和写入。它与 Buffer 打交道，读操作的时候将Channel 中的数据填充到 Buffer 中，而写操作时将 Buffer 中的数据写入到 Channel 中。所有的 NIO 操作始于通道，通道是数据来源或数据写入的目的地，主要地，我们将关心 java.nio 包中实现的以下几个 Channel：
-
FileChannel：文件通道，用于文件的读和写
-
DatagramChannel：用于 UDP 连接的接收和发送
-
SocketChannel：把它理解为 TCP 连接通道，简单理解就是 TCP 客户端
-
ServerSocketChannel：TCP 对应的服务端，用于监听某个端口进来的请求
3、使用通道
和缓冲区不同，通道API主要由接口指定。不同的操作系统上通道实现会有根本性的差异，所以通道API仅仅描述了可以做什么，因此很自然地，通道实现经常使用操作系统的本地代码，通道接口允许开发者以一种受控且可移植的方式来访问底层的I/O服务。可以从底层的Channel接口看到，对所有通道来说只有两种共同的操作：检查一个通道是否打开isOpen()和关闭一个打开的通道close()，其余所有的东西都是那些实现Channel接口以及它的子接口的类。
从Channel接口引申出的其他接口都是面向字节的子接口：
包括WritableByteChannel和ReadableByteChannel。这也正好支持了我们之前的所学：通道只能在字节缓冲区上操作。层次接口表明其他数据类型的通道也可以从Channel接口引申而来。这是一种很好的镭射机，不过非字节实现是不可能的，因为操作系统都是以字节的形式实现底层I/O接口的。
下面是基本的接口：
public interface ReadableByteChannel extends Channel
{
public int read(ByteBuffer dst) throws IOException;
}
public interface WritableByteChannel extends Channel
{
public int write(ByteBuffer src) throws IOException;
}
public interface ByteChannel extends ReadableByteChannel, WritableByteChannel
{
}
通道可以是单向的也可以是双向的。一个Channel类可能实现定义read()方法的ReadableByteChannel接口，而另一个Channel类也许实现WritableByteChannel接口以提供write()方法。实现这两种接口其中之一的类都是单向的，只能在一个方向上传输数据。如果一个类同时实现这两个接口，那么它是双向的，可以双向传输数据，就像上面的ByteChannel。
通道可以以阻塞（blocking）或非阻塞（nonblocking）模式运行，非阻塞模式的通道永远不会让调用的线程休眠，请求的操作要么立即完成，要么返回一个结果表明未进行任何操作。只有面向流的（stream-oriented）的通道，如sockets和pipes才能使用非阻塞模式。
比方说非阻塞的通道SocketChannel：
public abstract class SocketChannel extends AbstractSelectableChannel implements ByteChannel, ScatteringByteChannel, GatheringByteChannel
{
...
}
public abstract class AbstractSelectableChannel extends SelectableChannel
{
...
}
可以看出，socket通道类从SelectableChannel类引申而来，从SelectableChannel引申而来的类可以和支持有条件的选择的选择器（Selectors）一起使用。将非阻塞I/O和选择器组合起来可以使开发者的程序利用多路复用I/O。
4、文件通道FileChannel
通道是访问I/O服务的导管，I/O可以分为广义的两大类：File I/O和Stream I/O。那么相应的，通道也有两种类型，它们是文件（File）通道和套接字（Socket）通道。文件通道指的是FileChannel，套接字通道则有三个，分别是SocketChannel、ServerSocketChannel和DatagramChannel。
通道可以以多种方式创建。Socket通道可以有直接创建Socket通道的工厂方法，但是一个FileChannel对象却只能通过在一个打开的RandomAccessFile、FileInputStream或FileOutputStream对象上调用getChannel()方法来获取，开发者不能直接创建一个FileChannel。
文件I/O是我们最常使用的I/O，因此这部分先认识一下文件通道，下一部分再以代码形式演示如何使用文件通道高。用UML图表示一下文件通道的类层次关系：
文件通道总是阻塞式的，因此不能被置于非阻塞模式下。
前面提到过了，FileChannel对象不能直接创建，一个FileChannel实例只能通过在一个打开的File对象（RandomAccessFile、FileInputStream或FileOutputStream）上调用getChannel()方法获取，调用getChannel()方法会返回一个连接到相同文件的FileChannel对象且该FileChannel对象具有与file对象相同的访问权限，然后就可以使用通道对象来利用强大的FileChannel API了。
//初始化
FileInputStream inputStream = new FileInputStream(new File("/data.txt"));
FileChannel fileChannel = inputStream.getChannel();
//读取文件内容
ByteBuffer buffer = ByteBuffer.allocate(1024);
int num = fileChannel.read(buffer);
FileChannel对象是线程安全的，多个进程可以在同一个实例上并发调用方法而不会引起任何问题，不过并非所有的操作都是多线程的。影响通道位置或者影响文件的操作都是单线程的，如果有一个线程已经在执行会影响通道位置或文件大小的操作，那么其他尝试进行此类操作之一的线程必须等待，并发行为也会受到底层操作系统或文件系统的影响。
所有的 Channel 都是和 Buffer 打交道的。写入文件内容：
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("随机写入一些内容到 Buffer 中".getBytes());
// Buffer 切换为读模式
buffer.flip();
while(buffer.hasRemaining()) {
// 将 Buffer 中的内容写入文件
fileChannel.write(buffer);
}
5、使用文件通道读写数据
public class TestFileChannelWriteAndRead {
public static void main(String[] args) throws IOException {
File file = new File("D:/Files.txt");
RandomAccessFile raf = new RandomAccessFile(file, "rw");
FileChannel fc = raf.getChannel();
ByteBuffer bb = ByteBuffer.allocate(10);
String str = "abcdefghij";
System.out.println("开始向渠道写入数据");
bb.put(str.getBytes());
bb.flip();
fc.write(bb);
// bb.clear();
// fc.close();
//
// File file1 = new File("D:/Files.txt");
// FileInputStream fis = new FileInputStream(file1);
// FileChannel fc1 = fis.getChannel();
// ByteBuffer bb1 = ByteBuffer.allocate(35);
System.out.println("渠道开始读取数据");
fc.read(bb);
bb.flip();
while (bb.hasRemaining())
{
System.out.print((char)bb.get());
}
bb.clear();
fc.close();
}
}
输出：
开始向渠道写入数据
渠道开始读取数据
abcdefghij
文件通道必须通过一个打开的RandomAccessFile、FileInputStream、FileOutputStream获取到，因此这里使用FileInputStream来获取FileChannel。接着只要使用read方法将内容读取到缓冲区内即可，缓冲区内有了数据，就可以使用前文对于缓冲区的操作读取数据了。
写操作了中使用了RandomAccessFile去获取FileChannel，然后操作其实差不多，write方法写ByteBuffer中的内容至文件中，注意写之前还是要先把ByteBuffer给flip一下。可能有人觉得这种连续put的方法非常不方便，但是没有办法，之前已经提到过了：通道只能使用ByteBuffer。
6、SocketChannel
我们前面说了，我们可以将 SocketChannel 理解成一个 TCP 客户端。虽然这么理解有点狭隘，因为我们在介绍 ServerSocketChannel 的时候会看到另一种使用方式。
打开一个 TCP 连接：
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("https://www.zhihu.com", 80));
当然了，上面的这行代码等价于下面的两行：
// 打开一个通道
SocketChannel socketChannel = SocketChannel.open();
// 发起连接
socketChannel.connect(new InetSocketAddress("https://www.zhihu.com", 80));
SocketChannel 的读写和 FileChannel 没什么区别，就是操作缓冲区。
// 读取数据
socketChannel.read(buffer);
// 写入数据到网络连接中
while(buffer.hasRemaining()) {
socketChannel.write(buffer);
}
7、ServerSocketChannel
之前说 SocketChannel 是 TCP 客户端，这里说的 ServerSocketChannel 就是对应的服务端。ServerSocketChannel 用于监听机器端口，管理从这个端口进来的 TCP 连接。
// 实例化
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 监听 8080 端口
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
while (true) {
// 一旦有一个 TCP 连接进来，就对应创建一个 SocketChannel 进行处理
SocketChannel socketChannel = serverSocketChannel.accept();
}
SocketChannel 它不仅仅是 TCP 客户端，它代表的是一个网络通道，可读可写。ServerSocketChannel 不和 Buffer 打交道了，因为它并不实际处理数据，它一旦接收到请求后，实例化 SocketChannel，之后在这个连接通道上的数据传递它就不管了，因为它需要继续监听端口，等待下一个连接。
8、DatagramChannel
UDP 和 TCP 不一样，DatagramChannel 一个类处理了服务端和客户端。科普一下，UDP 是面向无连接的，不需要和对方握手，不需要通知对方，就可以直接将数据包投出去，至于能不能送达，它是不知道的
监听端口：
DatagramChannel channel = DatagramChannel.open();
channel.socket().bind(new InetSocketAddress(9090));
ByteBuffer buf = ByteBuffer.allocate(48);
channel.receive(buf);
发送数据：
String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.put(newData.getBytes());
buf.flip();
int bytesSent = channel.send(buf, new InetSocketAddress("jenkov.com", 80));
