NIO实践-心跳检测

　　今天将NIO实现简版心跳检测功能做一下笔记，旨在加深理解NIO客户端与服务端交互的状态监听，以及固定的编码套路。其实跟产品级的心跳检测（包括但不限于token验证、服务性能参数获取等）尚且存在差距。暂且忽略。

一、方案设计

 二、服务端代码实现

public class HeartBeatServer {
    @Test
    public void Test() throws IOException {
        // 构建服务端Socket
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 绑定端口
        serverSocketChannel.bind(new InetSocketAddress(8080));
        // 设置为异步Socket
        serverSocketChannel.configureBlocking(false);
        // 建立服务端多路复用器
        Selector selector = Selector.open();
        // 服务端Socket注册接入监听
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        try {
            dispatch(selector, serverSocketChannel);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void dispatch(Selector selector, ServerSocketChannel serverSocketChannel) throws IOException {
        while (true) {
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            if (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                if (!key.isValid()) {
                    continue;
                }
                if (key.isAcceptable()) {
                    // 服务端通过serverSocketChannel.accept()不断的处理新的客户端接入
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    // 注册新接入的客户端channel为可读，即等待读取客户端发送心跳信息
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    channel.read(buffer);
                    if (buffer.hasRemaining() && buffer.get(0) == 4) {
                        channel.close();
                        System.out.println("关闭管道：" + channel);
                        break;
                    }
                    System.out.println(new String(buffer.array(), 0, 20));
                    buffer.put(String.valueOf(System.currentTimeMillis()).getBytes());
                    buffer.flip();
                    channel.write(buffer);
                }
            }
        }
    }
}

三、客户端代码

public class HeartBeatClient1 {
    @Test
    public void Test() throws IOException, InterruptedException {
        // 初始化客户端Socket
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        Selector selector = Selector.open();
        // 注册连接成功事件监听
        socketChannel.register(selector, SelectionKey.OP_CONNECT);
        // 发起连接
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
        while (true) {
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            if (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();;
                if (!key.isValid()) {
                    continue;
                }
                // 当连接到服务端成功时，变更监听为 可写
                if (key.isConnectable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    channel.finishConnect();
                    key.interestOps(SelectionKey.OP_WRITE);
                }
                // 写入心跳信息，然后变更监听为 可读，即等待读取服务端 回执
                if (key.isWritable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    channel.write(ByteBuffer.wrap("heartBeatClient_1__".getBytes()));
                    key.interestOps(SelectionKey.OP_READ);
                }
                // 读取服务端回执后，然后变更监听为 可写，准备下一次写入心跳信息
                if (key.isReadable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(64);
                    channel.read(buffer);
                    buffer.flip();
                    System.out.println(new String(buffer.array(), 0, buffer.limit()));
                    key.interestOps(SelectionKey.OP_WRITE);
                    Thread.sleep(2000);
                }
            }
        }
    }
}

四、总结

　　其实这个Demo虽然很糙，但是基本囊括了原生NIO编程的常规套路。总结如下：

　　服务端：

　　　　<1>、构建ServerSocketChannel。并设置为非阻塞。

　　　　<2>、构建Selector。并注册服务端accept监听，来等待客户端接入事件。

　　　　<3>、监听到客户端接入后，将客户端接入的SocketChannel注册到Selector，并监听该SocketChannel的Read事件，即等待读取客户端发送的数据。

　　　　<4>、对于服务端来说，可能会有多个客户端接入，所以每次Selector轮询，都要从key里边取channel。

　　客户端：

　　　　<1>、构建客户端SockeChannel，并设置为非阻塞。

　　　　<2>、构建Selector。并注册客户端connect监听。

　　　　<3>、客户端发起connect操作，如果连接成功，则会触发<2>的监听。

　　　　<4>、客户端自始至终都是只有一个channel，所以不用每次都从key里边取，即始终都是构建时的那个channel对象，另外，每次执行完操作都要考虑下一步要监听的操作。