JAVA NIO 之Channel
缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。Channel 通道就是将数据传输给 ByteBuffer 对象或者从 ByteBuffer 对象获取数据进行传输。
Channel 用于在字节缓冲区和位于通道另一侧的实体（通常是一个文件或套接字）之间有效地传输数据。常用Channel有FileChannel、SocketChannel、DatagramChannel、ServerSocketChannel
Socket 可以通过socket 通道的工厂方法直接创建。但是FileChannel 对象却只能通过在一个打开的 RandomAccessFile、FileInputStream 或 FileOutputStream对象上调用 getChannel( )方法来获取。
通道可以以阻塞（blocking）或非阻塞（nonblocking）模式运行。只有面向流的（stream-oriented）的通道，如 sockets 和 pipes 才能使用非阻塞模式。
1.打开通道
a.打开FileChannel，以RandomAccessFile为例 ：
RandomAccessFile aFile = new RandomAccessFile("G:\\we.txt", "rw");
FileChannel inChannel = aFile.getChannel();
b.打开SocketChannel：
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("127.0.0.1",9011));
c.打开ServerSocketChannel
ServerSocketChannel ssc = ServerSocketChannel.open( ); ssc.socket( ).bind (new InetSocketAddress (9011));
2.使用通道
a.使用FileChannel从指定文件中读取数据：
/**
* @author monkjavaer
* @date 2018/10/18 21:00
*/
public class ChannelTest {
public static void main(String[] args) {
//RandomAccessFile、FileInputStream 或 FileOutputStream的close()会同时关闭chanel。
try (RandomAccessFile aFile = new RandomAccessFile("F:\\test.txt", "rw")) {
//1.FileChannel 对象却只能通过在一个打开的 RandomAccessFile、FileInputStream 或 FileOutputStream对象上调用 getChannel( )方法来获取
//2.三个 socket 通道类：SocketChannel、ServerSocketChannel 和 DatagramChannel有可以直接创建新 socket 通道的工厂方法
//随机流, mode 的值可选 "r"：可读，"w" ：可写，"rw"：可读写；
FileChannel inChannel = aFile.getChannel();
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);
while (bytesRead != -1) {
//通过flip()方法将Buffer从写模式切换到读模式
buf.flip();
while (buf.hasRemaining()) {
System.out.print((char) buf.get());
}
//两种方式能清空缓冲区：调用clear()或compact()方法,clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据
buf.clear();
bytesRead = inChannel.read(buf);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
b.在两个通道中复制数据：
/**
* 在通道之间复制数据
* @author monkjavaer
* @date 2018/10/18 21:12
*/
public class ChannelCopy {
public static void main(String[] argv) throws IOException {
FileInputStream inputStream = new FileInputStream("G:\\test.txt");
FileChannel inChanel = inputStream.getChannel();
FileOutputStream outputStream = new FileOutputStream("G:\\copyTest.txt");
FileChannel outChanel = outputStream.getChannel();
//channelCopy1 channelCopy2方法都是两个通道复制数据
channelCopy1(inChanel, outChanel);
// channelCopy2 (inChanel, outChanel);
inChanel.close();
outChanel.close();
}
/**
*
* @param inChanel
* @param outChanel
* @throws IOException
*/
private static void channelCopy1(FileChannel inChanel, FileChannel outChanel) throws IOException {
ByteBuffer buffer = ByteBuffer.allocateDirect(16 * 1024);
//将数据从输入通道读入缓冲区
while (inChanel.read(buffer) != -1) {
// buffer切换到读模式
buffer.flip();
while (buffer.hasRemaining()) {
//如果buffer中有数据就将数据写入输出通道
outChanel.write(buffer);
}
// buffer切换到写模式，确保缓冲区为空，准备继续填充数据
buffer.clear();
}
}
private static void channelCopy2(FileChannel inChanel, FileChannel outChanel) throws IOException {
ByteBuffer buffer = ByteBuffer.allocateDirect(16 * 1024);
while (inChanel.read(buffer) != -1) {
// Prepare the buffer to be drained
buffer.flip();
// Write to the channel; may block
outChanel.write(buffer);
// If partial transfer, shift remainder down
// If buffer is empty, same as doing clear( )
buffer.compact();
}
// EOF will leave buffer in fill state
buffer.flip();
// Make sure that the buffer is fully drained
while (buffer.hasRemaining()) {
outChanel.write(buffer);
}
}
c.注意：一个连接到只读文件的 Channel 实例不能进行写操作，即使该实例所属的类可能有 write( )方法；FileChannel 实现 ByteChannel
下面是ByteChannel的源码：
public interface ByteChannel
extends ReadableByteChannel, WritableByteChannel
{
}
可以看到ByteChannel其实什么也不做，这样设计起到了聚集的作用。
FileChannel 接口既有write也有read方法，为何说不能写呢？那是当使用只读流获取通道时：
/**
* @author monkjavaer
* @date 2018/10/18 21:15
*/
public class ChannelOnlyReadTest {
public static void main(String[] args) {
try {
ByteBuffer buffer = ByteBuffer.allocate(48);
// 但是从 FileInputStream 对象的getChannel( )方法获取的 FileChannel 对象是只读的，因为 FileInputStream 对象总是以 read-only 的权限打开文件
FileInputStream input = new FileInputStream ("G:\\we.txt");
FileChannel channel = input.getChannel( );
// 抛出 java.nio.channels.NonWritableChannelException
channel.write (buffer);
//FileInputStream的close同时会关闭chanel
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
上面的代码运行会报错：java.nio.channels.NonWritableChannelException
因为：从 FileInputStream 对象的getChannel( )方法获取的 FileChannel 对象是只读的，因为 FileInputStream 对象总是以 read-only 的权限打开文件。所以没有写权限。
之前我们用ServerSocket创建服务器的栗子中服务器是阻塞的。那NIO怎么实现非阻塞呢？
上面讲的FileChannel 是非阻塞的，因为没有依靠SelectableChannel 超类。全部 socket 通道类（DatagramChannel、 SocketChannel 和 ServerSocketChannel） 都可以设置成非阻塞的。
这里就要用到SelectableChannel 的方法
public abstract SelectableChannel configureBlocking(boolean block)
throws IOException;
通道设置configureBlocking方法为false就表示非阻塞模式。
下面是一个客服端和服务器代码说明；
客服端：
/**
* @author monkjavaer
* @date 2018/10/18 21:08
*/
public class ScoketChannelClient {
public static void main(String[] args) {
SocketChannel socketChannel = null;
try {
ByteBuffer buffer = ByteBuffer.wrap ("客服端".getBytes());
//获取SocketChannel
socketChannel = SocketChannel.open();
//设置通道为非阻塞
socketChannel.configureBlocking(false);
//连接
socketChannel.connect(new InetSocketAddress("127.0.0.1",9011));
//connect(InetSocketAddress) 等价于 open(InetSocketAddress)
//SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9010));
//一些判断
if (!socketChannel.isBlocking()){
System.out.println("非阻塞");
}
while (!socketChannel.finishConnect()){
System.out.println("连接没有建立");
}
System.out.println("连接已建立");
if (socketChannel.isConnected()){
System.out.println("连接已建立");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
assert socketChannel != null;
socketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
服务器：
package com.nio.java;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
/**
* ServerSocketChannel
* @author monkjavaer
* @date 2018/10/18 21:29
*/
public class ChannelAccept
{
public static final String HELLO = "Hello I am server.\r\n";
public static void main (String [] argv)throws Exception{
int port = 9011;
if (argv.length > 0) {
port = Integer.parseInt (argv [0]);
}
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open( );
serverSocketChannel.socket( ).bind (new InetSocketAddress (port));
//非阻塞模式
serverSocketChannel.configureBlocking (false);
while (true) {
System.out.println ("Waiting for connections");
//如果以非阻塞模式被调用，当没有传入连接在等待时，ServerSocketChannel.accept( )会立即返回 null
SocketChannel sc = serverSocketChannel.accept( );
if (sc == null) {
// 没有连接。。。睡觉
Thread.sleep (2000);
} else {
System.out.println ("Incoming connection from: "+ sc.socket().getRemoteSocketAddress( ));
//wrap buffer的另一种创建方式
ByteBuffer buffer = ByteBuffer.wrap (HELLO.getBytes( ));
//可以使用 rewind()后退，重读已经被flip()的缓冲区中的数据。
buffer.rewind( );
sc.write (buffer);
}
}
}
}
Scatter/Gather（ ScatteringByteChannel 和 GatheringByteChannel）
矢量化的 I/O 使您可以在多个缓冲区上自动执行一个 I/O 操作。使用多个而不是单个缓冲区来保存数据的读写方法。处理复杂数据结构时用。
