java netty之ByteToMessageDecoder

最新推荐文章于 2024-03-17 20:47:42 发布

NM_IT

最新推荐文章于 2024-03-17 20:47:42 发布

阅读量2.5k

点赞数 1

分类专栏： netty 文章标签： netty

本文链接：https://blog.csdn.net/u010395804/article/details/25889473

版权

netty 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

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

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

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

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

[java]view plaincopy 
   
 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部分的代码：

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

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

[java]view plaincopy 
   
 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方法定义如下：

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

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

[java]view plaincopy 
   
 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吧。。。

NM_IT

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java netty之ByteToMessageDecoder

在上面的一篇文章中，有说明ByteToMessageDecoder是怎么使用的，那么这一篇就来讲讲它是怎么实现的。。首先还是来看一下它的继承体系：它直接继承自ChannelInboundByteHandlerAdapter类型，至于说这个类型的介绍，在前面的文章中就已经有了说明，无非是实现了那些inboundhandler的方法，不过实现的都非常的粗糙，另外一些hand
复制链接

扫一扫

专栏目录