实战说明TCP协议栈的数据包拆包粘包问题

最新推荐文章于 2024-07-29 09:44:02 发布

代码狂魔v

最新推荐文章于 2024-07-29 09:44:02 发布

阅读量209

点赞数

分类专栏：代码狂魔文章标签：网络网络通信

本文链接：https://blog.csdn.net/xvktdmjg/article/details/114601180

版权

代码狂魔专栏收录该内容

90 篇文章 8 订阅

订阅专栏

所谓问题

严格来说不能叫问题，维基百科TCP协议这么定义的：

传输控制协议（英语：Transmission Control Protocol，缩写：TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义

也就是说TCP只能保证数据（字节流）按照顺序发送并且到达，发几次，怎么发，每次发的长度多少，是TCP说了算的，并不是应用层，所以就会出现下面的问题：

客户端发了两次，怎么服务端一次读取就读完了？
客户端发了很长的一段数据，怎么服务端两次读取才读取完？

要解决这个问题，就要定一个应用层协议，比如，HTTP协议，定一个head，一个body，head里面有个内容长度Content-Length，比如说服务端发了一段消息，长度为100，客户端你没收到100你继续收，收到100为止，而不管你收了几次，因为这是TCP来确定的（根据缓冲区大小，是否到达最大长度等）

这要求定义一个应用层协议，但是很多人将未定义协议的锅甩给TCP，称为拆包（案列2）粘包（案例1）问题。

这个问题，姑且称作未定协议问题

未定义协议问题

即未定义协议产生的问题

"粘包"问题演示

服务端

package ProtocolDesignProblem.problem;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    public static void main(String[] args) throws IOException {
        // 监听指定的端口
        int port = 8081;
        ServerSocket server = new ServerSocket(port);

        // server将一直等待连接的到来
        System.out.println("server将一直等待连接的到来");
        Socket socket = server.accept();
        // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024 * 1024];
        int len;
        int cnt = 1;
        while ((len = inputStream.read(bytes)) != -1) {
            //注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
            String content = new String(bytes, 0, len,"UTF-8");
            System.out.println("cnt = " + (cnt ++ ) + ", len = " + len + ", content: " + content);
        }
        inputStream.close();
        socket.close();
        server.close();
    }
}

客户端

客户端1

package ProtocolDesignProblem.problem;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Client1 {

    public static void main(String[] args) throws IOException, InterruptedException {
        // 要连接的服务端IP地址和端口
        String host = "127.0.0.1";
        int port = 8081;
        // 与服务端建立连接
        Socket socket = new Socket(host, port);
        // 建立连接后获得输出流
        OutputStream outputStream = socket.getOutputStream();
        String message = "【这是一段消息】";
        for (int i = 0; i < 100; i++) {
            //Thread.sleep(1);
            outputStream.write(message.getBytes("UTF-8"));
        }
        outputStream.close();
        socket.close();
        System.out.println("数据发送完毕！");
    }
}

先跑服务端、再跑客户端，服务端输出如下

cnt = 1, len = 408, content: 【这是一段消息】【这是一段消息】...
...
cnt = 15, len = 120, content: 【这是一段消息】

按照正常来讲，发一百次你得收一百次，这才能对上，现在只收到了15次，很多消息还连在一起了，明显不符合预期，这就是所谓的"粘包"问题

"拆包"问题演示

服务端

服务端，服务端还是和上面一样的

package ProtocolDesignProblem.problem;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    public static void main(String[] args) throws IOException {
        // 监听指定的端口
        int port = 8081;
        ServerSocket server = new ServerSocket(port);

        // server将一直等待连接的到来
        System.out.println("server将一直等待连接的到来");
        Socket socket = server.accept();
        // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024 * 1024];
        int len;
        int cnt = 1;
        while ((len = inputStream.read(bytes)) != -1) {
            //注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
            String content = new String(bytes, 0, len,"UTF-8");
            System.out.println("cnt = " + (cnt ++ ) + ", len = " + len + ", content: " + content);
        }
        inputStream.close();
        socket.close();
        server.close();
    }
}

客户端

客户端2

