golang 实战 简易聊天室服务(TCP)

已于 2023-09-11 22:12:16 修改
阅读量430 收藏
点赞数
文章标签： golang tcp/ip 开发语言 信息与通信
于 2023-09-10 16:43:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_super_C/article/details/132792578
版权

golang 实战 简易聊天室服务(TCP)

首先，我们对整个服务进行简单划分: 通讯模组；消息储存模组；连接与连接之间的逻辑关系

通讯模组

通信流程

  1. 客户端->注册发信服务连接请求->服务端
  2. 客户端<-返回生成的客户端请求id+房间号<-服务端
  3. 客户端->注册收信服务连接请求->服务端
  4. 客户端<->并发收信发信<->服务端
  5. (客户端，服务端)任意一端程序停止，断开连接

报文组成(总报文=操作码+分报文)

  • 总报文=[操作码 1 byte]+[正文]
  • 注册收信报文=[客户端id 3 byte]+[房间号 2 byte]
  • 注册发信报文=[房间号 2 byte]
  • 消息响应报文=[消息id 1 byte]+[房间号 2 byte]+[消息来源客户端id 3 byte]
  • 消息通知报文=[消息数量 1 byte]
  • 消息发送报文=[正文]

消息储存模组

这里我们为了方便，使用的sqlite3作为数据库(驱动使用的是 github.com/mattn/go-sqlite3)，当然也可以自行选者mysql，postgre, oracle或者你喜欢用的数据库。
如果你使用的也是sqlite，这里可能有个点需要注意。sqlite由于写入时不能同时写入，读取可以同时读的特性。所以使用时需要加锁，否则多线程执行非查询操作时会出现database is locked的错误

数据储存层代码(本演示全部数据库操作都经过此层)

func writeTodatabase(mod uint8, query string, args ...any) (any, error) {
	defer fmt.Printf("write to database finished,mod %d\n", mod)
	fmt.Println("start exec sql...")
	db, err := sql.Open("sqlite3", "data.db")
	if err == nil {
		defer db.Close()
		//如果是查询，加读锁。如果是写入或者修改，加写锁
		if mod == QUERY {
			dbmutex.RLock()
			defer dbmutex.RUnlock()
			return db.QueryContext(context.Background(), query, args...)
		} else if mod == QUERYROW {
			dbmutex.RLock()
			defer dbmutex.RUnlock()
			return db.QueryRowContext(context.Background(), query, args...), nil
		} else if mod == EXEC {
			dbmutex.Lock()
			defer dbmutex.Unlock()
			return db.ExecContext(context.Background(), query, args...)
		}
	}
	return nil, err

}

业务逻辑关系

type config struct {//整个通讯系统的运行信息
	Port int `yaml:"Port"`
}
type client struct {//用户连接实例
	roomid          uint32//此客户所属房间id
	last_reply_time time.Time
	last_verion     uint32//此客户端最新消息版本
	mutex           sync.RWMutex
	response_writer *response_Writer
}
type response_Writer struct {//用户收信实例，必须注册了收信实例才能接受信息
	con  net.Conn
	done chan struct{}
}
type room struct {//房间
	latestversion uint32
	mutex         sync.RWMutex
}
type message struct {//消息实例
	id             int//消息id，自增且唯一
	roomid, sendid uint32 //msgid,roomid,send userid
	content        string
}

room和client的关系
room实例本身就是一个房间最新消息版本号+读写锁。客户端读取信息只需要用room的锁上个读锁，获得最新消息后再解锁。写消息也一样(上写锁)。版本号由于向上增长，所以客户端版本号低于房间版本号就会拉取两个版本号之间的信息。
请添加图片描述

上代码

前置任务

const (
	TIMEOUTMAX = time.Duration(1000) * time.Millisecond
	MSG_SYN    = 10
	MSG_ACK    = 11
	MSG_CTR    = 12
)
const (
	DATA_OUT_OF_RANGE = "data out of range"
)
const (
	QUERY    = 90
	QUERYROW = 91
	EXEC     = 92
)

