在实际网络应用中，我们接收和发送的数据都是以实际应用数据类型为单位的（比如一个Http数据体，或者一个ThriftObject）。而对于Socket而言，它处理的是TCP传输层的数据，在它接收或发送的一个TCP包中，可能正好对应一个ThriftObject，或者多个ThriftObject、ThriftObject的一部分，甚至可能由多个ThriftObject的多个部分组成。这就是TCP的粘包半包问题。

Netty提供了一种机制可以帮助我们方便地处理TCP半包和粘包问题，它是通过嵌入ChannelHandler来实现的。

下面以一段简单的代码实例来看一下，如何在Netty中处理TCP粘包和拆包问题。可以看到代码中添加了类型为FixedLengthFrameDecoder的ChannelHandler，添加这段代码的效果就是每次会截取定量长度为1024的字节数据作为下层ChannelHandler的input处理对象。

    public void bind(int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 1024)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //处理TCP半包粘包问题
                        ch.pipeline().addLast(new FixedLengthFrameDecoder(1024));
                    }
                })
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new SimpleNettyServerHandler());
                    }
                });
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

1. 源码分析

我们就以FixedLengthFrameDecoder为例，它的实现非常简单，继承自类ByteToMessageDecoder,并对父类的抽象方法decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)进行了实现。所以，要分析Netty对TCP粘包拆包的处理，核心逻辑在于ByteToMessageDecoder。

public class FixedLengthFrameDecoder extends ByteToMessageDecoder{
 @Override
    protected final void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
    {.....}
}

1.1 流程概述

4个核心方法：
ByteToMessageDecoder channelRead(..)
ByteToMessageDecoder callDecode(..)
ByteToMessageDecoder fireChannelRead(..)
FixedLengthFrameDecoder decode(..)

1.2 channelRead方法分析

通过文章 Netty源码分析-ChannelPipeline 的分析，channelRead方法的调用是在ChannelPipeline中，入参msg会是一个ByteBuf。

第一步：首先会实例化一个空的CodecOutputList，用于存放一会将要解码生成的对象。
第二步：核心在于赋值cumulation，cumulation的类型也是ByteBuf，它与入参的msg会有什么不同呢？如果cumulation为null，会直接将msg的地址赋值给cumulation，否则会将cumulator.cumulate(ctx.alloc(), cumulation, data)方法返回值赋值给cumulation，看一下方法描述“Cumulate the given {@link ByteBuf}s and return the {@link ByteBuf} that holds the cumulated bytes.”，原来是将msg与cumulation进行一个merge。这就相当于将两个TCP包的数据进行了一个数据上的衔接。
第三步：调用callDecode对cumulation进行解码。

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                ByteBuf data = (ByteBuf) msg;
                first = cumulation == null;
                if (first) {
                    cumulation = data;
                } else {
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
                }
                callDecode(ctx, cumulation, out);
            } catch (DecoderException e) {
                throw e;
            } catch (Throwable t) {
                throw new DecoderException(t);
            } finally {
                if (cumulation != null && !cumulation.isReadable()) {
                    numReads = 0;
                    cumulation.release();
                    cumulation = null;
                } else if (++ numReads >= discardAfterReads) {
                    // We did enough reads already try to discard some bytes so we not risk to see a OOME.
                    // See https://github.com/netty/netty/issues/4275
                    numReads = 0;
                    discardSomeReadBytes();
                }

                int size = out.size();
                decodeWasNull = !out.insertSinceRecycled();
                fireChannelRead(ctx, out, size);
                out.recycle();
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }

1.3 callDecode方法分析

callDecode的核心流程就是对ByteBuf进行遍历，遍历的过程中不断调用decode方法解析出Object对象，并对解析出的对象执行fireChannelRead方法，保证Pipeline的往下传递。
代码注释中会对过程进行分析。

    protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        try {
            while (in.isReadable()) {
                int outSize = out.size();
                if (outSize > 0) {
                    //说明有解码好的对象，对这些对象进行Pipeline的往下传递
                    fireChannelRead(ctx, out, outSize);
                    out.clear();
                    if (ctx.isRemoved()) {
                        break;
                    }
                    outSize = 0;
                }
                int oldInputLength = in.readableBytes();
                //真正调用实际decode方法进行解码的地方
                decodeRemovalReentryProtection(ctx, in, out);
                if (ctx.isRemoved()) {
                    break;
                }
                // 说明没有解码到新对象，这时候如果ByteBuf没有移动，说明此次ByteBuf内容不足以解码，会直接break。
                if (outSize == out.size()) {
                    if (oldInputLength == in.readableBytes()) {
                        break;
                    } else {
                        continue;
                    }
                }
                //解码到了对象，但是却没有移动ByteBuf，说明有问题
                if (oldInputLength == in.readableBytes()) {
                    throw new DecoderException(
                            StringUtil.simpleClassName(getClass()) +
                                    ".decode() did not read anything but decoded a message.");
                }

                if (isSingleDecode()) {
                    break;
                }
            }
        } catch (DecoderException e) {
            throw e;
        } catch (Throwable cause) {
            throw new DecoderException(cause);
        }
    }

1.4 fireChannelRead方法分析

fireChannelRead(ChannelHandlerContext ctx, List<Object> msgs, int numElements)方法的入参是已经解码后产生的List<Object> ，会遍历这些Object，分别调用ctx.fireChannelRead(final Object msg)进行ChanelPipeline的往下传递。

下边也列出了ctx.fireChannelRead(final Object msg)的代码实现，findContextInbound()会找到ctx的下一个AbstractChannelHandlerContext，将ChannelPipeline进行往后传递。

static void fireChannelRead(ChannelHandlerContext ctx, List<Object> msgs, int numElements) {
        if (msgs instanceof CodecOutputList) {
            fireChannelRead(ctx, (CodecOutputList) msgs, numElements);
        } else {
            for (int i = 0; i < numElements; i++) {
                ctx.fireChannelRead(msgs.get(i));
            }
        }
    }
abstract class AbstractChannelHandlerContext{
    @Override
    public ChannelHandlerContext fireChannelRead(final Object msg) {
        invokeChannelRead(findContextInbound(), msg);
        return this;
    }
}

1.5 decode方法分析

下面是类FixedLengthFrameDecoder的代码实现。可以看到非常简单：判断当前的ByteBuf长度够不够一个Frame的长度，如果不够不处理，否则会解码出一个Frame并添加至 List<Object> out 中，然后将ByteBuf指针前移frameLength长度。

    @Override
    protected final void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        Object decoded = decode(ctx, in);
        if (decoded != null) {
            out.add(decoded);
        }
    }
    protected Object decode(
            @SuppressWarnings("UnusedParameters") ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        if (in.readableBytes() < frameLength) {
            return null;
        } else {
            return in.readRetainedSlice(frameLength);
        }
    }

2. 其他实现

上边的例子中，我们讲述了解决TCP粘包拆包的一个例子-分割成固定长度的Frame。在实际应用中，会根据应用层业务实体类型进行不同的decode解码，比如Http应用中需要解码出HttpRequest，thrift RPC调用中需要解码出ThriftObject等等。

实际Netty已经帮助使用者做了非常多的工作，像常用的HttpRequestDecoder可以帮助我们解码出Http对象，XmlDecoder可以帮助我们解码出XML对象，类似的还有json对象解码、WebSocket对象解码等等。

如果Netty已经提供的Decoder无法满足你的要求，你也可以实现自己的Decoder。过程非常简单，只需要继承ByteToMessageDecoder类并实现抽象方法decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out).