一．ChannelHandler的功能说明
ChannelHandler类似Servlet的Filter过滤器，负责对I/O事件或者I/O操作进行拦截和处理，它可以选择性地拦截和处理自己感兴趣的事件，也可以透传和终止事件的传递。
ChannelHandler支持注解，目前就支持两种注解：
1）@Sharable ：多个ChannelPipeline公用一个ChannelHandler
2）@Skip：被Skip注解的方法不会被调用，直接被忽略
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Skip {
}
@Inherited
@Documented
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Sharable {
}
大多数的ChannelHandler会选择性地拦截和处理某个或者某些事件，其他的事件会忽略，由下一个ChannelHandler进行拦截和处理。这会导致另一个问题：用户ChannelHandler必须实现ChannelHandler的所有接口，包括它不关心的那些事件处理接口，这会导致用户代码的臃肿，代码的可维护性也会变差。
为了解决这个问题，Netty提供了ChannelHandlerAdapter基类，它的所有接口实现都是事件透传。透传的方法一般用注解@Skip
二．ChannelHandler源码分析
2.1 ByteToMessageDecoder源码分析
ByteToMessageDecoder用于将ByteBuf解码成POJO对象。但是ByteToMessageDecoder并没有考虑到TCP粘包和组包等场景，读半包需要用户解码器自己负责处理。正式因为这个，对于大多数场景不会直接继承ByteToMessageDecoder。接下来看看channelRead的源码，如下：
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if(msg instanceof ByteBuf) {
RecyclableArrayList out = RecyclableArrayList.newInstance();
boolean var12 = false;
try {
var12 = true;
ByteBuf data = (ByteBuf)msg;
this.first = this.cumulation == null;
if(this.first) {
this.cumulation = data;
} else {
this.cumulation = this.cumulator.cumulate(ctx.alloc(), this.cumulation, data);
}
this.callDecode(ctx, this.cumulation, out);
var12 = false;
} catch (DecoderException var13) {
throw var13;
} catch (Throwable var14) {
throw new DecoderException(var14);
} finally {
if(var12) {
if(this.cumulation != null && !this.cumulation.isReadable()) {
this.cumulation.release();
this.cumulation = null;
}
int size = out.size();
for(int i = 0; i < size; ++i) {
ctx.fireChannelRead(out.get(i));
}
out.recycle();
}
}
if(this.cumulation != null && !this.cumulation.isReadable()) {
this.cumulation.release();
this.cumulation = null;
}
int size = out.size();
for(int i = 0; i < size; ++i) {
ctx.fireChannelRead(out.get(i));
}
out.recycle();
} else {
ctx.fireChannelRead(msg);
}
}
从源码可以看出来，首先判断需要解码msg对象是否是ByteBuf，如果是ByteBuf才需要进行解码，是否与直接透传。通过cumulation是否为空判断解码器是否缓存了没有解码完成的半包消息，如果为空，说明是首次解码或者最近一次已经处理完了半包消息，没有缓存的半包消息需要处理直接将需要解码的ByteBuf赋值给cumulation；如果cumulation缓存有上次没有解码完成的ByteBuf，则进行赋值操作，将需要解码的ByteBuf复制到cumulation中。
在复制之前需要对cumulation的可写缓冲区进行判断，如果不足则需要动态扩展，扩展的源码如下：
static ByteBuf expandCumulation(ByteBufAllocator alloc, ByteBuf cumulation, int readable) {
ByteBuf oldCumulation = cumulation;
cumulation = alloc.buffer(cumulation.readableBytes() + readable);
cumulation.writeBytes(oldCumulation);
oldCumulation.release();
return cumulation;
}
复制操作完成之后释放需要解码的ByteBuf对象，调用callDecode方法进行解码。
protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
try {
while(true) {
if(in.isReadable()) {
int outSize = out.size();
int oldInputLength = in.readableBytes();
this.decode(ctx, in, out);
if(!ctx.isRemoved()) {
if(outSize == out.size()) {
if(oldInputLength != in.readableBytes()) {
continue;
}
} else {
if(oldInputLength == in.readableBytes()) {
throw new DecoderException(StringUtil.simpleClassName(this.getClass()) + ".decode() did not read anything but decoded a message.");
}
if(!this.isSingleDecode()) {
continue;
}
}
}
}
return;
}
} catch (DecoderException var6) {
throw var6;
} catch (Throwable var7) {
throw new DecoderException(var7);
}
}
源码分析：对ByteBuf进行循环解码，循环的条件是解码缓冲区中有可读的字节，调用抽象decode方法，由用户的子类解码器进行解码，解码后需要对当前的pipeline状态和解码结果进行判断。
如果当前的ChannelHandlerContext已经被移除，则不能继续进行解码，直接退出循环；如果输出的out列表长度没有变化，说明解码没有成功，需要针对以下不同场景进行判断：
（1）如果用户解码器没有消费ByteBuf，则说明是个半包消息，需要由I/O线程继续读取后续的数据报，在这种场景下要退出循环。
（2）如果yoghurt解码器消费了ByteBuf，说明可以解码可以继续进行。
（3）如果用户解码器没有消费ByteBuf，但是却解码出了一个或者多个对象，这种行为被认为是非法的，需要抛出DecoderException异常。
（4）最后通过isSingleDecoder进行判断，如果是单条消息解码器，第一次解码完成之后就退出循环
2.2 MessageToMessageDecoder源码分析
MessageToMessageDecoder负责将一个POJO对象解码成另一个POJO对象，接下来看下channelRead的源码：
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
RecyclableArrayList out = RecyclableArrayList.newInstance();
boolean var13 = false;
try {
var13 = true;
if(this.acceptInboundMessage(msg)) {
Object cast = msg;
try {
this.decode(ctx, cast, out);
} finally {
ReferenceCountUtil.release(msg);
}
var13 = false;
} else {
out.add(msg);
var13 = false;
}
} catch (DecoderException var19) {
throw var19;
} catch (Exception var20) {
throw new DecoderException(var20);
} finally {
if(var13) {
int size = out.size();
for(int i = 0; i < size; ++i) {
ctx.fireChannelRead(out.get(i));
}
out.recycle();
}
}
int size = out.size();
for(int i = 0; i < size; ++i) {
ctx.fireChannelRead(out.get(i));
}
out.recycle();
}
第一通过RecyclableArrayList创建一个新的可循环利用的RecyclableArrayList，然后对解码的消息类型进行判断，通过类型参数校验器看是否是可接受的类型，如果是则校验通过，校验通过之后，直接调用decode抽象方法，有具体实现子类进行消息解码，如果需要解码的对象不是当前解码器 可以接收和处理的类型，则将它加入到RecyclableArrayList中不进行解码。最后对RecyclableArrayList进行遍历，循环调用ChannelHandlerContext的fireChannelRead方法，通知后续的ChannelHandler继续进行处理。循环通知完成之后，通过recycle方法释放RecyclableArrayList。
2.3 LengthFieldBasedFrameDecoder 源码分析
LengthFieldBasedFrameDecoder 基于消息长度的半包解码器。
protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
if(this.discardingTooLongFrame) {
long bytesToDiscard = this.bytesToDiscard;
int localBytesToDiscard = (int)Math.min(bytesToDiscard, (long)in.readableBytes());
in.skipBytes(localBytesToDiscard);
bytesToDiscard -= (long)localBytesToDiscard;
this.bytesToDiscard = bytesToDiscard;
this.failIfNecessary(false);
}
if(in.readableBytes() < this.lengthFieldEndOffset) {
return null;
} else {
int actualLengthFieldOffset = in.readerIndex() + this.lengthFieldOffset;
long frameLength = this.getUnadjustedFrameLength(in, actualLengthFieldOffset, this.lengthFieldLength, this.byteOrder);
if(frameLength < 0L) {
in.skipBytes(this.lengthFieldEndOffset);
throw new CorruptedFrameException("negative pre-adjustment length field: " + frameLength);
} else {
frameLength += (long)(this.lengthAdjustment + this.lengthFieldEndOffset);
if(frameLength < (long)this.lengthFieldEndOffset) {
in.skipBytes(this.lengthFieldEndOffset);
throw new CorruptedFrameException("Adjusted frame length (" + frameLength + ") is less " + "than lengthFieldEndOffset: " + this.lengthFieldEndOffset);
} else if(frameLength > (long)this.maxFrameLength) {
long discard = frameLength - (long)in.readableBytes();
this.tooLongFrameLength = frameLength;
if(discard < 0L) {
in.skipBytes((int)frameLength);
} else {
this.discardingTooLongFrame = true;
this.bytesToDiscard = discard;
in.skipBytes(in.readableBytes());
}
this.failIfNecessary(true);
return null;
} else {
int frameLengthInt = (int)frameLength;
if(in.readableBytes() < frameLengthInt) {
return null;
} else if(this.initialBytesToStrip > frameLengthInt) {
in.skipBytes(frameLengthInt);
throw new CorruptedFrameException("Adjusted frame length (" + frameLength + ") is less " + "than initialBytesToStrip: " + this.initialBytesToStrip);
} else {
in.skipBytes(this.initialBytesToStrip);
int readerIndex = in.readerIndex();
int actualFrameLength = frameLengthInt - this.initialBytesToStrip;
ByteBuf frame = this.extractFrame(ctx, in, readerIndex, actualFrameLength);
in.readerIndex(readerIndex + actualFrameLength);
return frame;
}
}
}
}
}
源码可以看出：如果解码成功，将其加入到输出的List<Object> out 列表中，然后判断discardingTooLongFrame标识，看是否需要丢弃当前可读的字节缓冲区，如果为真，则执行丢弃操作，具体操作如下：
private void failIfNecessary(boolean firstDetectionOfTooLongFrame) {
if(this.bytesToDiscard == 0L) {
long tooLongFrameLength = this.tooLongFrameLength;
this.tooLongFrameLength = 0L;
this.discardingTooLongFrame = false;
if(!this.failFast || this.failFast && firstDetectionOfTooLongFrame) {
this.fail(tooLongFrameLength);
}
} else if(this.failFast && firstDetectionOfTooLongFrame) {
this.fail(this.tooLongFrameLength);
}
}
判断需要丢弃的字节长度，由于丢弃的字节数 不能大于当前缓冲区可读的字节数，通过Max.min函数进行选择，取byteToDiscard和缓冲区可读直接之中的最小值。计算获取需要要丢弃的字节数之后，调用ByteBuf的skipBytes方法跳过需要忽略的字节长度，然后bytesToDiscard减去已经忽略的字节长度。最后判断是否已经达到需要忽略的字节数，达到的话对discardingTooLongFrame等进行置位。
对当前缓冲区的可读字节数和长度偏移量进行对比，如果小于长度偏移量，则说明当前缓冲区的数据报不够，需要返回空，由I/O线程继续读取后续的数据报。
然后通过读索引和lengthFieldOffset计算获取实际的长度字段索引，然后通过索引值获取消息报文的长度字段。然后根据长度字段自身的字节长度进行判断，获取长度之后，就需要对长度仅需合法性判断，同时根据其他解码器参数进行长度调整。如果长度小于0，说明报文非法，跳过lengthFieldEndOffset个字节，抛出CorruptedFrameException异常。根据lengthFieldEndOffset和lengthAdjustmet字段进行长度修正，如果修正后的报文长度小于lengthFieldEndOffset，则说明是非法数据报，需要抛出CorruptedFrameException 异常。
如果修正后报文长度大于ByteBuf的最大容量，说明接收到的消息长度大于系统允许的最大长度上限，需要设置discardingTooLongFrame，计算需要丢弃的字节数，根据情况选择是否需要抛出解码异常。
如果当前的可读字节数小于frameLength，说明是个半包消息，需要返回空，由I/O线程继续读取后续的数据报，等待下次解码。
对需要忽略的消息头字段进行判断，如果大于消息长度frameLength，说明码流非法，需要忽略当前的数据报，抛出CorruptedFrameException异常，通过ByteBuf的skipBytes方法忽略消息头中不需要的字段，得到整包ByteBuf。通过extractFrame方法获取解码后的整包消息缓冲区
根据消息的实际长度分配一个新的ByteBuf对象，将需要解码的ByteBuf可写缓冲区复制到新创建的ByteBuf中并返回，返回之后更新原解码缓冲区ByteBuf为原读索引+消息报文的实际长度。
2.4 MessageToByteEncoder源码分析
MessageToByteEncoder 负责将用户的POJO对象编码成ByteBuf，以便通过网络进行传输。
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
ByteBuf buf = null;
try {
if(this.acceptOutboundMessage(msg)) {
I cast = msg;
buf = this.allocateBuffer(ctx, msg, this.preferDirect);
try {
this.encode(ctx, cast, buf);
} finally {
ReferenceCountUtil.release(msg);
}
if(buf.isReadable()) {
ctx.write(buf, promise);
} else {
buf.release();
ctx.write(Unpooled.EMPTY_BUFFER, promise);
}
buf = null;
} else {
ctx.write(msg, promise);
}
} catch (EncoderException var17) {
throw var17;
} catch (Throwable var18) {
throw new EncoderException(var18);
} finally {
if(buf != null) {
buf.release();
}
}
}
首先判断当前编码器是否支持需要发送的消息，如果不支持则直接透传；如果支持则判断缓冲区的类型，对于直接内存分配ioBuffer（堆外内存），对于堆内存通过heapBuffer方法分配。编码使用的缓冲区分配完成之后，调用encode抽象方法进行编码，编码完成之后，调用ReferenceCountUtil的release方法释放编码对象msg。对编码后的ByteBuf进行以下判断：
1）如果缓冲区包含可发送的字节，则调用ChannelHandlerContext的write方法发送ByteBuf
2）如果缓冲区没有包含可写的字节，则需要释放编码后的ByteBuf，写入一个空的发送操作完成之后，在方法退出之前释放编码缓冲区ByteBuf对象。
2.5 LengthFieldPrepender 源码分析
LengthFieldPrepender 负责在待发送的ByteBuf消息头中增加一个长度字段来标识消息的长度，它简化了用户的编码开发，使用户不需要额外去设置这个长度字段。
protected void encode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
int length = msg.readableBytes() + this.lengthAdjustment;
if(this.lengthIncludesLengthFieldLength) {
length += this.lengthFieldLength;
}
if(length < 0) {
throw new IllegalArgumentException("Adjusted frame length (" + length + ") is less than zero");
} else {
switch(this.lengthFieldLength) {
case 1:
if(length >= 256) {
throw new IllegalArgumentException("length does not fit into a byte: " + length);
}
out.add(ctx.alloc().buffer(1).writeByte((byte)length));
break;
case 2:
if(length >= 65536) {
throw new IllegalArgumentException("length does not fit into a short integer: " + length);
}
out.add(ctx.alloc().buffer(2).writeShort((short)length));
break;
case 3:
if(length >= 16777216) {
throw new IllegalArgumentException("length does not fit into a medium integer: " + length);
}
out.add(ctx.alloc().buffer(3).writeMedium(length));
break;
case 4:
out.add(ctx.alloc().buffer(4).writeInt(length));
break;
case 5:
case 6:
case 7:
default:
throw new Error("should not reach here");
case 8:
out.add(ctx.alloc().buffer(8).writeLong((long)length));
}
out.add(msg.retain());
}
}
源码分析如下：
首先对长度字段进行设置，如果需要包含消息长度自身，则在原来长度的基础之上再加上lengthFieldLength的长度。
如果调整后的消息长度小于0，则抛出参数非法异常。对消息长度自身所占的字节数进行判断，以便采用正确的方法将长度字段写入到ByteBuf中，共有6种可能：
1）长度字段所占字节为1：如果使用1个Byte字节代表消息长度，则最大长度需要小于256个字节。对长度进行校验，如果校验失败，则抛出参数非法异常；若校验通过，则创建新的ByteBuf并通过writeByte将长度值写入到ByteBuf中。
2）长度字段所占字节为2,：如果使用2个Byte字节代表消息长度，则最大长度需要小于65536个字段，对长度进行校验，如果检验失败，则抛出参数非法异常；若校验通过，则创建新的ByteBuf并通过writeShort将长度值写入到ByteBuf中。
3）长度字段所占字节为3：如果使用3个Byte字节代表消息长度，则最大长度需要小于16777216个字节，对长度进行校验，如果校验失败，则抛出参数非法异常；若校验通过，则创建新的ByteBuf并通过writeMedium将长度值写入到ByteBuf中。
4）长度字段所占字节为4：创建新的ByteBuf，并通过writeInt将长度值写入到ByteBuf中。
5）长度字段所占字节为8：创建新的ByteBuf，并通过writeLong将长度值写入到ByteBuf中。
6）其他长度值：直接抛出Error