Netty应用(二) 之 ByteBuffer

目录

4.ByteBuffer详解

4.1 ByteBuffer为什么做成一个抽象类？

4.2 ByteBuffer是抽象类，他的主要实现类为

4.3 ByteBuffer的获取方式

4.4 核心结构（NIO的ByteBuffer底层是啥结构，以及读写模式都是根据这些核心结构进行维护的）

4.4 核心API

4.5 字符串操作

4.6 粘包与半包

---

4.ByteBuffer详解

4.1 ByteBuffer为什么做成一个抽象类？

回答这个问题之前，先说一下：啥时候设计成抽象类，啥时候设计成接口？

1.针对抽象的概念（名词）设计成抽象类。eg：动物，形状，汽车这些类设计成抽象类

2.针对抽象的动作，功能（动词）设计成接口。eg：DAO设计成接口，Service设计成接口

对于ByteBuffer的设计也是符合这项规定的，ByteBuffer是缓冲区，是一个名词，所以设计成抽象类。

但是同样存在特例，如InputStream，OutputStream，流是动词，应该设计成接口，但是java设计成了抽象类，因为早期java设计不是很通透。

为什么接口可以多继承？

打个比方，一个人有多少功能？一个人可以拥有很多个功能，对吧。所以一个类(一个人)可以继承(可以拥有)很多接口(很多功能)

4.2 ByteBuffer是抽象类，他的主要实现类为

1.HeapBuffer 堆ByteBuffer ----》占用的是JVM内的堆内存 ----》读写操作 效率低 会收到GC影响

2. MappedByteBuffer(DirectByteBuffer) ----》占用的是OS内存----》读写操作 效率高 不会收到GC影响 。 不主动析构，会造成内存的泄露

• 分析一下HeapBuffer与MappedByteBuffer的区别

HeapBuffer：占用的是JVM内的堆内存 ----》读写操作 相对效率低 会收到GC影响

MappedByteBuffer: 占用的是OS内存----》读写操作 相对效率高 不会收到GC影响。但是如果不主动去释放OS的内存，会造成内存泄漏！啥是内存泄漏？内存泄漏就是前一个用户所开辟的内存空间由于忘记释放，所以无法再被之后的其他用户正常使用了

为什么MappedByteBuffer相对效率要高？

很明显，通过图中可以看出，MappedByteBuffer是在OS中直接申请的内存空间，而HeapByteBuffer是在JVM进程中申请的堆内存空间，HeapByteBuffer操作的时候，中间还隔着OS操作系统，自然效率低一些。

补充：

JVM其实就相当于操作系统启动的一个进程，进程占用着一块内存空间，进程中有栈，堆，静态代码区域等，堆空间主要存储的就是new的对象，栈存储一些局部变量，参数等，静态代码区域存储的就是代码。操作系统本质上也是由很多进程组成的一个系统，来管理整个硬件。

• 内存溢出和内存泄漏有什么区别？

内存泄漏：

举个例子：明明具有100M内存，但是实际只处理了80M内存就不能再继续增加处理了。剩余的20M内存就内存泄漏了。

内存泄漏的原因：

1.不主动析构（没有主动释放内存）

分析：前一个用户申请了20M内存空间但是没有释放并且这一个用户的使用已经结束了，后一个用户去使用的时候，100M内存只能正常使用80M内存，按理说应该可以正常使用100M内存，所以20M内存发生内存泄漏

2.内存碎片

假设说内存碎片1的大小为20M，内存碎片2的大小为10M。假设说内存空间就是剩余30M(内存碎片1和内存碎片2的内存总大小)，但此时我们申请一块30M大小的空间，申请失败！！因为我们目前只有20M和10M的内存空间大小，没有一块连续的30M空间大小。这也造成了内存泄漏！

现在有很多优秀的内存管理器，来减少内存碎片的大小。但我们不能保证内存中不存在碎片，内存碎片(缝隙一定存在)一定存在！而是可以做到让碎片足够的小，这样才能提升空间利用效率。

内存管理器哪里使用的多？redis中用的多，redis是一个基于内存的nosql产品，它对内存的管理要求很高。它的内存管理整合第三方的内存管理器，如gemalloc，tcmalloc等。强大的内存管理器的一个指标就是：内存碎片的管理。

