công cộng lớp học EchoServerHandler mở rộng ChannelInboundHandlerAdapter {
    riêng tư tĩnh cuối cùng số nguyên HEADER_LENGTH = 4; //消息头部长度
    riêng tư ByteBuf buffer = Unpooled.buffer(1024); //缓存残缺消息

    @Ghi đè
    công cộng vô hiệu channelRead(ChannelHandlerContext ctx, Object msg) ném Exception { ByteBuf income = (ByteBuf) msg;

        //上一次有缓存存在，则本数据包不是消息头开头，
        nếu như(buffer.readableBytes() > 0) {
            //进行必要的扩容，下面的readBytes不会自动扩容
            buffer.ensureWritable(income.readableBytes()); income.readBytes(buffer, income.readableBytes()); readMsgFromBuffer(buffer);

            //剩下一点残缺消息
            nếu như(buffer.readableBytes() > 0) {
                //保留剩下的数据，重置读索引为0
                System.out.println("缓存剩余字节："+buffer.readableBytes()); buffer.discardReadBytes(); } khác { //刚刚好，则清空数据
                buffer.clear(); } } khác { readMsgFromBuffer(income);

            //剩下的数据全部写入缓存
            nếu như (income.readableBytes() >0) { System.out.println("剩余字节:"+income.readableBytes()); income.readBytes(buffer, income.readableBytes()); } } }

    //从字节数组中读取完整的消息
    riêng tư vô hiệu readMsgFromBuffer(ByteBuf byteBuf) {
        //剩余可读消息是否包含一个消息头
        trong khi(byteBuf.readableBytes() >= HEADER_LENGTH) { byteBuf.markReaderIndex(); //由于可能读不到完整的消息，所以读之前先标记索引位置，方便重置
            //读取消息头
            byte[] headerBytes = mới byte[4]; byteBuf.readBytes(headerBytes);
            //获取类型
            số nguyên type = headerBytes[0] & 0xFF;
            //获取消息体长度
            số nguyên bodyLength = ((headerBytes[1] & 0xFF) << 16) |
                    ((headerBytes[2] & 0xFF) << 8) |
                    (headerBytes[3] & 0xFF);

            //不包含请求体
            nếu như (byteBuf.readableBytes() < bodyLength) { byteBuf.resetReaderIndex(); //重置读索引到当前消息头位置
                phá vỡ; }

            // 完整消息体已经接收，处理消息
            byte[] body = mới byte[bodyLength]; byteBuf.readBytes(body);
            //System.out.println("type:"+type+"||length:"+bodyLength+"||body:"+new String(body, CharsetUtil.UTF_8));
            nếu như(type == 1) {
                thử { HelloRequest request = HelloRequest.parseFrom(body); System.out.println("收到消息:"+request.toString()); } nắm lấy (Exception e) { System.out.println("解析失败："+mới String(body, CharsetUtil.UTF_8)); } } khác { System.out.println("消息类型未知："+type); } } } ....
}

