ByteBuf 심화 — CompositeByteBuf & Slice

// 전통적인 방식 — 메모리 복사 발생
ByteBuf header = ...;
ByteBuf body = ...;

ByteBuf merged = Unpooled.buffer(header.readableBytes() + body.readableBytes());
merged.writeBytes(header); // 복사
merged.writeBytes(body);   // 복사

// CompositeByteBuf — 복사 없이 합성
CompositeByteBuf composite = Unpooled.compositeBuffer();
composite.addComponents(true, header, body);
// header와 body의 데이터를 복사하지 않고 참조만 보관
// 외부에서는 하나의 연속된 ByteBuf처럼 읽기 가능

CompositeByteBuf
├── Component 0: header (offset=0, length=12)
├── Component 1: body   (offset=12, length=256)
└── 총 readableBytes = 268

읽기 요청이 오면 → 인덱스로 어느 컴포넌트에 해당하는지 계산 → 해당 컴포넌트에서 읽기

CompositeByteBuf composite = Unpooled.compositeBuffer();

// true → writerIndex 자동 갱신 (권장)
composite.addComponents(true, header, body);
System.out.println(composite.readableBytes()); // header + body 크기

// false 또는 생략 → writerIndex 갱신 안 됨
CompositeByteBuf composite2 = Unpooled.compositeBuffer();
composite2.addComponents(header, body);
System.out.println(composite2.readableBytes()); // 0! writerIndex가 0이라 읽을 수 있는 데이터 없음

public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
    MyMessage message = (MyMessage) msg;

    // 헤더 생성
    ByteBuf header = ctx.alloc().buffer(8);
    header.writeInt(message.getType());
    header.writeInt(message.getBodyLength());

    // 바디 생성 (이미 인코딩된 상태)
    ByteBuf body = message.getBody();

    // 복사 없이 합성
    CompositeByteBuf packet = ctx.alloc().compositeBuffer();
    packet.addComponents(true, header, body);

    ctx.write(packet, promise);
}

// [길이(4바이트)] [페이로드] [체크섬(4바이트)]
ByteBuf lengthField = ctx.alloc().buffer(4);
lengthField.writeInt(payload.readableBytes());

ByteBuf checksum = ctx.alloc().buffer(4);
checksum.writeInt(calculateChecksum(payload));

CompositeByteBuf frame = ctx.alloc().compositeBuffer(3); // 최대 3개 컴포넌트
frame.addComponents(true, lengthField, payload, checksum);

ByteBuf original = Unpooled.copiedBuffer("Hello, Netty World!", StandardCharsets.UTF_8);

// 인자 없이 호출 — readableBytes 범위를 slice
ByteBuf sliced1 = original.slice();

// 범위 지정 — index 0부터 5바이트
ByteBuf sliced2 = original.slice(0, 5);  // "Hello"

// slice된 버퍼 수정 → 원본에도 반영
sliced2.setByte(0, 'h');
System.out.println(original.getByte(0)); // 'h' — 원본도 변경됨

ByteBuf original = Unpooled.copiedBuffer("Hello", StandardCharsets.UTF_8);

ByteBuf dup = original.duplicate();

// 인덱스 독립 — 원본의 readerIndex에 영향 없음
dup.readByte(); // dup의 readerIndex만 전진
System.out.println(original.readerIndex()); // 0 — 원본은 그대로

// 데이터 공유 — 수정하면 원본에도 반영
dup.setByte(0, 'h');
System.out.println((char) original.getByte(0)); // 'h'

ByteBuf original = ctx.alloc().buffer(256);
original.writeBytes("data".getBytes());

ByteBuf sliced = original.slice();

original.release(); // 원본 해제!

// 이후 sliced에 접근하면 → IllegalReferenceCountException 발생 가능
sliced.readByte(); // 위험!

// 방법 1: retainedSlice() / retainedDuplicate() 사용
ByteBuf safeSlice = original.retainedSlice(); // 참조 카운트 +1
// 사용 후 반드시 release() 필요

// 방법 2: 수동으로 retain()
ByteBuf sliced = original.slice();
sliced.retain(); // 참조 카운트 +1
// 사용 후 반드시 release() 필요

// slice() — 원본이 살아 있는 동안만 사용할 때
public void channelRead(ChannelHandlerContext ctx, ByteBuf msg) {
    ByteBuf header = msg.slice(0, 4);       // 헤더 4바이트만 뷰로 참조
    int length = header.readInt();
    ByteBuf body = msg.slice(4, length);    // 바디를 뷰로 참조
    processBody(body);                       // 이 메서드 안에서만 사용
    // msg가 해제되기 전에 모든 처리 완료
}

