[Netty学习笔记]二、NIO核心组件Buffer

通过上一节我们了解NIO的三大核心组件分别是Buffer、Channel、Selector。

三大核心部分的关联图:

1. 每个channel都会对应一个Buffer
2. Selector对应一个线程，一个线程对应多个channel
3. 上图显示有三个channel注册到selector上
4. Selector是由事件驱动的，程序切换到哪个channel是由事件觉得的
5. Selector会根据不同的时间，在各个通道上切换
6. Buffer是一个内存块，底层有一个数组
7. 数据的读取写入是通过Buffer(BIO中要么是输入流、要么是输出流，不能双向)。但是Buffer是可以读也可以写的，channel也是双向的。

缓冲区Buffer

缓冲区(Buffer)：本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组),该对象提供了一组方法，可以轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化清情况。Channel提供从文件、网络读取数据的渠道，但是读取或写入的数据必须经有Buffer。

在NIO中，Buffer是一个顶层父类，它是一个抽象类，常用子类如下：

1. ByteBuffer,存储字节数据到缓冲区
2. ShortBuffer，存储字符串数据到缓冲区
3. CharBuffer，存储字符数据到缓冲区
4. IntBuffer,存储整数数据到缓冲区
5. LongBuffer 存储长整型数据到缓冲区
6. DoubleBuffer 存储小数到缓冲区
7. FloatBuffer 存储小数到缓冲区
8. MappedByteBuffer 内存映射Buffer，可以实现数据在堆外内存中直接修改

Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:

属性	描述
capacity	容量，即可以容纳的做大数据量；在缓冲区创建时被设定并且不能改变
limit	表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作；且极限可以修改
position	位置，下一个要被读写的元素的索引。每次读写缓冲区数据时都会改变该值，为下次读写作准备
mark	标记

能读取的范围是position-limit之间的元素，否则可能会读取不到数据或者报错

Buffer类相关方法:

public final int capacity()//返回此缓冲区的容量
public final int position()//返回此缓冲区的位置
public final Buffer position(int newPosition)//设置此缓冲区的位置
public final int limit()//返回此缓冲区的限制
public final Buffer limit(int newLimit)//设置此缓冲区的限制
public final Buffer mark()//在此缓冲区的位置设置标记
public final Buffer reset()//将此缓冲区的位置重置为以前标记的位置
public final Buffer clear()//清除此缓冲区，将各个标记恢复到初始状态，但是数据并没有真正擦除；通常是在循环里读写数据之前调用
public final Buffer flip() //反转此缓冲区，通过是写完要读取的时候调用该方法
public final Buffer rewind() //重绕该缓冲区  
public final int remaining()//返回当前位置与限制之间的元素数
public final boolean hasRemaining()//告知在当前位置和限制之间是否有元素
public abstract boolean isReadOnly()//告知此缓冲区是否为只读缓冲区
public abstract boolean hasArray()//告知此缓冲区是否具有可访问的底层实现数组
public abstract Object array()//返回此缓冲区的底层实现数组
public abstract int arrayOffset()//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
public abstract boolean isDirect()//告知此缓冲区是否为直接缓冲区

ByteBuffer

该类的主要方法如下:

public static ByteBuffer allocateDirect(int capacity);//创建直接缓冲区
public static ByteBuffer allocate(int capacity);//设置缓冲区的初始容量
public static ByteBuffer wrap(byte[] array);//把一个数组放到缓冲区中使用
public abstract byte get();//从当前位置position上get,get之后，position会自动+1
public abstract byte get();//从决定位置上get
public abstract ByteBuffer put(byte b);//从当前位置上添加，put之后，position会自动+1
public abstract ByteBuffer put(int index,byte b);//从绝对位置上put

例子

public class IntBufferDemo {
    public static void main(String[] args) {
        //实现类HeapIntBuffer
        IntBuffer buffer = IntBuffer.allocate(5);
        buffer.put(1);
        buffer.put(2);
        buffer.put(3);
        buffer.put(4);
        buffer.put(5);

        //写模式切换成读模式 position/limit 数据变化
        buffer.flip();

        while (buffer.hasRemaining()) {
            System.out.println(buffer.get());
        }
    }
}

ByteBuffer 支持类型化的 put 和 get, put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException异常,代码如下：

public class ByteBufferDemo {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(40);
        //这里存放Double 需要8个字节 如果ByteBuffer空间小于8个字节 报错BufferOverflowException
        buffer.putDouble(0.1d);
        buffer.put((byte) 127);

        buffer.flip();

        /*
            ByteBuffer 支持类型化的 put 和 get, put 放入的是什么数据类型，
            get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常
         */
        System.out.println(buffer.getDouble());
        System.out.println(buffer.get());
    }
}

Buffer使用示例

Demo1:将一个普通Buffer转成只读Buffer

public class ReadBufferDemo {
    public static void main(String[] args) {
        //实际类是HeapByteBuffer
        ByteBuffer buffer = ByteBuffer.allocate(16);

        for (int i = 0; i < 16; i++) {
            buffer.put((byte) i);
        }

        buffer.flip();
        //只读缓冲区会共享当前缓存区内容，即便当前buffer内容改变了 readOnlyBuffer也会同步改变 包括pos/limit等
        //readOnlyBuffer 实现类实际是HeapByteBufferR
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

        while (readOnlyBuffer.hasRemaining()) {
            System.out.println(readOnlyBuffer.get());
        }
        //原始缓冲区发生变化则只读缓冲区对应数据也变化了
        buffer.put((byte) 16);

        readOnlyBuffer.flip();
        while (readOnlyBuffer.hasRemaining()) {
            System.out.println(readOnlyBuffer.get());
        }
        //这里会报错 只读缓冲区不能写
        readOnlyBuffer.put((byte) 17);

    }
}