netty权威指南学习笔记一——NIO入门（3）NIO

　　经过前面的铺垫，在这一节我们进入NIO编程，NIO弥补了原来同步阻塞IO的不足，他提供了高速的、面向块的I/O，NIO中加入的Buffer缓冲区，体现了与原I/O的一个重要区别。在面向流的I/O中，可以将数据直接写入或者将数据直接读到Stream对象中。下面看一些概念

　　Buffer缓冲区

　　而在NIO中，所有数据都是用缓冲区处理的，在读取数据时，直接读到缓冲区，在写数据时，也是写到缓冲区，任何时候访问NIO中的数据，都是通过缓冲区进行操作。最常用的是个ByteBuffer缓冲区，他提供了一组功能用于操作字节数组。

　　Channel通道

　　Channel 是一个通道，网络数据通过它进行读写，通道和流的区别在于通道是双向的，流是单向的，一个流必须是读或者写，而通道则可以读写同时进行。Channel可以分为用于网路读写的SelectableChannel和用于文件操作的FileChannel。

　　Selector多路复用器

　　首先强调一点，多路复用器对于NIO编程非常重要，非常重要，多路复用器提供选择已经就绪的任务的能力。简单的讲，Selector会不断的轮询注册在其上的Channel，如果某个Channel上面发生读或者写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以获取就绪Channel的集合，进行后续I/O操作。一个多路复用器可以轮询多个Channel,意味着只需要一个线程负责selector轮询，就可以接入成千上万个客户端。

现在改造上一节的代码使其成为NIO server端

 package com.example.biodemo;

 import java.io.*;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class TimeServer {
     public static void main(String[] args) throws IOException {
         int port = 8090;
         if (args != null && args.length > 0) {
             try {
                 port = Integer.valueOf(args[0]);
             } catch (NumberFormatException e) {
                 port = 8090;
             }
         }
 //        创建多路复用线程类并初始化多路复用器，绑定端口等以及轮询注册功能
         MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
 //        启动多路复用类线程负责轮询多路复用器Selector，IO数据处理等操作
         new Thread(timeServer, "NIO-MultiplexerTimeSever-001").start();

 // ===================以下内容注释掉=================================

        /* ServerSocket server = null;
         try {
             server = new ServerSocket(port);
             System.out.println("the timeServer is start in port :" + port);
             Socket socket = null;
 //           引入线程池start
             TimeServerHandlerExecutePool singleExecutor = new TimeServerHandlerExecutePool(50,10000);
             while (true) {
                 socket = server.accept();
 //           替换BIO中new Thread(new TimeServerHandler(socket)).start();为下一行代码
                 singleExecutor.execute(new TimeServerHandler(socket));
 //           引入线程池end

             }
         } finally {
             if (server != null) {
                 System.out.println("the time server close");
                 server.close();
                 server = null;
             }
         }*/

     }
 }