内存溢出：

举个例子：具有100M内存，但实际操作的过程中，把120M的真实数据一次性加入到内存中，由于超过了100M内存的真实大小，所以内存溢出。

总结：

内存溢出就是最后的一个表现，造成内存溢出的一个很大的原因是因为过程中存在内存泄漏。

想想是不是这个道理，在造成一个内存溢出结果的过程中，因为一定会有内存碎片----》所以一定会有内存泄漏。

4.3 ByteBuffer的获取方式

1.ByteBuffer.allocate(10);//一旦分配空间，不可以动态调整。但是在Netty中的ByteBuffer类就是具有动态调整的功能，可以进行动态修改调整所分配的空间大小。因为Netty对ByteBuffer进行了一系列的优化封装，使其可以动态调整空间大小

2.encode(); 注释：encode()方法会让字符串类型的数据转换成ByteBuffer类型

4.4 核心结构（NIO的ByteBuffer底层是啥结构，以及读写模式都是根据这些核心结构进行维护的）

ByteBuffer是一个类似数组的结构，整个结构中包含以下三个主要的指针状态：

以下这三个状态维护出了ByteBuffer的读写模式，读写模式的切换背后实际上都是由这三个状态的不断变化而实现的。

1.Capacity

buffer的容量，类似于数组的size，指向ByteBuffer最后一个位置

2.Position

buffer当前缓存的下标。读取操作时记录下一个待读取的位置下标。写操作时记录下一个待写入的位置下标。位置下标是从0开始，每读取一次，下标+1

3.Limit

读写操作时的一个限制下标。在读操作时，Limit设置你还能再读取多少个字节的数据。在写操作时，设置你还能再写入多少个字节的数据。

• 画图

• 为什么clear方法和compact方法都是把Buffer转换成写模式，为什么还需要compact？画图来说明：

单独演示compact方法底层三个指针是如何变化的：

• 代码演示

public class TestNIO4 {

    public static void main(String[] args) {
        TestNIO4 test = new TestNIO4();
        test.testState05();
    }

    public void testState01() {
        //创建完Buffer，默认是写模式
        ByteBuffer buffer = ByteBuffer.allocate(10);

        System.out.println("buffer.capacity() = " + buffer.capacity());//10
        System.out.println("buffer.position() = " + buffer.position());//0
        System.out.println("buffer.limit() = " + buffer.limit());//10

    }

    public void testState02() {
        //创建完Buffer，默认是写模式
        ByteBuffer buffer = ByteBuffer.allocate(10);
        //写入四个字节的数据
        buffer.put(new byte[]{'a','b','c','d'}) ;
        //
        System.out.println("buffer.capacity() = " + buffer.capacity());//10
        System.out.println("buffer.position() = " + buffer.position());//4
        System.out.println("buffer.limit() = " + buffer.limit());//10
    }

    public void testState03() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'}) ;

        //改为读模式
        buffer.flip();

        //
        System.out.println("buffer.capacity() = " + buffer.capacity());//10
        System.out.println("buffer.position() = " + buffer.position());//0
        System.out.println("buffer.limit() = " + buffer.limit());//4
    }
    public void testState04() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'}) ;

        //调用clear，让position指向第一个索引位置
        buffer.clear();

        //
        System.out.println("buffer.capacity() = " + buffer.capacity());//10
        System.out.println("buffer.position() = " + buffer.position());//0
        System.out.println("buffer.limit() = " + buffer.limit());//10
    }
    public void testState05() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put(new byte[]{'a','b','c','d'}) ;

        buffer.flip();
        System.out.println("(char) buffer.get() = " + (char) buffer.get());//a
        System.out.println("(char) buffer.get() = " + (char) buffer.get());//b

        System.out.println("buffer.capacity() = " + buffer.capacity());//10
        System.out.println("buffer.position() = " + buffer.position());//2
        System.out.println("buffer.limit() = " + buffer.limit());//4

        System.out.println("----------------------------------");

        //把未读取的c和d移到最前面索引位置保存起来 position指向下一个d后面的一个索引位置（未读取的索引位置）开始写入
        buffer.compact();

        System.out.println("buffer.capacity() = " + buffer.capacity());//10
        System.out.println("buffer.position() = " + buffer.position());//2
        System.out.println("buffer.limit() = " + buffer.limit());//10

        //转换为读模式
        buffer.flip();
        System.out.println("(char) buffer.get() = " + (char) buffer.get());//c
        System.out.println("(char) buffer.get() = " + (char) buffer.get());//d


    }


}

