go tcp 黏包处理

//server
package main

import (
   "bufio"
   "fmt"
   "io"
   "log"
   "net"
   "proto"
   "strings"
)

func main() {
   Listener, err := net.Listen("tcp", "0.0.0.0:9000")
   if err != nil {
      log.Println(err)
      return
   }
   defer Listener.Close()

   for {
      conn, err := Listener.Accept()
      if err != nil {
         log.Println("Accept失败")
         continue
      }
      go fn(conn)
   }
}
func fn(conn net.Conn) {
   defer conn.Close()
   remoteAddr := conn.RemoteAddr()
   fmt.Printf("%v连接成功\n", remoteAddr)
   reader := bufio.NewReader(conn)
   for {
      msg, err := proto.Decode(reader)
      if err == io.EOF {
         return
      }
      fmt.Printf("%v说: %v\n", remoteAddr, msg)
      conn.Write([]byte(strings.ToUpper(msg)))
   }
}

//client

package main

import (
   "fmt"
   "log"
   "net"
   "proto"
)

func main() {
   conn, err := net.Dial("tcp", "127.0.0.1:9000")
   if err != nil {
      log.Println("dial失败")
      return
   }
   for {
      var msg string
      fmt.Scan(&msg)
      for i := 0; i < 10; i++ {
         data, err := proto.Encode(msg)
         if err != nil {
            fmt.Println("encode msg failed, err:", err)
            return
         }
         conn.Write(data)
      }
   }
}

//proto

package proto

import (
   "bufio"
   "bytes"
   "encoding/binary"
)

// Encode 将消息编码
func Encode(message string) ([]byte, error) {
   // 读取消息的长度，转换成int32类型（占4个字节）
   var length = int32(len(message))
   var pkg = new(bytes.Buffer)
   // 写入消息头
   err := binary.Write(pkg, binary.LittleEndian, length)
   if err != nil {
      return nil, err
   }
   // 写入消息实体
   err = binary.Write(pkg, binary.LittleEndian, []byte(message))
   if err != nil {
      return nil, err
   }
   return pkg.Bytes(), nil
}

// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
   // 读取消息的长度
   lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
   lengthBuff := bytes.NewBuffer(lengthByte)
   var length int32
   err := binary.Read(lengthBuff, binary.LittleEndian, &length)
   if err != nil {
      return "", err
   }
   // Buffered返回缓冲中现有的可读取的字节数。
   if int32(reader.Buffered()) < length+4 {
      return "", err
   }

   // 读取真正的消息数据
   pack := make([]byte, int(4+length))
   _, err = reader.Read(pack)
   if err != nil {
      return "", err
   }
   return string(pack[4:]), nil
}