多路复用类代码，其注册轮询功能及请求消息处理返回在这里进行

 package com.example.biodemo;

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.Set;

 public class MultiplexerTimeServer implements Runnable {
     //    定义多路复用器
     private Selector selector;
     //    定义ServerSocketChannel
     private ServerSocketChannel servChannel;
     //    定义停止标识
     private boolean stop;

     //    构造函数初始化多路复用器、并绑定监听端口
     public MultiplexerTimeServer(int port) {
         try {
 //            打开一个多路复用器
             selector = Selector.open();
 //            打开ServerSocketChannel通道
             servChannel = ServerSocketChannel.open();
 //            绑定监听端口号，并设置backlog为1024
             servChannel.socket().bind(new InetSocketAddress(port), 1024);
 //            设置severSocketChannel为异步非阻塞模式
             servChannel.configureBlocking(false);
 //            将ServerSocketChannel 注册到Reactor 线程的多路复用器Selector上，监听ACCEPT事件,并返回一个SelectionKey类型的值
             SelectionKey selectionKey = servChannel.register(selector, SelectionKey.OP_ACCEPT);
             System.out.println("The time server is start in port:" + port);
         } catch (IOException ioe) {
             ioe.printStackTrace();
 //            资源初始化失败则退出
             System.exit(1);
         }
     }

     public void stop() {
         this.stop = true;
     }

     @Override
     public void run() {
 //        在线程中遍历轮询多路复用器selector
         while (!stop) {
             try {
              /*selector.select();选择一些I/O操作已经准备好的channel。每个channel对应着一个key。这个方法是一个阻塞的选择操作。
               当至少有一个通道被选择时才返回。当这个方法被执行时，当前线程是允许被中断的。*/
 //            该方法是阻塞的，选择一组键，其相应的通道已为 I/O 操作准备就绪。最多等1s，如果还没有就绪的就返回0
             /*如果 timeout为正，则select(long timeout)在等待有通道被选择时至多会阻塞timeout毫秒
               如果timeout为零，则永远阻塞直到有至少一个通道准备就绪。
               timeout不能为负数*/
                 selector.select(1000);
 //            当有处于就绪状态的channel时，返回该channel的selectionKey集合，此通道是已准备就绪的键集，已选择键集（I/O操作已就绪返回key）始终是键集的一个子集。
                 Set<SelectionKey> selectionKeys = selector.selectedKeys();
                 Iterator<SelectionKey> it = selectionKeys.iterator();
 //            Selector如果发现channel有OP_ACCEPT或READ事件发生，下列遍历就会进行。
                 SelectionKey key = null;
                 while (it.hasNext()) {
                     // 来一个事件 第一次触发一个accepter线程，SocketReadHandler
                     key = it.next();
 //                    从iterator中移除该元素
                     it.remove();
                     try {
 //                      去对该已经准备就绪的I/O操作进行处理
                         dispatch(key);
                     } catch (Exception e) {
 //                        删除处理完不为空的键，关闭相关通道
                         if (key != null) {
                             key.cancel();
                             if (key.channel() != null) {
                                 key.channel().close();
                             }
                         }
                     }
                 }
             } catch (IOException ioe1) {
                 ioe1.printStackTrace();
             }
         }
 //        最后关闭多路复用器
         if (selector != null) {
             try {
                 selector.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 //该方法用于处理轮询到的I/O已经就绪的SelectionKey键
     private void dispatch(SelectionKey key) throws IOException {
         if (key.isValid()) {
 //            处理请求接入的信息
             if (key.isAcceptable()) {
 //                接受新连接，通过SelectionKey获取其通道
                 ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
 //                接收客户端连接请求并创建SocketChannel实例
                 SocketChannel sc = ssc.accept();
                 sc.configureBlocking(false);
 //                添加新连接到多路复用器上
                 sc.register(selector, SelectionKey.OP_READ);
             }
             if (key.isReadable()) {
 //                本方法体读取客户端发来的请求数据
                 SocketChannel sc = (SocketChannel) key.channel();
 //                开辟一个缓冲区，这里开辟了1M
                 ByteBuffer readBuffer = ByteBuffer.allocate(1024);
 //                读取请求码流，返回值>0,读到字节数，返回值=0，没有读到字节数，返回值<0,说明链路已经关闭，
 //                需要关闭SocketChannel
                 int readBytes = sc.read(readBuffer);
                 if (readBytes > 0) {
 //                    读到字节数后的解码操作，对 readBuffer 进行 flip 操作， 作用是将缓冲区当前的 limit 设置为 position
 //                    position 设置为 0，用于后续对缓冲区的读取操作。
                     readBuffer.flip();
 //                    根据缓冲区的可读的字节个数创建字节数组
                     byte[] bytes = new byte[readBuffer.remaining()];
 //                   调用 ByteBuffer的 get 操作将缓冲区可读的字节数复制到新创建的字节数组中
                     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 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);
 //            进行flip操作，作用同上面
             writeBuffer.flip();
 //            将缓冲区中的字节数组发送出去
             channel.write(writeBuffer);
         }
     }
 }

下面是客户端的详细代码及注释，需要注意的是在客户端代码判断是否连接成功时需要进行两步判断（需要判断连接状态和连接结果是否成功），第二步判断成功需要注册状态，否则客户端发送不了消息。

 package com.example.biodemo;

 import java.io.*;
 import java.net.Socket;

 public class TimeClient {
     public static void main(String[] args) {
         int port = 8090;
         if (args != null && args.length > 0) {
             try {
                 port = Integer.valueOf(args[0]);
             } catch (NumberFormatException ne) {
                 port = 8090;
             }
         }
         new Thread(new TimeClientHandles("127.0.0.1",port),"TimeClient-001").start();
       /* 代码改造注释掉以下代码
        Socket socket = null;
         BufferedReader in = null;
         PrintWriter out = null;
         try {
             socket = new Socket("127.0.0.1", port);
             System.out.println(socket.getInputStream());
             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             out = new PrintWriter(socket.getOutputStream(), true);
             out.println("QUERY TIME ORDER");
             System.out.println("send order 2 server succeed.");
             String resp = in.readLine();
             System.out.println("now is :" + resp);
         } catch (IOException e1) {

         } finally {
             if (out != null) {
                 out.close();
                 out = null;
             }

             if (in != null) {
                 try {
                     in.close();
                 } catch (IOException e2) {
                     e2.printStackTrace();
                 }
                 in = null;
                 if (socket != null) {
                     try {
                         socket.close();
                     } catch (IOException e3) {
                         e3.printStackTrace();
                     }

                 }
                 socket = null;
             }
         }*/
     }
 }

客户端HandleInput代码

 package com.example.biodemo;

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.SocketChannel;
 import java.util.Iterator;
 import java.util.Set;

 //该类用来处理异步连接和读写操作
 public class TimeClientHandles implements Runnable {
     private String host;
     private int port;
     private Selector selector;
     private SocketChannel socketChannel;
     private volatile boolean stop;

     //    构造函数初始化并连接服务器
     public TimeClientHandles(String host, int port) {
         this.host = host == null ? "127.0.0.1" : host;
         this.port = port;
         try {
             selector = Selector.open();
             socketChannel = SocketChannel.open();
             socketChannel.configureBlocking(false);
         } catch (IOException e) {
             e.printStackTrace();
             System.exit(1);
         }
     }

     @Override
     public void run() {
 //        发送连接请求
         try {
             doConnection();
         }catch (Exception e){
             e.printStackTrace();
             System.exit(1);
         }
 //      在循环体内轮询多路复用器Selector,当有就绪的Channel时，执行handleInput(key);
         while (!stop) {
             try {
                 selector.select(1000);
                 Set<SelectionKey> keys = selector.selectedKeys();
                 Iterator<SelectionKey> it = keys.iterator();
                 SelectionKey key = null;
                 while (it.hasNext()) {
                     key = it.next();
                     it.remove();
                     try {
                         handleInput(key);
                     } catch (Exception e) {
                         if (key != null) {
                             key.cancel();
                             if (key.channel() != null) {
                                 key.channel().close();
                             }
                         }
                     }

                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }

         }
     }

     private void handleInput(SelectionKey key) throws IOException {
         if (key.isValid()) {
 //            判断是否连接成功（需要判断连接状态和连接结果是否成功）
             SocketChannel sc = (SocketChannel) key.channel();
 //            连接状态判断，是连接状态返回true，判断的是服务端是否已经返回ACK应答消息
             if (key.isConnectable()) {
 //                是连接状态则需要对连接结果进行判断，如果true，说明客户端连接成功，如果flase则抛出IO异常,连接失败
                 if(sc.finishConnect()){
                     sc.register(selector, SelectionKey.OP_READ);
                     doWrite(sc);
                 }else {
 //                    连接失败则进程退出
                     System.exit(1);
                 }
             }
             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);
                     this.stop = true;
                 } else if (readBytes < 0) {
                     key.cancel();
                     sc.close();
                 } else {
                     ;//没有读到字节什么都不做
                 }
             }
         }
     }

     private void doConnection() {
         try {
 //            如果直接连接成功，则注册到多路复用器上，并注册SelectionKey.OP_READ,发送请求消息，读应答
             if (socketChannel.connect(new InetSocketAddress(host, port))) {
                 socketChannel.register(selector, SelectionKey.OP_READ);
                 doWrite(socketChannel);
             } else {
 //                连接不成功说明服务端没有返回TCP握手应答消息，但是不代表连接失败，注册socketChannel到多路复用器上，
 //                并注册SelectionKey.OP_CONNECT,当服务器返回TCP syn-ack 消息后，Selector 就能轮询到这个SocketChannel
 //                处于连接就绪状态
                 socketChannel.register(selector, SelectionKey.OP_CONNECT);
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

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

     }
 }

　　通过上面代码的学习，我们对NIO的思路有一定的了解，尽管现在还不熟悉，但是认真看过，就会发现其套路脉络还是很清楚的。