java netty之ByteToMessageDecoder

在上面的一篇文章中，有说明ByteToMessageDecoder是怎么使用的，那么这一篇就来讲讲它是怎么实现的。。

首先还是来看一下它的继承体系：

它直接继承自ChannelInboundByteHandlerAdapter类型，至于说这个类型的介绍，在前面的文章中就已经有了说明，无非是实现了那些inboundhandler的方法，不过实现的都非常的粗糙，另外一些handler可以直接继承它，重写其中自己感兴趣的方法就可以了。。。

好吧，接下来我们来看看ByteToMessageDecoder的定义吧：

public abstract class ByteToMessageDecoder
    extends ChannelInboundByteHandlerAdapter {

    private volatile boolean singleDecode;
    private boolean decodeWasNull;

    /**
     * If set then only one message is decoded on each {@link #inboundBufferUpdated(ChannelHandlerContext)} call.
     * This may be useful if you need to do some protocol upgrade and want to make sure nothing is mixed up.
     *
     * Default is {@code false} as this has performance impacts.
     */
    public void setSingleDecode(boolean singleDecode) {
        this.singleDecode = singleDecode;
    }

    /**
     * If {@code true} then only one message is decoded on each
     * {@link #inboundBufferUpdated(ChannelHandlerContext)} call.
     *
     * Default is {@code false} as this has performance impacts.
     */
    public boolean isSingleDecode() {
        return singleDecode;
    }

    @Override
    public void inboundBufferUpdated(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        callDecode(ctx, in);   //当有数据进来的时候，直接调用callDecode方法
    }

    @Override
    public void channelReadSuspended(ChannelHandlerContext ctx) throws Exception {
        if (decodeWasNull) {
            decodeWasNull = false;
            if (!ctx.channel().config().isAutoRead()) {
                ctx.read();
            }
        }
        super.channelReadSuspended(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        OutputMessageBuf out = OutputMessageBuf.get();
        try {
            ByteBuf in = ctx.inboundByteBuffer();
            if (in.isReadable()) {
                callDecode(ctx, in);
            }
            decodeLast(ctx, in, out);
        } catch (CodecException e) {
            throw e;
        } catch (Throwable cause) {
            throw new DecoderException(cause);
        } finally {
            if (out.drainToNextInbound(ctx)) {
                ctx.fireInboundBufferUpdated();
            }
            ctx.fireChannelInactive();
        }
    }

    protected void callDecode(ChannelHandlerContext ctx, ByteBuf in) {
        boolean wasNull = false;
        OutputMessageBuf out = OutputMessageBuf.get();
        try {
            while (in.isReadable()) {  //是否有数据可以读
                int outSize = out.size();   //当前存放经过转码的数据的buffer
                int oldInputLength = in.readableBytes(); //可以读的数据量
                decode(ctx, in, out);   //调用用户定义的decode方法，用来解析数据，并将解析出来的对象放到out里面
                if (outSize == out.size()) {   //这个表明没有解析出任何对象
                    wasNull = true;
                    if (oldInputLength == in.readableBytes()) {
                        break;   //表示没有从in里面读取任何数据
                    } else {
                        continue;
                    }
                }

                wasNull = false;
                if (oldInputLength == in.readableBytes()) {
                    throw new IllegalStateException(
                         "decode() did not read anything but decoded a message.");
                }

                if (isSingleDecode()) {
                    break;
                }
            }
        } catch (CodecException e) {
            throw e;
        } catch (Throwable cause) {
            throw new DecoderException(cause);
        } finally {
            if (out.drainToNextInbound(ctx)) {  //把数据写到接下来的inboundhandler的inboundbuffer里面去
                decodeWasNull = false;
                ctx.fireInboundBufferUpdated();  //激活下一个handler的inboundBufferUpdated方法，用于处理刚刚写进去的数据
            } else {
                if (wasNull) {
                    decodeWasNull = true;
                }
            }
        }
    }

    /**
     * Decode the from one {@link ByteBuf} to an other. This method will be called till either the input
     * {@link ByteBuf} has nothing to read anymore, till nothing was read from the input {@link ByteBuf} or till
     * this method returns {@code null}.
     *
     * @param ctx           the {@link ChannelHandlerContext} which this {@link ByteToByteDecoder} belongs to
     * @param in            the {@link ByteBuf} from which to read data
     * @param out           the {@link MessageBuf} to which decoded messages should be added

     * @throws Exception    is thrown if an error accour
     */
   //用户自己定义的decode方法，用于将读取的byte类型的数据转化为用户自定义的类型
    protected abstract void decode(ChannelHandlerContext ctx, ByteBuf in, MessageBuf<Object> out) throws Exception;

    /**
     * Is called one last time when the {@link ChannelHandlerContext} goes in-active. Which means the
     * {@link #channelInactive(ChannelHandlerContext)} was triggered.
     *
     * By default this will just call {@link #decode(ChannelHandlerContext, ByteBuf, MessageBuf)} but sub-classes may
     * override this for some special cleanup operation.
     */
    protected void decodeLast(ChannelHandlerContext ctx, ByteBuf in, MessageBuf<Object> out) throws Exception {
        decode(ctx, in, out);
    }
}

这里需要注意到重写的方法是inboundBufferUpdated，也就是当数据进来的时候会调用的方法，又直接调用callDecode方法来处理，而callDecode方法的实现也还算是比较的简单，上面的注释也都基本上说的比较的清楚了，无非是调用用户定义的decode方法，用于将读进来的byte数据转化为用户自己定义的数据类型，然后再将转化的结果放入到一个messagebuf里面。。。

这里可以看到decode方法是个抽象的方法，所以需要用户自己继承ByteToMessageDecoder类型，然后重写decode方法用于按照自己的规则将数据转化为自定义的类型。。。

另外比较重要的是finally部分的代码：

if (out.drainToNextInbound(ctx)) {  //把数据写到接下来的inboundhandler的inboundbuffer里面去
                decodeWasNull = false;
                ctx.fireInboundBufferUpdated();  //激活下一个handler的inboundBufferUpdated方法，用于处理刚刚写进去的数据
            } else {
                if (wasNull) {
                    decodeWasNull = true;
                }
            }

其实这部分看名字也都能知道这些方法的意思吧，猜都能猜出来：见当前messagebuf里面的数据写到下一个inboundhandler的buffer里面去。。。然后再激活下一个inboundhandler的inboundBufferUpdated方法，用于处理数据。。我们还是来看看drainToNextInbound方法的定义吧：

    public boolean drainToNextInbound(ChannelHandlerContext ctx) {
        final int size = size();   //当前buf存放的数据的量
        if (size == 0) {
            return false;
        }
        //有可能是bytebuf的类型
        final int byteBufCnt = this.byteBufCnt;
        if (byteBufCnt == 0 || ctx.nextInboundBufferType() != BufType.BYTE) {
            return drainTo(ctx.nextInboundMessageBuffer()) > 0;
        }

        final ByteBuf nextByteBuf = ctx.nextInboundByteBuffer();
        if (byteBufCnt == size) {
            // Contains only ByteBufs
            for (Object o = poll();;) {
                writeAndRelease(nextByteBuf, (ByteBuf) o);
                if ((o = poll()) == null) {
                    break;
                }
            }
        } else {
            // Contains both ByteBufs and non-ByteBufs (0 < byteBufCnt < size())
            final MessageBuf<Object> nextMsgBuf = ctx.nextInboundMessageBuffer();   //获取下一个inboundhandler的messagebuffer
            for (Object o = poll();;) {   //将当前buffer里面存放的message放入到下一个handler的buffer里面去
                if (o instanceof ByteBuf) {
                    writeAndRelease(nextByteBuf, (ByteBuf) o);
                } else {
                    nextMsgBuf.add(o);
                }

                if ((o = poll()) == null) {
                    break;
                }
            }
        }

        return true;
    }

代码还是比较的简单，无非是将数据当前buf里面的数据取出来，然后放到下一个handler的buf里面去就行了，这里需要注意的是，这里有可能也是byte类型的。。。

这样，decode出来的数据，就转移到了下一个inboundhandler的buffer里面了，那么下一个handler就可以处理这些数据了。。。

这里我们再稍微来看看ChannelInboundMessageHandlerAdapter这个类型吧，它的inboundBufferUpdated方法定义如下：

    @Override
    public final void inboundBufferUpdated(ChannelHandlerContext ctx) throws Exception {
        ChannelHandlerUtil.handleInboundBufferUpdated(ctx, this);
    }

很简单，我们再来看看它的具体实现吧：

    public static <T> void handleInboundBufferUpdated(
            ChannelHandlerContext ctx, SingleInboundMessageHandler<T> handler) throws Exception {
        MessageBuf<Object> in = ctx.inboundMessageBuffer();
        if (in.isEmpty() || !handler.beginMessageReceived(ctx)) {
            return;
        }

        MessageBuf<Object> out = ctx.nextInboundMessageBuffer();
        int oldOutSize = out.size();
        try {
        	//这里一个循环可以看出，对于每一个解码出来的object对象，都会调用用户定义的messageReceived方法来处理
            for (;;) {
                Object msg = in.poll();
                if (msg == null) {
                    break;
                }

                if (!handler.acceptInboundMessage(msg)) {  //如果当前这个handler不支持这个类型，那么将数据写到下一个handler的buffer里面
                    out.add(msg);
                    continue;
                }

                @SuppressWarnings("unchecked")
                T imsg = (T) msg;
                try {
                    handler.messageReceived(ctx, imsg);   //调用用户定义的messageReceived方法来处理message
                } finally {
                    BufUtil.release(imsg);
                }
            }
        } catch (Signal abort) {
            abort.expect(ABORT);
        } finally {
            if (oldOutSize != out.size()) {  //这里表示由message写入到下一个inboundhandler的inbuffer里面，那么需要进行处理
                ctx.fireInboundBufferUpdated();  //这里会激活下一个inboundhandler的inboundBufferUpdated方法，用于处理写进去的message
            }

            handler.endMessageReceived(ctx);
        }
    }

意思也很简单吧，将buf里面的数据一个一个的取出来，然后调用用户自己定义的messageReceived方法用于处理这些数据。。

好了，decoder就差不多了，下一篇看一下encoder吧。。。