NIO核心知识（区别、Channel、Buffer、Selector、SelectionKey、完整代码案例）

NIO核心知识

注：图片转载于并发编程网，链接：http://ifeve.com/。

0、IO和NIO的区别

①Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。
②Java IO的各种流是阻塞的。Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。
③Java NIO还提供Selector选择器，使得单线程更容易管理多个连接（多个通道的多个监听事件）。

1、Channel
Channel：翻译为通道，是一个接口，提供通道的实现规范。
作用：一个用于输入/输出操作的连接。通道表示一个实体的开放连接，例如硬件设备、文件、网络套接字或可以使用的程序组件执行一个或多个不同的输入/输出操作，例如读取或写操作。一般来说，通道是安全的，用于多线程访问。
实现类：FileChannel、SocketChannel、ServerSocketChannel、DatagramChannelChannel。

核心方法：
服务端
//打开通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
客户端
//打开通道
SocketChannel socketChannel = SocketChannel.open();

2、Buffer
Buffer：缓存区，是一个抽象类，提供实现不同数据类型缓存区的实现规范。
作用：Buffer用于与NIO通道进行交互，数据是从通道读入到缓冲区，从缓冲区写入通道的。
实现类：ByteBuffer、MappedByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer。

核心方法：
ByteBuffer byteBuffer = ByteBuffer.allocate(buffer_size);
byteBuffer.put(byteArray);

核心属性:
position：当前游标
limit：游标限制
capacity：容量



查看源码

//将position设回0，可以重读Buffer中的所有数据。

public final Buffer rewind() {
position = 0;
mark = -1;
return this;
}

//clear方法将缓冲区清空，在重新写缓冲区时调用。

public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}

//反转缓冲区，在准备从缓冲区中读取数据时调用flip方法。

public final Buffer flip() {
limit = position;
position = 0;
mark = -1;
return this;
}

3、Selector
Selector是通道监测器，能监测多个通道（Channel）的多个监听事件。

核心方法:
//获取通道监测器
Selector selector = Selector.open();
//监听
select();//阻塞到至少有一个通道在你注册的事件上就绪了。
select(long timeout);//和select()一样，除了最长会阻塞timeout毫秒(参数)。
selectNow();不会阻塞，不管什么通道就绪都立刻返回。



4、SelectionKey

监听事件集合。

核心属性：
public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

核心方法：
//通道注册监听事件到通道监测器
channel.register(selector, SelectionKey.OP_READ);
//如何注册多个监听事件呢？
channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
//轮询就绪事件

while(iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
//略...
iterator.remove();
}

5、完整代码案例

具体步骤：
1、服务端进入监听状态
2、客户端连接服务端，连接成功后向服务端发送消息
3、服务端接受到数据后，向客户端发送消息

服务端：

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
* @author 周杰
* @time 2017年10月25日 下午2:53:37
*/
public class Server {
private static final int port = 12345;
private static final int buffer_size = 1024;
private static final String charsetName = "UTF-8";
private static final String hello_message = "hello client !";
public static void main(String[] args) throws Exception {
//获取通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(new InetSocketAddress(port));
//获取通道管理器
Selector selector = Selector.open();
//将通道注册通道管理器的OP_ACCEPT事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

while(true) {
//当有注册事件到达时，方法返回，否则阻塞
selector.select();
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while(iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
if(!selectionKey.isValid()) {
continue;
}
if(selectionKey.isAcceptable()) {
System.out.println("accept a connection...");
ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
}else if(selectionKey.isReadable()) {
System.out.println("accept a message...");
SocketChannel sc = (SocketChannel) selectionKey.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(buffer_size);
int length = sc.read(byteBuffer);
if(length > 0) {
String receive_message = new String(byteBuffer.array(), charsetName);
System.out.println("server accept : "+receive_message);
sc.write(ByteBuffer.wrap(hello_message.getBytes(charsetName)));
}
}
iterator.remove();
}
}
}
}

客户端：

import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

/**
* @author 周杰
* @time 2017年10月25日 下午3:10:49
*/
public class Client {
private static final int port = 12345;
private static final int buffer_size = 1024;
private static final String charsetName = "UTF-8";
private static final String hello_message = "hello server !";
public static void main(String[] args) throws Exception {
//获取通道
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
//获取通道管理器
Selector selector = Selector.open();
//连接
socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(), port));
//将通道注册通道管理器的OP_CONNECT事件
socketChannel.register(selector, SelectionKey.OP_CONNECT);
while(true) {
selector.select();
for (SelectionKey key : selector.selectedKeys()) {
if(!key.isValid()) {
continue;
}
if(key.isConnectable()) {
System.out.println("connect successfully...");
SocketChannel sc = (SocketChannel) key.channel();
if(sc.isConnectionPending()) {
sc.finishConnect();
}
sc.register(selector, SelectionKey.OP_READ);
sc.write(ByteBuffer.wrap(hello_message.getBytes(charsetName)));
}else if(key.isReadable()) {
System.out.println("accept a message...");
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(buffer_size);
int length = sc.read(byteBuffer);
if(length > 0) {
String receive_message = new String(byteBuffer.array(), charsetName);
System.out.println("client accept : "+receive_message);
}
}
}
}
}
}