30分钟掌握NIO

NIO对文件的操作 

先来看一段BIO也就是传统IO复制文档的代码片段。

   public static void bioCopy() throws Exception {
        //读取这个文件
        FileInputStream in = new FileInputStream("C:\Users\szwb295\Desktop\1.txt");
        //往这个文件写入内容
        FileOutputStream out = new FileOutputStream("C:\Users\szwb295\Desktop\2.txt");


        //输入流缓冲区
        BufferedInputStream bufferedInputStream = new BufferedInputStream(in);
        //输出流缓冲区
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(out);

        //临时保存字节，字节数组的 Capacity（容量） 为1024 最多一次放1024个字节
        byte[] b = new byte[3];

        //一次读取到的字节数量
        int len;
        /*
         * 例如 b的Capacity为3，总共需要读取的数据10,则read()方法会执行5次len分别为3,3,3,1,-1
         * */
        while ((len = bufferedInputStream.read(b)) != -1) {
            //将每次放入字节数组中的数据写入到流中，position（位置），0开始写，最大限度（limit）为len
            bufferedOutputStream.write(b, 0, len);
        }

        //关闭流
        bufferedInputStream.close();
        bufferedOutputStream.close();

    }

下面看NIO复制文件代码片段。

 public static void nioCopy() throws Exception {

        // 1. 输入流
        FileInputStream fin = new FileInputStream("C:\Users\szwb295\Desktop\a.txt");

        //输出流
        FileOutputStream fout = new FileOutputStream("C:\Users\szwb295\Desktop\b.txt");

        // 2. 获取数据源的输入输出通道
        FileChannel fcin = fin.getChannel();


        FileChannel fcout = fout.getChannel();

        // 3. 创建 缓冲区 对象 参数为Buffer的  Capacity（容量）代表这个缓冲区最大存储字节数
        ByteBuffer buff = ByteBuffer.allocate(3);


        int len;
        // 4. 从通道读取数据 & 写入到缓冲区
        // 注：若 以读取到该通道数据的末尾，则返回-1
        while ((len = fcin.read(buff)) != -1) {
            // 5. 将 limit设置为当前位置然后将 position设置为0
            buff.flip();

            // 6. 从 Buffer 中读取数据 & 传出数据到通道
            fcout.write(buff);

            //将 limit设置为当前位置然后将 position设置为0
            buff.flip();
        }

        //直接关闭FileInputStream会自动关闭channel
        fin.close();
        //同上
        fout.close();
    }

以上NIO代码片段包含两部分内容 Buffer（缓冲区）和Channel（通道）。

我们从InputStream和OutputStream中获取两个通道，通道是连接输入/输出的一端，另一端则是Buffer。

例如 fcin.read(buff)这一行代码是从磁盘中将文件内容读取到Buffer。fcout.write(buff);则是从缓冲区将数据写入到磁盘中。如下图

Channel有多种类型，以上我们通过InputStream/OutputStream获取的是对文件操作的管道。在API文档中还有针对Socket的通道 ServerSocketChannel SocketChannel

ByteBuffer buff = ByteBuffer.allocate(3);创建一个字节类型的缓冲区，其Capacity为3，也就是最大容量为3个字节

Buffer有三个重要的属性：Capacity（容量）代表一个缓冲器最多存储的内容。Position（标记位）一个指针，指向下一个操作的位置，

例如读一个Capacity为10的Buffer，起始位的Position是0每读一个位置增加1。若Position为10则不能继读，0-9。Limit（限制位）代表可以对当前缓冲区操作的最大位置-1

，例如当前缓冲区的Capacity为10，若Limit为5则表示无论是读或写只能到4的位置。

接下来的while循环读，就和BIO的逻辑一样了，若读的返回值不是-1则表示有值，读到的数据放到Buffer中，若Buffer满了，则进入循环体。此时Position，Capacity，Limit一样。

接下来我们要执行写操作，将Buffer中的数据写入到输出流中，我们执行了。flip()方法。该方法会将Limit更改为Position，然后将Position更改为0，表示从0开始，直到Position和Limit

一致则表示已经把缓冲区的数据全部复制到输入流了。此时我们又要往缓冲区写数据，所以在调用flip()将Position更改为0，表示从0开始写入缓冲区，直到Position和Limit。然后诸如

