(初学者)使用go搭建简单的服务器(计算器)

go 服务器搭建

    • 通讯协议
      • proto
      • uml
    • 使用方式
    • 效果
    • 服务器端
    • 客户端
    • tcp封包解包协议

通讯协议

proto

CS // 客户端到服务器 
SC // 服务器到客户端

proto:
	type csproto struct {
      // 两个数字
		a int
		b int
	}
	type scproto struct {
      // 结果
		ans int 
	}
	// 判断是什么指令协议在更上一层
	type data name {
     
		msg_id int // 操作id
		msg_data []byte // 前一个协议的字节数据
	}

uml

client server add/sub/mul/div req ans res client server

使用方式

先调用服务器端TCPServerStart
再调用客户端TCPClientStrat
接着即可在服务器端输入数据获得结果

ex:

TCPServerStart("127.0.0.1:9099")
TCPClientStrat("127.0.0.1:9099")

效果

(初学者)使用go搭建简单的服务器(计算器)_第1张图片

服务器端

package Tcp

import (
	proto "../tcp_proto"
	"bufio"
	"encoding/json"
	"fmt"
	"io"
	. "net"
)

const (
	Add      int = 0
	Sub      int = 1
	Mul      int = 2
	Div      int = 3
)

type csproto struct {
     
	A int `json:"a"` // json 用法, 大写才能被识别,使用`json:"a"`可以将其变成小写
	B int `json:"b"`
}

type scproto struct {
     
	Ans int `json:"ans"`
}

type client struct {
     
	ch chan msg
	conn Conn
}

type msg struct {
     
	Msg_id int
	Data []byte
}

type cliMsg struct {
     
	cli client
	msg_id int
	data []byte
}


func (cli client)send(ch chan msg){
     
	for {
     
		send_msg := <-ch
		msg_id, data := send_msg.Msg_id, send_msg.Data
		fmt.Println("send", msg_id)
		data, err := proto.Packet(msg_id, data)
		if err != nil {
     
			fmt.Println("Packet fail, err:", err)
			return
		}
		cli.conn.Write(data)
	}
}

func (cli client)receive(ch chan cliMsg){
     
	defer cli.conn.Close()  // 关闭连接
	reader := bufio.NewReader(cli.conn)
	for {
     
		msg_id, data_byte, err := proto.Unpack(reader)
		if err == io.EOF{
     
			return
		}
		if err != nil{
     
			fmt.Println("Unpack fail, err:", err)
			return
		}
		var csmsg csproto
		json.Unmarshal(data_byte, &csmsg)
		fmt.Println(msg_id, csmsg)
		reivece_msg := cliMsg{
     cli,msg_id,data_byte}
		ch <- reivece_msg
	}
}

func add(data []byte)(int, []byte) {
     
	var csmsg csproto
	var scmsg scproto
	json.Unmarshal(data, &csmsg)
	scmsg.Ans = csmsg.A + csmsg.B
	data, err := json.Marshal(scmsg)
	if err != nil {
     
		fmt.Println("encode fail, err:", err)
	}
	return 0, data
}

func sub(data []byte)(int, []byte) {
     
	var csmsg csproto
	var scmsg scproto
	fmt.Print("sub")
	json.Unmarshal(data, &csmsg)
	scmsg.Ans = csmsg.A - csmsg.B
	data, err := json.Marshal(scmsg)
	if err != nil {
     
		fmt.Println("encode fail, err:", err)
	}
	return 1, data
}

func mul(data []byte)(int, []byte) {
     
	var csmsg csproto
	var scmsg scproto
	json.Unmarshal(data, &csmsg)
	scmsg.Ans = csmsg.A * csmsg.B
	data, err := json.Marshal(scmsg)
	if err != nil {
     
		fmt.Println("encode fail, err:", err)
	}
	return 2, data
}

func div(data []byte) (int, []byte) {
     
	var csmsg csproto
	var scmsg scproto
	json.Unmarshal(data, &csmsg)
	if csmsg.B == 0 {
     
		fmt.Println("error, Dividend is zero")
		return 10, nil
	}
	scmsg.Ans = csmsg.A / csmsg.B
	data, err := json.Marshal(scmsg)
	if err != nil {
     
		fmt.Println("encode fail, err:", err)
	}
	return 3, data
}

