Netty（3）——ByteBuf最全最详细16个案例

最新推荐文章于 2024-11-16 17:35:58 发布
原创 最新推荐文章于 2024-11-16 17:35:58 发布 · 1.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#netty #ByteBuf

代码基本每行都有注释，还是比较好理解的

  • 代码清单 5-1 支撑数组
  • 代码清单 5-2 访问直接缓冲区的数据
  • 代码清单 5-3 使用 ByteBuffer 的复合缓冲区模式
  • 代码清单 5-4 使用 CompositeByteBuf 的复合缓冲区模式
  • 代码清单 5-5 访问 CompositeByteBuf 中的数据
  • 代码清单 5-6 访问数据
  • 代码清单 5-7 读取所有数据
  • 代码清单 5-8 写数据
  • 代码清单 5-9 使用 ByteBufProcessor 来寻找
  • 代码清单 5-10 对 ByteBuf 进行切片
  • 代码清单 5-11 复制一个 ByteBuf
  • 代码清单 5-12 get()和 set()方法的用法
  • 代码清单 5-13 ByteBuf 上的 read()和 write()操作
  • 代码清单 5-14 获取一个到 ByteBufAllocator 的引用
  • 代码清单 5-15 引用计数
  • 代码清单 5-16 释放引用计数的对象
public class ByteBufExamples {
    private final static Random random = new Random();
    private static final ByteBuf BYTE_BUF_FROM_SOMEWHERE = Unpooled.buffer(1024);
    private static final Channel CHANNEL_FROM_SOMEWHERE = new NioSocketChannel();
    private static final ChannelHandlerContext CHANNEL_HANDLER_CONTEXT_FROM_SOMEWHERE = DUMMY_INSTANCE;
    /**
     * 代码清单 5-1 支撑数组
     */
    public static void heapBuffer() {
        ByteBuf heapBuf = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        //检查 ByteBuf 是否有一个支撑数组
        if (heapBuf.hasArray()) {
            //如果有，则获取对该数组的引用
            byte[] array = heapBuf.array();
            //计算第一个字节的偏移量
            int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();
            //获得可读字节数
            int length = heapBuf.readableBytes();
            //使用数组、偏移量和长度作为参数调用你的方法
            handleArray(array, offset, length);
        }
    }

    /**
     * 代码清单 5-2 访问直接缓冲区的数据
     */
    public static void directBuffer() {
        ByteBuf directBuf = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        //检查 ByteBuf 是否由数组支撑。如果不是，则这是一个直接缓冲区
        if (!directBuf.hasArray()) {
            //获取可读字节数
            int length = directBuf.readableBytes();
            //分配一个新的数组来保存具有该长度的字节数据
            byte[] array = new byte[length];
            //将字节复制到该数组
            directBuf.getBytes(directBuf.readerIndex(), array);
            //使用数组、偏移量和长度作为参数调用你的方法
            handleArray(array, 0, length);
        }
    }

    /**
     * 代码清单 5-3 使用 ByteBuffer 的复合缓冲区模式
     */
    public static void byteBufferComposite(ByteBuffer header, ByteBuffer body) {
        // Use an array to hold the message parts
        ByteBuffer[] message =  new ByteBuffer[]{ header, body };

        // Create a new ByteBuffer and use copy to merge the header and body
        ByteBuffer message2 =
                ByteBuffer.allocate(header.remaining() + body.remaining());
        message2.put(header);
        message2.put(body);
        message2.flip();
    }


    /**
     * 代码清单 5-4 使用 CompositeByteBuf 的复合缓冲区模式
     */
    public static void byteBufComposite() {
        CompositeByteBuf messageBuf = Unpooled.compositeBuffer();
        ByteBuf headerBuf = BYTE_BUF_FROM_SOMEWHERE; // can be backing or direct
        ByteBuf bodyBuf = BYTE_BUF_FROM_SOMEWHERE;   // can be backing or direct
        //将 ByteBuf 实例追加到 CompositeByteBuf
        messageBuf.addComponents(headerBuf, bodyBuf);
        //...
        //删除位于索引位置为 0（第一个组件）的 ByteBuf
        messageBuf.removeComponent(0); // remove the header
        //循环遍历所有的 ByteBuf 实例
        for (ByteBuf buf : messageBuf) {
            System.out.println(buf.toString());
        }
    }

