二 NIO-ByteBuffer

最新推荐文章于 2021-10-25 16:06:00 发布
最新推荐文章于 2021-10-25 16:06:00 发布
阅读量147 收藏
点赞数
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37119960/article/details/118753939
版权

1.使用案例

有一普通文本文件 data.txt，内容为

1234567890abcd

使用 FileChannel 来读取文件内容

@Slf4j
public class ChannelDemo1 {
    public static void main(String[] args) {
        try (RandomAccessFile file = new RandomAccessFile("helloword/data.txt", "rw")) {
            FileChannel channel = file.getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(10);
            do {
                // 向 buffer 写入
                int len = channel.read(buffer);
                log.debug("读到字节数：{}", len);
                if (len == -1) {
                    break;
                }
                // 切换 buffer 读模式
                buffer.flip();
                while(buffer.hasRemaining()) {
                    log.debug("{}", (char)buffer.get());
                }
                // 切换 buffer 写模式
                buffer.clear();
            } while (true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出

10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数：10
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 1
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 2
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 3
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 4
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 5
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 6
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 7
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 8
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 9
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 0
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数：4
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - a
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - b
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - c
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - d
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数：-1

2.ByteBuffer 正确使用姿势

  1. 向 buffer 写入数据，例如调用 channel.read(buffer)
  2. 调用 flip() 切换至读模式
  3. 从 buffer 读取数据，例如调用 buffer.get()
  4. 调用 clear() 或 compact() 切换至写模式
  5. 重复 1~4 步骤

3. ByteBuffer 结构

ByteBuffer 有以下重要属性

  • capacity
  • position
  • limit

一开始
在这里插入图片描述
写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态
在这里插入图片描述
flip 动作发生后，position 切换为读取位置，limit 切换为读取限制
在这里插入图片描述
clear 动作发生后，全部清空，回到最初申请的时候，状态
在这里插入图片描述
compact 方法，是把未读完的部分向前压缩，然后切换至写模式
在这里插入图片描述
💡 调试工具类

public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }
}

此工具类可以打印出ByteBuffer内部的存储结构，方便查看，使用方式debugAll(ByteBuffer byte)

4.ByteBuffer 常见方法

分配空间

可以使用 allocate 方法为 ByteBuffer 分配空间，其它 buffer 类也有该方法

Bytebuffer buf = ByteBuffer.allocate(16);
向 buffer 写入数据

有两种办法

  • 调用 channel 的 read 方法
  • 调用 buffer 自己的 put 方法
int readBytes = channel.read(buf);

和

buf.put((byte)127);
从 buffer 读取数据

同样有两种办法

  • 调用 channel 的 write 方法
  • 调用 buffer 自己的 get 方法
int writeBytes = channel.write(buf);

和

byte b = buf.get();

get 方法会让 position 读指针向后走，如果想重复读取数据

  • 可以调用 rewind 方法将 position 重新置为 0
  • 或者调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针
mark 和 reset

mark 是在读取时，做一个标记，即使 position 改变，只要调用 reset 就能回到 mark 的位置

**注意**

rewind 和 flip 都会清除 mark 位置
字符串与 ByteBuffer 互转
ByteBuffer buffer1 = StandardCharsets.UTF_8.encode("你好");
ByteBuffer buffer2 = Charset.forName("utf-8").encode("你好");

debug(buffer1);
debug(buffer2);

CharBuffer buffer3 = StandardCharsets.UTF_8.decode(buffer1);
System.out.println(buffer3.getClass());
System.out.println(buffer3.toString());

输出
在这里插入图片描述

⚠️ Buffer 的线程安全
Buffer 是非线程安全的

5. Scattering Reads

分散读取，有一个文本文件 3parts.txt

onetwothree

使用如下方式读取，可以将数据填充至多个 buffer。一个文本数据写到多个ByteBuffer中

try (RandomAccessFile file = new RandomAccessFile("helloword/3parts.txt", "rw")) {
    FileChannel channel = file.getChannel();
    ByteBuffer a = ByteBuffer.allocate(3);
    ByteBuffer b = ByteBuffer.allocate(3);
    ByteBuffer c = ByteBuffer.allocate(5);
    channel.read(new ByteBuffer[]{a, b, c});
    a.flip();
    b.flip();
    c.flip();
    debug(a);
    debug(b);
    debug(c);
} catch (IOException e) {
    e.printStackTrace();
}

结果
在这里插入图片描述

6. Gathering Writes

使用如下方式写入，可以将多个 buffer 的数据填充至 channel，将多个ByteBuffer里面的数据写入文件。

try (RandomAccessFile file = new RandomAccessFile("helloword/3parts.txt", "rw")) {
    FileChannel channel = file.getChannel();
    ByteBuffer d = ByteBuffer.allocate(4);
    ByteBuffer e = ByteBuffer.allocate(4);
    channel.position(11);

    d.put(new byte[]{'f', 'o', 'u', 'r'});
    e.put(new byte[]{'f', 'i', 'v', 'e'});
    d.flip();
    e.flip();
    debug(d);
    debug(e);
    channel.write(new ByteBuffer[]{d, e});
} catch (IOException e) {
    e.printStackTrace();
}

输出
在这里插入图片描述
文件内容

onetwothreefourfive

7. 练习

网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有3条为

  • Hello,world\n
  • I’m zhangsan\n
  • How are you?\n

变成了下面的两个 byteBuffer (黏包，半包)

  • Hello,world\nI’m zhangsan\nHo
  • w are you?\n

现在要求你编写程序，将错乱的数据恢复成原始的按 \n 分隔的数据

public static void main(String[] args) {
    ByteBuffer source = ByteBuffer.allocate(32);
    //                     11            24
    source.put("Hello,world\nI'm zhangsan\nHo".getBytes());
    split(source);

    source.put("w are you?\nhaha!\n".getBytes());
    split(source);
}

private static void split(ByteBuffer source) {
    source.flip();
    int oldLimit = source.limit();
    for (int i = 0; i < oldLimit; i++) {
        if (source.get(i) == '\n') {
            System.out.println(i);
            ByteBuffer target = ByteBuffer.allocate(i + 1 - source.position());
            // 0 ~ limit
            source.limit(i + 1);
            target.put(source); // 从source 读，向 target 写
            debugAll(target);
            source.limit(oldLimit);
        }
    }
    source.compact();
}

在Netty框架中解决黏包问题的底层实现就是这样。

qq_37119960
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-NIO-demo
01-10
Java NIO提供了多种类型的缓冲区，如ByteBuffer、CharBuffer、IntBuffer等，对应不同的数据类型。 选择器（Selector）是NIO中的多路复用机制。通过一个选择器，我们可以监控多个通道的状态，例如是否有数据可读、可...
Dependency not found解决方案（Springboot，绝对有效）
最新发布
m0_54355172的博客
06-10 1万+
springboot 中 Maven 依赖无法拉取的解决方案
Netty网络框架在安卓端的使用介绍
weixin_42324979的博客
07-29 4181
Netty的介绍 介绍： Netty 是JBoss提供的一个java开源框架，Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可用性的网络服务器和客户端程序。也就是说 Netty 是一个基于 Nio 的编程框架，使用Netty可以快速的开发出一个网络应用。 并且可以在不妥协的情况下实现易于开发、性能、稳定性和灵活性。 . . Netty核心概念的介绍 . 1. Bootstrap、ServerBootstrap 介绍： Bootstrap 的意思是引导，其主要作用是配置
《Netty权威指南》之NIO ByteBuffer详解
凌夜知惜
05-16 422
  Java NIO（New IO） 是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。 NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同， NIO支持面向缓冲区的、基于   通道的IO操作。 NIO将以更加高效的方式进行文件的读写操作。 Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到 ...
Netty详解之九：ByteBuf介绍
longhuihu的专栏
08-03 4083
本篇深入剖析Netty读写缓冲区的设计，内容包括ByteBuf抽象、池化ByteBuf、Direct ByteBuf、Channel的读写冲缓冲区。 ByteBuf 为了提高性能，Netty重新设计了字节缓冲区ByteBuf，类似Nio的ByteBuffer，但工作方式略有区别，比后者更加灵活、高效。 ByteBuf有几个重要属性： capacity：容量； 0：缓冲区开始位置； readIndex：下一个读位置； writeIndex：下一个写位置； 一个ByteBuf对象即可像byte数组一样工作，
ByteBuffer的allocate()方法详解
热门推荐
weixin_44400390的博客
06-28 1万+
ByteBuffer的allocate()方法详解 allocate()方法用于分配缓冲区。但是如果是聚集写入,与分散读取,就需要注意这个大小设置, String property = System.getProperty("user.dir"); FileOutputStream FileOutputStream = new FileOutputStream(property ...
Java-NIO-Programming-Cookbook(含源码)
02-03
在Java NIO中，`ByteBuffer`是核心类之一，它用于存储和读写数据。`DirectByteBuffer`是`ByteBuffer`的一个实现，它与`Non-Direct Buffer`（即堆缓冲区）有所不同。直接缓冲区在Java中使用JNI（Java Native ...
Java-NIO-Netty框架学习
03-23
3. **高性能的缓冲区**：Netty使用ByteBuf作为缓冲区，相较于Java原生的ByteBuffer，提供了更丰富的操作接口和更优秀的性能。 4. **强大的编码解码器**：Netty提供了一系列预定义的编解码器，用于处理各种常见协议...
NIO(byteBuffer)按行读取文件
08-31
使用nio byteBuffer 实现按行读取文件(大文件) 在window/linux/macOS上均测试通过 对于中文乱码也已处理成功 完整注释，可随需求更改 有问题请邮件:mly610865580@126.com
nio.rar_NIO_NIO-socket_java nio_java 实例_java.nio
09-19
4. **ByteBuffer**：用于存储和传输数据的缓冲区，可以在通道和缓冲区之间进行数据的读写操作。 5. **Selectors.open()** 和 **Channels.register()**：用于打开`Selector`并将其与通道关联。 6. **SelectionKey**：...
netty-all-4.1.5.Final完整pom.xml文件配置
08-16
由于netty各个版本之间差异较大，这里整理了一下各个版本的包及样例，使用了maven工程，将各个版本需要的最简jar文件已配置完全，可以在些基础上进行正式项目的开发。
java bufferarray_Java中的ByteBuffer arrayOffset()方法
weixin_32260467的博客
02-23 261
使用arrayOffset()类java.nio.ByteBuffer中的方法可以获得缓冲区数组内部缓冲区的第一个元素的偏移量。如果数组支持的缓冲区是只读的，则抛出ReadOnlyBufferException。演示此的程序如下所示-示例importjava.nio.*;importjava.util.*;publicclassDemo{publicstaticvoidmain(S...
java项目模板-Netty
艰苦奋斗
12-10 1158
gradle implementation 'io.netty:netty-all:4.1.31.Final' 常用服务端辅助代码: import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io...
Andriod中导入Netty的两种方式
qq_49919058的博客
10-25 1913
方式一： 1.在build.gradle中添加 implementation 'io.netty:netty-all:4.1.69.Final' 2.点击Sync同步，如下图所示 方式二： 1.下载netty jar包并导入至libs下方 2.在build.gradle(app)文件dependencies中添加 compile fileTree(include:['*.jar'],dir:'libs') ...
netty依赖精简
kgdngitfk的博客
08-11 3669
通常情况下为了方便我们在使用netty时会使用以下的maven依赖声明 <!-- https://mvnrepository.com/artifact/io.netty/netty-all --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.66.Final</v
maven 由于传递依赖导致的引入低版本jar包导致classnotfind异常问题解决
卖辣椒也用券
10-08 4338
maven导入jar包时，可能由于不同jar包之间依赖了不同版本的另外的jar包，会导致classnotfind异常。 举个我遇到的例子：         &lt;dependency&gt;             &lt;groupId&gt;org.glassfish.jersey.containers&lt;/groupId&gt;             &lt;artifactI...
netty案例，netty4.1中级拓展篇一《Netty与SpringBoot整合》
bugstack虫洞栈
08-22 2257
前言介绍 在实际的开发中，我们需要对netty服务进行更多的操作，包括；获取它的状态信息、启动/停止、对客户端用户强制下线等等，为此我们需要把netty服务加入到web系统中，那么本章节介绍如何将Netty与SpringBoot整合。 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使...
记一次springboot集成elasticsearch的netty版本冲突问题
fzc17864293318的博客
05-29 4250
1.pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven...
java.nio.bytebuffer的duplicate
05-11
`java.nio.ByteBuffer` 的 `duplicate()` 方法会创建一个新的 `ByteBuffer` 对象，与原始对象共享相同的底层数组和位置、限制和标记。这意味着，对其中一个 `ByteBuffer` 对象的更改将反映在另一个对象中。 以下是使用 `duplicate()` 方法创建 `ByteBuffer` 对象的示例代码： ```java ByteBuffer originalBuffer = ByteBuffer.allocate(10); ByteBuffer duplicateBuffer = originalBuffer.duplicate(); ``` 在这个例子中，`duplicateBuffer` 与 `originalBuffer` 共享相同的底层数组、位置、限制和标记。如果你更改 `originalBuffer` 的位置或限制，则 `duplicateBuffer` 的位置或限制也会相应更改。同样地，如果你在 `originalBuffer` 中写入数据，那么这些数据也会在 `duplicateBuffer` 中可见。 需要注意的是，通过 `duplicate()` 方法创建的 `ByteBuffer` 对象不是线程安全的，因此在多线程环境下使用时需要注意同步问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值