手写JAVA NIO实现Socket通信及其过程中注意的问题

           当然现在不需要自己手写NIO实现socket，都是在需要建立TCP/IP连接的程序中直接使用mina框架，或者netty框架， 后者使用的更多。趁着在用mina框架解析网关协议之际，本文手写NIO实现socket的服务端，找一找学习NIO中遇到的问题，以及在调试的过程中学习对某些API的理解，文中只写了服务端，客户端用SocketTools这个工具充当，测试。

服务端代码实现：（运行起来只需要导入log4j和slf4j的jar包，看启动日志需要加上log4j.properties）

本来是同一个文件的东西，我也不知道系统为什么给自动分到两个部分去了

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;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * @author yanzh
 *
 */
public class NIOServer {

	private Logger LOG = LoggerFactory.getLogger(NIOServer.class);
	private ServerSocketChannel server;
	private ByteBuffer sendBuffer;
	private ByteBuffer recvBuffer;
	private Selector selector;
	private int port = 9012;
	//初始化服务器
	NIOServer(int port){
		this.port = port;
	  try{
		recvBuffer = ByteBuffer.allocate(1024);	
		sendBuffer = ByteBuffer.allocate(1024);
		server = ServerSocketChannel.open();
		server.socket().bind(new InetSocketAddress(port));
		server.configureBlocking(false);
		selector = Selector.open();
		server.register(selector, SelectionKey.OP_ACCEPT);
		LOG.info("服务器已启动，监控端口号：{}", this.port);
		
		 }catch(IOException e){
			LOG.error("连接时出现IO异常");
		 }
		 	
	 }
	
