1.生命周期

2.ChannelInboundHandler事件

3.ByteBuf的釋放

3.1顯式釋放

3.2 SimpleChannelInboundHandler自動釋放

重寫channelRead0方法

public class SimpleDiscardHandler
extends SimpleChannelInboundHandler<Object> {
@Override
public void channelRead0(ChannelHandlerContext ctx,
Object msg) {
// No need to do anything special
 }
}

參考:
Netty4（十三）：SimpleChannelInBoundHandler 源碼分析

4.ChannelOutboundHandler事件

出站操作和數據將由 ChannelOutboundHandler 處理。它的方法將被 Channel、ChannelPipeline 以及 ChannelHandlerContext 調用。
ChannelOutboundHandler 的一個強大的功能是可以按需推遲操作或者事件，這使得可
以通過一些復雜的方法來處理請求。例如， 如果到遠程節(jié)點的寫入被暫停了， 那么你可以推遲沖
刷操作并在稍后繼續(xù)。
表6-4顯示了所有由ChannelOutboundHandler本身所定義的方法（忽略了那些從ChannelHandler 繼承的方法）

5.ChannelHandler適配器

6.ChannelDuplexHandler

同時實現了ChannelInboundHandler和ChannelOutboundHandler

public class ChannelDuplexHandler extends ChannelInboundHandlerAdapter implements ChannelOutboundHandler {
}

7.CombinedChannelDuplexHandler

CombinedChannelDuplexHandler繼承自ChannelDuplexHandler,其需要傳入ChannelInboundHandler和ChannelOutboundHandler,本質上其是一個代理對象

public class CombinedChannelDuplexHandler<I extends ChannelInboundHandler, O extends ChannelOutboundHandler>
        extends ChannelDuplexHandler {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(CombinedChannelDuplexHandler.class);

    private DelegatingChannelHandlerContext inboundCtx;
    private DelegatingChannelHandlerContext outboundCtx;
    private volatile boolean handlerAdded;

    private I inboundHandler;
    private O outboundHandler;

    /**
     * Creates a new uninitialized instance. A class that extends this handler must invoke
     * {@link #init(ChannelInboundHandler, ChannelOutboundHandler)} before adding this handler into a
     * {@link ChannelPipeline}.
     */
    protected CombinedChannelDuplexHandler() {
        ensureNotSharable();
    }

    /**
     * Creates a new instance that combines the specified two handlers into one.
     */
    public CombinedChannelDuplexHandler(I inboundHandler, O outboundHandler) {
        ensureNotSharable();
        init(inboundHandler, outboundHandler);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        assert ctx == inboundCtx.ctx;
        if (!inboundCtx.removed) {
            inboundHandler.channelActive(inboundCtx);
        } else {
            inboundCtx.fireChannelActive();
        }
    }

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        assert ctx == outboundCtx.ctx;
        if (!outboundCtx.removed) {
            outboundHandler.write(outboundCtx, msg, promise);
        } else {
            outboundCtx.write(msg, promise);
        }
    }
}