// copy() — 원본과 독립적으로 보관해야 할 때
public void channelRead(ChannelHandlerContext ctx, ByteBuf msg) {
    ByteBuf snapshot = msg.copy();          // 독립 복사본 생성
    pendingMessages.add(snapshot);           // 나중에 처리하기 위해 보관
    // msg가 해제되어도 snapshot은 안전
}

byte[] data = new byte[]{0x01, 0x02, 0x03, 0x04};

// wrappedBuffer — 복사 없음, data 배열을 그대로 사용
ByteBuf wrapped = Unpooled.wrappedBuffer(data);

// 원본 배열 수정 → ByteBuf에도 반영
data[0] = 0x10;
System.out.println(wrapped.getByte(0)); // 0x10

// copiedBuffer와 비교 — 복사 발생
ByteBuf copied = Unpooled.copiedBuffer(data);
data[0] = 0x20;
System.out.println(copied.getByte(0)); // 0x10 — 복사 시점의 값 유지

byte[] part1 = "Hello, ".getBytes();
byte[] part2 = "Netty!".getBytes();

// 내부적으로 CompositeByteBuf 생성 — 복사 없음
ByteBuf combined = Unpooled.wrappedBuffer(part1, part2);
// combined.readableBytes() == part1.length + part2.length

ByteBuffer nioBuffer = ByteBuffer.allocateDirect(256);
nioBuffer.put("data".getBytes());
nioBuffer.flip();

// NIO ByteBuffer를 Netty ByteBuf로 변환 — 복사 없음
ByteBuf wrapped = Unpooled.wrappedBuffer(nioBuffer);

public ByteBuf assemblePacket(ChannelHandlerContext ctx,
                               int messageType,
                               byte[] payload) {

    // 1. wrappedBuffer — byte[] 복사 없이 ByteBuf 생성
    ByteBuf body = Unpooled.wrappedBuffer(payload);

    // 2. 헤더 생성
    ByteBuf header = ctx.alloc().buffer(8);
    header.writeInt(messageType);
    header.writeInt(payload.length);

    // 3. CompositeByteBuf — 헤더 + 바디를 복사 없이 합성
    CompositeByteBuf packet = ctx.alloc().compositeBuffer(2);
    packet.addComponents(true, header, body);

    return packet;
    // 전체 과정에서 payload 데이터의 복사가 한 번도 발생하지 않음
}

public void channelRead(ChannelHandlerContext ctx, ByteBuf msg) {
    // slice — 헤더와 바디를 복사 없이 분리
    ByteBuf header = msg.slice(0, 8);
    int type = header.readInt();
    int length = header.readInt();

    ByteBuf body = msg.slice(8, length);

    // body를 다음 핸들러로 전달
    // 원본 msg가 이 핸들러에서 해제되지 않으므로 안전
    ctx.fireChannelRead(body.retain()); // retain()으로 참조 카운트 보호
}

// 잘못된 패턴
ByteBuf sliced;
{
    ByteBuf temp = ctx.alloc().buffer();
    temp.writeBytes(data);
    sliced = temp.slice();
    temp.release(); // 원본 해제!
}
sliced.readByte(); // IllegalReferenceCountException!

// 올바른 패턴
ByteBuf sliced;
{
    ByteBuf temp = ctx.alloc().buffer();
    temp.writeBytes(data);
    sliced = temp.retainedSlice(); // 참조 카운트 +1
    temp.release(); // 원본 해제해도 sliced는 안전
}
sliced.readByte(); // 정상 동작
sliced.release();  // 사용 후 반드시 해제

// 기본 — 최대 16개 컴포넌트
CompositeByteBuf composite = Unpooled.compositeBuffer();

// 명시적으로 설정
CompositeByteBuf composite = Unpooled.compositeBuffer(32);

CompositeByteBuf composite = Unpooled.compositeBuffer(4); // 최대 4개

// 5번째 추가 시 → 기존 컴포넌트들을 하나로 병합 (복사 발생)
for (int i = 0; i < 5; i++) {
    composite.addComponent(true, Unpooled.wrappedBuffer(new byte[]{(byte) i}));
}
// 내부적으로 consolidation이 발생해서 컴포넌트 수가 줄어듦

CompositeByteBuf composite = ...;

// nioBuffer() 호출 시 내부 데이터를 하나의 ByteBuffer로 복사
ByteBuffer nioBuffer = composite.nioBuffer();

// nioBufferCount()로 사전 확인 가능
if (composite.nioBufferCount() > 1) {
    // 여러 개의 ByteBuffer로 분리해서 처리할 수도 있음
    ByteBuffer[] buffers = composite.nioBuffers();
}

ByteBuf original = Unpooled.buffer(100);
original.writeBytes(new byte[50]);

ByteBuf sliced = original.slice(0, 10); // 10바이트 영역만 참조
sliced.writerIndex(10);
sliced.writeByte(0x01); // IndexOutOfBoundsException — capacity(10) 초과