    /**
     * 代码清单 5-5 访问 CompositeByteBuf 中的数据
     */
    public static void byteBufCompositeArray() {
        CompositeByteBuf compBuf = Unpooled.compositeBuffer();
        //获得可读字节数
        int length = compBuf.readableBytes();
        //分配一个具有可读字节数长度的新数组
        byte[] array = new byte[length];
        //将字节读到该数组中
        compBuf.getBytes(compBuf.readerIndex(), array);
        //使用偏移量和长度作为参数使用该数组
        handleArray(array, 0, array.length);
    }

    /**
     * 代码清单 5-6 访问数据
     */
    public static void byteBufRelativeAccess() {
        ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        for (int i = 0; i < buffer.capacity(); i++) {
            byte b = buffer.getByte(i);
            System.out.println((char) b);
        }
    }

    /**
     * 代码清单 5-7 读取所有数据
     */
    public static void readAllData() {
        ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        while (buffer.isReadable()) {
            System.out.println(buffer.readByte());
        }
    }

    /**
     * 代码清单 5-8 写数据
     */
    public static void write() {
        // Fills the writable bytes of a buffer with random integers.
        ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        while (buffer.writableBytes() >= 4) {
            buffer.writeInt(random.nextInt());
        }
    }

    /**
     * 代码清单 5-9 使用 ByteBufProcessor 来寻找\r
     *
     * use {@link io.netty.buffer.ByteBufProcessor in Netty 4.0.x}
     */
    public static void byteProcessor() {
        ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        int index = buffer.forEachByte(ByteProcessor.FIND_CR);
    }

    /**
     * 代码清单 5-9 使用 ByteBufProcessor 来寻找\r
     *
     * use {@link io.netty.util.ByteProcessor in Netty 4.1.x}
     */
    public static void byteBufProcessor() {
        ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        int index = buffer.forEachByte(ByteBufProcessor.FIND_CR);
    }

    /**
     * 代码清单 5-10 对 ByteBuf 进行切片
     */
    public static void byteBufSlice() {
        Charset utf8 = Charset.forName("UTF-8");
        //创建一个用于保存给定字符串的字节的 ByteBuf
        ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
        //创建该 ByteBuf 从索引 0 开始到索引 15 结束的一个新切片
        ByteBuf sliced = buf.slice(0, 15);
        //将打印“Netty in Action”
        System.out.println(sliced.toString(utf8));
        //更新索引 0 处的字节
        buf.setByte(0, (byte)'J');
        //将会成功，因为数据是共享的，对其中一个所做的更改对另外一个也是可见的
        assert buf.getByte(0) == sliced.getByte(0);
    }

    /**
     * 代码清单 5-11 复制一个 ByteBuf
     */
    public static void byteBufCopy() {
        Charset utf8 = Charset.forName("UTF-8");
        //创建 ByteBuf 以保存所提供的字符串的字节
        ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
        //创建该 ByteBuf 从索引 0 开始到索引 15 结束的分段的副本
        ByteBuf copy = buf.copy(0, 15);
        //将打印“Netty in Action”
        System.out.println(copy.toString(utf8));
        //更新索引 0 处的字节
        buf.setByte(0, (byte)'J');
        //将会成功，因为数据不是共享的
        assert buf.getByte(0) != copy.getByte(0);
    }

