ChannelInboundHandlerAdapter 与 SimpleChannelInboundHandler 功能详解

SimpleChannelInboundHandler

【类的关系】：如下就是两个类的声明，SimpleChannelInboundHandler是继承 ChannelInboundHandlerAdapter的。也就是说SimpleChannelInboundHandler 也拥有 ChannelInboundHandlerAdapter的方法。

1 //ChannelInboundHandlerAdapter 类
2 ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler
3 //SimpleChannelInboundHandler 类
4 SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter

继承关系图：
​

SimpleChannelInboundHandler的 channelRead相比 ChannelInboundHandlerAdapter而言，主要做了类型匹配以及用完之后释放指向保存该消息的 ByteBuf的内存引用。这里提供了一个模板，作用是把处理逻辑不变的内容写好在channelRead(ctx,msg) 中，并且在里面调用 channelRead0 ，这样变化的内容通过抽象方法实现传递到子类中去了(在Netty5中channelRead0已被重命名为 messageReceived)。

 1 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 2     boolean release = true;
 3
 4     try {
 5         if (this.acceptInboundMessage(msg)) {
 6             this.channelRead0(ctx, msg);
 7         } else {
 8             release = false;
 9             ctx.fireChannelRead(msg);
10         }
11     } finally {
12         if (this.autoRelease && release) {
13             ReferenceCountUtil.release(msg);
14         }
15     }
16 }
17
18 protected abstract void channelRead0(ChannelHandlerContext var1, I var2) throws Exception;

ChannelInboundHandlerAdapter

相比之下，ChannelInboundHandlerAdapter好像一无是处，毕竟他要自己处理资源的释放，例如如下的调用：buf.release();如果说 channelRead都是同步操作的话，SimpleChannelInboundHandler是不错的选择，如果操作是异步的话，那他的逻辑就有点麻烦了，例如你把数据交给另外的线程处理了，还没处理就会释放了 。这里必须说明一个问题，他的回收和 jvm的垃圾回收还不完全是一回事。netty是自己做了引用计数的操作。 buf.refCnt(); 通过上面的 api就可以获取到计数的个数。具体的引用计数的部分，不知道也不影响 netty的学习，这个点后面具体再说。ChannelInboundHandlerAdapter 处理自由的优点也就提现出来了，可以更好的处理更多的特定场景。

那该方法是什么时候释放资源的呢？当 writeAndFlush() 方法被调用时才被释放，我们点进去源码验证一下：

 1 public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) {
 2     if (msg == null) {// msg不能为空
 3         throw new NullPointerException("msg");
 4     }
 5     if (isNotValidPromise(promise, true)) {
 6         ReferenceCountUtil.release(msg);// 释放资源(保存消息的ByteBuf)
 7         // cancelled
 8         return promise;
 9     }
10     write(msg, true, promise);// 异步写操作
11     return promise;
12 }

上面源码中，最后资源是通过 ReferenceCountUtil来释放的。也就是说，当我们需要释放 ByteBuf相关内存的时候，也可以使用 ReferenceCountUtil.release()。ReferenceCountUtil 底层实现是 ReferenceCounted ，当新的对象初始化的时候计数为1，retain() 方法被调用时引用计数加1，release()方法被调用时引用计数减1，当计数减少到0的时候会被显示清除，再次访问被清除的对象会出现访问冲突(这里想起了JVM判断对象是否存活的引用计数算法)。ReferenceCountUtil.release源码如下：

1 public static boolean release(Object msg) {
2     if (msg instanceof ReferenceCounted) {
3         return ((ReferenceCounted) msg).release();// Decreases the reference count by 1
4     }
5     return false;
6 }

SimpleChannelInboundHandler 和 ChannelInboundHandlerAdapter区别

在客户端的业务 Handler继承的是 SimpleChannelInboundHandler，而在服务器端继承的是 ChannelInboundHandlerAdapter。最主要的区别就是 SimpleChannelInboundHandler在接收到数据后会自动 release掉数据占用的 Bytebuffer资源(自动调用Bytebuffer.release())。而为何服务器端不能用呢，因为我们想让服务器把客户端请求的数据发送回去，而 write() 操作是异步的，而服务器端有可能在channelRead方法返回后还没有写完数据，因此不能让它自动release。SimpleChannelInboundHandler 是有泛型参数的。可以指定一个具体的类型参数，通过 decoder配合使用，非常方便。ChannelInboundHandlerAdapter 则是直接操作 byte数组的。

SimpleChannelInboundHandler 的好处是可以处理不同的类型对象，并且可以做释放。ChannelInboundHandlerAdapter的好处则是更自由，在异步的场景下更适合。

ChannelInboundHandlerAdapter 注意事项

用户自定义了一个 Handler类，代码如下：

 1 @Override
 2 public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
 3     this.ctx = ctx;
 4 }
 5
 6 @Override
 7 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 8     super.channelRead(ctx, msg);
 9     log.debug("thread.name={}", Thread.currentThread().getName());
10
11     ByteBuf in = (ByteBuf) msg;
12
13     String readStr = in.toString(CharsetUtil.UTF_8);
14     log.debug("Server received: {}", readStr);
15
16     log.debug("release msg");
17     ReferenceCountUtil.release(msg);
18  }
19
20 @Override
21 public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
22     ctx.flush();
23 }
24
25 @Override
26 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
27     cause.printStackTrace();
28     ctx.close();
29 }

运行时出现了如下堆栈异常：

io.netty.util.IllegalReferenceCountException: refCnt: 0
at io.netty.buffer.AbstractByteBuf.ensureAccessible(AbstractByteBuf.java:1173)
at io.netty.buffer.AbstractByteBuf.checkIndex(AbstractByteBuf.java:1119)
at io.netty.buffer.UnpooledUnsafeDirectByteBuf.internalNioBuffer(UnpooledUnsafeDirectByteBuf.java:385)
at io.netty.buffer.ByteBufUtil.decodeString(ByteBufUtil.java:568)
at io.netty.buffer.AbstractByteBuf.toString(AbstractByteBuf.java:979)
at io.netty.buffer.AbstractByteBuf.toString(AbstractByteBuf.java:974)
at com.spy.apollo.netty.demo.demo02_biz_logic.ServerBizHandler.channelRead(ServerBizHandler.java:50) 

异常说是引用计数 refCnf =0，也就是没有被引用，因此报错；常规的 channelRead中消息读取完毕是要立即释放当前消息的引用计数即（减一操作）如下代码操作。但是其他 Handler也去释放时，发现没有引用，就会报错。

ReferenceCountUtil.release(msg);

分析：通过调试代码发现根源就在 super.channelRead(ctx, msg);这个函数。其实 ChannelInboundHandlerAdapter 是提供了一种默认实现，子类如果要继承，需要覆盖父类中的方法，并且不需要调用 super.xxxxMethod()。源码如下：意思是此实现只是将操作转发到下一个 channelhandler。子类可以重写方法实现来改变这一点。

1 /**
2  * <p>
3  * This implementation just forward the operation to the next {@link ChannelHandler} in the
4  * {@link ChannelPipeline}. Sub-classes may override a method implementation to change this.
5  * </p>
6  */
7 public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {