Codec 编码

public class ToIntegerDecoder extends ByteToMessageDecoder {  //1 实现继承了 ByteToMessageDecode 用于将字节解码为消息
    @Override
    public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
        throws Exception {
        if (in.readableBytes() >= 4) {  //2 检查可读的字节是否至少有4个 ( int 是4个字节长度)
            out.add(in.readInt());  //3 从入站 ByteBuf 读取 int ， 添加到解码消息的 List 中
        }
    }
}

public class IntegerToStringDecoder extends MessageToMessageDecoder<Integer>

protected void decode( ChannelHandlerContext ctx,
               Integer msg, List<Object> out ) throws Exception

public class IntegerToStringDecoder extends
                    MessageToMessageDecoder<Integer> { //1 实现继承自 MessageToMessageDecoder 

    @Override
    public void decode(ChannelHandlerContext ctx, Integer msg, List<Object> out)
        throws Exception {
        out.add(String.valueOf(msg)); //2 通过 String.valueOf() 转换 Integer 消息字符串
    }
}

public class SafeByteToMessageDecoder extends ByteToMessageDecoder {  //1 实现继承 ByteToMessageDecoder 来将字节解码为消息
    private static final int MAX_FRAME_SIZE = 1024;

    @Override
    public void decode(ChannelHandlerContext ctx, ByteBuf in,
               List<Object> out) throws Exception {
        int readable = in.readableBytes();
        if (readable > MAX_FRAME_SIZE) { //2 检测缓冲区数据是否大于 MAX_FRAME_SIZE
            in.skipBytes(readable);        //3 忽略所有可读的字节，并抛出 TooLongFrameException 来通知 ChannelPipeline 中的 ChannelHandler
            throw new TooLongFrameException("Frame too big!");
        }
        // do something
    }
}

public class ShortToByteEncoder extends
                MessageToByteEncoder<Short> {  //1 实现继承自 MessageToByteEncoder
    @Override
    public void encode(ChannelHandlerContext ctx, Short msg, ByteBuf out)
        throws Exception {
        out.writeShort(msg);  //2 写 Short 到 ByteBuf
    }
}

public class IntegerToStringEncoder extends
                    MessageToMessageEncoder<Integer> { //1 实现继承自 MessageToMessageEncoder

    @Override
    public void encode(ChannelHandlerContext ctx, Integer msg, List<Object> out)
        throws Exception {
        out.add(String.valueOf(msg));  //2 转 Integer 为 String，并添加到 MessageBuf
    }
}

public abstract class MessageToMessageCodec<INBOUND,OUTBOUND>

protected abstract void encode(ChannelHandlerContext ctx,
                   OUTBOUND msg, List<Object> out);

protected abstract void decode(ChannelHandlerContext ctx,
                   INBOUND msg, List<Object> out);

public class WebSocketConvertHandler extends MessageToMessageCodec<WebSocketFrame, WebSocketConvertHandler.WebSocketFrame> {  //1 编码 WebSocketFrame 消息转为 WebSocketFrame 消息
    public static final WebSocketConvertHandler INSTANCE = new WebSocketConvertHandler();

    @Override
    protected void encode(ChannelHandlerContext ctx, WebSocketFrame msg, List<Object> out) throws Exception {   
        ByteBuf payload = msg.getData().duplicate().retain();
        switch (msg.getType()) {   //2 检测 WebSocketFrame 的 FrameType 类型，并且创建一个新的响应的 FrameType 类型的 WebSocketFrame
        case BINARY:
            out.add(new BinaryWebSocketFrame(payload));
            break;
        case TEXT:
            out.add(new TextWebSocketFrame(payload));
            break;
        case CLOSE:
            out.add(new CloseWebSocketFrame(true, 0, payload));
            break;
        case CONTINUATION:
            out.add(new ContinuationWebSocketFrame(payload));
            break;
        case PONG:
            out.add(new PongWebSocketFrame(payload));
            break;
        case PING:
            out.add(new PingWebSocketFrame(payload));
            break;
        default:
            throw new IllegalStateException("Unsupported websocket msg " + msg);
        }
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, io.netty.handler.codec.http.websocketx.WebSocketFrame msg, List<Object> out) throws Exception {
        if (msg instanceof BinaryWebSocketFrame) {  //3 通过 instanceof 来检测正确的 FrameType
            out.add(new WebSocketFrame(WebSocketFrame.FrameType.BINARY, msg.content().copy()));
        } else if (msg instanceof CloseWebSocketFrame) {
            out.add(new WebSocketFrame(WebSocketFrame.FrameType.CLOSE, msg.content().copy()));
        } else if (msg instanceof PingWebSocketFrame) {
            out.add(new WebSocketFrame(WebSocketFrame.FrameType.PING, msg.content().copy()));
        } else if (msg instanceof PongWebSocketFrame) {
            out.add(new WebSocketFrame(WebSocketFrame.FrameType.PONG, msg.content().copy()));
        } else if (msg instanceof TextWebSocketFrame) {
            out.add(new WebSocketFrame(WebSocketFrame.FrameType.TEXT, msg.content().copy()));
        } else if (msg instanceof ContinuationWebSocketFrame) {
            out.add(new WebSocketFrame(WebSocketFrame.FrameType.CONTINUATION, msg.content().copy()));
        } else {
            throw new IllegalStateException("Unsupported websocket msg " + msg);
        }
    }

    public static final class WebSocketFrame {  //4 自定义消息类型 WebSocketFrame
        public enum FrameType {        //5 枚举类明确了 WebSocketFrame 的类型
            BINARY,
            CLOSE,
            PING,
            PONG,
            TEXT,
            CONTINUATION
        }

        private final FrameType type;
        private final ByteBuf data;
        public WebSocketFrame(FrameType type, ByteBuf data) {
            this.type = type;
            this.data = data;
        }

        public FrameType getType() {
            return type;
        }

        public ByteBuf getData() {
            return data;
        }
    }
}

public class CombinedChannelDuplexHandler<I extends ChannelInboundHandler,
                        O extends ChannelOutboundHandler>

public class ByteToCharDecoder extends
                   ByteToMessageDecoder { //1 继承 ByteToMessageDecoder

    @Override
    public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
        throws Exception {
        if (in.readableBytes() >= 2) {  //2 写 char 到 MessageBuf
            out.add(in.readChar());
        }
    }
}

public class CharToByteEncoder extends
                   MessageToByteEncoder<Character> { //1 继承 MessageToByteEncoder

    @Override
    public void encode(ChannelHandlerContext ctx, Character msg, ByteBuf out)
        throws Exception {
        out.writeChar(msg);   //2 写 char 到 ByteBuf
    }
}

public class CombinedByteCharCodec extends CombinedChannelDuplexHandler<ByteToCharDecoder,
                                        CharToByteEncoder> { //1 参数是解码器和编码器的实现用于处理进站字节和出站消息
    public CombinedByteCharCodec() {
        super(new ByteToCharDecoder(), new CharToByteEncoder()); //2 传递 ByteToCharDecoder 和 CharToByteEncoder 实例到 super 构造函数来委托调用使他们结合起来
    }
}