全部测试成功，主要是对读写模式切换的理解即可，以及对Buffer读写模式切换底层核心结构的理解！

• 总结

最后总结一下：其实在日常开发过程中，无需知道在读写模式切换时底层核心结构标记是如何切换的，但是对于一些复杂开发，我们需要理解底层核心结构标记的切换

写入Buffer数据之前要设置写模式

1. 写模式

1. 新创建的Buffer，默认是写模式

2. 调用了clear,compact方法

读取Buffer数据之前要设置读模式

2. 读模式

1. 调用flip方法

4.4 核心API

• 向Buffer缓冲区写入数据（写模式，创建一个ByteBuffer时默认为写模式 或 clear方法调用 或 compact方法调用）

1.channel的read方法

channel.read(buffer) --->向ByteBuffer这一缓冲区中写入数据

2.buffer的put方法

buffer.put(byte) ---->一个字节一个字节的写入数据到ByteBuffer 如：buffer.put((byte) 'a')

buffer.put(byte[]) ---->向ByteBuffer缓冲区中写入一个字节数组

• 从Buffer缓冲区中读出数据（读模式）

1.channel的write方法 ---》把ByteBuffer的数据读出到文件中

2.buffer的get()方法调用 ----》每调用一次get()，position位置向后移动一位

3.rewind方法（像手风琴一样来回拉扯）----》将position指向重置为0，用于重新读取数据

4.mark & reset方法 ---》这两个方法结合使用，通过mark方法进行标记一个 position位置，当调用reset方法时，会跳转到上一次mark标记的position的位置坐标，并且从这个position指向的位置坐标开始重新执行。记住一点：mark和reset方法都是结合使用的！！！！

5.get(i)方法 -----》获取特定索引位置上的数据，与get()的不同之处在于：get(i)可以特定获取某一索引位置的数据值 并且 get(i)方法不会改变position的指向！

• 代码演示

public class TestNIO5 {

    public static void main(String[] args) {

        ByteBuffer buffer = ByteBuffer.allocate(10) ;
        buffer.put(new byte[]{'a','b','c','d'}) ;

        buffer.flip();

        while (buffer.hasRemaining()) {
            System.out.println("(char) = " + (char) buffer.get()) ;
        }
        //此时此刻
        //position = 4 limit=4 capacity=10
        System.out.println("--------------------------");

        //把position置为0
        buffer.rewind();

        while (buffer.hasRemaining()) {
            System.out.println("(char) buffer.get() = " + (char) buffer.get());
        }

    }

}

public class TestNIO6 {

    public static void main(String[] args) {

        ByteBuffer buffer = ByteBuffer.allocate(10);

        buffer.put(new byte[]{'a','b','c','d'}) ;

        buffer.flip();
        System.out.println("buffer.get() = " + (char) buffer.get());//a
        System.out.println("buffer.get() = " + (char) buffer.get());//b

        //记录此时position的位置：2
        buffer.mark();
        System.out.println("buffer.get() = " + (char) buffer.get());//c
        System.out.println("buffer.get() = " + (char) buffer.get());//d

        //恢复成上一次记录的position所指向的位置：2
        buffer.reset();
        System.out.println("buffer.get() = " + (char) buffer.get());//c
        System.out.println("buffer.get() = " + (char) buffer.get());//d
    }

}

public class TestNIO7 {

    public static void main(String[] args) {

        ByteBuffer buffer = ByteBuffer.allocate(10) ;
        buffer.put(new byte[]{'a','b','c','d'}) ;

        buffer.flip();
        System.out.println("(char)buffer.get() = " + (char) buffer.get());//a
        //虽然此时position指向1，但是由于调用的是get(0)，所以输出的还是第一个数据值
        System.out.println("(char)buffer.get(0) = " + (char) buffer.get(0));//a

        System.out.println(buffer.position());//1
    }

}

4.5 字符串操作

• 字符串存储到Buffer缓冲区中

1.使用allocate方法创建ByteBuffer

