• Netty（8）netty组件：ByteBuf

    概述

    ByteBuf是对字节数据的封装

    ByteBuf的容量是可以自动扩容的

    创建

    ByteBuf 如果不指定容量的话，默认是256

    //指定初始容量为10
ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(10);


    • 1
    • 2
    • 3

    使用

    ByteBuf buf = ByteBufAllocator.DEFAULT.buffer();
System.out.println(buf);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 320; i++) {
    sb.append("a");
}
buf.writeBytes(sb.toString().getBytes());
System.out.println(buf);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    运行结果

    PooledUnsafeDirectByteBuf(ridx: 0, widx: 0, cap: 256)
PooledUnsafeDirectByteBuf(ridx: 0, widx: 320, cap: 512)

    • 1
    • 2

    调试的工具类

    import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;

import static io.netty.buffer.ByteBufUtil.appendPrettyHexDump;
import static io.netty.util.internal.StringUtil.NEWLINE;

public static void log(ByteBuf buffer) {
    int length = buffer.readableBytes();
    int rows = length / 16 + (length % 15 == 0 ? 0 : 1) + 4;
    StringBuilder buf = new StringBuilder(rows * 80 * 2)
            .append("read index:").append(buffer.readerIndex())
            .append(" write index:").append(buffer.writerIndex())
            .append(" capacity:").append(buffer.capacity())
            .append(NEWLINE);
    appendPrettyHexDump(buf, buffer);
    System.out.println(buf.toString());
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    使用上面的方法打印出来的数据如下（for循环的次数改为了32）：
    在这里插入图片描述

    ByteBuf支持的内存分配

    直接内存

    分配效率较低，但是读写效果高

    netty默认情况下，使用的是直接内存作为ByteBuf的内存（也可以选择）

    下面的代码来创建池化基于直接内存的 ByteBuf

    ByteBuf buffer = ByteBufAllocator.DEFAULT.directBuffer(10);
//不指定的话，默认使用的是直接内存

    • 1
    • 2
    • 直接内存创建和销毁的代价昂贵，但读写性能高（少一次内存复制），适合配合池化功能一起用
    • 直接内存对 GC 压力小，因为这部分内存不受 JVM 垃圾回收的管理，但也要注意及时主动释放

    堆内存

    分配效率较高，但是读写效率比较低

    下面的代码来创建池化基于堆的 ByteBuf

    ByteBuf buffer = ByteBufAllocator.DEFAULT.heapBuffer(10);

    • 1

    支持池化的管理

    池化管理：对于创建比较慢的一些资源，可以使用池化管理的思想进行优化

    池化 vs 非池化

    池化的 最大意义在于可以重用 ByteBuf，优点有

    • 没有池化，则每次都得创建新的 ByteBuf 实例，这个操作对直接内存代价昂贵，就算是堆内存，也会增加 GC 压力
    • 有了池化，则可以重用池中 ByteBuf 实例，并且采用了与 jemalloc 类似的内存分配算法提升分配效率
    • 高并发时，池化功能更节约内存，减少内存溢出的可能

    开启池化功能

    池化功能是否开启，可以通过下面的系统环境变量来设置

    -Dio.netty.allocator.type={unpooled|pooled}

    • 1
    • 4.1 以后，非 Android 平台默认启用池化实现，Android 平台启用非池化实现
    • 4.1 之前，池化功能还不成熟，默认是非池化实现

    查看当前的实现是什么
    在这里插入图片描述

    在IDEA进行设置

    在这里插入图片描述

    ByteBuf组成

    ByteBuf 由四部分组成

    1. 最大容量：整数的最大值，21
    2. 容量：容量与最大容量之间为可扩容区域
    3. 读指针：读指针到写指针的位置，称为可读部分
    4. 写指针：写指针到可写位置，称为可写部分
    5. 已经读过的这些数据，称为废弃部分

    在这里插入图片描述
    最开始读写指针都在 0 位置

    写入

    方法列表，省略一些不重要的方法

    方法签名含义备注
    writeBoolean(boolean value) 写入 boolean 值用一字节 01|00 代表 true|false
    writeByte(int value)写入 byte 值
    writeShort(int value)写入 short 值
    writeInt(int value)写入 int 值Big Endian（大端写入），即 0x250，写入后 00 00 02 50
    writeIntLE(int value)写入 int 值Little Endian（小端写入），即 0x250，写入后 50 02 00 00
    writeLong(long value)写入 long 值
    writeChar(int value)写入 char 值
    writeFloat(float value)写入 float 值
    writeDouble(double value)写入 double 值
    writeBytes(ByteBuf src)写入 netty 的 ByteBuf
    writeBytes(byte[] src)写入 byte[]
    writeBytes(ByteBuffer src) 写入 nio 的 ByteBuffer
    int writeCharSequence(CharSequence sequence, Charset charset) 写入字符串

    注意

    • 这些方法的未指明返回值的，其返回值都是 ByteBuf，意味着可以链式调用
    • 网络传输，默认习惯是 Big Endian

    大端：一个整数写入时，是先写高位字节还是低位字节，大端就是先写高位的
    小端：先写低位的，再写高位的

    还有一类方法是 set 开头的一系列方法，也可以写入数据，但不会改变写指针位置

    writeBytes

    先写入 4 个字节

    
buffer.writeBytes(new byte[]{1, 2, 3, 4});
log(buffer);

    • 1
    • 2
    • 3

    结果

    read index:0 write index:4 capacity:10
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04                                     |....            |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    writeInt

    没有带LE，是大端写入，从高位写

    在上面的基础上，再写四个字节

    
buffer.writeInt(5);
log(buffer);

    • 1
    • 2
    • 3

    结果是

    read index:0 write index:8 capacity:10
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 00 00 00 05                         |........        |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    扩容

    如果在上面的基础上，再进行希尔一个int整数时，便会触发扩容

    扩容规则

    如何写入后数据大小未超过 512，则选择下一个 16 的整数倍，例如写入后大小为 12 ，则扩容后 capacity 是 16

    如果写入后数据大小超过 512，则选择下一个 2^n，例如写入后大小为 513，则扩容后 capacity 是 2^10=1024
    （2^9=512 已经不够了）

    扩容不能超过 max capacity 会报错

    再次写入一个整数

    buffer.writeInt(6);
log(buffer);


    • 1
    • 2
    • 3

    结果是

    read index:0 write index:12 capacity:16
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 00 00 00 05 00 00 00 06             |............    |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    读取

    在写入这个章节里面，我们进行了三次写入，每次写入一个整数（四字节）

    现在，在之前的基础上，进行读，如下：读四次，每次读一个字节

    System.out.println(buffer.readByte());
System.out.println(buffer.readByte());
System.out.println(buffer.readByte());
System.out.println(buffer.readByte());
log(buffer);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    运行结果

    1
2
3
4
read index:4 write index:12 capacity:16
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 00 00 05 00 00 00 06                         |........        |
+--------+-------------------------------------------------+----------------+


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    现在，读过的内容，就属于废弃部分了，再读只能读那些尚未读取的部分

    重复读取

    如果需要重复读取 int 整数 5，可以在 read 前先做个标记 mark

    buffer.markReaderIndex();
System.out.println(buffer.readInt());
log(buffer);


    • 1
    • 2
    • 3
    • 4

    运行结果：

    5
read index:8 write index:12 capacity:16
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 00 00 06                                     |....            |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    现在，进行重复读取

    要重复读取的话，重置到标记位置 reset，

    将其还原到之前的位置，使用reset

    buffer.resetReaderIndex();
log(buffer);


    • 1
    • 2
    • 3

    结果：还原成功

    read index:4 write index:12 capacity:16
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 00 00 05 00 00 00 06                         |........        |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    其他方法

    采用 get 开头的一系列方法（通过索引去获取），这些方法不会改变 read index

    ByteBuf的内存回收

    ByteBuf回收方法

    Netty 中有堆外内存的 ByteBuf 实现，堆外内存最好是手动来释放，而不是等 GC 垃圾回收。

    • UnpooledHeapByteBuf 使用的是 JVM 内存，只需等 GC 回收内存即可
    • UnpooledDirectByteBuf 使用的就是直接内存了，需要特殊的方法来回收内存
    • PooledByteBuf 和它的子类使用了池化机制，需要更复杂的规则来回收内存

    netty提供的统一接口进行回收方法

    Netty 这里**采用了引用计数法**来控制回收内存，每个 ByteBuf 都实现了 ReferenceCounted 接口

    • 每个 ByteBuf 对象的初始计数为 1
    • 调用 release 方法计数减 1，如果计数为 0，ByteBuf 内存被回收
    • 调用 retain 方法计数加 1，表示调用者没用完之前，其它 handler 即使调用了 release 也不会造成回收
    • 当 计数为 0 时，底层内存会被回收，这时即使 ByteBuf 对象还在，其各个方法均无法正常使用

    release在何处进行

    因为 pipeline 的存在，一般需要将 ByteBuf 传递给下一个 ChannelHandler，如果在 finally 中 release 了，就失去了传递性（当然，如果在这个 ChannelHandler 内这个 ByteBuf 已完成了它的使命，那么便无须再传递）

    基本规则是，谁是最后使用者，谁负责 release，详细分析如下

    谁最后使用ByteBuf，谁就去使用release进行处理

    • 起点，对于 NIO 实现来讲，在 io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe#read 方法中首次创建 ByteBuf 放入 pipeline（line 163 pipeline.fireChannelRead(byteBuf)）
    • 入站 ByteBuf 处理原则
      • 对原始 ByteBuf 不做处理，调用 ctx.fireChannelRead(msg) 向后传递，这时无须 release
      • 将原始 ByteBuf 转换为其它类型的 Java 对象，这时 ByteBuf 就没用了，必须 release
      • 如果不调用 ctx.fireChannelRead(msg) 向后传递，那么也必须 release
      • 注意各种异常，如果 ByteBuf 没有成功传递到下一个 ChannelHandler，必须 release
      • 假设消息一直向后传，那么 TailContext 会负责释放未处理消息（原始的 ByteBuf）
    • 出站 ByteBuf 处理原则
      • 出站消息最终都会转为 ByteBuf 输出，一直向前传，由 HeadContext flush 后 release
    • 异常处理原则
      • 有时候不清楚 ByteBuf 被引用了多少次，但又必须彻底释放，可以循环调用 release 直到返回 true

    slice【零拷贝】

    这里的零拷贝是指：减少数据复制

    slice作用：【零拷贝】的体现之一，对原始 ByteBuf 进行切片成多个 ByteBuf，切片后的 ByteBuf 并没有发生内存复制，还是使用原始 ByteBuf 的内存，切片后的 ByteBuf 维护独立的 read，write 指针
    在这里插入图片描述

    ByteBuf buf = ByteBufAllocator.DEFAULT.buffer(10);
buf.writeBytes(new byte[]{'a','b','c','d','e','f','g','h','i','j'});
log(buf);

// 在切片过程中，没有发生数据复制
ByteBuf f1 = buf.slice(0, 5);//从a到e
ByteBuf f2 = buf.slice(5, 5);//从f到j
log(f1);
log(f2);
System.out.println("===========演示是否是同一个内存=============");
//修改其中的一个数据，查看buf和f1是否都改变了
f1.setByte(0, 'b');
log(f1);
log(buf);
//通过查看日志可知，二者都发生了变化，所以是操作的同一个内容
//原始 ByteBuf 也会受影响，因为底层都是同一块内存

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    运行结果：

    read index:0 write index:10 capacity:10
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65 66 67 68 69 6a                   |abcdefghij      |
+--------+-------------------------------------------------+----------------+
read index:0 write index:5 capacity:5
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65                                  |abcde           |
+--------+-------------------------------------------------+----------------+
read index:0 write index:5 capacity:5
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 66 67 68 69 6a                                  |fghij           |
+--------+-------------------------------------------------+----------------+
========================
read index:0 write index:5 capacity:5
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 62 62 63 64 65                                  |bbcde           |
+--------+-------------------------------------------------+----------------+
read index:0 write index:10 capacity:10
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 62 62 63 64 65 66 67 68 69 6a                   |bbcdefghij      |
+--------+-------------------------------------------------+----------------+

Process finished with exit code 0


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    注意点

    注意点1：切片后区间被固定

    注意点1：调用 slice 进行切片，无参 slice 是从原始 ByteBuf 的 read index 到 write index 之间的内容进行切片，切片后的 max capacity 被固定为这个区间的大小，因此不能追加 write

    如果执行，会报 IndexOutOfBoundsException 异常

    ByteBuf buf = ByteBufAllocator.DEFAULT.buffer(10);
buf.writeBytes(new byte[]{'a','b','c','d','e','f','g','h','i','j'});
log(buf);

// 在切片过程中，没有发生数据复制
ByteBuf f1 = buf.slice(0, 5);
// 如果想再写入一个x数据到f1中：'a','b','c','d','e', 'x'
ByteBuf f2 = buf.slice(5, 5);
f1.writeByte('x');
log(f1);
log(f2);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    运行结果

    read index:0 write index:10 capacity:10
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65 66 67 68 69 6a                   |abcdefghij      |
+--------+-------------------------------------------------+----------------+
Exception in thread "main" java.lang.IndexOutOfBoundsException: writerIndex(5) + minWritableBytes(1) exceeds maxCapacity(5): UnpooledSlicedByteBuf(ridx: 0, widx: 5, cap: 5/5, unwrapped: PooledUnsafeDirectByteBuf(ridx: 0, widx: 10, cap: 10))


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    注意点2：release

    注意点2：如果原始的ByteBuf被release（释放内存），由该ByteBuf切片的内容便不能再使用

    ByteBuf buf = ByteBufAllocator.DEFAULT.buffer(10);
buf.writeBytes(new byte[]{'a','b','c','d','e','f','g','h','i','j'});
log(buf);

// 在切片过程中，没有发生数据复制
ByteBuf f1 = buf.slice(0, 5);
ByteBuf f2 = buf.slice(5, 5);

System.out.println("释放原有 byteBuf 内存");
buf.release();
log(f1);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    运行结果

    read index:0 write index:10 capacity:10
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 65 66 67 68 69 6a                   |abcdefghij      |
+--------+-------------------------------------------------+----------------+
释放原有 byteBuf 内存
Exception in thread "main" io.netty.util.IllegalReferenceCountException: refCnt: 0



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    解决方法：使用retain（retain：+1；release：-1）方法

    ByteBuf buf= ByteBufAllocator.DEFAULT.buffer(10);
buf.writeBytes(new byte[]{'a','b','c','d','e','f','g','h','i','j'});
log(buf);

// 在切片过程中，没有发生数据复制
ByteBuf f1 = buf.slice(0, 5);
//使buf，release后不影响f1
f1.retain();
ByteBuf f2 = buf.slice(5, 5);
//使buf，release后不影响f2
f2.retain();
log(f1);
log(f2);

System.out.println("释放原有 byteBuf 内存");
buf.release();
log(f1);
//f1和f2使用完了，自己去release
f1.release();
f2.release();


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    duplicate【复制，零拷贝】

    作用：【零拷贝】的体现之一，就好比截取了原始 ByteBuf 所有内容，并且没有 max capacity 的限制，也是与原始 ByteBuf 使用同一块底层内存，只是读写指针是独立的

    在这里插入图片描述

    copy

    会将底层内存数据进行深拷贝，因此无论读写，都与原始 ByteBuf 无关

    CompositeByteBuf【零拷贝】

    作用：【零拷贝】的体现之一，可以将多个 ByteBuf 合并为一个逻辑上的 ByteBuf，避免拷贝

    CompositeByteBuf 是一个组合的 ByteBuf，它内部维护了一个 Component 数组，每个 Component 管理一个 ByteBuf，记录了这个 ByteBuf 相对于整体偏移量等信息，代表着整体中某一段的数据。

    • 优点，对外是一个虚拟视图，组合这些 ByteBuf 不会产生内存复制
    • 缺点，复杂了很多，多次操作会带来性能的损耗（如每次都要去维护写指针的位置）
    ByteBuf buf1 = ByteBufAllocator.DEFAULT.buffer();
buf1.writeBytes(new byte[]{1, 2, 3, 4, 5});

ByteBuf buf2 = ByteBufAllocator.DEFAULT.buffer();
buf2.writeBytes(new byte[]{6, 7, 8, 9, 10});

//这种方法进行了多次数据复制
/*ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
buffer.writeBytes(buf1).writeBytes(buf2);
log(buffer);*/

//把多个小的ByteBuf组成到了一起
CompositeByteBuf buffer = ByteBufAllocator.DEFAULT.compositeBuffer();
/*
addComponents：
   参数1：自动增长写指针，如果不填true，
       addComponents/addComponent都默认不会去调整写指针的位置；
       所以数据不会
   参数2和参数3：这些是可变参数，需要添加的buf
*/
buffer.addComponents(true, buf1, buf2);
log(buffer);


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    Unpooled

    Unpooled 是一个工具类，类如其名，提供了非池化的 ByteBuf 创建、组合、复制等操作

    这里仅介绍其跟【零拷贝】相关的 wrappedBuffer 方法，可以用来包装 ByteBuf

    ByteBuf buf1 = ByteBufAllocator.DEFAULT.buffer(5);
buf1.writeBytes(new byte[]{1, 2, 3, 4, 5});
ByteBuf buf2 = ByteBufAllocator.DEFAULT.buffer(5);
buf2.writeBytes(new byte[]{6, 7, 8, 9, 10});

// 当包装 ByteBuf 个数超过一个时, 底层使用了 CompositeByteBuf
ByteBuf buf3 = Unpooled.wrappedBuffer(buf1, buf2);
System.out.println(ByteBufUtil.prettyHexDump(buf3));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    输出

             +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 05 06 07 08 09 0a                   |..........      |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5

    也可以用来包装普通字节数组，底层也不会有拷贝操作

    ByteBuf buf4 = Unpooled.wrappedBuffer(new byte[]{1, 2, 3}, new byte[]{4, 5, 6});
System.out.println(buf4.getClass());
System.out.println(ByteBufUtil.prettyHexDump(buf4));

    • 1
    • 2
    • 3

    输出

    class io.netty.buffer.CompositeByteBuf
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 05 06                               |......          |
+--------+-------------------------------------------------+----------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    ByteBuf的优势总结

    池化：可以重用池中 ByteBuf 实例，更节约内存，减少内存溢出的可能

    读写指针分离，不需要像 ByteBuffer 一样切换读写模式

    可以自动扩容

    支持链式调用，使用更流畅

    很多地方体现零拷贝，例如 slice、duplicate、CompositeByteBuf

  • 相关阅读:
    ofxTimeMeasurements——OpenFrameworks插件，可以轻松测量C++代码任何部分的执行时间
    网络专线学习
    如何自定义feign方法级别的超时时间
    Rocky Linux怎么安装mysql
    CDH Kerberos启动后hue报错Couldn‘t renew kerberos ticket
    C# OpenCvSharp Yolov8 Face Landmarks 人脸特征检测
    SpringMvc第五战-【SpringMvcJSR303和拦截器】
    邮政编码，格式校验：@ZipCode（自定义注解）
    Python virtualenv工具设置虚拟环境和VS code调试Python
    【离线/并查集】CF1213 G
  • 原文地址：https://blog.csdn.net/yyuggjggg/article/details/126457061