第一章 java nio三大组件与使用姿势

本案例来源于《netty权威指南》

一、三大组件

• Selector：多路复用器。轮询注册在其上的Channel，当发现某个或者多个Channel处于“就绪状态”后（accept接收连接事件、connect连接完成事件、read读事件、write写事件），从阻塞状态返回就绪的Channel的SelectionKey集合，之后进行IO操作。
• Channel：封装了socket。
  • ServerSocketChannel：封装了ServerSocket，用于accept客户端连接请求；
  • SocketChannel：一对SocketChannel组成一条虚电路，进行读写通信
• Buffer：用于存取数据，最主要的是ByteBuffer
  • position：下一个将被操作的字节位置
  • limit：在写模式下表示可以进行写的字节数，在读模式下表示可以进行读的字节数
  • capacity：Buffer的大小

二、服务端代码

1、服务端启动类

 public class Server {
     public static void main(String[] args) throws IOException {
         new Thread(new ServerHandler(), "server-1").start();
     }
 }

创建一个任务ServerHandler，然后创建一条线程，启动执行该任务。

2、逻辑处理类

 public class ServerHandler implements Runnable {
     private Selector selector;
     private ServerSocketChannel ssChannel;

     public ServerHandler(int port) {
         try {
             //等价于 Selector selector = SelectorProvider.provider().openSelector();
             selector = Selector.open();
             //等价于 SelectorProvider.provider().openServerSocketChannel()
             ssChannel = ServerSocketChannel.open();
             ssChannel.configureBlocking(false);
             ssChannel.bind(new InetSocketAddress(port), 1024);
             ssChannel.register(selector, SelectionKey.OP_ACCEPT);
         } catch (IOException e) {
             e.printStackTrace();
             System.exit(1);
         }
     }

     public void run() {
         for (; ; ) {
             try {
                 selector.select();
                 Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                 while (it.hasNext()) {
                     SelectionKey key = it.next();
                     it.remove();
                     handleInput(key);
                 }
             } catch (Throwable t) {
                 t.printStackTrace();
             }
         }

     }

     private void handleInput(SelectionKey key) throws IOException {
         if (key.isValid()) {
             // 处理新接入的请求消息
             if (key.isAcceptable()) {
                 // Accept the new connection
                 ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                 SocketChannel sc = ssc.accept();
                 sc.configureBlocking(false);
                 // Add the new connection to the selector
                 sc.register(selector, SelectionKey.OP_READ);
             }
             if (key.isReadable()) {
                 // Read the data
                 SocketChannel sc = (SocketChannel) key.channel();
                 ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                 int readBytes = sc.read(readBuffer);
                 if (readBytes > 0) {
                     readBuffer.flip();
                     byte[] bytes = new byte[readBuffer.remaining()];
                     readBuffer.get(bytes);
                     String body = new String(bytes, "UTF-8");
                     System.out.println("The time server receive order : "
                             + body);
                     String currentTime = "QUERY TIME ORDER"
                             .equalsIgnoreCase(body) ? new java.util.Date(
                             System.currentTimeMillis()).toString()
                             : "BAD ORDER";
                     doWrite(sc, currentTime);
                 } else if (readBytes < 0) {
                     // 对端链路关闭
                     key.cancel();
                     sc.close();
                 } else
                     ; // 读到0字节，忽略
             }
         }
     }

     private void doWrite(SocketChannel channel, String response)
             throws IOException {
         if (response != null && response.trim().length() > 0) {
             byte[] bytes = response.getBytes();
             ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
             writeBuffer.put(bytes);
             writeBuffer.flip();
             channel.write(writeBuffer);
         }
     }
 }

步骤：

1、创建一个Selector和ServerSocketChannel实例

2、配置ServerSocketChannel实例为非阻塞

3、ServerSocketChannel实例bind端口

4、将ServerSocketChannel实例注册到selector上，监听OP_ACCEPT事件

下面的任务在Server创建的新的线程中执行，不影响主线程执行其他逻辑

5、之后进入死循环

5.1、使用select.select()阻塞等待就绪事件（这里是等待OP_ACCEPT事件），一旦有有就绪事件到达，立即向下执行

5.2、使用selector.selectedKeys()获取已经就绪的SelectionKey（即OP_ACCEPT/OP_CONECT/OP_READ/OP_WRITE）集合，之后循环遍历

5.3、从迭代器删除该SelectionKey，防止下一次再被遍历到