    /**
     * 代码清单 5-12 get()和 set()方法的用法
     */
    public static void byteBufSetGet() {
        Charset utf8 = Charset.forName("UTF-8");
        //创建一个新的 ByteBuf以保存给定字符串的字节
        ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
        //打印第一个字符'N'
        System.out.println((char)buf.getByte(0));
        //存储当前的 readerIndex 和 writerIndex
        int readerIndex = buf.readerIndex();
        int writerIndex = buf.writerIndex();
        //将索引 0 处的字 节更新为字符'B'
        buf.setByte(0, (byte)'B');
        //打印第一个字符，现在是'B'
        System.out.println((char)buf.getByte(0));
        //将会成功，因为这些操作并不会修改相应的索引
        assert readerIndex == buf.readerIndex();
        assert writerIndex == buf.writerIndex();
    }

    /**
     * 代码清单 5-13 ByteBuf 上的 read()和 write()操作
     */
    public static void byteBufWriteRead() {
        Charset utf8 = Charset.forName("UTF-8");
        //创建一个新的 ByteBuf 以保存给定字符串的字节
        ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
        //打印第一个字符'N'
        System.out.println((char)buf.readByte());
        //存储当前的readerIndex
        int readerIndex = buf.readerIndex();
        //存储当前的writerIndex
        int writerIndex = buf.writerIndex();
        //将字符 '?'追加到缓冲区
        buf.writeByte((byte)'?');
        assert readerIndex == buf.readerIndex();
        //将会成功，因为 writeByte()方法移动了 writerIndex
        assert writerIndex != buf.writerIndex();
    }

    private static void handleArray(byte[] array, int offset, int len) {}

    /**
     * 代码清单 5-14 获取一个到 ByteBufAllocator 的引用
     */
    public static void obtainingByteBufAllocatorReference(){
        Channel channel = CHANNEL_FROM_SOMEWHERE; //get reference form somewhere
        //从 Channel 获取一个到ByteBufAllocator 的引用
        ByteBufAllocator allocator = channel.alloc();
        //...
        ChannelHandlerContext ctx = CHANNEL_HANDLER_CONTEXT_FROM_SOMEWHERE; //get reference form somewhere
        //从 ChannelHandlerContext 获取一个到 ByteBufAllocator 的引用
        ByteBufAllocator allocator2 = ctx.alloc();
        //...
    }

    /**
     * 代码清单 5-15 引用计数
     * */
    public static void referenceCounting(){
        Channel channel = CHANNEL_FROM_SOMEWHERE; //get reference form somewhere
        //从 Channel 获取ByteBufAllocator
        ByteBufAllocator allocator = channel.alloc();
        //...
        //从 ByteBufAllocator分配一个 ByteBuf
        ByteBuf buffer = allocator.directBuffer();
        //检查引用计数是否为预期的 1
        assert buffer.refCnt() == 1;
        //...
    }

    /**
     * 代码清单 5-16 释放引用计数的对象
     */
    public static void releaseReferenceCountedObject(){
        ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere
        //减少到该对象的活动引用。当减少到 0 时，该对象被释放，并且该方法返回 true
        boolean released = buffer.release();
        //...
    }


}

 

全方位技术攻关 | 带你建立Netty网络编程技术栈 ——【基础篇】分析Netty的组件和架构设计（1）
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
03-07 284
本文将通过构建一个简易的网络客户端与服务器，从类库和框架这两个紧密相连的视角，深入剖析Netty。同时，我们还将站在更高的层次上，探讨Netty的技术特性与体系结构，主要包含了设计角度和组件角度。接下来，我们将重点介绍Netty的核心组件，包括Channel、EventLoop和ChannelFuture类。这些组件构成了Netty网络通信架构的基础，我们将深入探讨它们的实现细节，并分析它们如何协同工作以支持高效的网络通信。
Netty(四)——HTTP服务端之例
学会改变自己——才能突破
10-28 1524
        HTTP（HyperText Transfer Protocol，超文本传输协议）是因特网上应用最为广泛的一种网络传输协议，所有的WWW文件都必须遵守这个标准。我们用的tomcat、jetty、jobss等各种服务器，其实就是一个服务端容器，方便我们直接部署我们应用，让用户通过使用客户端（WEB浏览器、手机H5、app等）借住HTTP协议，来完成信息的提交和获取。这篇文章简单总结一...
