Golang Socket Server自定义协议的简单实现方案

const (
 ConstHeader = "Headers"
 ConstHeaderLength = 7
 ConstMLength = 4
)

/**
* protocol
* @Author: Jian Junbo
* @Email: junbojian@qq.com
* @Create: 2017/9/14 11:49
*
* Description: 通讯协议处理
*/
package protocol 
import (
 "bytes"
 "encoding/binary"
)
 
const (
 ConstHeader = "Headers"
 ConstHeaderLength = 7
 ConstMLength = 4
)
 
//封包
func Enpack(message []byte) []byte {
 return append(append([]byte(ConstHeader), IntToBytes(len(message))...), message...)
}
 
//解包
func Depack(buffer []byte) []byte {
 length := len(buffer)
 
 var i int
 data := make([]byte, 32)
 for i = 0; i < length; i++ {
 
  if length < i + ConstHeaderLength + ConstMLength{
   break
  }
  if string(buffer[i:i+ConstHeaderLength]) == ConstHeader {
   messageLength := ByteToInt(buffer[i+ConstHeaderLength : i+ConstHeaderLength+ConstMLength])
   if length < i+ConstHeaderLength+ConstMLength+messageLength {
    break
   }
   data = buffer[i+ConstHeaderLength+ConstMLength : i+ConstHeaderLength+ConstMLength+messageLength]
  }
 }
 
 if i == length {
  return make([]byte, 0)
 } 
 return data
}
 
//字节转换成整形
func ByteToInt(n []byte) int {
 bytesbuffer := bytes.NewBuffer(n)
 var x int32
 binary.Read(bytesbuffer, binary.BigEndian, &x) 
 return int(x)
}
 
//整数转换成字节
func IntToBytes(n int) []byte {
 x := int32(n)
 bytesBuffer := bytes.NewBuffer([]byte{})
 binary.Write(bytesBuffer, binary.BigEndian, x)
 return bytesBuffer.Bytes()
}

//连接处理
func handleConnection(conn net.Conn) {
 //缓冲区，存储被截断的数据
 tmpBuffer := make([]byte, 0)
 //接收解包
 readerChannel := make(chan []byte, 10000)
 go reader(readerChannel)
 
 buffer := make([]byte, 1024)
 for{
  n, err := conn.Read(buffer)
  if err != nil{
   Log(conn.RemoteAddr().String(), "connection error: ", err)
   return
  }
  tmpBuffer = protocol.Depack(append(tmpBuffer, buffer[:n]...))
  readerChannel <- tmpBuffer  //接收的信息写入通道
 
 }
 defer conn.Close()
}

//获取通道数据
func reader(readerchannel chan []byte) {
 for{
  select {
  case data := <-readerchannel:
   Log(string(data))  //打印通道内的信息
  }
 }
}

/**
* MySocketProtocalServer
* @Author: Jian Junbo
* @Email: junbojian@qq.com
* @Create: 2017/9/14 13:54
* Copyright (c) 2017 Jian Junbo All rights reserved.
*
* Description: 服务端，接收客户端传来的信息
*/
package main 
import (
 "net"
 "fmt"
 "os"
 "log"
 "protocol"
)
 
func main() {
 netListen, err := net.Listen("tcp", "localhost:7373")
 CheckErr(err)
 defer netListen.Close()
 
 Log("Waiting for client ...")  //启动后，等待客户端访问。
 for{
  conn, err := netListen.Accept()  //监听客户端
  if err != nil {
   Log(conn.RemoteAddr().String(), "发了了错误：", err)
   continue
  }
  Log(conn.RemoteAddr().String(), "tcp connection success")
  go handleConnection(conn)
 }
}
 
//连接处理
func handleConnection(conn net.Conn) {
 //缓冲区，存储被截断的数据
 tmpBuffer := make([]byte, 0)
 //接收解包
 readerChannel := make(chan []byte, 10000)
 go reader(readerChannel)
 
 buffer := make([]byte, 1024)
 for{
  n, err := conn.Read(buffer)
  if err != nil{
   Log(conn.RemoteAddr().String(), "connection error: ", err)
   return
  }
  tmpBuffer = protocol.Depack(append(tmpBuffer, buffer[:n]...))
  readerChannel <- tmpBuffer  //接收的信息写入通道 
 }
 defer conn.Close()
}
 
//获取通道数据
func reader(readerchannel chan []byte) {
 for{
  select {
  case data := <-readerchannel:
   Log(string(data))  //打印通道内的信息
  }
 }
}
 
//日志处理
func Log(v ...interface{}) {
 log.Println(v...)
}
 
//错误处理
func CheckErr(err error) {
 if err != nil {
  fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
  os.Exit(1)
 }
}

/**
* MySocketProtocalClient
* @Author: Jian Junbo
* @Email: junbojian@qq.com
* @Create: 2017/9/14 15:23
* Copyright (c) 2017 Jian Junbo All rights reserved.
*
* Description: 
*/
package main 
import (
 "net"
 "time"
 "strconv"
 "protocol"
 "fmt"
 "os"
)
 
//发送100次请求
func send(conn net.Conn) {
 for i := 0; i < 100; i++ {
  session := GetSession()
  words := "{\"ID\":\""+strconv.Itoa(i)+"\",\"Session\":\""+session+"20170914165908\",\"Meta\":\"golang\",\"Content\":\"message\"}"
  conn.Write(protocol.Enpack([]byte(words)))
  fmt.Println(words)  //打印发送出去的信息
 }
 fmt.Println("send over")
 defer conn.Close()
}
//用当前时间做识别。当前时间的十进制整数
func GetSession() string {
 gs1 := time.Now().Unix()
 gs2 := strconv.FormatInt(gs1, 10)
 return gs2
}
 
func main() {
 server := "localhost:7373"
 tcpAddr, err := net.ResolveTCPAddr("tcp4", server)
 if err != nil{
  fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
  os.Exit(1)
 }
 
 conn, err := net.DialTCP("tcp", nil, tcpAddr)
 if err != nil{
  fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
  os.Exit(1)
 }
 
 fmt.Println("connect success") 
 send(conn) 
}

package main
import (
	"fmt"
	"net"
)
func accept_request_thread(conn net.Conn) {
	defer conn.Close()
	for {
		// 创建一个新切片， 用作保存数据的缓冲区
		buf := make([]byte, 1024)
		n, err := conn.Read(buf) // 从conn中读取客户端发送的数据内容
		if err != nil {
			fmt.Printf("客户端退出 err=%v\n", err)
			return
		}
		fmt.Printf(" 接受消息 %s\n", string(buf[:n]))
	}
}
func main() {
	listen, err := net.Listen("tcp", ":8888") // 创建用于监听的 socket
	if err != nil {
		fmt.Println("listen err=", err)
		return
	}
	fmt.Println("监听套接字，创建成功, 服务器开始监听。。。")
	defer listen.Close() // 服务器结束前关闭 listener
	// 循环等待客户端来链接
	for {
		fmt.Println("阻塞等待客户端来链接...")
		conn, err := listen.Accept() // 创建用户数据通信的socket
		if err != nil {
			fmt.Println("Accept() err=", err)
		} else {
			fmt.Println("通信套接字，创建成功。。。")
		}
		// 这里准备起一个协程，为客户端服务
		go accept_request_thread(conn)
	}
}