《MMO 服务器开发》4.2 双栈对照：Go 编解码与 Netty ByteBuf 零拷贝

[内核缓冲区] --recv--> [应用缓冲 buf] --视图--> [payload 视图] --decode--> [结构体]
                         ^^^^^^^^^^^^          ^^^^^^^^^^^
                         真正分配的地方        零拷贝：与 buf 共享底层数组

// file: internal/codec/zerocopy.go
// tier: L1
// verify: go test ./internal/codec/
package codec

// 本文件演示「切片视图」式的零拷贝：从一帧原始字节里切出 payload，
// 不 new、不 copy，payload 与原始帧共享同一块底层数组。
//
// 这是 Go 里最便宜的零拷贝手段：一次切片头赋值（3 个机器字），
// 代价是 payload 的生命周期被绑定到原始帧——原始帧不释放，payload 就一直在。

// SplitFrame 从一帧「uint32 长度前缀 + payload」里切出 payload 视图。
//
// 返回的 payload 是 raw 的切片，与 raw 共享底层数组。调用方必须保证
// 在使用 payload 期间，raw 不被复用或写坏。
func SplitFrame(raw []byte) (payload []byte, err error) {
	r := NewReader(raw)
	n, err := r.GetUint32()
	if err != nil {
		return nil, err
	}
	if uint64(n) > uint64(r.Remaining()) {
		return nil, ErrShortBuffer
	}
	start := r.Pos()
	// 直接切片：不 new、不 copy。&payload[0] == &raw[start]。
	return raw[start : start+int(n)], nil
}

// SliceBytes 与 Reader.GetBytes 相对：同样读「uint32 长度前缀 + 内容」，
// 但返回的是 raw 的切片视图而非拷贝。适合「读完立刻转发」的网关场景。
func (r *Reader) SliceBytes() ([]byte, error) {
	n, err := r.GetUint32()
	if err != nil {
		return nil, err
	}
	if uint64(n) > uint64(r.Remaining()) {
		return nil, ErrShortBuffer
	}
	start := r.pos
	r.pos += int(n)
	return r.buf[start:r.pos], nil
}

// SharesBackingArray 判断两个字节切片是否共享同一底层数组。
// 仅用于测试与断言——生产代码不该依赖这个。
func SharesBackingArray(a, b []byte) bool {
	if len(a) == 0 || len(b) == 0 {
		return false
	}
	return &a[0] == &b[0]
}

// snippet: internal/codec/zerocopy_test.go（摘录）
func TestSplitFrameIsZeroCopy(t *testing.T) {
	// 一帧：uint32 长度前缀 3 + 3 字节 payload。
	raw := []byte{0, 0, 0, 3, 0xAA, 0xBB, 0xCC}
	payload, err := SplitFrame(raw)
	if err != nil {
		t.Fatalf("SplitFrame: %v", err)
	}
	if !SharesBackingArray(payload, raw[4:]) {
		t.Fatal("payload 未与 raw 共享底层数组——说明发生了拷贝")
	}
	// 改原始帧的一个字节，payload 视图应同步变化。
	raw[4] = 0x99
	if payload[0] != 0x99 {
		t.Fatalf("改 raw[4] 后 payload[0] = %#x，未共享底层数组", payload[0])
	}
	// 反过来改 payload，raw 也应变化。
	payload[2] = 0x77
	if raw[6] != 0x77 {
		t.Fatalf("改 payload[2] 后 raw[6] = %#x，未共享底层数组", raw[6])
	}
}

// file: $HOME/.aegis-java/ch04/ByteBufDemo.java
// tier: L2J
// verify: docker run --rm -v "$HOME/.aegis-java/ch04:/w" -w /w eclipse-temurin:21-jdk sh -c "javac ByteBufDemo.java && java ByteBufDemo"
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ReadOnlyBufferException;

// 用 JDK 自带的 java.nio.ByteBuffer 演示「视图式零拷贝」：
// slice() / duplicate() / asReadOnlyBuffer() 都返回共享同一底层数组的视图，
// 不复制数据。Netty 的 ByteBuf 是同一思路的工程化版本（读写指针分离 + 引用计数 + 池化）。
public class ByteBufDemo {
    public static void main(String[] args) {
        // 一帧：uint32 长度前缀 3 + 3 字节 payload。
        ByteBuffer frame = ByteBuffer.allocate(32).order(ByteOrder.BIG_ENDIAN);
        frame.putInt(3);
        frame.put((byte) 0xAA);
        frame.put((byte) 0xBB);
        frame.put((byte) 0xCC);
        frame.flip();

        // 读长度前缀，然后把 limit 卡到 payload 末尾（等价于「拆包」）。
        int len = frame.getInt();
        frame.limit(frame.position() + len);

        // 关键：slice() 是零拷贝视图——共享同一底层数组，只换独立的 position/limit。
        ByteBuffer payload = frame.slice();

        System.out.println("len=" + len);
        System.out.println("payload.position=" + payload.position()
                + " limit=" + payload.limit() + " remaining=" + payload.remaining());
        System.out.println("frame.array() == payload.array() ? " + (frame.array() == payload.array()));

        // 通过 payload 改一个字节，原始 frame 的底层数组同步变化 → 证明共享。
        payload.put(0, (byte) 0x99);
        System.out.printf("frame.array()[4]=0x%02X payload.get(0)=0x%02X%n",
                frame.array()[4], payload.get(0));

        // duplicate()：独立读写指针，仍共享数据。
        ByteBuffer dup = payload.duplicate();
        dup.position(1);
        System.out.printf("dup.get()=0x%02X%n", dup.get() & 0xFF);

        // asReadOnlyBuffer()：只读视图，写入抛异常。
        ByteBuffer ro = payload.asReadOnlyBuffer();
        try {
            ro.put(0, (byte) 0x00);
            System.out.println("readonly write: 未抛异常（不该发生）");
        } catch (ReadOnlyBufferException e) {
            System.out.println("readonly write: ReadOnlyBufferException（符合预期）");
        }

        // 对照：真正复制会得到另一块底层数组。
        byte[] copied = new byte[len];
        payload.duplicate().get(copied);
        System.out.println("copied 与视图共享底层数组 ? " + (copied == payload.array()));

        // 池化视角：直接缓冲区（堆外）不能拿 array()，只能靠视图共享。
        ByteBuffer direct = ByteBuffer.allocateDirect(32).order(ByteOrder.BIG_ENDIAN);
        direct.putInt(2).put((byte) 0x11).put((byte) 0x22).flip();
        int dlen = direct.getInt();
        direct.limit(direct.position() + dlen);
        ByteBuffer dview = direct.slice();
        dview.put(0, (byte) 0x33);
        System.out.printf("direct view 写回后 direct.get(4)=0x%02X hasArray=%b%n",
                direct.get(4) & 0xFF, direct.hasArray());
    }
}

len=3
payload.position=0 limit=3 remaining=3
frame.array() == payload.array() ? true
frame.array()[4]=0x99 payload.get(0)=0x99
dup.get()=0xBB
readonly write: ReadOnlyBufferException（符合预期）
copied 与视图共享底层数组 ? false
direct view 写回后 direct.get(4)=0x33 hasArray=false