tcp服务端和客户端建立连接后会长时间维持这个连接，用于互相传递数据，tcp是以流的方式传输数据的，就像一个水管里的水一样，从一头不断的流向另一头。理想情况下，发送的数据包都是独立的，
现实要复杂一些，发送方和接收方都有各自的缓冲区。发送缓冲区：应用不断的把数据发送到缓冲区，系统不断的从缓冲区取数据发送到接收端。接收缓冲区：系统把接收到的数据放入缓冲区，应用不断的从缓冲区获取数据。当发送方快速的发送多个数据包时，每个数据包都小于缓冲区，tcp会将多次写入的数据放入缓冲区，一次发送出去，服务器在接收到数据流无法区分哪部分数据包独立的，这样产生了粘包。
或者接收方因为各种原因没有从缓冲区里读取数据，缓冲区的数据会积压，等再取出数据时，也是无法区分哪部分数据包独立的，一样会产生粘包。发送方的数据包大于缓存区了，其中有一部分数据会在下一次发送，接收端一次接收到时的数据不是完整的数据，就会出现半包的情况。
我们可以还原一下粘包和半包，写一个测试代码服务端
func main() {
l, err := net.Listen("tcp", ":8899")
if err != nil {
panic(err)
}
fmt.Println("listen to 8899")
for {
conn, err := l.Accept()
if err != nil {
panic(err)
} else {
go handleConn(conn)
}
}
}
func handleConn(conn net.Conn) {
defer conn.Close()
var buf [1024]byte
for {
n, err := conn.Read(buf[:])
if err != nil {
break
} else {
fmt.Printf("recv: %s \n", string(buf[0:n]))
}
}
}客户端
func main() {
data := []byte("~测试数据：一二三四五~")
conn, err := net.Dial("tcp", ":8899")
if err != nil {
panic(err)
}
for i := 0; i < 2000; i++ {
if _, err = conn.Write(data); err != nil {
fmt.Printf("write failed , err : %v\n", err)
break
}
}
}查看一下输出
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~ ~测试数据：一二三四五~
recv: ~测试数据：一?
recv: ??三四五~ ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~ ~测试数据：一二三四五~ ~测试数据：一二三四五~ ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~
正常情况下输出是recv: ~测试数据：一二三四五~，发生粘包的时候会输出多个数据包，当有半包的情况下输出的是乱码数据，再下一次会把剩下的半包数据也输出。要解决也简单的就想办法确定数据的边界，常见的处理方式：
- 固定长度： 比如规定所有的数据包长度为100byte，如果不够则补充至100长度。优点就是实现很简单，缺点就是空间有极大的浪费，如果传递的消息中大部分都比较短，这样就会有很多空间是浪费的，同样浪费的还有流量。
- 分隔符：用分隔符来确定数据的边界，这样做比较简单也不浪费空间，但数据包内就不能包含相应的分隔符，如果有会造成错误的解析。
- 数据头：通过数据头部来解析数据包长度，比如用4个字节来当数据头，保存每个实数据包的长度。
个人更推荐数据头方式来确定数据边界，在发送和接收数据时做好规定，每个数据包是不定长的，比如4字节的包头+真实的数据可以根据自己的业务进行扩展，比如上更多的包头或者包尾，加上数据校验等。我修改一下上面的代码：客户端
data := []byte("~测试数据：一二三四五~")
conn, err := net.Dial("tcp", ":8899")
if err != nil {
panic(err)
}
for i := 0; i < 2000; i++ {
var total int64 = -1
var buf [4]byte
bufs := buf[:]
binary.BigEndian.PutUint32(bufs, uint32(len(data)))
n, err := conn.Write(bufs)
total += int64(n)
n, err = conn.Write(data)
total += int64(n)
if err != nil {
fmt.Printf("write failed , err : %v\n", err)
break
}
}服务端
func main() {
l, err := net.Listen("tcp", ":8899")
if err != nil {
panic(err)
}
fmt.Println("listen to 8899")
for {
conn, err := l.Accept()
if err != nil {
panic(err)
} else {
go handleConn(conn)
}
}
}
func handleConn(conn net.Conn) {
defer conn.Close()
for {
var msgSize int32
err := binary.Read(conn, binary.BigEndian, &msgSize)
if err != nil {
break
}
buf := make([]byte, msgSize)
_, err = io.ReadFull(conn, buf)
if err != nil {
break
}
fmt.Printf("recv: %s \n", string(buf))
}
}执行再看一下输出，没有粘包或者半包的情况
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~
recv: ~测试数据：一二三四五~也可以像第一个例子一样用一个指定大小的buf var buf [1024]byte，每次从conn里取出指定大小的数据，然后进行数据解析，如果发现有半包的情况，就再读取一次，加上上次未解析的数据，再次重新解析。