package ProtocolDesignProblem.problem;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Client2 {

    public static void main(String[] args) throws IOException, InterruptedException {
        // 要连接的服务端IP地址和端口
        String host = "127.0.0.1";
        int port = 8081;
        // 与服务端建立连接
        Socket socket = new Socket(host, port);
        // 建立连接后获得输出流
        OutputStream outputStream = socket.getOutputStream();
        String message = genLongChinese(Integer.valueOf(args[0]));//utf-8编码，一个汉字三字节
        for (int i = 0; i < 1; i++) {
            //Thread.sleep(1);
            outputStream.write(message.getBytes("UTF-8"));
        }
        outputStream.close();
        socket.close();
        System.out.println("数据发送完毕！");
    }


    public static String genLongChinese(int len){
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < len; i++) {
            sb.append("中");//一个中字在UTF-8编码中占3个字节
        }
        return sb.toString();
    }
}

第二个就要麻烦些了，需要在Linux环境下演示，本例在CentOS7中演示，本地回环网卡lo，查看lo的MTU（Maximum Transmission Unit，即为最大传输单元），超过此值将会被截断发送，如果太大就设置小点，比如设置mtu为10240字节（临时设置）

ifconfig lo mtu 10240 up

顺带提一下MTU的概念

MTU泛指通讯协议中的最大传输单元。一般用来说明TCP/IP四层协议中数据链路层的最大传输单元，不同类型的网络MTU也会不同，我们普遍使用的以太网的MTU是1500，即最大只能传输1500字节的数据帧。可以通过ifconfig命令查看电脑各个网卡的MTU。

同时需要tcpdump观察数据的发送，如果没有tcpdump，则执行yum install -y tcpdump安装，执行下面命令观察8081端口

tcpdump -i lo 'port 8081'

跑服务端java Server，跑客户端，先发送1000个汉字试试java Client2 1000，观察tcpdump输出

# 三次握手
09:46:39.083150 IP localhost.42110 > localhost.tproxy: Flags [S], seq 214022135, win 20400, options [mss 10200,sackOK,TS val 3970228 ecr 0,nop,wscale 7], length 0
09:46:39.083166 IP localhost.tproxy > localhost.42110: Flags [S.], seq 879271140, ack 214022136, win 20376, options [mss 10200,sackOK,TS val 3970228 ecr 3970228,nop,wscale 7], length 0
09:46:39.083174 IP localhost.42110 > localhost.tproxy: Flags [.], ack 1, win 160, options [nop,nop,TS val 3970228 ecr 3970228], length 0
# length 3000 数据发送，刚好3000字节
09:46:39.084746 IP localhost.42110 > localhost.tproxy: Flags [P.], seq 1:3001, ack 1, win 160, options [nop,nop,TS val 3970229 ecr 3970228], length 3000
# 四次挥手
09:46:39.084783 IP localhost.42110 > localhost.tproxy: Flags [F.], seq 3001, ack 1, win 160, options [nop,nop,TS val 3970229 ecr 3970228], length 0
09:46:39.086550 IP localhost.tproxy > localhost.42110: Flags [.], ack 3001, win 319, options [nop,nop,TS val 3970232 ecr 3970229], length 0
09:46:39.087278 IP localhost.tproxy > localhost.42110: Flags [F.], seq 1, ack 3002, win 319, options [nop,nop,TS val 3970232 ecr 3970229], length 0
09:46:39.087284 IP localhost.42110 > localhost.tproxy: Flags [.], ack 2, win 160, options [nop,nop,TS val 3970232 ecr 3970232], length 0

TCP三次握手、四次挥手看的清清楚楚，数据发送一次发完3000字节，没毛病

下面来试验下4000个汉字，也就是12000字节，超过了我们设置的mtu 10240字节，跑服务端java Server，跑客户端，这次发送4000个汉字试试java Client2 4000，观察tcpdump输出

