java NiO

从业务开发的角度来看，应该很少有业务场景在使用NIO了。毕竟消息中间件用起来其实就应该满足诉求了。但如果是中间件开发同学应该比较了解这个。我其实在业务开发的过程中就从来没有用过，随手写写，不考虑业务实战情况。

QUICKSTART

其实重点主要是3个   Channel, Buffer和Selector(熟悉linux C语言的开发的，应该知道有个select函数，很久以前看过）。

• Channel:渠道，其实理解就是和linux文件定义差不多，能产生和消费信息的都可以抽象成channel，比如文件，网络，键盘（能产生信息），显示器终端（能消费信息）。
• Buffer:缓冲区。
• Selector:如果知道linux select函数的就很好理解了，简单理解就是我都NIO了，我就不等你channel准备好，把消息发给我了。我先去忙其它的，等你准备好了，就通过selector来通知我，我再腾出手来处理你给我的消息。

比如说，当前我监听8080端口，基于TCP链接，接收别人给我发消息。然后处理这个消息。传统的做法，比如我接收到一个来自外面的连接请求，然后建立一个线程去管理这个链接，这个线程负责从连接上获取数据，并处理数据，主线程在这里只负责监听端口，等有请求过来就创立子线程去处理。换一种做法，我主线程既负责监听端口，也负责管理连接，监听连接上是否有数据过来。也就是我同时在处理多个事情，{BANNED}中国第一个，我监听端口是否有连接请求，第二个，有了多个连接请求后，我监听这些连接上是否有数据，我接收到数据并进行处理。下面上代码：

服务端代码：

package sty.zchi;

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.nio.charset.StandardCharsets;
import java.util.Set;

/**
 * Hello world!
 *
 */
public class StyServerSocket {
    public static void main( String[] args ) {
        try {
            //开始监听8080号端口，并且是非阻塞式
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1", 8080));
            Selector selector = Selector.open();
            //将端口的OP_ACCEPT事件注册给selector
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while(true) {
                /**
                 * 开始监控selector上所有的时间，注意这里是阻塞式的，主线程到这里如果没有事情发生，就会阻塞住。
                 * 另外如果是循环第一次进来，此时selector上只有一个8080的OP_ACCEPT在监控
                 */
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                selectionKeys.forEach(key -> {
                    try {
                        final SocketChannel client;
                        if (key.isAcceptable()) {
                            //说明有人连进来
                            System.out.println("some one connect server");
                            ServerSocketChannel server = (ServerSocketChannel) key.channel();
                            //接受8080上的连接请求，并且也设置成非阻塞式，然后将连接的OP_READ事件注册到selector上
                            client = serverSocketChannel.accept();
                            client.configureBlocking(false);
                            client.register(selector, SelectionKey.OP_READ);
                        } else if(key.isReadable()) {
                            client = (SocketChannel) key.channel();
                            ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                            int count = client.read(readBuffer);
                            if(count > 0) {
                                readBuffer.flip();
                                String receiveMessage = String.valueOf(StandardCharsets.UTF_8.decode(readBuffer).array());
                                System.out.println("receive message = " + receiveMessage);
                            }
                            client.close();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        selectionKeys.clear();
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

客户端代码：

package sty.zchi;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class StyClient {
    public static void main(String[] args) {
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            ByteBuffer writeBuffer = ByteBuffer.allocate(32);

            while(true) {
                Scanner sc = new Scanner(System.in);
                String str = sc.nextLine();
                if(str.equals("quit")) {
                    socketChannel.close();
                    return;
                }
                writeBuffer.put(str.getBytes(StandardCharsets.UTF_8));
                writeBuffer.flip();
                socketChannel.write(writeBuffer);
                writeBuffer.clear();
            }

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

基本上看代码注释就明白了，其实业务实际上也没这么简单。我这里只是个开门的样例，下面具体看看后面的内容。

CHANNEL

中文名叫通道，有人说类似于JAVA语言中的流，但我觉得其实更相似的类比应该是linux中关于文件的定义既：能产生或者消费信息的东西。所以文件，网络端口，甚至是键盘，显示器都可以这定。上面的例子是个TCP网络套接字(SOCKET的channel)。其实我们还有FileChannel， UDP协议的DatagramChannel等。
注意是的通道能产生和消费信息，这个过程是不能直接交互的，需要通过下面的BUFFER来中转。

BUFFER

中文名叫缓冲区，既然是用于交换信息的缓冲区，首先从类型上有（我理解是数据类型）

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• FloatBuffer
• DoubleBuffer
• LongBuffer

很容易理解不是么。说几个关键的方法操作

关键属性和数据结构理解

缓冲区是既能读也能写的，那么就需要一个结构来支持，我写数据，我也能读出数据出来，设计的思想就不赘述了，我直接写核心的属性

• capacity:这个好理解，就是这个这个缓冲区最大容量，注意不是可用容量。他在allocate之后就分配了，当然可以改。除非你手动改，不然就是allocate分配后就是个固定值。
• position:这个表示下一次操作的位置，这个操作可以是读，也可以是写。比如我现在分配了一个10char容量的缓冲区，那么position就是0，这标识我下次写操作就写到0号位。如果我没写之前就不讲武德的开始做get操作呢，我试了下，没有报错，就是个乱码。当然你实际业务不会出这种事情。
• limit:标识实际可以操作数据的大小。是不是有点晕，实际操作大小不就是capacity么，怎么又冒出了个limit呢。下面讲读写切换filp时候就明白了。

开始讲翻转吧，我们设想下，我申请了一个10 char位置的charBuffer。刚申请完，就是往里面写啦。这个时候我们理解下：

• capacity:这个就不解释了，肯定是10，怎么弄都是10.
• position:这个好理解，肯定是0，我写的第一个字符肯定放在第0位
• limit:容量是10么，我写肯定最多能写10个，所以就是10.

好了，我们向里面写了6个数据，这个时候容量肯定是10，position肯定是6，因为我写了6个数据占满了0,1,2,3,4,5 所以下一个能写操作就是6号位，limit还是10，毕竟一共能操作的是10个。

接下来，我就开始想读数据，此时想想，对于读操作来说，你的position应该是0，limit应该是6，capacity应该是10。那是不是需要我们去修改这些属性呢（有方法可以改的，但没必要）。我们只用调用flip来进行读写转换。这就是为什么每次在对缓冲区做读写操作之前，如果上一次操作和这次操作有变化，就需要调用flip的原因。那我们写个代码试试。

package sty.zchi;

import java.nio.CharBuffer;

public class BufferTest {
    public static void main(String[] args) {
        CharBuffer charBuffer = CharBuffer.allocate(10);
        System.out.println("刚初始化的charBuffer关键属性 position = " + charBuffer.position()
                + " limit = " + charBuffer.limit() + " capacity = " + charBuffer.capacity());

        System.out.println("不讲武德的操作，啥都没写，就开始读 结果是" + charBuffer.get());

        System.out.println("在不讲武德的一次写操作后，charBuffer关键属性position = " + charBuffer.position()
                + " limit = " + charBuffer.limit() + " capacity = " + charBuffer.capacity());

        charBuffer.clear();
        System.out.println("好吧不讲武德的操作影响了我们属性，我们clear一把后，看看charBuffer关键属性position = " + charBuffer.position()
                + " limit = " + charBuffer.limit() + " capacity = " + charBuffer.capacity());

        char[] charArray = {'0', '1', '2', '3', '4', '5'};
        charBuffer.put(charArray);
        System.out.println("在放入6个char数据后charBuffer关键属性 position = " + charBuffer.position()
                + " limit = " + charBuffer.limit() + " capacity = " + charBuffer.capacity());

        charBuffer.flip();
        System.out.println("在放入6个char数据后charBuffer经过翻转后关键属性 position = " + charBuffer.position()
                + " limit = " + charBuffer.limit() + " capacity = " + charBuffer.capacity());
    }
}

好吧运行结果是

我理解BUFFER将的也挺明白的了。