目录

TCP粘包拆包

粘包和拆包是TCP网络编程中不可避免的,无论是服务端还是客户端,当我们读取或者发送消息的时候,都需要考虑TCP底层的粘包/拆包机制。

TCP粘包和拆包

TCP是个“流”协议,所谓流,就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义,它会根据TCP缓冲区的实际情况进行包的划分,所以在业务上认为,一个完整的包可能会被TCP拆分成多个包进行发送,也有可能把多个小的包封装成一个大的数据包发送,这就是所谓的TCP粘包和拆包问题。

https://gitee.com/lienhui68/picStore/raw/master/null/20200904081506.png

如图所示,假设客户端分别发送了两个数据包D1和D2给服务端,由于服务端一次读取到的字节数是不确定的,故可能存在以下4种情况。

  1. 服务端分两次读取到了两个独立的数据包,分别是D1和D2,没有粘包和拆包;
  2. 服务端一次接收到了两个数据包,D1和D2粘合在一起,被称为TCP粘包;
  3. 服务端分两次读取到了两个数据包,第一次读取到了完整的D1包和D2包的部分内容,第二次读取到了D2包的剩余内容,这被称为TCP拆包
  4. 服务端分两次读取到了两个数据包,第一次读取到了D1包的部分内容D1_1,第二次读取到了D1包的剩余内容D1_2和D2包的整包。

如果此时服务端TCP接收滑窗非常小,而数据包D1和D2比较大,很有可能会发生第五种可能,即服务端分多次才能将D1和D2包接收完全,期间发生多次拆包。

TCP粘包和拆包产生的原因

数据从发送方到接收方需要经过操作系统的缓冲区,而造成粘包和拆包的主要原因就在这个缓冲区上。粘包可以理解为缓冲区数据堆积,导致多个请求数据粘在一起,而拆包可以理解为发送的数据大于缓冲区,进行拆分处理。

https://gitee.com/lienhui68/picStore/raw/master/null/20200904081652.png

拆包

  • 要发送的数据大于TCP发送缓冲区剩余空间大小,将会发生拆包。
  • 待发送数据大于MSS(最大报文长度),TCP在传输前将进行拆包。

粘包

  • 要发送的数据小于TCP发送缓冲区的大小,TCP将多次写入缓冲区的数据一次发送出去,将会发生粘包。
  • 接收数据端的应用层没有及时读取接收缓冲区中的数据,将发生粘包。

说白了就是TCP是个"流"协议,没有界限的一串数据,发送和接受的数据会暂存在TCP缓冲区,所以应用层需要一套将TCP消息拆包的机制。

总结来说,造成粘包和拆包的原因主要有以下三个:

  1. 应用程序write写入的字节大小大于套接口发送缓冲区大小
  2. 进行MSS大小的TCP分段
  3. 以太网帧的payload大于MTU进行IP分片。

https://gitee.com/lienhui68/picStore/raw/master/null/20200904081732.png

粘包和拆包的解决办法

由于底层的TCP无法理解上层的业务数据,所以在底层是无法保证数据包不被拆分和重组的,这个问题只能通过上层的应用协议栈设计来解决,根据业界的主流协议的解决方案,归纳如下:

消息定长

发送端将每个数据包封装为固定长度(不够的可以通过补0填充),这样接收端每次接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。

设置消息边界

服务端从网络流中按消息边界分离出消息内容。在包尾增加回车换行符进行分割,例如FTP协议。

将消息分为消息头和消息体

将消息分为消息头和消息体,消息头中包含表示消息总长度(或者消息体长度)的字段。

更复杂的应用层协议

比如Netty中实现的一些协议都对粘包、拆包做了很好的处理。

Netty的拆包解决方案

Netty这个框架,对于客户端和服务端之间的数据传输做了很好的处理,服务端在发送数据之前先对数据按一定的规则进行编码,客户端在接收到数据后按照相同的规则进行解码,这就是Netty解决粘包拆包问题的思路,下面我们详细来看一看。

拆包这个工作,Netty 已经为大家备好了很多不同的拆包器。 本着不重复发明轮子的原则,我们直接使用Netty现成的拆包器。

Netty 中的拆包器大致如下:

固定长度的拆包器 FixedLengthFrameDecoder

每个应用层数据包的都拆分成都是固定长度的大小,比如 1024字节。

对于使用固定长度的粘包和拆包场景,可以使用FixedLengthFrameDecoder,该解码一器会每次读取固定长度的消息,如果当前读取到的消息不足指定长度,那么就会等待下一个消息到达后进行补足。 其使用也比较简单,只需要在构造函数中指定每个消息的长度即可。 这里需要注意的是,FixedLengthFrameDecoder只是一个解码一器,Netty也只提供了一个解码一器,这是因为对于解码是需要等待下一个包的进行补全的,代码相对复杂,而对于编码器,用户可以自行编写,因为编码时只需要将不足指定长度的部分进行补全即可。

数据在编码发送的时候,也会以固定长度作为一条完整的消息。

行拆包器 LineBasedFrameDecoder

每个应用层数据包,都以换行符作为分隔符,进行分割拆分。

数据在编码发送的时候,会以换行符作为一条完整的消息。

分隔符拆包器 DelimiterBasedFrameDecoder

每个应用层数据包,都通过自定义的分隔符,进行分割拆分。 这个版本,是LineBasedFrameDecoder 的通用版本,本质上是一样的。

数据在编码发送的时候,会以一个自定义的分隔符作为一条完整的消息。

基于数据包长度的拆包器 LengthFieldBasedFrameDecoder

将应用层数据包的长度,作为接收端应用层数据包的拆分依据。 按照应用层数据包的大小,拆包。 这个拆包器,有一个要求,就是应用层协议中包含数据包的长度。