2.使用encode方法创建ByteBuffer缓冲区

flip方法源码：

3.使用新的方法创建ByteBuffer缓冲区

4.使用wrap方法创建ByteBuffer缓冲区

• Buffer缓冲区的数据转换成字符串

补充演示：

4.6 粘包与半包

粘包：下一句话不完整的粘到上一句话的后面，这就是粘包

半包：不完整的一句话就是半包

eg：

在客户端-服务端网络通信的过程中，客户端原本想要发送三句话给服务端：

1.Hi leomessi\n

2.I love you\n

3.Do you love me?\n

但是由于服务端开辟的ByteBuffer缓冲区大小问题，假设服务端ByteBuffer设为20个字节大小，那么最终服务端接收的时候：第一次ByteBuffer接收读取到的是：Hi leomessi\nI love y，第二次ByteBuffer接收读取到的是：ou\nDo you love me?\n。

服务端本来应该接收到的是完整无缺的三句话：

1.Hi leomessi\n

2.I love you\n

3.Do you love me?\n

结果现在造成割裂，其中第一次接收到的"I love y"就是粘包，第二次接收到的"ou\n"就是半包

补充：

又有新的疑惑了，既然由于ByteBuffer过小造成粘包，半包，那为什么不增大ByteBuffer的大小呢？？当然是可以增大的，但是极限法思考一下，可以无限大吗？当然不行！ByteBuffer占用的是内存，无论是JVM进程的内存还是操作系统的内存都是有限的，所以一味的增大ByteBuffer的大小而保证一次可以接收读取客户端所有的数据，这一操作改善是不靠谱的！

所以后续我们需要引出其他解决方法，代码如下：

• 解决半包粘包

public class TestNIO10 {

    public static void main(String[] args) {
        //难点2：合理开辟ByteBuffer的大小，如果太小，可能i love y+追加的空间 可能造成Buffer缓冲区的溢出（后续Netty动态扩容会解决，这里手动设置）
        ByteBuffer buffer = ByteBuffer.allocate(50) ;
        //难点3：假设说put一行的数据中没有\n，那么就会不断的追加，不断的追加就很难控制ByteBuffer缓冲区的大小。
        // 那么该如何设置ByteBuffer的大小，同理难点2，后续Netty会自动调整容量大小
        buffer.put("Hello leomessi\ni love y".getBytes());
        doLineSplit(buffer);
        //i love you\nDo you like me?\n
        buffer.put("ou\nDo you like me\n?".getBytes());
        doLineSplit(buffer);
        buffer.put("ceshi\n".getBytes());
        doLineSplit(buffer);
    }

    //ByteBuffer接收的数据 \n
    private static void doLineSplit(ByteBuffer buffer) {
        //写模式转换成读模式
        buffer.flip();
        for (int i = 0; i < buffer.limit(); i++) {
            if(buffer.get(i) == '\n') {
                //难点1：为什么要减去buffer.position()? 为了在当前buffer数据中存在多个\n,此时为了节省开辟的target空间大小
                int length = i+1-buffer.position();
                ByteBuffer target = ByteBuffer.allocate(length) ;
                for (int j = 0; j < length; j++) {
                    target.put(buffer.get());
                }
                //写入工作完成，从写模式转换成读模式
                target.flip();
                System.out.println("StandardCharsets.UTF_8.decode(target).toString() = " + StandardCharsets.UTF_8.decode(target).toString());
            }
        }
        buffer.compact();
    }

}

• 上述代码未解决的问题

1.

代码依旧存在问题，当读取行数据没有\n，我们需要读取完第一行后接着继续读取第二行的数据，直到第3，4，5........第n行的数据。这个过程需要ByteBuffer缓冲区的大小不断扩容，使用NIO就很麻烦，后续Netty帮我们都做好了，并且Netty可以动态调整ByteBuffer缓冲区的大小

2.

ByteBuffer buffer = ByteBuffer.allocate(50)，50这个值不可以设置的太小。

假如设为20，设为20后。

第一次读取Hi sunshuai\n，第一次读取后，未读取的l love y被移到前面，后面接着追加写入ou\nDo you like me\n? 但是ByteBuffer的空间(20)不够用了，所以会Buffer缓冲区溢出！