	   NIOServer(){
		   this(9012);
	   }	
	 //初始化，监听端口  
	public void start(){
		
	  try {
		  
	     	listener();
	     	
	      } catch (IOException e) {
	    	  
		    LOG.info("监听端口IO异常");
	      }
	  
    }
	//一个死循环一直在监听，处理端口事件
	public void listener() throws IOException{
		while(true){
			LOG.info("-----------------------------------------------------");
			LOG.info("1.selectedKeys的值:{}", selector.selectedKeys().size());
			LOG.info("1.registe的值：{}", selector.keys().size());
			int n = selector.select();
			LOG.info("----------------------fengexian1---------------------");
			LOG.info("2.select返回值:{}", n);
			LOG.info("2.selectedKeys的值:{}", selector.selectedKeys().size());
			LOG.info("2.registe的值：{}", selector.keys().size());
			LOG.info("-------------------------------------------------------");
			//没有准备好的通道，其实我觉得根本不会到这里，因为如果没有通道准备好，
			//应该select函数一直阻塞着。
			if(n == 0){
				continue;
			}
			Set<SelectionKey> eventKeys = selector.selectedKeys();
			Iterator<SelectionKey> it = eventKeys.iterator();
			while(it.hasNext()){
				SelectionKey eventKey = it.next();
				it.remove();
				//准备好的通道中取得了通道和选择器的对应关系，利用此关系可以得到通道或者选择器。
				//开始具体处理通道相关内容，连接，读，写等；
				handleKey(eventKey);
			}
	   }
	}
	//处理IO口连接，读写等函数
	public void handleKey(SelectionKey eventKey) throws IOException{
		if(eventKey.isAcceptable()){
			SocketChannel sc = server.accept();
	        LOG.info("新的客户端已经连接成功");
	        sc.configureBlocking(false);
	        sc.register(selector, SelectionKey.OP_READ);
		}
		
		if(eventKey.isReadable()){
			SocketChannel sc = (SocketChannel)eventKey.channel();
			String content = "";
			int n;
			recvBuffer.clear();
			try{
			while((n = sc.read(recvBuffer)) > 0){
				    
			      	content = content + new String(recvBuffer.array(), 0, n);
			     }
			}catch(IOException e){
				eventKey.cancel();
				sc.close();
				return;
			}
			if(n == -1){
				SocketChannel scc = (SocketChannel)eventKey.channel();
				eventKey.channel().close();
				eventKey.cancel();
				LOG.info("客户端{}已经关闭。", scc.socket().getRemoteSocketAddress());
				return;
			}
			LOG.info("receive client input Stirng : {}", content);
			//content = "yanzh";
			if(content.length() > 0){
				sendBuffer.clear();
				sendBuffer.put(content.getBytes());
				sendBuffer.flip();
				sc.write(sendBuffer);								
			}

			//sc.configureBlocking(false);
			//sc.register(selector, SelectionKey.OP_WRITE);
			//eventKey.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
		}
		if(eventKey.isWritable()){
			LOG.info("sendBuffer可写");
			SocketChannel sc = (SocketChannel)eventKey.channel();
			if(sendBuffer.remaining()>0){
			    sc.write(sendBuffer);
			    LOG.info("sendBuffer剩余大小:{}", sendBuffer.remaining());
			}
		}
		
		
	}
        //主函数启动服务
	public static void main(String[] args) {
		new NIOServer().start();
	}
	
}

       学习的过程中对一些概念的理解、常见的问题以及网上一些相关NIO程序中的问题总结：

       1. Selector的select方法在没有准备好的IO操作时，一直处于阻塞状态，直到有可操作的IO准备好。这里的准备好不是指有通道注册在Selector上，而是指在所注册的通道里已经有了相关请求（例如有客户端的连接，客户端输入了数据等）。

       2. 一旦通道注册在Selector上，就是一直注册在其上，除非关闭此通道（调用channe的close方法）。每次select方法返回大于0后，会调用selectionKeys()方法找出所有准备好的选择键，对SelectionKeys的遍历过程中，必须删除SelectionKeys集合中单个SelectionKey,此处与通道的注册毫无关系，注册在通道上的channel仍旧在通道上，删除的只是当前select大于0的单次的准备好的SelectionKey.(显然对SelectionKey的处理是以select返回为周期的，返回一次处理一次，而且每次处理必须把返回的SelectionKey清理干净（放在一个Set中的，由selectionKeys（）方法返回）)。

       3. SelectionKey的interestOps()只是改变已经注册在Selector上那个的通道感兴趣的事件，覆盖原来调用register时注册的感兴趣事件，这里并不是新增注册或者其他，仅仅是对原有状态的改变（疯狂java讲义中，NIO实现非阻塞socket通信中对此方法的使用显然是多余的，不用使用此方法设置成准备下次连接/读 ，照样是可以被连接或者读的，因为本来注册的时候就是对读/连接的事件感兴趣）。

       4.网上有些程序例子在调用完isReadable()方法后，将SelectionKey取出的channel注册为可写register(selector,OP_WRITE),显然这样处理以后，对所注册通道感兴趣事件修改为 了可写，不可以与当前客户端进行下次读了。此通道先前是注册的可读，现在被修改为了可写，是同一个通道，如果正常操作，此处注册为可读｜可写，当然调用interestOps修改也是可以的，和注册是同一个意思（因为是一个已经注册的通道）

       5. 一旦注册了可写通道，select方法返回值永远大于0，因为至少有一个可写的通道注册在上面，所以一直陷入了IsWritable的死循环中，其实也不能叫死循环，其他请求来照样可以处理，只是每次必然会走这个判断，下同

       6.不对socket连接断开的情况做处理的话，一旦连接服务器的客户端TCP/IP连接断开，会使得服务器select方法一直返回值大于0，因为里面一直有一个可读的请求，这样每次都会进入isReadable的判断里，陷入一个可读的死循环。具体需要处理断开的方法是对这个读请求捕获，捕获到以后将此通道关闭。（判断Socketchannel的read方法返回值，如果是-1，表示已经断开，取消当前SelectionKey  .cancel,关闭当前通道  .close()）