一、.基本使用
使用ByteBuffer读取文件中的内容：
public class TestByteBuffer {
public static void main(String[] args) {
// 获得FileChannel
try (FileChannel channel = new FileInputStream("stu.txt").getChannel()) {
// 获得缓冲区
ByteBuffer buffer = ByteBuffer.allocate(10);
int hasNext = 0;
StringBuilder builder = new StringBuilder();
while((hasNext = channel.read(buffer)) > 0) {
// 切换模式 limit=position, position=0
buffer.flip();
// 当buffer中还有数据时，获取其中的数据
while(buffer.hasRemaining()) {
builder.append((char)buffer.get());
}
// 切换模式 position=0, limit=capacity
buffer.clear();
}
System.out.println(builder.toString());
} catch (IOException e) {
}
}
}
- 向 buffer 写入数据，调用 channel.read(buffer)：从channel读取数据写入buffer
- 调用 flip() 切换至读模式
- flip会使得buffer中的limit变为position，position变为0
- 从 buffer 读取数据，调用 buffer.get()
- 调用 clear() 或者compact()切换至写模式
- 调用clear()方法时position=0，limit变为capacity
- 调用compact()方法时，会将缓冲区中的未读数据压缩到缓冲区前面
- 重复以上步骤
二、结构
bytebuffer.png
public class TestByteBufferReadWrite {
public static void main(String[] args) {
ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put((byte) 0x61); // 'a'
debugAll(buffer);
/**
* position: [1], limit: [10]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 61 00 00 00 00 00 00 00 00 00 |a......... |
* +--------+-------------------------------------------------+----------------+
*/
buffer.put(new byte[]{0x62, 0x63, 0x64}); // b c d
debugAll(buffer);
/**
* position: [4], limit: [10]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 61 62 63 64 00 00 00 00 00 00 |abcd...... |
* +--------+-------------------------------------------------+----------------+
*/
//0 不切换成读模式，读不到数据
// System.out.println(buffer.get());
buffer.flip();
//97
System.out.println(buffer.get());
debugAll(buffer);
/**
* position: [1], limit: [5]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 61 62 63 64 00 00 00 00 00 00 |abcd...... |
* +--------+-------------------------------------------------+----------------+
*/
buffer.compact();
debugAll(buffer);
/**
* position: [3], limit: [10]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 62 63 64 64 00 00 00 00 00 00 |bcdd...... |
* +--------+-------------------------------------------------+----------------+
* +--------+-------------------- all ------------------------+----------------+
*/
buffer.put(new byte[]{0x65,0x66});
debugAll(buffer);
/**
* position: [5], limit: [10]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 62 63 64 65 66 00 00 00 00 00 |bcdef..... |
* +--------+-------------------------------------------------+----------------+
*/
}
}
三、常见方法
1.分配空间
可以使用 allocate 方法为 ByteBuffer 分配空间，其它 buffer 类也有该方法
import java.nio.ByteBuffer;
public class TestByteBufferAllocate {
public static void main(String[] args) {
System.out.println(ByteBuffer.allocate(16).getClass()); // class java.nio.HeapByteBuffer
System.out.println(ByteBuffer.allocateDirect(16).getClass()); // class java.nio.DirectByteBuffer
}
}
- class java.nio.HeapByteBuffer - java 堆内存，读写效率较低，受到 GC 的影响
- class java.nio.DirectByteBuffer - 直接内存，读写效率高（少一次拷贝），不会受 GC 影响，分配的效率低
2.向 buffer 写入数据
- 调用 channel 的 read 方法：
int readBytes = channel.read(buf); - 调用 buffer 自己的 put 方法：
buf.put((byte)127);
3.从 buffer 读取数据
- 调用 channel 的 write 方法：
int writeBytes = channel.write(buf); - 调用 buffer 自己的 get 方法：
byte b = buf.get();
get 方法会让 position 读指针向后走，如果想重复读取数据
- 可以调用 rewind 方法将 position 重新置为 0
- 或者调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针
4.mark 和 reset
mark 是在读取时，做一个标记，即使 position 改变，只要调用 reset 就能回到 mark 的位置
public class TestByteBufferRead {
public static void main(String[] args) {
ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put(new byte[]{'a', 'b', 'c', 'd'});
buffer.flip();
// rewind 从头开始读
/*
buffer.get(new byte[4]);
debugAll(buffer);
buffer.rewind();
System.out.println((char)buffer.get());
*/
/**
* position: [4], limit: [4]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 61 62 63 64 00 00 00 00 00 00 |abcd...... |
* a
*/
// mark & reset
// mark 做一个标记，记录 position 位置， reset 是将 position 重置到 mark 的位置
/*
System.out.println((char) buffer.get()); //a
System.out.println((char) buffer.get()); //b
buffer.mark(); // 加标记，索引 2 的位置
System.out.println((char) buffer.get()); //c
System.out.println((char) buffer.get()); //d
buffer.reset(); // 将 position 重置到做标记的地方，即索引 2
System.out.println((char) buffer.get()); //c
System.out.println((char) buffer.get()); //d
*/
// get(i) 不会改变读索引的位置
System.out.println((char) buffer.get(3)); //d
debugAll(buffer);
/**
* position: [0], limit: [4]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 61 62 63 64 00 00 00 00 00 00 |abcd...... |
*/
}
}
rewind 和 flip 都会清除 mark 位置
四、字符串与 ByteBuffer 互转
public class TestByteBufferString {
public static void main(String[] args) {
// 1. 字符串转为 ByteBuffer
ByteBuffer buffer1 = ByteBuffer.allocate(16);
buffer1.put("hello".getBytes());
debugAll(buffer1);
/**
* position: [5], limit: [16]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 |hello...........|
*/
// 2. Charset 会自动切换到读模式
ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("hello");
debugAll(buffer2);
/**
* position: [0], limit: [5]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 68 65 6c 6c 6f |hello |
*/
// 3. wrap 会自动切换到读模式
ByteBuffer buffer3 = ByteBuffer.wrap("hello".getBytes());
debugAll(buffer3);
/**
* position: [0], limit: [5]
* +-------------------------------------------------+
* | 0 1 2 3 4 5 6 7 8 9 a b c d e f |
* +--------+-------------------------------------------------+----------------+
* |00000000| 68 65 6c 6c 6f |hello |
*/
// 4. 转为字符串 读模式下可以直接转 写模式下找不到数据
String str1 = StandardCharsets.UTF_8.decode(buffer2).toString();
System.out.println(str1);//hello
// 写模式下需要切换为读模式
buffer1.flip();
String str2 = StandardCharsets.UTF_8.decode(buffer1).toString();
System.out.println(str2);//hello
}
}
五、Scattering Reads
分散读取，文本文件 3parts.txt
onetwothree
public class TestScatteringReads {
public static void main(String[] args) {
try (FileChannel channel = new RandomAccessFile("words2.txt", "r").getChannel()) {
ByteBuffer b1 = ByteBuffer.allocate(3);
ByteBuffer b2 = ByteBuffer.allocate(3);
ByteBuffer b3 = ByteBuffer.allocate(5);
channel.read(new ByteBuffer[]{b1, b2, b3});
b1.flip();
b2.flip();
b3.flip();
debugAll(b1);
debugAll(b2);
debugAll(b3);
} catch (IOException e) {
}
}
}
position: [0], limit: [3]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c |hel |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 6c 6f 77 |low |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 6f 72 6c 64 e4 |orld. |
六、Gathering Writes
将多个 buffer 的数据填充至 channel
public class TestGatheringWrites {
public static void main(String[] args) {
ByteBuffer b1 = StandardCharsets.UTF_8.encode("hello");
ByteBuffer b2 = StandardCharsets.UTF_8.encode("world");
ByteBuffer b3 = StandardCharsets.UTF_8.encode("你好");
try (FileChannel channel = new RandomAccessFile("words.txt", "rw").getChannel()) {
channel.write(new ByteBuffer[]{b1, b2, b3});
} catch (IOException e) {
}
}
}
减少数据拷贝，提高效率
七、网络数据传输粘包和半包
粘包：一次性发送多条数据
半包：接收方缓冲区大小限制
网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
但由于某种原因这些数据在接收时，被进行了重新组合。
将错乱的数据恢复成原始的按 \n 分隔的数据
public class TestByteBufferExam {
public static void main(String[] args) {
/*
例如原始数据有3条为
Hello,world\n
I'm zhangsan\n
How are you?\n
变成了下面的两个 byteBuffer (黏包，半包)
Hello,world\nI'm zhangsan\nHo
w are you?\n
将错乱的数据恢复成原始的按 \n 分隔的数据
*/
ByteBuffer source = ByteBuffer.allocate(32);
source.put("Hello,world\nI'm zhangsan\nHo".getBytes());
split(source);
source.put("w are you?\n".getBytes());
split(source);
}
private static void split(ByteBuffer source) {
source.flip();
for (int i = 0; i < source.limit(); i++) {
// 找到一条完整消息
if (source.get(i) == '\n') {
int length = i + 1 - source.position();
// 把这条完整消息存入新的 ByteBuffer
ByteBuffer target = ByteBuffer.allocate(length);
// 从 source 读，向 target 写
for (int j = 0; j < length; j++) {
target.put(source.get());
}
debugAll(target);
}
}
source.compact();
}
}
网友评论