var (
	cnf      config
	errorlog = log.New(os.Stderr, "[error]", log.Ltime|log.Llongfile)//调试利器，快速定位到出错点
	debuglog = log.New(os.Stdout, "[debug]", log.Ltime|log.Llongfile)
	clientlist = make(map[uint32]*client)
	roomlist   = make(map[uint32]*room)
	dbmutex    sync.RWMutex //database mutex
)

func init() {
	flag.IntVar(&cnf.Port, "Port", 9000, "--cnf.Port xxx")
	flag.Parse()
}

主函数

func main() {
	if cnf.Port < 0 {
		errorlog.Println("Port", cnf.Port, " is invalid")
		os.Exit(1)
	}
	rand.Seed(time.Now().UnixNano()) //set rand seed
	listener, err := net.Listen("tcp", ":"+strconv.Itoa(cnf.Port))
	if err == nil {
		var con net.Conn
		for {
			con, err = listener.Accept()
			if err == nil {
				go readconse(con)
			} else {
				errorlog.Println(err.Error())
			}
		}
	} else {
		errorlog.Println(err.Error())
	}
}

连接处理

func readconse(con net.Conn) {
	defer con.Close()

	buffer := make([]byte, 1024)
	var (
		lang      int
		err       error
		resp      []byte
		id        uint32
		cli       *client
		is_accept bool = false//是否为收信连接
	)
	defer func() {
		if !is_accept {
			debuglog.Println("start deregister main", id, "process")
		} else {
			debuglog.Println("start deregister accept", id, "process")
		}
		if !is_accept && cli != nil && cli.response_writer != nil {
			debuglog.Println(id, "send end signal to accept process")
			cli.response_writer.done <- struct{}{}
		}
		if _, ok := clientlist[id]; ok {
			if !is_accept {
				debuglog.Println(id, "send server deregistered")
				delete(clientlist, id)
			} else {
				debuglog.Println(id, "accept server deregistered")
			}

		}
	}()
	for {
		lang, err = con.Read(buffer)
		if err == nil {
			switch buffer[0] {
			case MSG_SYN:
				if lang == 4 { //注册客户端收信连接
					is_accept = true
					id = uint32(buffer[1])*256*256 + uint32(buffer[2])*256 + uint32(buffer[3])
					var ok bool
					if cli, ok = clientlist[id]; ok {
						debuglog.Println("register client", id, "accept server")
						cli.response_writer = &response_Writer{con: con, done: make(chan struct{})}
						var msgarr []message
						tck := time.NewTicker(1 * time.Second)//每秒进行一波版本比较，可自行根据需求更改间隔时间
						for {
							select {
							case <-cli.response_writer.done:
								debuglog.Println(id, "accept done signal")
								return
							case <-tck.C:
								roomlist[cli.roomid].mutex.RLock()
								if cli.last_verion < roomlist[cli.roomid].latestversion {
									debuglog.Printf("client %v find new message", id)
									roomlist[cli.roomid].mutex.RUnlock()
									msgarr = getmessage(cli.last_verion, cli.roomid)
									debuglog.Printf("client %v find %d new messages", id, len(msgarr))
									if len(msgarr) > 0 {
										err = sendtocli(&msgarr, con)
										if err != nil {
											errorlog.Printf("cli accept server %v closed by client", id)
											return
										} else {
											cli.mutex.Lock()
											cli.last_verion = roomlist[cli.roomid].latestversion
											cli.mutex.Unlock()
											debuglog.Printf("client %v latest version update finished", id)
										}
									}
								} else {
									roomlist[cli.roomid].mutex.RUnlock()
								}
							}
						}
					}
				} else if lang == 3 { //注册客户端发信连接
					id = rand.Uint32() % (256*256*256 + 256*256 + 256)
					resp = make([]byte, 5)
					resp[0] = byte((id / (256 * 256)) % 256)
					resp[1] = byte((id / 256) % 256)
					resp[2] = byte(id % 256)
					copy(resp[3:5], buffer[1:3])
					_, err = con.Write(resp)
					if err != nil {
						debuglog.Println("connection closed by client")
						break
					}
					clientlist[id] = &client{roomid: uint32(buffer[1])*256 + uint32(buffer[2]), last_reply_time: time.Now()}
					cli = clientlist[id]
					if _, ok := roomlist[cli.roomid]; !ok {
						roomlist[cli.roomid] = &room{}
						debuglog.Println("create new room", cli.roomid)
					}
					debuglog.Printf("register client %v send server", id)
				}
			case MSG_ACK: //客户端向服务端发送信息
				if !writetomessage(buffer[1:lang], cli.roomid, id) {
					err = cli.write(MSG_CTR, []byte("send message failed unknown error"))
					if err != nil {
						errorlog.Println(err.Error())
						break
					}
				}
			case MSG_CTR: //切换房间等操作

			}
		} else {
			debuglog.Println("client", id, "closed connection")
			return
		}
	}
}