func handle_data(proch chan cliMsg){
     
	for {
     
		select {
     
		case cli_msg := <- proch:
			msg_id, data := cli_msg.msg_id, cli_msg.data
			switch {
     
			case msg_id == Add:
				cli_msg.msg_id, cli_msg.data = add(data)
			case msg_id == Sub:
				cli_msg.msg_id, cli_msg.data = sub(data)
			case msg_id == Mul:
				cli_msg.msg_id, cli_msg.data = mul(data)
			case msg_id == Div:
				cli_msg.msg_id, cli_msg.data = div(data)
			}
			proch <- cli_msg
		}
	}
}

func handle(unch, proch chan cliMsg)  {
      // 消息转发站,可以省略直接处理
	var cli_msg cliMsg
	for {
     
		select {
     
		case cli_msg = <-unch: // 收到未处理的信息
			proch <- cli_msg // 不会被当前goroutine接收到,发送给 // 先检查其他线程有没有proch接收消息,最后检查当前线程
		case cli_msg = <-proch: // 收到已处理的信息
			cli_ch := cli_msg.cli.ch
			pro_msg := msg{
     cli_msg.msg_id, cli_msg.data}
			cli_ch <- pro_msg // 发送给对应的send
		}
	}
}

func TCPServerStart(port string) {
     
	fmt.Println("tcp server start!")
	listen, err := Listen("tcp", port)
	if err != nil {
     
		fmt.Println("tcp server listen fail, err:", err)
	}
	unch, proch := make(chan cliMsg, 20), make(chan cliMsg, 20)
	go handle(unch, proch)
	go handle_data(proch)
	for {
     
		conn, err := listen.Accept() // 建立连接
		if err != nil {
     
			fmt.Println("server accept fail, err:", err)
			continue
		}
		fmt.Println("connect")
		cli_ch := make(chan msg, 20)
		cli := client{
     cli_ch,conn}
		go cli.receive(unch)
		go cli.send(cli_ch)
	}
}

客户端

package Tcp

import (
	proto "../tcp_proto"
	"bufio"
	"encoding/json"
	"fmt"
	"io"
	"net"
)

const (
	Quit      int = 0
	Addc      int = 1
	Subc      int = 2
	Mulc      int = 3
	Divc      int = 4
	ERROR     int = 10
)

var (
	chadd chan []byte
	chsub chan []byte
	chmul chan []byte
	chdiv chan []byte
	chsend chan msg
	)

func sendc(conn net.Conn) {
     
	for {
     
		chsend = make(chan msg, 20)
		msg := <- chsend
		msg_id := msg.Msg_id
		msg_id--
		data, err := proto.Packet(msg_id, msg.Data)
		if err != nil {
     
			fmt.Println("encode fail, err:", err)
		}

		conn.Write(data)

	}
}

func receivec(conn net.Conn)  {
     
	chadd = make(chan []byte, 20)
	chsub = make(chan []byte, 20)
	chmul = make(chan []byte, 20)
	chdiv = make(chan []byte, 20)
	defer conn.Close()  // 关闭连接
	reader := bufio.NewReader(conn)
	for {
     
		msg_id, data_byte, err := proto.Unpack(reader)
		if err == io.EOF{
     
			return
		}
		if err != nil{
     
			fmt.Println("Unpack fail, err:", err)
			return
		}

		msg_id++
		switch {
     
		case msg_id == Addc:chadd <- data_byte
		case msg_id == Subc:chsub <- data_byte
		case msg_id == Mulc:chmul <- data_byte
		case msg_id == Divc:chdiv <- data_byte
		case msg_id == ERROR:// error 处理
		}
	}
}

func addc()  {
     
	for {
     
		fmt.Println("Please enter two addends, enter 0, 0 to return to the previous level")
		var a, b, ans int
		fmt.Scanf("%d %d", &a, &b)
		if a == 0 && b == 0 {
     
			return
		}

		var csmsg = csproto{
     a,b}
		csdata, err := json.Marshal(csmsg)
		if err != nil {
     
			fmt.Println("encode fail, err:", err)
		}
		var msgc = msg{
     Addc,csdata}
		chsend <- msgc

		data := <- chadd
		var scmsg scproto
		json.Unmarshal(data, &scmsg)
		ans = scmsg.Ans
		fmt.Printf("%d + %d = %d\n", a, b, ans)
	}
}

