tcp服务是一个流数据的双工服务,tcp client 端会源源不断的把二进制字节流发发给服务端.假设有下面一个这样的需求,我们需要发送一个用户信息给服务端.我们怎么样知道到那里是一个客户端发来的一个完整的用户信息呢,如果我们不认真处理这个问题就会产生粘包的问题,对于这个问题一般会有下面几种方式来解决.
- 使用分格符
如果我们约定一个分隔符作为我们2个用户数据之间的分隔，如果读到这个符号我们就约定一个完整的数据结构读完了. - 给数据头部添加数据部分长度,先读取长度,再根据这个长度数据剩下的数据.
定义协议
type Packet struct {
Version [2]byte
Length int16
Timestamp int64
Message []byte
}
在这个协议中我们使用前2个字节表示协议版本,2个字节表示数据长度,8个字节表示时间戳,前12字节是属于协议头部部分,剩下的是数据部分.
server端
package main
import (
"net"
"log"
"fmt"
"encoding/binary"
"time"
)
const (
ProtocolVersion = "V1"
)
func main() {
l, err := net.Listen("tcp", ":8090")
if err != nil {
log.Println(err)
}
defer l.Close()
for {
conn, err := l.Accept()
if err != nil {
log.Println(err)
}
go handlerConn(conn)
}
}
func handlerConn(conn net.Conn) {
defer conn.Close()
header := make([]byte, 12)
//var u user.User
for {
//read packet header
_, err := conn.Read(header)
if err != nil {
return
}
if fmt.Sprintf("%s", header[:2]) != ProtocolVersion {
log.Println("valid protoc version")
return
}
timestamp := binary.BigEndian.Uint64(header[2:10])
t := time.Unix(int64(timestamp), 0).Format("2006-01-02 03:04:05 PM")
log.Printf("client send data time %s", t)
length := int16(binary.BigEndian.Uint16(header[10:]))
log.Println("data length", length)
//read data
databuf := make([]byte, length)
_, err = conn.Read(databuf)
if err != nil {
return
}
fmt.Printf("%s\n", databuf)
conn.Write(databuf)
}
}
在server端先读取12个字节,然后分别读取出版本号和时间戳,数据长度.然后读取数据.
client 端
package main
import (
"net"
"log"
"time"
"math/rand"
"encoding/binary"
"github.com/myonlyzzy/go-exmaple/example5/pkg/user"
"encoding/json"
)
type User struct {
Name string `json:"name"`
Age int64 `json:"age"`
Msg string `json:"msg"`
}
func main() {
addr := ":8090"
conn, err := net.Dial("tcp", addr)
if err != nil {
log.Println(err)
}
for {
msg := getRandString()
u := user.User{
Name: "john",
Age: 24,
Msg: msg,
}
data, err := json.Marshal(u)
if err != nil {
log.Fatal(err)
}
dataLen := len(data)
b := make([]byte, dataLen+12)
b[0] = 'V'
b[1] = '1'
binary.BigEndian.PutUint64(b[2:10], uint64(time.Now().Unix()))
binary.BigEndian.PutUint16(b[10:12], uint16(dataLen))
copy(b[12:], data)
_, err = conn.Write(b)
if err != nil {
log.Fatal(err)
}
time.Sleep(time.Second)
}
}
func getRandString() string {
length := rand.Intn(5000)
strBytes := make([]byte, length)
for i := 0; i < length; i++ {
strBytes[i] = byte(rand.Intn(26) + 97)
}
return string(strBytes)
}
client端先将表示用户数据的json转成字节流然后取的长度,然后再分别填入头部信息。
总结
这是一个最简单的tcp数据包的结构定义,但基本原理就是这样。
