ByteToMessageDecoder

ByteToMessageDecoder是解码器的基类, 具有最基本的能力, 将字节解码成消息, 以便在pipeline上进行传递.

1564365188195.png

关键属性

// 对入站数据进行临时缓冲, 直到它准备好处理
ByteBuf cumulation;
// 缓冲的策略
private Cumulator cumulator = MERGE_CUMULATOR;
// 是否只解码一次
private boolean singleDecode;
// 意思是解码有没有结果, true为没有
private boolean decodeWasNull;
// 这批数据是不是第一次处理
private boolean first;
private int discardAfterReads = 16;
private int numReads;

channelRead

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    // 如果消息是ByteBuf类型
    if (msg instanceof ByteBuf) {
        // 从对象池取出一个CodecOutputList, 用来收集解码后的消息
        CodecOutputList out = CodecOutputList.newInstance();
        try {
            ByteBuf data = (ByteBuf) msg;
            // 看累积器是不是为空来决定是不是首次处理
            first = cumulation == null;
            // 看是不是第一次处理,如果是,那么直接赋予累积器
            if (first) {
                cumulation = data;
            } else {
                // 否则累加到累积器, 见cumulator部分
                cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
            }
            // 对消息进行解码
            callDecode(ctx, cumulation, out);
        } catch (DecoderException e) {
            throw e;
        } catch (Throwable t) {
            throw new DecoderException(t);
        } finally {
            // 如果累积器的内容已经读取完毕,那么回收掉
            if (cumulation != null && !cumulation.isReadable()) {
                numReads = 0;
                cumulation.release();
                cumulation = null;
            // 当这批数据已经读了有16次之多后,需要整理下内存
            } else if (++ numReads >= discardAfterReads) {               
                numReads = 0;
                // 这里主要是对累积器进行整理,清理discard区域为读写空间腾地方
                discardSomeReadBytes();
            }
            
            // 将解码后的结果通知下游, 且回收out容器
            int size = out.size();
            decodeWasNull = !out.insertSinceRecycled();
            fireChannelRead(ctx, out, size);
            out.recycle();
        }
    } else {
        // 如果不是ByteBuf类型,直接传递给下游
        ctx.fireChannelRead(msg);
    }
}

callDecode

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List out) {
    try {
        // 如果缓冲器有内容可读
        while (in.isReadable()) {
            int outSize = out.size();

            // 如果out容器有内容,那么说明解码有结果了,那么马上需要通知下游handle
            // 通知完,清理容器out
            if (outSize > 0) {
                fireChannelRead(ctx, out, outSize);
                out.clear();
                
                // 如果此时hanler被移除,那么不用继续处理,直接退出
                if (ctx.isRemoved()) {
                    break;
                }
                outSize = 0;
            }

            int oldInputLength = in.readableBytes();
            // 子类来处理具体解码的工作,最终将解码后的消息放在out里面就好
            decode(ctx, in, out);

            // 如果此时hanler被移除,那么不用继续处理,直接退出
            if (ctx.isRemoved()) {
                break;
            }
            
            // 如果这时,out容器的大小没有变化,说明子类那边解码还没有结果
            if (outSize == out.size()) {
                // 如果没有读取任何数据, 那么结束循环
                if (oldInputLength == in.readableBytes()) {
                    break;
                } else {
                    // 如果有读取,但不足与产生结果,那么需要继续读取
                    continue;
                }
            }
            
            // 如果有结果,但是根本就没有读取数据,那么不是很诡异么?
            if (oldInputLength == in.readableBytes()) {
                throw new DecoderException(
                        StringUtil.simpleClassName(getClass()) +
                        ".decode() did not read anything but decoded a message.");
            }
            
            // 是否只执行一次
            if (isSingleDecode()) {
                break;
            }
        }
    } catch (DecoderException e) {
        throw e;
    } catch (Throwable cause) {
        throw new DecoderException(cause);
    }
}
 
 

Cumulator

MERGE_CUMULATOR

public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
    @Override
    public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
        ByteBuf buffer;
        // 简单的情况是当前的累积器空间不足,需要扩容
        // 因为read的时候,每隔一段时间都需要对累积器的内存空间进行整理,那么整理的过程会导致
        // 读写index变更, 进而导致浅拷贝后的ByteBuf不可用.
        if (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes()
                || cumulation.refCnt() > 1) { 
            buffer = expandCumulation(alloc, cumulation, in.readableBytes());
        } else {
            buffer = cumulation;
        }
        buffer.writeBytes(in);
        in.release();
        return buffer;
    }
};

子缓冲区

Netty中调用ByteBuf.duplicate(),ByteBuf.slice()和ByteBuf.order(ByteOrder)三个方法, 会创建一个子缓冲区,子缓冲区共享父缓冲区的内存区域。子缓冲区没有自己的引用计数,而是 共享父缓冲区的引用计数。

当父缓冲区release的时候, 会引用计数清零, 导致该内存区域被回收, 进而影响子缓冲区, 导致读写失败. 那么需要注意的事, 子缓冲区需要显示调用retain来提示Netty有其他人在使用, 防止被错误回收. 这里带来额外的坏处是, 所有子缓冲区在使用完后, 要及时release, 防止内存泄漏.

在前面的场景中可以看到, 解码器在解码完后视情况来决定要不要做内存整理, 而整理的过程会进行数据移动, 且按照整理后的结果重置read和write索引, 这样会影响到子缓冲区的读写. 下面是个简单的例子, 自己体会. 另外一个问题是, 如果源Buffer提前release, 那么子缓冲区也会读写异常.

ByteBuf source = ByteBufAllocator.DEFAULT.buffer(20, 20);

source.writeInt(1);
source.readInt();

source.writeInt(2);

ByteBuf duplicate = source.duplicate();
System.out.println("source" + source.toString());
System.out.println("duplicate" + duplicate.toString());
source.discardReadBytes();
System.out.println("source" + source.toString());
System.out.println("duplicate" + duplicate.toString());
System.out.println("duplicate" + duplicate.readInt());
duplicate.readerIndex(0);
System.out.println("duplicate" + duplicate.toString());
System.out.println("duplicate" + duplicate.readInt());
source:PooledUnsafeDirectByteBuf(ridx: 4, widx: 16, cap: 20/20)
duplicate:UnpooledDuplicatedByteBuf(ridx: 4, widx: 16, cap: 20/20)
source:PooledUnsafeDirectByteBuf(ridx: 0, widx: 12, cap: 20/20)
duplicate:UnpooledDuplicatedByteBuf(ridx: 4, widx: 16, cap: 20/20)
duplicate:0
duplicate:UnpooledDuplicatedByteBuf(ridx: 0, widx: 16, cap: 20/20)
duplicate:2

expandCumulation

可以看到解决上面问题的方案也是简单粗暴, 直接重建一个ByteBuf, 将数据拷贝过来. 这样, 之前的子缓冲区也不会被之后可能的内存整理给影响.

static ByteBuf expandCumulation(ByteBufAllocator alloc, ByteBuf cumulation, int readable) {
    ByteBuf oldCumulation = cumulation;
    cumulation = alloc.buffer(oldCumulation.readableBytes() + readable);
    cumulation.writeBytes(oldCumulation);
    oldCumulation.release();
    return cumulation;
}

你可能感兴趣的:(ByteToMessageDecoder)