此循环。

其实上边代码循环体最后一个flip()方法使用的不得当。思考一个问题，设缓冲区Capacity为10，若最后一次往Buffer中放数据

的个数为5在循环体内取数据也是5.那么最后一个flip()会将Limit置为5。然后循环结束。但如果我们在循环外想在此使用该Buffer

那无论是读或写最多只能操作5个空间的位置，因为Limit()为5。

Buffer还有两个方法。clear()这个方法将Limit置为Capacity，将Position置为0。rewind()这个方法Limit位置不变，只将Position置为0。

NIO网络编程

关于BIO网络编程，也就是Socket的代码已经弊端，在我的上一篇博客中有写到，感兴趣的可以去看。这里直接贴出来NIO的网络编程。

package com.datang.pet.control.test;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOClient {
    public static void main(String[] args) throws Exception {

        for (int i = 0; i < 20; i++) {
            new Thread() {
                @Override
                public void run() {
                    send();
                }
            }.start();
        }
    }

    public static void send() {
        try {
            //获取一个客户端的通道
            SocketChannel clientChannel = SocketChannel.open();

            //设置非阻塞客户端
            clientChannel.configureBlocking(false);

            //服务端的地址
            InetSocketAddress serverAddr = new InetSocketAddress("localhost", 9999);

            /*
             * 当connect()正确的连接上服务端后，才会返回true
             * 因为上边设置了非阻塞的，意味着无论连接成功或者
             * 失败都会执行后续代码，若连接失败则后边发送数据
             * 也会失败。
             * finishConnect()则是刷新连接，尝试重新连接。
             * 如果连接成功返回 true。
             * */
            if (!clientChannel.connect(serverAddr)) {
                while (!clientChannel.finishConnect()) {
                    System.out.println("正在尝试重新连接服务端");
                    continue;
                }
            }


            ByteBuffer byteBuffer = ByteBuffer.wrap("我是客户端".getBytes("UTF-8"));

            //发送消息
            clientChannel.write(byteBuffer);

            System.out.println("已发送消息");

            //将缓存区的limit设置为capacity，将position设为0
            byteBuffer.clear();

            //获取服务端的响应信息
            clientChannel.read(byteBuffer);

            System.out.println(new String(byteBuffer.array(),"UTF-8"));

            System.in.read();

        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

上边代码片段为客户端代码。为了模拟多客户的情况，使用了循环+线程模拟。

clientChannel.configureBlocking(false);这行代码设置了客户端的是否是阻塞的。如果true，则表示是阻塞客户端

意味着在调用 clientChannel.connect(serverAddr)时，如果连接不上服务端，则会一直阻塞，直到超时。我们选择

的是非阻塞客户端。这意味着调用 clientChannel.connect(serverAddr) 无论是否连接上都会继续执行剩余代码。

那肯定是会报错的，没有连接上服务端，发送接收消息都会失败。所以我们使用while循环，如果连接失败则尝试重新连接。

剩下的代码逻辑上和Socket并无差别。

package com.datang.pet.control.test;


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.Iterator;
import java.util.Set;

public class NIOServer {
    public static void main(String[] args) throws Exception {
        //服务端channel
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        //非阻塞的服务端
        serverChannel.configureBlocking(false);
        //绑定服务端端口号
        serverChannel.bind(new InetSocketAddress(9999));

        //多路复用器 selector
        Selector selector = Selector.open();

        //将服务端channel注册到多路复用器,并告诉selector，这个管道对“接受客户端请求的事件感兴趣”
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        //循环不停的执行select()
        while (true) {
            /* 轮询监听 有 Channel就绪，所谓的就绪就是 channel感兴趣的事件来了。
             *  如果select()返回值是0，则表示没有就绪的channel
             * */
            if (selector.select(1000) == 0) {
                System.out.println("没有channel准备就绪");
                continue;
            }

            //能走到这说明有就绪的channel，一个channel有一个唯一的SelectionKey。
            //这个集合包含所有就绪的channel。
            Set<SelectionKey> selectionKeys = selector.selectedKeys();

            //注意这里一定要用迭代器循环，不要用增强for。很多博客上直接用的增强for，其实会有bug。

            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            //遍历所有就绪的key
            while (iterator.hasNext()) {

                SelectionKey key = iterator.next();

                //如果当期key的类型为 OP_ACCEPT,说明可以接受客户端连接了。
                if (key.isAcceptable()) {
                    System.out.println("-------------接受到Client的连接了-----------------");

                    //获取一个客户端的 channel
                    SocketChannel clientChannel = serverChannel.accept();
                    //设置客户端为非阻塞
                    clientChannel.configureBlocking(false);
                    //获取到客户端channel后，需要将其注册到多路复用器，并告诉selector，这个管道对“我对读事件感兴趣”
                    clientChannel.register(selector, SelectionKey.OP_READ);

                }

                //如果当期key的类型为 OP_READ,说明可以读客户端的数据了。
                if (key.isReadable()) {
                    try {
                        System.out.println("----------------channel可读了----------------");
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //注意，当前类里的操作都是异步的，以为这，当前这个key，上边的key肯定不是同一个。
                        //这个key是上一个里获取到的客户端channel。
                        SocketChannel clientChannel = (SocketChannel) key.channel();
                        //将数据读到Buffer
                        clientChannel.read(buffer);
                        //将buffer转换为字节数组
                        byte[] array = buffer.array();

                        System.out.println(new String(array, "UTF-8"));

                        //向客户端发送消息
                        clientChannel.write(ByteBuffer.wrap("我是服务端".getBytes()));
                    } catch (Exception e) {
                        //如果客户端关闭了，会走到这里，则调用cancel关闭此通道
                        key.cancel();
                    }
                }
                //防止重复执行 已准备好的key
                iterator.remove();
            }

        }

    }


}

上边代码片段是服务端代码。首先我们需要关注的是创建服务端，设置非阻塞服务端，绑定端口。接下来Selector多路复用器就要

出场了。Selector.open();获取一个多路复用器。serverChannel.register(selector, SelectionKey.OP_ACCEPT);服务端管道将

自身注册到Selector中，并且添加感兴趣的事件，事件类型为接受客户端的连接。

接下来while(true)在循环中调用 select(1000)方法，此方法是阻塞方法，参数则为阻塞的毫秒数。select(1000)方法，轮询的去查看

当前注册到selector中的channel有没有准备就绪的，也就是有没有触发相应的事件。如果1秒内有准备就绪的channel。则拿到准备

就绪的集合。这里需要说明一点，所有注册到selector的channel都变成了一个SelectionKey,该对象有channel的所有特征。

接下来拿到set的迭代器。遍历迭代器，判断SelectionKey的事件类型。对于一个客户端连接来说，最开始触发的肯定是 isAcceptable()

也就是OP_ACCEPT，然后调用服务端channel的　accept()获取一个客户端连接channel，这里就类似bio的socket了。同样的，我们需要

将这个客户端channel注册到selector中，此时我们关注的事件类型是OP_READ,可读。也就是说当一个客户端连接到达后，我们需要

读取客户端发来的消息，但是这个读取本身是阻塞的，在bio中我们做个测试。所以我们将这个channel注册到selector中，并且告诉

selector如果这个客户端channel可以读了，你告诉我。剩下的就是等待可读后，再次遍历SelectionKey。selector流程类似下图。

最后我们要注意两点。在while迭代的最后，我们将当前的key从迭代器中移除了，为什么要移除？思考一下，如果当前的key为OP_ACCEPT,代表客户端连接了，我们获取到客户端连接后，如果不将

此key从准备就绪的 selectedKeys中移除掉，那再次执行select()方法这个key依然是准备就绪的状态，会再次的到 if(key.isAcceptable()) 此时就出现问题了，同样的一个客户端被我们

获取了两次channel，报错！。

最后一点，在可读事件执行的代码块中，用try{}catch(key.cancle())，因为当客户端关闭后，同样会发送一条消息，该消息会被识别到OP_READ，但是此时客户端已经关闭，读取会报错。所以

执行cancle()表示将该key,对应的channel移除掉，表示会话结束。

以上是NIO的基础使用，学习NIO是为了学习NIO框架Netty。如有错误，望指正。