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的思路有一定的了解，尽管现在还不熟悉，但是认真看过，就会发现其套路脉络还是很清楚的。