ChannelHandler — 이벤트 처리의 단위

// ChannelHandler 인터페이스의 핵심 메서드
public interface ChannelHandler {
    // 핸들러가 파이프라인에 추가될 때
    void handlerAdded(ChannelHandlerContext ctx) throws Exception;
    // 핸들러가 파이프라인에서 제거될 때
    void handlerRemoved(ChannelHandlerContext ctx) throws Exception;
}

public interface ChannelInboundHandler extends ChannelHandler {
    void channelRegistered(ChannelHandlerContext ctx);   // Channel이 EventLoop에 등록
    void channelActive(ChannelHandlerContext ctx);       // 연결 활성화 (TCP 핸드셰이크 완료)
    void channelRead(ChannelHandlerContext ctx, Object msg);  // 데이터 수신
    void channelReadComplete(ChannelHandlerContext ctx);      // 읽기 작업 완료
    void channelInactive(ChannelHandlerContext ctx);     // 연결 비활성화
    void exceptionCaught(ChannelHandlerContext ctx, Throwable cause);
}

public interface ChannelOutboundHandler extends ChannelHandler {
    void bind(ChannelHandlerContext ctx, SocketAddress addr, ChannelPromise promise);
    void connect(ChannelHandlerContext ctx, SocketAddress addr,
                 SocketAddress localAddr, ChannelPromise promise);
    void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise);
    void flush(ChannelHandlerContext ctx);
    void close(ChannelHandlerContext ctx, ChannelPromise promise);
}

// 실무에서 가장 많이 보는 패턴: 어댑터 상속 후 필요한 메서드만 오버라이드
public class MyInboundHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 수신한 메시지 처리
        ByteBuf buf = (ByteBuf) msg;
        try {
            System.out.println("수신: " + buf.toString(CharsetUtil.UTF_8));
        } finally {
            buf.release(); // 직접 release 해야 함
        }
    }
}

// 문자열 메시지만 처리하는 핸들러
public class ChatHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        // msg는 이미 String 타입으로 캐스팅되어 있음
        // 메서드 종료 후 자동 release (String은 참조 카운트 대상이 아니지만, ByteBuf 등은 자동 해제)
        System.out.println("메시지 수신: " + msg);
        ctx.writeAndFlush("에코: " + msg + "\n");
    }
}

@ChannelHandler.Sharable
public class LoggingHandler extends ChannelInboundHandlerAdapter {
    // 인스턴스 필드 없음 — 무상태
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("[LOG] " + ctx.channel().remoteAddress() + " → " + msg);
        ctx.fireChannelRead(msg); // 다음 핸들러로 전달
    }
}

// 하나의 인스턴스를 여러 채널에서 공유
LoggingHandler sharedLogger = new LoggingHandler();

ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(sharedLogger);          // 모든 채널에서 같은 인스턴스 사용
        ch.pipeline().addLast(new BusinessHandler());  // 이건 채널마다 새 인스턴스
    }
});

// 잘못된 예: @Sharable인데 상태를 가지고 있음
@ChannelHandler.Sharable
public class CountHandler extends ChannelInboundHandlerAdapter {
    private int count = 0; // 여러 채널에서 동시 접근 → 경쟁 조건(race condition)

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        count++; // 위험! 동시성 보장 안 됨
        ctx.fireChannelRead(msg);
    }
}

public class ResourceHandler extends ChannelInboundHandlerAdapter {
    private BufferedWriter writer;

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // 파이프라인에 추가될 때 — 리소스 초기화
        writer = new BufferedWriter(new FileWriter("access.log", true));
        System.out.println("핸들러 추가됨: " + ctx.channel());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        // 파이프라인에서 제거될 때 — 리소스 정리
        if (writer != null) {
            writer.close();
        }
        System.out.println("핸들러 제거됨: " + ctx.channel());
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        writer.write(ctx.channel().remoteAddress() + ": " + msg);
        writer.newLine();
        ctx.fireChannelRead(msg);
    }
}

public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // ctx를 통해 할 수 있는 것들
        ctx.fireChannelRead(msg);       // 다음 인바운드 핸들러로 이벤트 전달
        ctx.write(response);            // 다음 아웃바운드 핸들러로 쓰기 이벤트 전달
        ctx.channel();                  // 현재 채널 참조
        ctx.pipeline();                 // 파이프라인 참조
        ctx.alloc();                    // ByteBuf 할당자 참조
    }
}

Pipeline: Head ↔ Encoder ↔ LogHandler ↔ BusinessHandler ↔ Tail

BusinessHandler에서 ctx.write()를 호출하면:
  → LogHandler → Encoder → Head → 네트워크 (BusinessHandler 이전의 아웃바운드만 거침)

BusinessHandler에서 channel.write()를 호출하면:
  → Tail → BusinessHandler → LogHandler → Encoder → Head → 네트워크 (전체)

// 안 좋은 예: 핸들러 인스턴스에 연결별 상태 저장
public class BadHandler extends ChannelInboundHandlerAdapter {
    private int messageCount = 0;       // 어느 채널의 카운트인지 구분 불가
    private StringBuilder buffer = new StringBuilder(); // 채널 간 데이터 섞임

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        messageCount++;
        buffer.append(msg);
        ctx.fireChannelRead(msg);
    }
}

@ChannelHandler.Sharable
public class StatefulHandler extends ChannelInboundHandlerAdapter {
    // 키 정의 — static final로 한 번만 생성
    private static final AttributeKey<Integer> MSG_COUNT =
            AttributeKey.valueOf("msgCount");

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        // 채널별 초기값 설정
        ctx.channel().attr(MSG_COUNT).set(0);
        ctx.fireChannelActive();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 채널별 상태 읽기/쓰기
        Attribute<Integer> attr = ctx.channel().attr(MSG_COUNT);
        int count = attr.get() + 1;
        attr.set(count);

        System.out.println(ctx.channel().remoteAddress() + " 메시지 수: " + count);
        ctx.fireChannelRead(msg);
    }
}