先上代码
server.go
package main
import (
"wingbow.com.cn/server/controller"
)
func main() {
controller.ServerRun()
}
controller.go
package controller
import (
"fmt"
"io"
"net"
"wingbow.com.cn/server/network"
)
//ServerRun 服务
func ServerRun() {
lister, err := net.Listen("tcp", "localhost:8888")
fmt.Println("服务启动成功：localhost:8888")
CheckErr(err)
defer lister.Close()
for {
conn, err := lister.Accept()
CheckErr(err)
fmt.Println("用户接入")
client := network.NewTCPSocket(conn)
go func() {
defer client.Close()
for {
data, err := client.Read()
if err == io.EOF {
fmt.Println("断开链接")
return
}
if err != nil {
continue
}
switchController(data, client)
}
}()
}
}
//CheckErr 异常检查
func CheckErr(err error) {
if err != nil {
panic(err)
}
}
func switchController(data []byte, c *network.TCPSocket) {
fmt.Println("读到的数据: " + string(data))
switch string(data) {
case "ping":
c.Write([]byte("pong"))
fmt.Println("发出的数据: pong")
break
}
}
network.go
package network
import (
"bufio"
"bytes"
"encoding/binary"
"net"
)
//TCPSocket 连接
type TCPSocket struct {
tag string
conn net.Conn
r *bufio.Reader
}
//NewTCPSocket 创建一个TCP客户端
func NewTCPSocket(conn net.Conn) *TCPSocket {
return &TCPSocket{conn: conn, r: bufio.NewReader(conn)}
}
//LocalAddr 本地地址
func (c *TCPSocket) LocalAddr() net.Addr {
return c.conn.LocalAddr()
}
//RemoteAddr 远程地址
func (c *TCPSocket) RemoteAddr() net.Addr {
return c.conn.RemoteAddr()
}
//Close 关闭
func (c *TCPSocket) Close() error {
return c.conn.Close()
}
//Write 写消息
func (c *TCPSocket) Write(message []byte) (int, error) {
// 读取消息的长度
var length = int32(len(message))
var pkg = new(bytes.Buffer)
//写入消息头
err := binary.Write(pkg, binary.BigEndian, length)
if err != nil {
return 0, err
}
//写入消息体
err = binary.Write(pkg, binary.BigEndian, message)
if err != nil {
return 0, err
}
nn, err := c.conn.Write(pkg.Bytes())
if err != nil {
return 0, err
}
return nn, nil
}
//Read 读消息
func (c *TCPSocket) Read() ([]byte, error) {
// Peek 返回缓存的一个切片，该切片引用缓存中前 n 个字节的数据，
// 该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之
// 前是有效的。如果切片长度小于 n，则返回一个错误信息说明原因。
// 如果 n 大于缓存的总大小，则返回 ErrBufferFull。
lengthByte, err := c.r.Peek(4)
if err != nil {
return nil, err
}
//创建 Buffer缓冲器
lengthBuff := bytes.NewBuffer(lengthByte)
var length int32
// 通过Read接口可以将buf中得内容填充到data参数表示的数据结构中
err = binary.Read(lengthBuff, binary.BigEndian, &length)
if err != nil {
return nil, err
}
// Buffered 返回缓存中未读取的数据的长度
if int32(c.r.Buffered()) < length+4 {
return nil, err
}
// 读取消息真正的内容
pack := make([]byte, int(4+length))
// Read 从 b 中读出数据到 p 中，返回读出的字节数和遇到的错误。
// 如果缓存不为空，则只能读出缓存中的数据，不会从底层 io.Reader
// 中提取数据，如果缓存为空，则：
// 1、len(p) >= 缓存大小，则跳过缓存，直接从底层 io.Reader 中读
// 出到 p 中。
// 2、len(p) < 缓存大小，则先将数据从底层 io.Reader 中读取到缓存
// 中，再从缓存读取到 p 中。
_, err = c.r.Read(pack)
if err != nil {
return nil, err
}
return pack[4:], nil
}
客户端
client.go
package main
import (
"bytes"
"encoding/binary"
"fmt"
"log"
"net"
"time"
)
func main() {
conn, err := net.Dial("tcp", "localhost:8888")
if err != nil {
log.Println("dial error:", err)
return
}
defer conn.Close()
for {
data, _ := Encode(time.Now().Format("2006-01-02 15:04:05"))
time.Sleep(time.Second)
_, err := conn.Write(data)
fmt.Println(err)
}
}
func Encode(message string) ([]byte, error) {
// 读取消息的长度
var length = int32(len(message))
var pkg = new(bytes.Buffer)
// 写入消息头
err := binary.Write(pkg, binary.BigEndian, length)
if err != nil {
return nil, err
}
// 写入消息实体
err = binary.Write(pkg, binary.BigEndian, []byte(message))
if err != nil {
return nil, err
}
return pkg.Bytes(), nil
}
上面处理粘包的方法是用了自定义的非定长的数据包，这也是一种常用的粘包处理方式。
另外还有自定义分隔符、定长分割等方法。