netty的ByteBuf的演示Demo
shuixiou1的博客
03-20 353
Netty的ByteBuf的演示Demo 1、概述 * Netty内部数据结构是一个byte，其中有一个readIndex字段，和一个writeIndex字段，标记读的位置和写的位置 * [ discardable | readable | writeable ] * [ readIndex writeIndex capacity] 2、常用API * Byte...
Netty的深入浅出--72.数据容器ByteBuf简单实例
moxiaolin的博客
06-20 171
这一章我们要讲的重点是bytebuf 首先通过一个程序实例来理解一下： 通过调用Unpooled静态类来创建一个长度为10的buffer（在netty中数据有两种存放方式，pool和unpool） 向buffer中写入数据 取出数据 运行结果 ...
Netty in Action -ByteBuf
lzf的博客
05-27 637
Buffer（缓冲）正如我们先前所指出的，网络数据的基本单位永远是 byte(字节)。Java NIO 提供 ByteBuffer 作为字节的容器，但这个类是过于复杂，有点难以使用。Netty 中 ByteBuffer 替代是 ByteBuf，一个强大的实现，解决JDK 的 API 的限制，以及为网络应用程序开发者一个更好的工具。但 ByteBuf 并不仅仅暴露操作一个字节序列的方法;这也是专门的...
ByteBuf使用实例
wuxun1997的专栏
10-25 472
　　之前我们有个netty5的拆包解决方案(参加netty5拆包问题解决实例)，现在我们采用另一种思路，不需要新增LengthFieldBasedFrameDecoder，直接修改NettyMessageDecoder： package com.wlf.netty.nettyapi.msgpack; import com.wlf.netty.nettyapi.constant.Delimit...
Netty实战-读书笔记-ByteBuf
编程战五渣
07-22 297
网络数据的基本单位是字节，那么在JavaNIO和netty分别用什么作为字节容易呢？ 在JavaNIO中使用ByteBuffer作为字节容器，Netty使用ByteBuf Netty的数据处理API通过两个组件暴露出来，一个是ByteBuf，一个是ByteBufHolder ------- 跟ByteBuffer相比，ByteBuf有以下几个优点（个人觉得比较重要的几个点）： 1.通过内...
Netty——简单的入门代码示例
共勉
02-21 1742
一个非常简单的Netty入门示例，简简单单搞定服务端和客户端的通信
《Netty最佳实践》——《Netty实战》补遗-Netty-Best-Practices.zip
11-06
1. **ByteBuf**: Netty自定义的字节缓冲区，提供了比Java NIO ByteBuffer更高效的内存管理和操作接口。 2. **Channel**: 表示网络连接，可以用来读写数据。 3. **EventLoop**: 事件循环，负责处理I/O事件并调度任务...
深入浅出Netty框架开发——权威指南第二版
《Netty权威指南[第2版]带书签...它不仅介绍了Netty的基础，还深入探讨了Netty的高级特性与实战案例，为想要精通Netty的开发者提供了全方位的学习路径。通过对这本书的学习，读者可以实现从Netty初学者到专家的转变。
抽象类ByteBuffer能否实例化？——由一个实例化疑问说开去
yongliang567的博客
08-03 338
ByteBuffer是java.nio中最常用的缓冲区,它提供了读写其他数据类型的方法。然而查看API文档后发现，java.nio.ByteBuffer其实是一个抽象类，其中有许多的抽象方法，如asCharBuffer(),asIntBuffer()等. 有两类静态工厂方法用于创建ByteBuffer：ByteBuffer.allocate(int capacity)和Byt...
深入研究Netty框架之ByteBuf家族
weixin_34122604的博客
09-06 186
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty源码解析之ByteBuf简析
Lisam Blog
11-11 1020
ByteBuf是什么？ 首先当前类是ByteBuf.java类，是netty缓存的抽象类。主要包含如下几个Index 0<=readerIndex<=writerIndex<=capacity 包含的方法大致如下 setXxx //设置当前index对应的值 readXxx //读...
重学Netty（五）——细说一下ByteBuf
qq_42605968的博客
04-16 820
在上篇文章也提到ByteBuf和它的几种模式，下面就来了解一下ByteBuf的其他方面，及其优点。还有一些关于ByteBuf池化的一些问题。 ByteBuf的几种获取方式 在Netty中可以通过下面三种方法来获取ByteBuf ByteBufAllocator 可以使用ByteBufAllocator来进行Buffer的按需分配，可以自己定义大小，也可以自己决定是否使用Buffer内存池。 B...
Netty学习5——ByteBuf
TomWu的博客
06-06 360
ByteBuf    网络数据的基本单位总是字节。Java NIO提供了ByteBuffer作为它的字节容器，但是这个类使用起来过于复杂，而且也有些繁琐。    Netty的ByteBuffer替代品是ByteBuf，一个强大的实现，既解决了JDK API的局限性，又为网络应用程序的开发者提供了更好地API。1.ByteBuf的API    Netty的数据处理API通过两个组件暴露——abstr...
ByteBuff常用方法，使用
热门推荐
一点光辉的博客
07-04 1万+
ByteBuff常用方法，使用
Netty之ByteBuf详解与实战
HaSaKing的博客
02-26 2318
ByteBuf是Netty中处理字节数据的核心类，设计用来替代Java NIO中的ByteBuffer。与ByteBuffer相比，ByteBuf提供了更高的性能和更丰富的API。它支持引用计数、池化和零拷贝操作，使得数据处理更加高效。
通过案例学Netty1-ButeBuf
qq_52107150的博客
11-16 254
可以看到上面两个案例切换服务器端就是依靠切换Handler，netty通过链式添加处理链条同时服务器端和客户端也十分详细，一个serverBootstrap，一个Bootstrap。除了服务器端多了一个EventLoopGroup外，其他都一样。
netty系列之:netty中的ByteBuf详解
m0_60028455的博客
08-04 3210
工具与资源中心 帮助开发者更加高效的工作，提供围绕开发者全生命周期的工具与资源 https://developer.aliyun.com/tool?spm=a1z389.11499242.0.0.65452413R1MRKF&utm_content=g_1000283979 简介 netty中用于进行信息承载和交流的类叫做ByteBuf，从名字可以看出这是Byte的缓存区，那么ByteBuf都有哪些特性呢？一起来看看。 ByteBuf详解 netty提供了一个io.netty.buff.
netty怎么把ByteBuf包装进类里传输
最新发布
01-03
Netty是一个高性能、异步事件驱动的网络应用程序框架，特别适合于服务端应用和高并发场景。为了将`ByteBuf`（内部字节缓冲区）包装进自定义的类中并方便地在网络传输，你可以创建一个包含`ByteBuf`作为成员变量的POJO（Plain Old Java Object），然后通过Netty的`ChannelHandlerContext`来处理数据交换。 首先，定义一个类，比如`Message`： ```java public class Message { private final ByteBuf content; // 或者有其他属性 public Message(ByteBuf content) { this.content = content.copy(); // 复制ByteBuf以便持久化 } // 提供getter和setter方法，以及释放资源的close()方法 public ByteBuf getContent() { return content; } public void close() { content.release(); } } ``` 在服务器端，当接收到`ByteBuf`时，可以构造`Message`对象： ```java ByteBuf receivedContent = ... // 从网络接收的数据 Message message = new Message(receivedContent); // 然后可以在需要的地方发送消息，例如通过Channel发送出去 channel.writeAndFlush(message); ``` 客户端则相反，发送数据前先构造`Message`，再转换回`ByteBuf`： ```java Message outgoingMessage = new Message(someDataToSend); // 填充内容 ByteBuf byteBuf = outgoingMessage.getContent(); channel.writeAndFlush(byteBuf); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值