LengthFieldBasedFrameDecoder与LengthFieldPrepender需要配合起来使用,其实本质上来讲,这两者一个是解码,一个是编码的关系。 它们处理粘拆包的主要思想是在生成的数据包中添加一个长度字段,用于记录当前数据包的长度。 LengthFieldBasedFrameDecoder会按照参数指定的包长度偏移量数据对接收到的数据进行解码,从而得到目标消息体数据; 而LengthFieldPrepender则会在响应的数据前面添加指定的字节数据,这个字节数据中保存了当前消息体的整体字节数据长度。

数据在编码发送的时候,会指定当前这条消息的长度。

以上解码器在使用时只需要添加到Netty的责任链中即可,大多数情况下这4种解码器都可以满足了,当然除了以上4种解码器,用户也可以自定义自己的解码器进行处理。具体可以参考以下代码示例:

固定长度的拆包器 FixedLengthFrameDecoder示例代码

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package com.eh.eden.netty.chapter2;


import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

// Server主程序
public class XNettyServer {
    public static void main(String[] args) throws InterruptedException {
        // accept 处理连接的线程池
        NioEventLoopGroup acceptGroup = new NioEventLoopGroup();
        // read io 处理数据的线程池
        NioEventLoopGroup readGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap
                    .group(acceptGroup, readGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();

                            // 增加解码器
                            pipeline.addLast(new XDecoder());
                            // 打印出内容 handler
                            pipeline.addLast(new XHandler());
                        }
                    });
            System.out.println("启动成功,端口 7777");
            serverBootstrap.bind(7777).sync().channel().closeFuture().sync();
        } finally {
            acceptGroup.shutdownGracefully();
            readGroup.shutdownGracefully();
        }

    }
}

class XDecoder extends ByteToMessageDecoder {

    static final int PACKET_SIZE = 10;

    // 用来临时保留没有处理过的请求报文
    ByteBuf tmpMsg = Unpooled.buffer();

    /**
     * @param ctx
     * @param in  请求的数据
     * @param out 将粘在一起的报文拆分后的结果放入out列表,交由后面的业务逻辑处理
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println(Thread.currentThread() + "收到了一次数据包,长度是:" + in.readableBytes());

        // 合并报文
        ByteBuf message;
        int tmpMsgSize = tmpMsg.readableBytes();
        if (tmpMsgSize > 0) {
            message = Unpooled.buffer();
            message.writeBytes(tmpMsg);
            message.writeBytes(in);
            System.out.println("合并:上一数据包余下的长度为:" + tmpMsgSize + ",合并后长度为:" + message.readableBytes());

        } else {
            message = in;
        }

        int size = message.readableBytes();
        int counter = size / PACKET_SIZE;
        for (int i = 0; i < counter; i++) {
            byte[] request = new byte[PACKET_SIZE];
            // 每次从总的消息中读取220个字节的数据
            message.readBytes(request);

            // 将拆分后的结果放入out列表中,交由后面的业务逻辑去处理
            out.add(Unpooled.copiedBuffer(request));
        }

        // 多余的报文存起来
        // 第一个报文: i+  暂存
        // 第二个报文: 1 与第一次
        size = message.readableBytes();
        if (size != 0) {
            System.out.println("多余的数据长度:" + size);
            // 剩下来的数据放到tempMsg暂存
            tmpMsg.clear();
            tmpMsg.writeBytes(message.readBytes(size));
        }
    }
}

class XHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        byte[] content = new byte[byteBuf.readableBytes()];
        byteBuf.readBytes(content);
        System.out.println(Thread.currentThread() + ": 最终打印" + new String(content));
        ((ByteBuf) msg).release();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

实战:远扬通信中自定义协议的粘包、拆包解决方案

对于我们要做的项目,也可以自己定义消息传输的协议,在我做过的一个项目中,远洋货轮需要进行通信,大家都知道,在海上信号是很差的,每次收消息都很难保证收到的是一条完整的消息,但此时我们可以自定义协议,在消息的头部用两个字节把本次消息发送的长度加上,中间部分是消息正文,消息的尾部用4个字节保存本条消息md5值的低四位。 这样,接收方在收到部分消息后,可根据消息的头部判断该条消息的具体长度,然后继续接收消息,当收到完整的消息后,在去计算接收到消息的md5四位,去跟接收的低四位做比较,如果一致,就认为是收到了完整的消息,接着根据约定的协议进行解码交流。

当然,消息的校验位还是比较复杂的,需要给每台设备都指定唯一标识来区别身份等,这里就不展开叙述了。

此种方案特别适合网络环境差的情况,能保证正常的通信。 也经受住了实战的考验,基本可以做到消息的零丢失。

总结:一个面试题

我们都知道TCP属于传输层的协议,传输层除了有TCP协议外还有UDP协议。

那么UDP是否会发生粘包或拆包的现象呢?

答案是不会。 UDP是基于报文发送的,从UDP的帧结构可以看出,在UDP首部采用了16bit来指示UDP数据报文的长度,因此在应用层能很好的将不同的数据报文区分开,从而避免粘包和拆包的问题。

而TCP是基于字节流的,虽然应用层和TCP传输层之间的数据交互是大小不等的数据块,但是TCP把这些数据块仅仅看成一连串无结构的字节流,没有边界; 另外从TCP的帧结构也可以看出,在TCP的首部没有表示数据长度的字段,基于上面两点,在使用TCP传输数据时,才有粘包或者拆包现象发生的可能。

参考

https://www.cnblogs.com/coding-diary/p/11650686.html

https://zhuanlan.zhihu.com/p/98444590