Java Socket NIO示例总结

Java NIO是非阻塞IO的实现，基于事件驱动，非常适用于服务器需要维持大量连接，但是数据交换量不大的情况，例如一些即时通信的服务等等，它主要有三个部分组成：

• Channels
• Buffers
• Selectors

Channel有两种ServerSocketChannel 和 SocketChannel，ServerSocketChannel可以监听新加入的Socket连接，SocketChannel用于读和写操作。NIO总是把缓冲区的数据写入通道，或者把通道里的数据读出到缓冲区。

Buffer本质上是一块用于读写的内存，只是被包装成了buffer对象，你可以通过allocateDirect()或者allocate()申请内存空间（allocate分配方式产生的内存开销是在JVM中的，而allocateDirect的分配方式产生的开销在JVM之外，以就是系统级的内存分配，使用allocateDirect尤其注意内存溢出问题），Buffer尤其需要理解三个概念，

capacity、position、limit，capacity是固定大小，position是当前读写位置，limit是一个类似于门限的值，用于控制读写的最大的位置。Buffer的常用方法有clear、compact、flip等等，还有比如Buffer的静态方法wrap等等，这些需要根据capacity、position、limit的值进行理解，上面ifeve上的文章就很详细了，我就不再累述了。

Selector用于检测通道，我们通过它才知道哪个通道发生了哪个事件，所以如果需要用selector的话就需要首先进行register，然后遍历SelectionKey对事件进行处理。它一共有SelectionKey.OP_CONNECT、SelectionKey.OP_ACCEPT、SelectionKey.OP_READ、SelectionKey.OP_WRITE四种事件类型。

我在这里只是粗略的总结，关于NIO的概念 http://ifeve.com/java-nio-all/ 可以看这里。

http://blog.csdn.net/ns_code/article/details/15545057 兰亭风雨的这个demo不错，我直接照搬过来了。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;


public class NIOServer {
    
    private static int BUFF_SIZE=1024;
    private static int TIME_OUT = 2000;
    public static void main(String[] args) throws IOException {
        
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(10083));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        TCPProtocol protocol = new EchoSelectorProtocol(BUFF_SIZE); 
        
        while (true) {
            if(selector.select(TIME_OUT)==0){
                //在等待信道准备的同时，也可以异步地执行其他任务，  这里打印*
                System.out.print("*");  
                continue;  
            }
            Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();
            while (keyIter.hasNext()) {
                SelectionKey key = keyIter.next(); 
                //如果服务端信道感兴趣的I/O操作为accept  
                if (key.isAcceptable()){  
                    protocol.handleAccept(key);  
                }  
                //如果客户端信道感兴趣的I/O操作为read  
                if (key.isReadable()){  
                    protocol.handleRead(key);  
                }  
                //如果该键值有效，并且其对应的客户端信道感兴趣的I/O操作为write  
                if (key.isValid() && key.isWritable()) {  
                    protocol.handleWrite(key);  
                }
                
                //这里需要手动从键集中移除当前的key  
                keyIter.remove(); 
            }
            
        }
    }
}

import java.io.IOException;
import java.nio.channels.SelectionKey;


public interface TCPProtocol {

    void handleAccept(SelectionKey key) throws IOException;

    void handleRead(SelectionKey key) throws IOException;

    void handleWrite(SelectionKey key) throws IOException;

}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;


public class EchoSelectorProtocol implements TCPProtocol {
    
    private int bufSize; // 缓冲区的长度  
    public EchoSelectorProtocol(int bufSize){  
    this.bufSize = bufSize;  
    }

    @Override
    public void handleAccept(SelectionKey key) throws IOException {
        System.out.println("Accept");
        SocketChannel socketChannel = ((ServerSocketChannel)key.channel()).accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufSize));
        
    }

    @Override
    public void handleRead(SelectionKey key) throws IOException {
        SocketChannel clntChan = (SocketChannel) key.channel();  
        //获取该信道所关联的附件，这里为缓冲区  
        ByteBuffer buf = (ByteBuffer) key.attachment();
        buf.clear();
        long bytesRead = clntChan.read(buf);
        //如果read（）方法返回-1，说明客户端关闭了连接，那么客户端已经接收到了与自己发送字节数相等的数据，可以安全地关闭  
        if (bytesRead == -1){   
            clntChan.close();  
        }else if(bytesRead > 0){
            //如果缓冲区总读入了数据，则将该信道感兴趣的操作设置为为可读可写  
            key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);  
        }  
        
    }

    @Override
    public void handleWrite(SelectionKey key) throws IOException {
        // TODO Auto-generated method stub
        ByteBuffer buffer=(ByteBuffer) key.attachment();
        buffer.flip();
        SocketChannel clntChan = (SocketChannel) key.channel();  
        //将数据写入到信道中  
        clntChan.write(buffer);  
        if (!buffer.hasRemaining()){
            
        //如果缓冲区中的数据已经全部写入了信道，则将该信道感兴趣的操作设置为可读  
          key.interestOps(SelectionKey.OP_READ);  
        } 
        //为读入更多的数据腾出空间  
        buffer.compact();   
        
    }

} 

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;


public class NIOClient {
    
    public static void main(String[] args) throws IOException {
        SocketChannel clntChan = SocketChannel.open();
        clntChan.configureBlocking(false);
        if (!clntChan.connect(new InetSocketAddress("localhost", 10083))){  
            //不断地轮询连接状态，直到完成连接  
            while (!clntChan.finishConnect()){  
                //在等待连接的时间里，可以执行其他任务，以充分发挥非阻塞IO的异步特性  
                //这里为了演示该方法的使用，只是一直打印"."  
                System.out.print(".");    
            }  
         }
        
        //为了与后面打印的"."区别开来，这里输出换行符  
        System.out.print("\n");  
        //分别实例化用来读写的缓冲区  
        
        ByteBuffer writeBuf = ByteBuffer.wrap("send send send".getBytes());
        ByteBuffer readBuf = ByteBuffer.allocate("send".getBytes().length-1);
        
        while (writeBuf.hasRemaining()) {
            //如果用来向通道中写数据的缓冲区中还有剩余的字节，则继续将数据写入信道  
                clntChan.write(writeBuf);  
            
        }
        StringBuffer stringBuffer=new StringBuffer(); 
        //如果read（）接收到-1，表明服务端关闭，抛出异常  
            while ((clntChan.read(readBuf)) >0){
                readBuf.flip();
                stringBuffer.append(new String(readBuf.array(),0,readBuf.limit()));
                readBuf.clear();
            }  
        
      //打印出接收到的数据  
        System.out.println("Client Received: " +  stringBuffer.toString());  
        //关闭信道  
        clntChan.close();  
    }
}