获取最新消息发往客户端

func getmessage(version, roomid uint32) []message {
	var msgarr = []message{}
	var msg *message
	debuglog.Println("room list read locked")
	roomlist[roomid].mutex.RLock()//挂房间读锁，函数结束时会自动解锁
	defer roomlist[roomid].mutex.RUnlock()
	defer fmt.Println("room list read unlocked")
	rwsany, err := writeTodatabase(QUERY, "select id,sendid,content from `"+strconv.FormatUint(uint64(roomid), 10)+"` where id>?", version)
	if err == nil {
		debuglog.Println("write to database finished")
		rws := rwsany.(*sql.Rows)
		for rws.Next() {
			debuglog.Println("read message...")
			msgarr = append(msgarr, message{roomid: roomid})
			msg = &msgarr[len(msgarr)-1]
			err = rws.Scan(&msg.id, &msg.sendid, &msg.content)
			if err != nil {
				debuglog.Printf("select id,sendid,content from `"+strconv.FormatUint(uint64(roomid), 10)+"` where id>%v", version)
				errorlog.Printf("read room %v msg failed,version %v, err %s", roomid, version, err.Error())
				return msgarr
			}
		}
	}
	return msgarr
}
func sendtocli(src *[]message, con net.Conn) error {
	if len(*src) == 0 {
		return nil
	}
	_, err := con.Write([]byte{MSG_SYN, byte(len(*src))})
	if err == nil {
		debuglog.Println("prepare send", len(*src))
		for _, ele := range *src {
			time.Sleep(10 * time.Millisecond) //sleep 10 milliseconds
			_, err = con.Write(ele.tobytes())
			if err != nil {
				return err
			} else {
				debuglog.Println("send message", string(ele.tobytes()[7:]))
			}
		}
	}
	return err
}

我们可能注意到发往客户端时有10毫秒休眠间隔，这个休眠间隔可以设置的小，但不能没有。计算机处理速度很快的现在，别看这里循环有那么几行代码，在计算机面前，嗖的一下就全没了。然后由于太快了，最后接收端缓冲区都还没读，我们就把东西全给别人塞进去了，最后几个独立的包可能被粘成一个了。
请添加图片描述
请添加图片描述

数据量大的时候又有另一个坑，接收端缓冲区设置的也许是1MB,但是我们发送端发的包是800kb，连发四包，最后接收端又读出问题，我们第二个包可能被接收端读出来就是身首异处。我们第二个包自己设置的控制层直接被读到第一个包末尾处了，第二个包我们解析的时候数据就是有问题的
请添加图片描述

消息结构体转byte数组

// message = id[1]+roomid[2]+sendcliid[3]+content
func (s *message) tobytes() []byte {
	ans := make([]byte, 7+len(s.content))
	ans[0] = MSG_ACK
	ans[1] = byte(s.id)
	ans[2] = byte((s.roomid / 256) % 256)
	ans[3] = byte(s.roomid % 256)
	ans[4] = byte((s.sendid / (256 * 256)) % 256)
	ans[5] = byte((s.sendid / 256) % 256)
	ans[6] = byte(s.sendid % 256)
	copy(ans[7:], []byte(s.content))
	return ans
}
func (s *client) write(code uint8, v []byte) error {
	ans := make([]byte, 1+len(v))
	ans[0] = code
	copy(ans[1:], v)
	if s.response_writer == nil {
		return fmt.Errorf("not set response writer")
	}
	_, err := s.response_writer.con.Write(ans)
	return err
}