5.4、如果SelectionKey==OP_ACCEPT，则通过ServerSocketChannel.accept()创建SocketChannel，该SocketChannel是后续真正的与客户端的SocketChannel进行通信的实体

5.5、配置新创建的SocketChannel实例为非阻塞，然后将该SocketChannel实例注册到selector实例上，监听OP_READ事件

5.6、等客户端发出请求数据时，此处监听到SelectionKey==OP_READ，则创建ByteBuffer实例，将SocketChannel中的数据读取到ByteBuffer中，然后再创建ByteBuffer将信息写回到SocketChannel（也就是说数据的读写一定要通过Buffer）

三、客户端代码

1、客户端启动类

 public class Client {
     public static void main(String[] args) {
         new Thread(new ClientHandler("127.0.0.1", 8080), "client-1").start();
     }
 }

创建一个任务ClientHandler，然后创建一条线程，启动执行该任务。

2、逻辑处理类

 public class ClientHandler implements Runnable {
     private String host;
     private int port;

     private Selector selector;
     private SocketChannel socketChannel;

     public ClientHandler(String host, int port) {
         this.host = host;
         this.port = port;
         try {
             selector = Selector.open();
             socketChannel = SocketChannel.open();
             socketChannel.configureBlocking(false);
         } catch (IOException e) {
             e.printStackTrace();
             System.exit(1);
         }
     }

     public void run() {
         try {
             doConnect();
         } catch (IOException e) {
             e.printStackTrace();
             System.exit(1);
         }
         while (true) {
             try {
                 selector.select();
                 Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                 while (it.hasNext()) {
                     SelectionKey key = it.next();
                     it.remove();
                     handleInput(key);
                 }
             } catch (Exception e) {
                 e.printStackTrace();
                 System.exit(1);
             }
         }
     }

     private void handleInput(SelectionKey key) throws IOException {
         if (key.isValid()) {
             // 判断是否连接成功
             SocketChannel sc = (SocketChannel) key.channel();
             if (key.isConnectable()) {
                 if (sc.finishConnect()) {
                     sc.register(selector, SelectionKey.OP_READ);
                     doWrite(sc);
                 } else
                     System.exit(1);// 连接失败，进程退出
             } else if (key.isReadable()) {
                 ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                 int readBytes = sc.read(readBuffer);
                 if (readBytes > 0) {
                     readBuffer.flip();
                     byte[] bytes = new byte[readBuffer.remaining()];
                     readBuffer.get(bytes);
                     String body = new String(bytes, "UTF-8");
                     System.out.println("Now is : " + body);
                 } else if (readBytes < 0) {
                     // 对端链路关闭
                     key.cancel();
                     sc.close();
                 } else
                     ; // 读到0字节，忽略
             }
         }

     }

     private void doConnect() throws IOException {
         // 如果直接连接成功，则注册到多路复用器上，发送请求消息，读应答
         if (socketChannel.connect(new InetSocketAddress(host, port))) {
             socketChannel.register(selector, SelectionKey.OP_READ);
             doWrite(socketChannel);
         } else
             socketChannel.register(selector, SelectionKey.OP_CONNECT);
     }

     private void doWrite(SocketChannel sc) throws IOException {
         byte[] req = "QUERY TIME ORDER".getBytes();
         ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
         writeBuffer.put(req);
         writeBuffer.flip();
         sc.write(writeBuffer);
         if (!writeBuffer.hasRemaining())
             System.out.println("Send order 2 server succeed.");
     }
 }

步骤：

1、创建一个Selector和SocketChannel实例

2、配置SocketChannel实例为非阻塞

下面的任务在Cilent创建的新的线程中执行，不影响主线程执行其他逻辑

3、SocketChannel.connect连接到server端，如果连接没有马上成功，将该SocketChannel实例注册到selector上，监听OP_CONNECT事件；如果连接成功，将该SocketChannel实例注册到selector上，监听OP_READ事件，之后写数据给server端

4、之后进入死循环

4.1、使用select.select()阻塞等待就绪事件，一旦有有就绪事件到达，立即向下执行

4.2、使用selector.selectedKeys()获取已经就绪的SelectionKey（即OP_ACCEPT/OP_CONECT/OP_READ/OP_WRITE）集合，之后循环遍历

4.3、从迭代器删除该SelectionKey，防止下一次再被遍历到

4.4、如果SelectionKey==OP_CONNECT，将该SocketChannel实例注册到selector上，监听OP_READ事件，之后写数据给server端；如果监听到SelectionKey==OP_READ，则创建ByteBuffer实例，将SocketChannel中的数据读取到ByteBuffer中