#三次握手
09:47:22.003451 IP localhost.42114 > localhost.tproxy: Flags [S], seq 182084378, win 20400, options [mss 10200,sackOK,TS val 4013148 ecr 0,nop,wscale 7], length 0
09:47:22.003465 IP localhost.tproxy > localhost.42114: Flags [S.], seq 1098406208, ack 182084379, win 20376, options [mss 10200,sackOK,TS val 4013148 ecr 4013148,nop,wscale 7], length 0
09:47:22.003474 IP localhost.42114 > localhost.tproxy: Flags [.], ack 1, win 160, options [nop,nop,TS val 4013148 ecr 4013148], length 0
# 数据发送，发送了两次 10188 + 1812 刚好为 12000
09:47:22.007582 IP localhost.42114 > localhost.tproxy: Flags [.], seq 1:10189, ack 1, win 160, options [nop,nop,TS val 4013152 ecr 4013148], length 10188
09:47:22.007593 IP localhost.42114 > localhost.tproxy: Flags [P.], seq 10189:12001, ack 1, win 160, options [nop,nop,TS val 4013152 ecr 4013148], length 1812
# 四次挥手，还设有一次不知道是干啥的，可能是上面数据拆分后的确认信息？
09:47:22.007631 IP localhost.42114 > localhost.tproxy: Flags [F.], seq 12001, ack 1, win 160, options [nop,nop,TS val 4013152 ecr 4013148], length 0
09:47:22.008012 IP localhost.tproxy > localhost.42114: Flags [.], ack 10189, win 319, options [nop,nop,TS val 4013152 ecr 4013152], length 0
09:47:22.008020 IP localhost.tproxy > localhost.42114: Flags [.], ack 12001, win 478, options [nop,nop,TS val 4013152 ecr 4013152], length 0
09:47:22.011443 IP localhost.tproxy > localhost.42114: Flags [F.], seq 1, ack 12002, win 478, options [nop,nop,TS val 4013156 ecr 4013152], length 0
09:47:22.011450 IP localhost.42114 > localhost.tproxy: Flags [.], ack 2, win 160, options [nop,nop,TS val 4013156 ecr 4013156], length 0

直接看上面注释就知道，这4000个汉字其实是被分两次发送了，这就是所谓的"拆包"问题

定义应用层协议

那怎么解决上面的问题？定义个协议就好，比如每次发送的时候前面四个字节用来指定后面内容的长度，如果发送没够长度就继续发送，直到长度够为止，接收长度不够就继续接收，直到收够数据为止，定义协议如下，int32位整数占用前面四个字节用来表示后面数据的长度

长度 真正数据
----==========

粘包：A区域数据拿出来得到数据长度为length，根据length则知道B为真实数据，拿出来处理，最后把A和B扔掉，留下CDE做下一次解析，长度够就继续解析，不够就读取下数据再做解析，最后留下E拼接在下次数据的前面

 A      B      C        D      E
----==========----=============---

拆包：A区域数据拿出来得到数据长度为length，则知道了真实数据B的长度，发现B长度不够，则再去读，读到C和D，根据length则知道B+C为真实数据，拿出来处理，最后把ABC扔掉，D留下拼接在下次数据的前面

  A   B                   C          D
----=====        ===================---

参考代码：先跑服务端、再跑客户端，现在发1000次消息顺序都不会乱

客户端

客户端相对简单，要将发送的数据编码成长度和消息本体

package ProtocolDesignProblem.designProtocol;

import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;

import static ProtocolDesignProblem.designProtocol.Util.*;

public class Client {

    public static void main(String[] args) throws IOException {
        // 要连接的服务端IP地址和端口
        String host = "127.0.0.1";
        int port = 8081;
        // 与服务端建立连接
        Socket socket = new Socket(host, port);
        // 建立连接后获得输出流
        OutputStream outputStream = socket.getOutputStream();
        String message = "【这是一段消息】";
        for (int i = 0; i < 1000; i++) {
            outputStream.write(encodeMessage(message));
        }
        outputStream.close();
        socket.close();
        System.out.println("数据发送完毕！");
    }


    /**
     *
     * @param message 消息
     * @return 消息长度+消息本体
     * @throws UnsupportedEncodingException
     */
    public static byte[] encodeMessage(String message) throws UnsupportedEncodingException {
        //消息
        byte[] content = message.getBytes(CHAR_SET);

        //消息长度编码成字节
        byte[] contentLengthBytes = int2Bytes(content.length);

        //消息长度 + 消息本体
        byte[] encode = new byte[content.length + INTEGER_LENGTH];
        System.arraycopy(contentLengthBytes,0,encode,0,INTEGER_LENGTH);
        System.arraycopy(content,0,encode,INTEGER_LENGTH,content.length);
        return encode;
    }


}

服务端

服务端就相对复杂了

package ProtocolDesignProblem.designProtocol;


import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

import static ProtocolDesignProblem.designProtocol.Util.*;

public class Server {