客户端储存消息至房间数据库，并更新消息版本号

func writetomessage(message []byte, roomid, sendid uint32) bool {
	debuglog.Printf("client %v locked room %v", sendid, roomid)
	roomlist[roomid].mutex.Lock()
	defer roomlist[roomid].mutex.Unlock()
	defer debuglog.Printf("client %v unlocked room %v", sendid, roomid)
	_, err := writeTodatabase(EXEC, "insert into `"+strconv.FormatUint(uint64(roomid), 10)+"` (sendid,content)values(?,?)", sendid, string(message))
	if err == nil {
		debuglog.Printf("insert into `%v` (sendid,content)values(%v,'%v')", roomid, sendid, string(message))
		rowany, _ := writeTodatabase(QUERYROW, "select MAX(id) from `"+strconv.FormatUint(uint64(roomid), 10)+"`")//我们这里上的写锁，所以最大消息id就是刚才我们插入的那条消息
		var maxversion uint32
		row := rowany.(*sql.Row)
		if row.Scan(&maxversion) == nil {
			roomlist[roomid].latestversion = maxversion
			clientlist[sendid].last_verion = maxversion
		} else {
			errorlog.Println("get maxversion failed")
		}
		return true
	} else {
		errorlog.Println("insert data error", err.Error())
		_, err = writeTodatabase(EXEC, "create table `"+strconv.FormatUint(uint64(roomid), 10)+"` (id INTEGER PRIMARY KEY autoincrement NOT NULL,sendid INTEGER NOT NULL,content VARCHAR(1000))")
		if err == nil {
			_, err = writeTodatabase(EXEC, "insert into `"+strconv.FormatUint(uint64(roomid), 10)+"` (sendid,content)values(?,?)", sendid, string(message))
			if err == nil {
				rowany, _ := writeTodatabase(QUERYROW, "select MAX(id) from `"+strconv.FormatUint(uint64(roomid), 10)+"`")
				var maxversion uint32
				row := rowany.(*sql.Row)
				if row.Scan(&maxversion) == nil {
					roomlist[roomid].latestversion = maxversion
				} else {
					errorlog.Println("get maxversion failed")
				}
				return true
			} else {
				errorlog.Println(err.Error())
			}
		} else {
			errorlog.Printf("insert data to room %v failed,err=%s", roomid, err.Error())
		}

	}
	return false
}

实机演示

在这里插入图片描述
完整代码地址 https://github.com/oswaldoooo/mini_im