công cộng lớp học MessageDecoder mở rộng ByteToMessageDecoder {
    riêng tư tĩnh cuối cùng số nguyên HEADER_LENGTH = 4; //消息头部长度

    @Ghi đè
    được bảo vệ vô hiệu decode(ChannelHandlerContext ctx, ByteBuf in, List

    //缓存
    riêng tư ByteBuf cumulation;
    //累加器（用于拼接缓存和新到数据）
    riêng tư Cumulator cumulator = MERGE_CUMULATOR;
   
    //X次channelRead之后，释放已读数据
    riêng tư số nguyên discardAfterReads = 16;
    //累计channelRead次数（每次释放完会重置）
    riêng tư số nguyên numReads;

    công cộng tĩnh cuối cùng Cumulator MERGE_CUMULATOR = mới Cumulator() {
        //cumulation是上一次的缓存，in是新到的数据
        @Ghi đè
        công cộng ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
            thử {
                cuối cùng ByteBuf buffer;
                nếu như (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes()
                    || cumulation.refCnt() > 1 || cumulation.isReadOnly()) {
                    // Expand cumulation (by replace it) when either there is not more room in the buffer
                    // or if the refCnt is greater then 1 which may happen when the user use slice().retain() or
                    // duplicate().retain() or if its read-only.
                    //
                    // See:
                    // - https://github.com/netty/netty/issues/2327
                    // - https://github.com/netty/netty/issues/1764
                    buffer = expandCumulation(alloc, cumulation, in.readableBytes()); } khác { buffer = cumulation; }
                //新到数据写入缓存
                buffer.writeBytes(in);
                trở lại buffer; } Cuối cùng {
                // We must release in in all cases as otherwise it may produce a leak if writeBytes(...) throw
                // for whatever release (for example because of OutOfMemoryError)
                in.release(); } } };

  công cộng tĩnh cuối cùng Cumulator COMPOSITE_CUMULATOR = mới Cumulator() { @Override
        công cộng ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) { ByteBuf buffer;
            thử {
                nếu như (cumulation.refCnt() > 1) {
                    // Expand cumulation (by replace it) when the refCnt is greater then 1 which may happen when the
                    // user use slice().retain() or duplicate().retain().
                    //
                    // See:
                    // - https://github.com/netty/netty/issues/2327
                    // - https://github.com/netty/netty/issues/1764
                    buffer = expandCumulation(alloc, cumulation, in.readableBytes()); buffer.writeBytes(in); } khác { CompositeByteBuf composite;
                    nếu như (cumulation trường hợp của CompositeByteBuf) {
                        //上一次缓存已经是组合对象
                        composite = (CompositeByteBuf) cumulation; } khác { composite = alloc.compositeBuffer(Integer.MAX_VALUE);
                        //缓存加入组合
                        composite.addComponent(ĐÚNG VẬY, cumulation); }
                    //新到数据加入组合
                    composite.addComponent(ĐÚNG VẬY, in); in = vô giá trị; buffer = composite; }
                trở lại buffer; } Cuối cùng {
                //由于使用组合方式，数据还在原来的地方。不能直接释放
                nếu như (in != vô giá trị) {
                    // We must release if the ownership was not transferred as otherwise it may produce a leak if
                    // writeBytes(...) throw for whatever release (for example because of OutOfMemoryError).
                    in.release(); } } } };

    @Ghi đè
    công cộng vô hiệu channelRead(ChannelHandlerContext ctx, Object msg) ném Ngoại lệ {
        //仅处理ByteBuf，其他消息直接传给下一个Handler
        nếu như (msg trường hợp của ByteBuf) { CodecOutputList out = CodecOutputList.newInstance();
            thử { ByteBuf data = (ByteBuf) msg; first = cumulation == vô giá trị;
                //缓冲区为空，直接赋值
                nếu như (first) { cumulation = data; } khác {
                    //使用累加器进行数据合并
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data); }
                //调用子类实现，从缓冲区中解析消息
                callDecode(ctx, cumulation, out); } nắm lấy (DecoderException e) {
                ném e; } nắm lấy (Ngoại lệ e) {
                ném mới DecoderException(e); } Cuối cùng {
                nếu như (cumulation != vô giá trị && !cumulation.isReadable()) {
                    //缓冲区数据刚好读完，清空缓冲区，清空已读次数
                    numReads = 0; cumulation.release(); cumulation = vô giá trị; } khác nếu như (++ numReads >= discardAfterReads) {
                    // We did enough reads already try to discard some bytes so we not risk to see a OOME.
                    // See https://github.com/netty/netty/issues/4275
                    //已读数达到限定次数（默认16），释放已读数据
                    numReads = 0; discardSomeReadBytes(); }

                số nguyên kích thước = out.size();
                //是不是没解析到消息
                decodeWasNull = !out.insertSinceRecycled();
                //将解析出来的消息逐个传个下一个Handler
                fireChannelRead(ctx, out, size);
                //清空List，下次再用
                out.recycle(); } } khác {
            //直接丢给下一个Handler
            ctx.fireChannelRead(msg); } }

    được bảo vệ vô hiệu callDecode(ChannelHandlerContext ctx, ByteBuf in, List