func subc()  {
     
	for {
     
		fmt.Println("Please subtract and subtract, enter 0, 0 to return to the previous level")
		var a, b, ans int
		fmt.Scanf("%d %d", &a, &b)
		if a == 0 && b == 0 {
     
			return
		}

		var csmsg = csproto{
     a,b}
		csdata, err := json.Marshal(csmsg)
		if err != nil {
     
			fmt.Println("encode fail, err:", err)
		}
		var msgc = msg{
     Subc,csdata}
		chsend <- msgc

		data := <- chsub
		var scmsg scproto
		json.Unmarshal(data, &scmsg)
		ans = scmsg.Ans
		fmt.Printf("%d - %d = %d\n", a, b, ans)
	}
}

func mulc()  {
     
	for {
     
		fmt.Println("Please enter two multipliers, enter 0, 0 to return to the previous level")
		var a, b, ans int
		fmt.Scanf("%d %d", &a, &b)
		if a == 0 && b == 0 {
     
			return
		}

		var csmsg = csproto{
     a,b}
		csdata, err := json.Marshal(csmsg)
		if err != nil {
     
			fmt.Println("encode fail, err:", err)
		}
		var msgc = msg{
     Mulc,csdata}
		chsend <- msgc

		data := <- chmul
		var scmsg scproto
		json.Unmarshal(data, &scmsg)
		ans = scmsg.Ans
		fmt.Printf("%d * %d = %d\n", a, b, ans)
	}
}

func divc()  {
     
	for {
     
		fmt.Println("Please divisor and dividend, enter 0, 0 to return to the previous level")
		var a, b, ans int
		fmt.Scanf("%d %d", &a, &b)
		if a == 0 && b == 0 {
     
			return
		}
		if b == 0 {
     
			fmt.Println("dividend is zero, restart")
			continue
		}

		var csmsg = csproto{
     a,b}
		csdata, err := json.Marshal(csmsg)
		if err != nil {
     
			fmt.Println("encode fail, err:", err)
		}
		var msgc = msg{
     Divc,csdata}
		chsend <- msgc

		data := <- chdiv
		var scmsg scproto
		json.Unmarshal(data, &scmsg)
		ans = scmsg.Ans
		fmt.Printf("%d / %d = %d\n", a, b, ans)
	}
}


func TCPClientStrat(addr string) {
     
	conn, err := net.Dial("tcp", addr)
	if err != nil {
     
		fmt.Println("connect fail, err:", err)
		return
	}

	defer conn.Close()
	go sendc(conn)
	go receivec(conn)

	for {
     
		fmt.Println("Please choose an operation:")
		fmt.Println("1 add\n2 sub\n3 mul\n4 div\n0 quit")
		var ot int
		fmt.Scanf("%d", &ot)
		switch {
     
		case ot == Quit:
			return
		case ot == Addc:
			addc()
			break
		case ot == Subc:
			subc()
			break
		case ot == Mulc:
			mulc()
			break
		case ot == Divc:
			divc()
			break
		}
	}
}

tcp封包解包协议

package tcp_proto

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

type MsgDate struct {
     
	Msg_id int `json:"msg_id"`
	Date []byte `json:"date"`
}

// Encode 将消息编码
func Packet(msg_id int, data []byte)([]byte, error)  {
     
	// 读取消息的长度,转换成int32类型(占4个字节)
	msg := MsgDate{
     msg_id,data}

	msg_bytes, err:= json.Marshal(msg)
	if err != nil{
     
		return nil, err
	}

	length := int32(len(msg_bytes))
	var pkg = new(bytes.Buffer)

	//写入消息头
	err = binary.Write(pkg, binary.LittleEndian, length)
	if err != nil{
     
		return nil, err
	}

	//写入消息实体
	err = binary.Write(pkg, binary.LittleEndian, msg_bytes)
	if err != nil{
     
		return nil, err
	}
	return pkg.Bytes(), nil
}

// Decode 消息解码
func Unpack(reader *bufio.Reader)(int, []byte, error)  {
     
	//读取消息长度
	lengthByte, _ := reader.Peek(4) //读取前4个字节数据
	lengthBuff := bytes.NewBuffer(lengthByte)

	var length int32
	err := binary.Read(lengthBuff, binary.LittleEndian, &length)
	if err != nil{
     
		return 0, nil, err
	}

	// Buffered返回缓冲中现有的可读取的字节数。
	if int32(reader.Buffered()) < length + 4 {
     
		return 0, nil, err
	}

	//读取真正的消息数据
	pack := make([]byte,int(4 + length))
	_, err = reader.Read(pack)
	if err != nil{
     
		return 0, nil, err
	}
	var msg MsgDate
	json.Unmarshal(pack[4:], &msg)
	return msg.Msg_id, msg.Date, nil
}

你可能感兴趣的:(Go自学)