（四）Netty之Buffer缓冲区

基本介绍

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

Buffer类及其子类

1.在NIO中，Buffer是一个顶层父类，它是一个抽象类，类的层级关系图：

常用Buffer子类一览

1. ByteBuffer，存储字节数据到缓冲区
2. ShortBuffer，存储字符串数据到缓冲区
3. CharBuffer，存储字符数据到缓冲区
4. IntBuffer，存储整数数据到缓冲区
5. LongBuffer，存储长整型数据到缓冲区
6. DoubleBuffer，存储小数到缓冲区
7. FloateBuffer，存储小数到缓冲区

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

属性	描述
Capacity	容量，既可以容纳的最大数据量；在缓冲区创建时被设定并且不能改变
Limit	便是缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的
Position	位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变该值，为下次读写作准备
Mark	标记，调用mark()来设置mark=position，再调用reset()可以让position恢复到标记的位置

3.Buffer类相关方法一览

ByteBuffer
从前面可以看出对于java中的基本数据类型(boolean除外)，都有一个Buffer类型与之相对应，最常用的自然是ByteBuffer类（二进制数据），该类的主要方法如下：

Buffer简单使用

debug运行，查看buffer属性值的变化

package com.example.demo.netty;

import java.nio.IntBuffer;

public class BasicBuffer {
    public static void main(String[] args) {

        //举例说明Buffer的使用（简单说明）
        //创建一个Buffer，大小为5，既可以存放5个int
        IntBuffer intBuffer = IntBuffer.allocate(5);

        //向Buufer存放数据
//        intBuffer.put(10);
//        intBuffer.put(11);
//        intBuffer.put(12);
//        intBuffer.put(13);
//        intBuffer.put(14);

        for (int i = 0; i < intBuffer.capacity(); i++) {
            intBuffer.put( i * 2);
        }


        //如何从buffer读取数据
        //将buffer转换，读写切换
        intBuffer.flip();

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

查看flip()方法做了什么

	public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

关于Buffer和Channel的注意事项和细节

1. ByteBuffer支持类型化的put和get，put放入的是什么数据类型，get就应该使用相应的数据类型来取出，否则可能有BufferUnderflowException异常
2. 可以将一个普通Buffer转化成只读Buffer
3. NIO还提供了MappedByteBuffer，可以让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由NIO来完成
4. 前面我们讲的读写操组，都是通过一个Buffer完成的，NIO还支持通过多个Buffer（即Buffer数组）完成读写操作，即Scattering和Gatering

demo1

package com.example.demo.netty;

import java.nio.ByteBuffer;

/**
 * ByteBuffer 支持类型化的 put 和 get，put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常
 */
public class NIOByteBufferPutGet {
    public static void main(String[] args) {

        // 创建一个 Buffer
        ByteBuffer buffer = ByteBuffer.allocate(64);

        // 类型化方式放入数据
        buffer.putInt(100);
        buffer.putLong(9L);
        buffer.putChar('我');
        buffer.putShort((short) 4);

        // 读取数据
        buffer.flip();

        System.out.println("----------");
        System.out.println(buffer.getInt());
        System.out.println(buffer.getLong());
        System.out.println(buffer.getChar());
        System.out.println(buffer.getShort());
    }
}

demo2

package com.example.demo.netty;

import java.nio.ByteBuffer;

/**
 * 可以将一个普通Buffer转化成只读Buffer
 */
public class ReadOnlyBuffer {
    public static void main(String[] args) {
        //创建一个buffer
        ByteBuffer buffer = ByteBuffer.allocate(64);

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

        //读取
        buffer.flip();

        //得到一个只读的buffer
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
        System.out.println(readOnlyBuffer.getClass());

        //读取
        while (readOnlyBuffer.hasRemaining()) {
            System.out.println(readOnlyBuffer.get());
        }

        readOnlyBuffer.put((byte) 100); // ReadOnlyBufferException
    }
}

demo3

package com.example.demo.netty;

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 说明
 * MappedByteBuffer 可以让文件直接在内存（堆外内存）修改，操作系统不需要拷贝一次
 */
public class MappedByteBufferTest {
    public static void main(String[] args) throws Exception {
        RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
        //获取对应的通道
        FileChannel channel = randomAccessFile.getChannel();

        /**
         * 参数1：FileChannel.MapMode.READ_WRITE 使用的读写模式
         * 参数2： 0：可以直接修改的起始位置
         * 参数3： 5：是映射到内存的大小，即将1.txt的多少个字节映射到内存
         * 可以直接修改的范围就是0-5
         */
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

        mappedByteBuffer.put(0, (byte) 'H');
        mappedByteBuffer.put(3, (byte) '9');
        
//        mappedByteBuffer.put(5, (byte) 'Y');//IndexOutOfBoundsException

        randomAccessFile.close();
    }
}

demo4

package com.example.demo.netty;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

/**
 * Scattering: 将数据写入到buffer时，可以采用buffer数组，依次写入（分散）
 * Gathering: 从buffer读取数据时，可以采用buffer数组，依次读
 */
public class ScatteringAndGatheringTest {
    public static void main(String[] args) throws Exception {

        // 使用 ServerSocketChannel 和 ServerSocketChannel 网络
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);

        // 绑定端口到socket，并启动
        serverSocketChannel.socket().bind(inetSocketAddress);

        // 创建buffer数组
        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        byteBuffers[0] = ByteBuffer.allocate(5);
        byteBuffers[1] = ByteBuffer.allocate(3);

        // 等客户端连接（telnet）
        SocketChannel socketChannel = serverSocketChannel.accept();
        int msgLen = 8; // 假定从客户端接收8个字符

        while (true) {
            int byteRead = 0;
            while (byteRead < msgLen) {
                long l = socketChannel.read(byteBuffers);
                byteRead += l; //累计读取的字节数
                System.out.println("byteRead=" + byteRead);
                Arrays.asList(byteBuffers).stream().map(buffer -> "postion=" + buffer.position() + ",limit=" + buffer.limit()).forEach(System.out::println);
            }

            // 将所有的buffer进行flip
            Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());

            // 将数据读出显示到客户端
            long byteWrite = 0;
            while (byteWrite < msgLen) {
                long l = socketChannel.write(byteBuffers);
                byteWrite += l;
            }
            // 将所有的buffer 进行clear
            Arrays.asList(byteBuffers).forEach(buffer -> buffer.clear());

            System.out.println("byteRead:=" + byteRead + " byteWrite=" + byteWrite + ",messageLenth=" + msgLen);
        }
    }
}