Java Socket NIO示例总结

时间：2023-03-05 17:23:37

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();

    }

}

相关文章