    public static void main(String[] args) throws IOException {
        // 监听指定的端口
        int port = 8081;
        ServerSocket server = new ServerSocket(port);

        // server将一直等待连接的到来
        System.out.println("server将一直等待连接的到来");
        Socket socket = server.accept();
        // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
        InputStream inputStream = socket.getInputStream();


        byte[] bytes = new byte[1024 * 1024];
        int len = 0,cnt = 0;

        /*1 定义出上次未处理完的字节（超出的字节）*/
        int lastBytesLength = 0;
        byte[] lastBytes = new byte[lastBytesLength];

        while ((len = inputStream.read(bytes)) != -1) {
            /*2 将本次读取到的字节和上次没处理完的字节拼接在一起
            形成【上次未处理完字节 + 本次新读取到的字节】*/
            byte[] tempBytes = new byte[lastBytesLength + len];
            System.arraycopy(lastBytes,0,tempBytes,0,lastBytesLength);
            System.arraycopy(bytes,0,tempBytes,0,len);
            lastBytesLength += len;
            lastBytes = tempBytes;

            /*3 到目前为止如果字节大于了内容长度的字节数，说明可以取内容了，
            否则继续读取，读到多余4个字节为止*/
            while (lastBytesLength > INTEGER_LENGTH){
                /*4 取出前面4个字节解析成内容长度*/
                byte[] contentLengthBytes = new byte[INTEGER_LENGTH];
                System.arraycopy(lastBytes,0,contentLengthBytes,0,INTEGER_LENGTH);
                int contentLength = bytes2Int(contentLengthBytes);//内容长度

                /*5 如果目前读取到的字节还没撑够内容的长度，
                那继续读，读到撑够为止，即可能发生了拆包*/
                if (lastBytesLength - INTEGER_LENGTH < contentLength){
                    break;
                }

                /*6 内容够了 取出内容做处理*/
                String message = new String(lastBytes,INTEGER_LENGTH,contentLength,CHAR_SET);
                System.out.println("cnt = " + (++cnt) + ", content: " + message);

                /*7 重点，将本次未处理完的内容保留下来，
                拼接在下次读取到数据的前面，即可能发生了粘包*/
                lastBytesLength -= (contentLength + INTEGER_LENGTH);
                byte[] leftBytes = new byte[lastBytesLength];
                System.arraycopy(lastBytes,contentLength+INTEGER_LENGTH,leftBytes,0,lastBytesLength);
                lastBytes = leftBytes;
            }
        }

        inputStream.close();
        socket.close();
        server.close();
    }
}

Util.java

package ProtocolDesignProblem.designProtocol;

public class Util {

    public static void main(String[] args) {
        System.out.println(bytes2Int(int2Bytes(12)));
    }

    public static final int INTEGER_LENGTH = 4;//内容长度数据本身的长度，即为int32位整数4字节长

    public static final String CHAR_SET = "UTF-8";//客户端与服务端编码一致

    //int数值转为字节数组
    public static byte[] int2Bytes(int i) {
        byte[] result = new byte[4];
        result[0] = (byte) (i >> 24 & 0xFF);//i向右移动24位，然后和0xFF也就是（11111111）进行与运算
        result[1] = (byte) (i >> 16 & 0xFF);
        result[2] = (byte) (i >> 8 & 0xFF);
        result[3] = (byte) (i & 0xFF);
        return result;
    }
    //字节数组转为int数值
    public static int bytes2Int(byte[] bytes){
        int num = bytes[3] & 0xFF;
        num |= ((bytes[2] << 8) & 0xFF00);
        num |= ((bytes[1] << 16) & 0xFF0000);
        num |= ((bytes[0] << 24)  & 0xFF000000);
        return num;
    }
}

参考代码：先跑服务端、再跑客户端，现在发1000次消息顺序都不会乱！

运行结果

server将一直等待连接的到来
cnt = 1, content: 【这是一段消息】
cnt = 2, content: 【这是一段消息】
....省略
cnt = 512, content: 【这是一段消息】
....省略
cnt = 998, content: 【这是一段消息】
cnt = 999, content: 【这是一段消息】
cnt = 1000, content: 【这是一段消息】

代码狂魔v

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
实战说明TCP协议栈的数据包拆包粘包问题

所谓问题严格来说不能叫问题，维基百科TCP协议这么定义的：传输控制协议（英语：Transmission Control Protocol，缩写：TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义也就是说TCP只能保证数据（字节流）按照顺序发送并且到达，发几次，怎么发，每次发的长度多少，是TCP说了算的，并不是应用层，所以就会出现下面的问题：客户端发了两次，怎么服务端一次读取就读完了？客户端发了很长的一段数据，怎么服务端两次读取才读取完？要解决这个
复制链接

扫一扫