docker真的爽爆了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
golang实现简单聊天室
hechunbao987的博客
04-20 681
server端 package main import ( "fmt" "net" "strconv" "strings" ) type user struct { conn net.Conn name string } //定义用户结构体 var online map[string]*user //该map储存在线用户 var msg chan string //定义全局的消息channel,接受到的消息会储存在这里,然后通过manager读取消息,做出相应处理 func man
Golang实现并发聊天室
01-20
在本项目中，我们将探讨如何使用Golang实现一个并发聊天室。Golang以其独特的并发模型和高效性能，成为了许多开发者首选的编程语言，尤其适合处理并发和网络编程任务。这个并发聊天室项目是针对Go语言学习者的一个...
golang基于websocket实现的简易聊天室程序
09-21
主要介绍了golang基于websocket实现的简易聊天室,分析了websocket的下载、安装及使用实现聊天室功能的相关技巧,需要的朋友可以参考下
Golang 从零开始实现多人聊天室（二）客户端访问
猫轻王的博客
05-11 1168
从零开始实现一个基于Go的多人在线聊天室，功能包括：单聊、群聊、昵称、上下线通知、聊天日志等等，该博文简单实现，下篇博文将会讲客户端的访问，也正式与服务端勾搭上了，服务端的功能也将正式开始显现，下篇博文也就是多人聊天室为什么支持多人的所在，服务端的广播完成了不同用户的通信。客户端的代码比较清晰明了，将两端真正融会贯通将是之后不断地努力方向。·
golang怎么搭建Websocket聊天室服务端
最新发布
Maisu的博客
07-21 48
收到客户端消息马上发回给客户端go代码解读复制代码。
golang 简易聊天
weixin_34186128的博客
04-11 118
client.go ------------------------------ package main import ( "net" "fmt" "bufio" "echo/codec" "time" ) var quitSemaphore chan bool func main() { var tcpAd...
Golang实现完整聊天室（内附源码）
paterl的博客
08-12 1655
一篇带你掌握IM聊天原理
golang 聊天室
行者游学
07-25 1840
使用golang实现简单的websocket聊天室
golang聊天室
baixiao9898的博客
03-05 132
golang对并发的支持非常好，就是因为他有一个goroutine机制和channel机制，实现并发场景轻松高效。 下面我们实现一个聊天室程序，代码不多，但是功能很强大 //代码转载自：http://blog.csdn.net/ygrx/article/details/11773151 package main import ( "fmt" "net" "os...
Golang 搭建 Web 聊天室
06-07
【Golang 搭建 Web 聊天室】是一个关于使用 Go 语言构建实时通信应用的教程，重点是利用 WebSocket 协议实现一个在线聊天室。WebSocket 是一种在 Web 端支持双向通信的协议，它克服了 HTTP 的单向传输限制，允许...
golang(基于goroutine实现的tcp聊天室)
07-11
golang(基于goroutine实现的tcp聊天室)
GoLang 实现的TCP/Socket：（一） 客户端
10-23
GoLang 实现的TCP Socket 客户端 ,模拟与服务器通信的例子
ChatRoom:golang 聊天室实现
05-10
ChatRoom golang 聊天室实现 实现功能 登入或者注册进入系统 登入验证 注册验证 可以跟别人私聊，可以进入聊天室群聊 可以查看注册人列表 可以查看在线人列表 链接超时处理 用户主动退出处理 注册，登入，上线，下线的系统广播通知 上线，下线 所有人可以收到通知 聊天室广播消息：进入聊天室，退出聊天室 聊天室中的消息只有聊天室成员可以看到
goLang简单聊天室
a568283992的博客
05-23 984
有一段时间没写博客了，现在因为工作需要学习了go，做一个小Demo，简单的聊天室。 首先服务端开启监听8889端口，监听每一个客户端。 客户端需要先登录，登录成功后，服务端会发送给每一个客户端一个消息，XXX用户登陆成功，目前程序还没写完全，后续会不断更新~~ message.go: 首先需要一个消息传送的protocol，因为是基于TCP协议，传输过程中会有粘包和拆包问题，因此定义一个协议来保证数据完整性。 package message const ( LoginMesType =.
golang实现聊天室
ChangUper的博客
08-25 809
用golang实现聊天室用户上线以及群发消息功能
golang搭建简易的聊天室
onepylearner的博客
04-14 342
1. 利用tcp协议，golang源生的net包实现 话不多说，我们知道聊天室需要一个服务端和客户端，这里就令服务端为server，客户端为client 2. 新建两个go文件，分别为server.go(服务端)，client.go(客户端) server.go package main import ( "fmt" "net" ) // ProcessClient ... Mu...
Go语言实现TCP通信
u012780655的博客
10-19 7273
章节 go 优势 go 实现 TCP 通信 1 go 语言优势 1.1 go 语言优势 go 优势 注意：跟本章似乎没有什么联系 2 go 实现TCP通信 2.1 server.go unix 网络编程步骤： Server-&gt;Bind-&gt;Listen-&gt;Accept go 语言实现 socket 编程步骤： Listen...
golang-TCP通信实例
flowerxxxxx的博客
09-08 265
client（用户端） package main import ( "fmt" "net" ) // tcp client func main() { //1.与server端建立连接 conn,err := net.Dial("tcp","127.0.0.1:20000") if err != nil { fmt.Println("dial failde err:",err) return } //2.发送数据 conn.Write([]byte("hello mayil..
golang实现聊天服务器
Gdl.痕迹 的博客
11-28 401
学了一段时间的golang，不得不说go的内裤的设计和抽象层次很高，很漂亮，用来来很爽。 直接上代码： chatServer: package main import ( "bufio" "fmt" "log" "net" ) type client chan<- string var ( entering = make(chan client) leaving = m...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值