最近做的项目中使用到了一些基于java的socket长连接的一些功能，用来穿透有关行业的网闸。用到了也就学习了一下，下面是对学习内容的一个笔记，记录一下也希望有兴趣的同学可以参考一下，加深对javasocket的理解。
我们知道在java5之前 我们使用的IO是BIO java5之后是NIO 最新的AIO
BIO 是阻塞IO NIO 是同步非阻塞IO AIO 是异步非堵塞IO
现在我使用的更多的是NIO，但是我们自己去实现一个NIO做的没有类似的框架给我们做的好，比如MINA NETTY等等，他们是使用NIO来实现的IO操作的框架，关于NETTY和MINA 有空的时候我们也去看看他的源码，在源码中是如何使用NIO中诸如selecter channel bytebuffer selectionKey等等这些创建一个NIO必备的东西的。下面只是对原生态的NIO的做一个简单的实现，知道NIO的原理的什么。首先解释一些NIO中涉及的这几个词语都是什么意思。
selector 是一个选择器，这个玩意是用来管理具体的通信管道的，说到管道，我好想忘了说为什么要使用NIO ,是这样的我们知道IO操作对资源CPU是有很大的消耗的，比如我们NIO之前的BIO 在建立连接的时候必须要按照TCP的三次握手才能建立连接，我们知道从网络层来说的话建立三次握手是很耗时间的。所以NIO在处理创建连接的这个握手上面做了一个优化，什么优化呢，就是连接的创建次数越少越好，这时候就出现了一种叫做管道的概念和技术，管道是对一次连接的一个抽象，通道这个管道就不需要每次都去建立三次握手的连接。哪管道又是谁来管理的呢，这个就是我们说的selector这个东东了，这个东东类似于一个管家，就是这个关键管理所有的通信管道，比如那个管道里面接收到数据了，那个管道中可以写入数据了，等等 都由这个selector来管理调度。说到这里我们知道管道是有socketServerChannel和socketCleintChannel客户端管道的，这些管道通通都是由selector来进行调度管理的。说到管道中的数据我们就想到了缓存，是的 管道中的数据是通过bytebuffer来进行缓存的。最后看一个叫Selectionkey的东东，这个东东是用来判断每一个IO事件的状态的，比如是否就绪等等，他主要由如下的几种状态①key.isAccptable:是否可以接受客户端的连接。②Key.isconnctionable:是否可以连接服务端。③Key.isreadable():缓冲区是否可读。④Key.iswriteable():缓冲区是否可写。
这几个之间的使用关系是这样的，首先我们会去创建一个通道channel，然后通道要绑定我们的selector，channel.regist(Selector,Selectionkey.OP_Write);这样才能去管理。当然绑定的时候要去注册是什么状态的绑定。上面的selcector需要我们打开，类似于打开一个连接Selectionkey keys= Selector.selectedkeys();这个时候selector就开始管理了，等服务端或者客户端的channel有可写，可读，可连通等等事件的时候，selector就会捕获到，并将管道中的数据写到bytebuffer中，等待具体的业务去处理。
好了我上代码看一下吧
下面是服务端的：
package cn.nio;
import java.io.IOException;
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;
/**
* NIO服务端
* @author 小路
*/
public class NIOServer {
//通道管理器
private Selector selector;
/**
* 获得一个ServerSocket通道，并对该通道做一些初始化的工作
* @param port 绑定的端口号
* @throws IOException
*/
public void initServer(int port) throws IOException {
// 获得一个ServerSocket通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
// 设置通道为非阻塞
serverChannel.configureBlocking(false);
// 将该通道对应的ServerSocket绑定到port端口
serverChannel.socket().bind(new InetSocketAddress(port));
// 获得一个通道管理器
this.selector = Selector.open();
//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
//当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}
/**
* 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
* @throws IOException
*/
@SuppressWarnings("unchecked")
public void listen() throws IOException {
System.out.println("服务端启动成功！");
// 轮询访问selector
while (true) {
//当注册的事件到达时，方法返回；否则,该方法会一直阻塞
selector.select();
// 获得selector中选中的项的迭代器，选中的项为注册的事件
Iterator ite = this.selector.selectedKeys().iterator();
while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
// 删除已选的key,以防重复处理
ite.remove();
// 客户端请求连接事件
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key
.channel();
// 获得和客户端连接的通道
SocketChannel channel = server.accept();
// 设置成非阻塞
channel.configureBlocking(false);
//在这里可以给客户端发送信息哦
channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes()));
//在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
channel.register(this.selector, SelectionKey.OP_READ);
// 获得了可读的事件
} else if (key.isReadable()) {
read(key);
}
}
}
}
/**
* 处理读取客户端发来的信息 的事件
* @param key
* @throws IOException
*/
public void read(SelectionKey key) throws IOException{
// 服务器可读取消息:得到事件发生的Socket通道
SocketChannel channel = (SocketChannel) key.channel();
// 创建读取的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(10);
channel.read(buffer);
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println("服务端收到信息："+msg);
ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
channel.write(outBuffer);// 将消息回送给客户端
}
/**
* 启动服务端测试
* @throws IOException
*/
public static void main(String[] args) throws IOException {
NIOServer server = new NIOServer();
server.initServer(8000);
server.listen();
}
}
下面是客户端的：
package cn.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
/**
* NIO客户端
* @author 小路
*/
public class NIOClient {
//通道管理器
private Selector selector;
/**
* 获得一个Socket通道，并对该通道做一些初始化的工作
* @param ip 连接的服务器的ip
* @param port 连接的服务器的端口号
* @throws IOException
*/
public void initClient(String ip,int port) throws IOException {
// 获得一个Socket通道
SocketChannel channel = SocketChannel.open();
// 设置通道为非阻塞
channel.configureBlocking(false);
// 获得一个通道管理器
this.selector = Selector.open();
// 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调
//用channel.finishConnect();才能完成连接
channel.connect(new InetSocketAddress(ip,port));
//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
channel.register(selector, SelectionKey.OP_CONNECT);
}
/**
* 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
* @throws IOException
*/
@SuppressWarnings("unchecked")
public void listen() throws IOException {
// 轮询访问selector
while (true) {
selector.select();
// 获得selector中选中的项的迭代器
Iterator ite = this.selector.selectedKeys().iterator();
while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
// 删除已选的key,以防重复处理
ite.remove();
// 连接事件发生
if (key.isConnectable()) {
SocketChannel channel = (SocketChannel) key
.channel();
// 如果正在连接，则完成连接
if(channel.isConnectionPending()){
channel.finishConnect();
}
// 设置成非阻塞
channel.configureBlocking(false);
//在这里可以给服务端发送信息哦
channel.write(ByteBuffer.wrap(new String("向服务端发送了一条信息").getBytes()));
//在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
channel.register(this.selector, SelectionKey.OP_READ);
// 获得了可读的事件
} else if (key.isReadable()) {
read(key);
}
}
}
}
/**
* 处理读取服务端发来的信息 的事件
* @param key
* @throws IOException
*/
public void read(SelectionKey key) throws IOException{
//和服务端的read方法一样
}
/**
* 启动客户端测试
* @throws IOException
*/
public static void main(String[] args) throws IOException {
NIOClient client = new NIOClient();
client.initClient("localhost",8000);
client.listen();
}
}
其实我们可以看到其实服务端和客户端在实现方式上大概是差不多的。上面的例子中我们再服务端可客户端各建立了一个服务端的通道和客户端的通道，同时设置两个通道都是非阻塞的。然后将通道绑定到selector上，设置监听的时间是接收到数据。
关于NIO和BIO的一些区别，其实是很明显的，或者说是显而易见的，我们说，NIO的机制可以概括为 增加一个专门用来处理IO的线程，采用轮询的方式来监听IO事件，等有IO事件相应的时候去处理，没有的情况下就一直轮询堵塞在哪里不做任何处理。关于selector管理的线程之间的通信 通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。
先写到这里吧，打算今天晚上将NIO有关的东西都写完，但是现在要下班了，下班回去后再继续写。bruce at beijing
