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

最新推荐文章于 2023-11-19 10:39:31 发布
最新推荐文章于 2023-11-19 10:39:31 发布
阅读量558 收藏 1
点赞数
分类专栏： Go自学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38271800/article/details/108527607
版权

go 服务器搭建

通讯协议

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")

效果

绿色字为输入数字

服务器端

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
}
向着曙光前进
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go语言搭建服务器的方式
太阳上的雨天
03-15 2291
Go语言内置了http包提供了HTTP客户端和服务端的实现 通俗一点讲：Go语言可以通过net/http包搭建自己的服务器处理http的请求 搭建服务器分为两大种方式：第一种是通过默认多路复用器DefaultServeMux，第二种是通过新建多路复用器NewServeMux的方式。 默认多路复用器DefaultServeMux提供了Handle、HandleFunc、Server搭建服务器。不论哪一种都可以实现服务器的搭建。Demo案例 Handle package main import ( "net
C#初学者简单计算器
10-17
程序非常简单，适用于新学者，试验一个简单加法计算器，新入门的可以到我博客看看，会经常更新哦
go项目部署服务器保姆级教程（带图）
tzxwoaini的博客
09-19 874
go项目部署服务器保姆级教程（带图）
【Go Web 篇】从零开始：构建最简单的 Go 语言 Web 服务器
繁依Fanyi的博客
08-25 2540
通过本篇博客，我们从头开始构建了一个最简单的 Go 语言 Web 服务器。我们了解了为什么选择 Go 语言来构建 Web 服务器，并通过实际的代码示例展示了如何创建一个基本的服务器并在浏览器中查看结果。尽管这只是一个简单的示例，但它奠定了你进一步探索 Go 语言 Web 开发的基础。从这里开始，你可以逐步深入学习更多关于路由、中间件、模板引擎、数据库交互等方面的知识，构建更加复杂和功能丰富的 Web 应用程序。无论。
go搭建服务器基础
weixin_43878062的博客
06-26 1342
goweb 搭建
使用Go构建服务器
磨镜台的博客
08-21 3986
Server的结构如下： type Server struct { Addr string // 网络地址，默认使用80端口 Handler Handler // 处理器，若为空则默认使用http.DefaultServeMux这个实例 TLSConfig *tls.Config ReadTimeout time.Duration ReadH...
C# 简易计算器源码-非常适合初学者学习
08-06
C# 简易计算器源码-非常适合初学者学习，C# 简易计算器源码-非常适合初学者学习，C# 简易计算器源码-非常适合初学者学习，重要的事情说三遍
仿微软计算器_计算器程序_初学者_python_
09-30
用python写的计算器程序，功能相当齐全，不仅限于加减乘除。结构简单清晰，适合初学者学习。
03.CalculateV1.0_初学者_csharp_计算器_加法_
10-02
方便初学者自己编写计算器时做个参考，目前主要展示了加法部分自编运算规则函数的方法，希望能对初学者有帮助，解压后直接运行即可。
Android APP + JAVA + 简易计算器 + 初学者开发
10-23
Android APP开发、初学者开发、JAVA开发，简易计算器应用，入门级代码
腾讯云服务器价格计算器真心好用，推荐给大家！
最新发布
fuwuqiba的博客
11-19 95
腾讯云服务器价格计算器可以一键计算出云服务器的精准报价，包括CVM实例规格价格、CPU内存费用、公网带宽收费、存储系统盘和数据盘详细费用，腾讯云百科txybk.com分享腾讯云价格计算器链接入口、使用方法说明
Go后端部署服务器
EGXXM的博客
01-05 2901
go部署服务器的两种方式，不会的来问我哦，我可是非常熟悉了，里边的都全是我操作的，确保成功了的
小白上手Golang搭建HTTP服务器
qq_29701691的博客
04-11 838
通过本文的介绍，我们了解了如何使用Golang搭建HTTP服务器。虽然本文只介绍了一些最基础的操作，但是它们已经足够我们实现一个简单的Web应用程序了。在以后的学习过程中，我们可以通过使用其他库和框架来实现更加丰富的Web应用程序。
阿里云服务器价格计算器终于找到了
yunweifun的博客
06-27 228
终于找到了阿里云服务器计算器，最近公司需要采购几台阿里云服务器，之前记得阿里云有个计算器，现在找不到了，阿里云服务器价格计算器在哪？费了九牛二虎之力终于找到了，就在阿里云服务器ECS页面
网站服务器配置计算,服务器配置计算公式
weixin_31094177的博客
08-09 993
服务器配置计算公式 内容精选换一换简要介绍HTSlib是一个C库，用于读取和写入高通量测序数据。 HTSlib是SAMtools使用的核心库。 HTSlib还提供了bgzip，htsfile和tabix实用程序。开发语言：C一句话描述：一款用于读取和写入高通量测序数据的C库开源协议：GNU建议的版本根据实际需要选择版本，本文档以htslib-1.10.2为例进行说明。云服简要介绍一组Java命令行...
Go语言学习：搭建简易的websocket服务器
三思而先行的博客
08-14 2767
Go语言学习：搭建简易的websocket服务器
简易应用服务器配置要求计算公式
凌云客
11-22 5468
业务模型参数如下： 业务模型数据 每月使用业务数：用户数×个人用户月使用次数＝11000×5＝55000次。 忙日峰值使用业务数：55000×0.01＝550次/天。 忙时峰值使用业务数=忙日峰值使用业务数×忙时集中系数=550×0.06＝33次/小时 CPU性能 用户应用服务器要求的TPCC＝单位用户数忙时每分钟登录次数×每用户每次登录操作数/60（分钟/小时）×平均每用户每操作消耗5个TP...
怎么搭建高性能计算服务器,搭建高性能计算集群四大步骤
weixin_32657751的博客
07-30 2443
尽管高性能计算发展的步伐已经够快，硬件成本也日趋下降，这也并不意味着在构建HPC系统时就可以“肆无忌惮”，日前，英特尔HPC架构师陈健接受比特网(Chinabyte)专访，并讲述了石油行业如何构建基于应用实际性能的HPC机群设计方法。陈健表示，构建基于应用的的HPC应当遵循以下四大原则：1、确定合适的测试应用和负载——这个步骤主要由用户完成，毕竟最后的应用肯定用户最了解，现在一般在选择应用作为测试...
初学者使用的MQTT互联网服务器
05-05
初学者可以使用以下一些MQTT互联网服务器： 1. Mosquitto：它是一个轻量级的MQTT代理，易于使用和安装。它还提供了一个基于Web的控制台，使用户能够轻松地监视和管理它们的MQTT连接。 2. HiveMQ：它是一个可扩展的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值