Java NIO实例

/**NIOServer.java**/
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.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer {
    public static void main(String[] args) throws IOException {
        //1. 打开一个选择器
        Selector selector = Selector.open();

        //2. 打开一个ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //3. 配置异步模式
        serverSocketChannel.configureBlocking(false);
        //4. 绑定到TCP端口上，注意ServerSocketChannel不提供bind方法
        //需要使用ServerSocketChannel 内部的socket对象对应的bind方法
        serverSocketChannel.socket().bind(new InetSocketAddress("127.0.0.1",12122));

        //5. 注册
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //6. 服务器循环，调用Selector.select()方法等待IO事件，如果返回值为0，表明没有事件发生
        while (true) {
            //如果select()带参数，它将不会堵塞到等有感兴趣的数据过来
            if (selector.select() == 0) {
                System.out.println("Nothing to do!");
                continue;
            }

            //获得连接已选键
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();

                //如果是事件是”通道上有请求“
                if (key.isAcceptable()) {
                    //相应的处理是通过accept()操作获得SocketChannel对象，并配置对象的异步工作方式
                    SocketChannel channel = serverSocketChannel.accept();

                    //设置异步工作模式、注册到选择器中，注册事件为通道可读 SelectionKeys.OP_READ
                    channel.configureBlocking(false);
                    SelectionKey connkey = channel.register(selector, SelectionKey.OP_READ);
                    //根据注册分到的SelectionKey 对象构造连接对象，并将对象作为SelectionKey对象附件
                    NIOConnection conn = new NIOConnection(connkey);
                    connkey.attach(conn);
                }
                //key有效，即通道未关闭，并且为可读的OP_READ
                if (key.isValid() && key.isReadable()) {
                    NIOConnection conn = (NIOConnection) key.attachment();
                    conn.handleRead();
                }
                //key有效，即通道未关闭，并且为可写的 OP_WRITE
                if (key.isValid() && key.isWritable()) {
                    NIOConnection conn = (NIOConnection) key.attachment();
                    conn.handleWrite();
                }
            }
        }
    }
}

/**NIOConnection.java**/
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

public class NIOConnection {
    private SelectionKey key;
    private SocketChannel channel;
    private ByteBuffer buffer;

    public NIOConnection(SelectionKey key) {
        this.buffer = ByteBuffer.allocate(1024);
        this.key = key;
        this.channel = (SocketChannel) key.channel();
    }

    /**
     * 读操作
     * @throws IOException
     */
    public void handleRead() throws IOException {
        int byteRead = channel.read(buffer);

        if (byteRead == -1) {
            //对方已关闭socket，服务器就将通道关闭
            channel.close();
        }else {
            //有数据可读，此时设置感兴趣的I/O事件为读或写，
            //读出了一部分数据，就说嘛有空间可以写了，当然还有可能有其他数据可读
            key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);

        }
    }

    public void handleWrite() throws IOException {
        //要开始读数据了，就得先把数据的开始索引，也就是当前索引position，改为数据的开始位置，
        //在此之前，得先把limit的改为position,position所在位置是数据的下一个写入位置，
        // 把限制limit设置为position
        // 结合上面position ~ limit就是当前的全部数据的位置
        buffer.flip();
        //开始写出
        System.out.println("收到的数据：" + Charset.forName("UTF-8").decode(buffer).toString());
        channel.write(buffer);

        //之后判断是否还有数据存在，如果没数据了，就可以将其设置为只可以读了
        if (!buffer.hasRemaining()) {
            key.interestOps(SelectionKey.OP_READ);
        }
        //写完后，有可能还有数据剩余，就将数据移到buffer的最前面
        buffer.compact();
    }