go 实现多人聊天系统客户端代码实现

最新推荐文章于 2022-10-13 17:26:07 发布
最新推荐文章于 2022-10-13 17:26:07 发布
阅读量276 收藏 1
点赞数
分类专栏： Go 文章标签： Go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqiuming/article/details/117196423
版权

一 客户端目录结构图

二 model 包

chatroom\client\model\curUser.go

package model

import (
   "chatroom/common/message"
   "net"
)

// 因为在客户端，我们很多地方会使用到 curUser,所以将其定义为一个全局
type CurUser struct {
   Conn net.Conn
   message.User
}

三 utils 包

chatroom\client\utils\utils.go

package utils

import (
   "chatroom/common/message"
   "encoding/binary"
   "encoding/json"
   "fmt"
   "net"
)

// 将这些方法关联到 Transfer 结构体中
type Transfer struct {
   // 连接
   Conn net.Conn
   // 传输数据的缓冲
   Buf [8096]byte
}

// 读消息
func (this *Transfer) ReadPkg() (mes message.Message, err error) {
   fmt.Println("读取客户端发送的数据...")
   //conn.Read 在conn没有被关闭的情况下，才会阻塞
   //如果客户端关闭了 conn 则，就不会阻塞
   _, err = this.Conn.Read(this.Buf[:4])
   if err != nil {
      return
   }
   // 根据 buf[:4] 转成一个 uint32 类型
   var pkgLen uint32
   pkgLen = binary.BigEndian.Uint32(this.Buf[0:4])
   // 根据 pkgLen 读取消息内容
   n, err := this.Conn.Read(this.Buf[:pkgLen])
   if n != int(pkgLen) || err != nil {
      return
   }
   // 反序列化成 message.Message
   err = json.Unmarshal(this.Buf[:pkgLen], &mes)
   if err != nil {
      fmt.Println("json.Unmarsha err=", err)
      return
   }
   return
}

// 写消息
func (this *Transfer) WritePkg(data []byte) (err error) {
   // 先发送一个长度给对方
   var pkgLen uint32
   pkgLen = uint32(len(data))
   binary.BigEndian.PutUint32(this.Buf[0:4], pkgLen)
   // 发送长度
   n, err := this.Conn.Write(this.Buf[:4])
   if n != 4 || err != nil {
      fmt.Println("conn.Write(bytes) fail", err)
      return
   }
   // 发送 data 本身
   n, err = this.Conn.Write(data)
   if n != int(pkgLen) || err != nil {
      fmt.Println("conn.Write(bytes) fail", err)
      return
   }
   return
}

四 process 包

chatroom\client\process\server.go

package process

import (
   "chatroom/client/utils"
   "chatroom/common/message"
   "encoding/json"
   "fmt"
   "net"
   "os"
)

// 显示登录成功后的界面
func ShowMenu() {
   fmt.Println("-------恭喜登录成功---------")
   fmt.Println("-------1 显示在线用户列表---------")
   fmt.Println("-------2 发送消息---------")
   fmt.Println("-------3 信息列表---------")
   fmt.Println("-------4 退出系统---------")
   fmt.Println("请选择(1-4):")
   var key int
   var content string
   // 因为总会使用到 SmsProcess 实例，因此将其定义在 swtich 外部
   smsProcess := &SmsProcess{}
   fmt.Scanf("%d\n", &key)
   switch key {
   case 1:
      // 显示在线用户列表
      outputOnlineUser()
   case 2:
      fmt.Println("想对大家说点什么:)")
      fmt.Scanf("%s\n", &content)
      // 群发消息
      smsProcess.SendGroupMes(content)
   case 3:
      fmt.Println("信息列表")
   case 4:
      fmt.Println("你选择退出了系统...")
      os.Exit(0)
   default:
      fmt.Println("你输入的选项不正确..")
   }
}

// 和服务器保持通讯
func serverProcessMes(conn net.Conn) {
   // 创建一个 transfer 实例, 不停的读取服务器发送的消息
   tf := &utils.Transfer{
      Conn: conn,
   }
   for {
      fmt.Println("客户端正在等待读取服务器发送的消息")
      mes, err := tf.ReadPkg()
      if err != nil {
         fmt.Println("tf.ReadPkg err=", err)
         return
      }
      // 如果读取到消息
      switch mes.Type {
      case message.NotifyUserStatusMesType: // 有人上线了
         // 1 取出 NotifyUserStatusMes
         var notifyUserStatusMes message.NotifyUserStatusMes
         json.Unmarshal([]byte(mes.Data), &notifyUserStatusMes)
         // 2 把这个用户的信息，状态保存到客户 map[int]User 中
         updateUserStatus(&notifyUserStatusMes)
      case message.SmsMesType: // 有人群发消息
         outputGroupMes(&mes)
      default:
         fmt.Println("服务器端返回了未知的消息类型")
      }
   }
}

chatroom\client\process\smsMgr.go

package process

import (
   "chatroom/common/message"
   "encoding/json"
   "fmt"
)

// 显示群发消息
func outputGroupMes(mes *message.Message) { // 这个地方 mes 一定 SmsMes
   // 1 反序列化 mes.Data 成 SmsMes
   var smsMes message.SmsMes
   err := json.Unmarshal([]byte(mes.Data), &smsMes)
   if err != nil {
      fmt.Println("json.Unmarshal err=", err.Error())
      return
   }
   // 显示信息
   info := fmt.Sprintf("用户id:\t%d 对大家说:\t%s",
      smsMes.UserId, smsMes.Content)
   fmt.Println(info)
   fmt.Println()
}

chatroom\client\process\smsProcess.go

package process

import (
   "chatroom/client/utils"
   "chatroom/common/message"
   "encoding/json"
   "fmt"
)

type SmsProcess struct {
}

// 客户端发送群聊的消息
func (this *SmsProcess) SendGroupMes(content string) (err error) {
   // 1 创建一个Mes
   var mes message.Message
   mes.Type = message.SmsMesType
   // 2 创建一个 SmsMes 实例
   var smsMes message.SmsMes
   smsMes.Content = content               // 消息内容
   smsMes.UserId = CurUser.UserId         // 用户Id
   smsMes.UserStatus = CurUser.UserStatus // 用户状态
   // 3 序列化 smsMes
   data, err := json.Marshal(smsMes)
   if err != nil {
      fmt.Println("SendGroupMes json.Marshal fail =", err.Error())
      return
   }
   mes.Data = string(data)
   // 4 对 mes 再次序列化
   data, err = json.Marshal(mes)
   if err != nil {
      fmt.Println("SendGroupMes json.Marshal fail =", err.Error())
      return
   }
   // 5 创建一个 Transfer 实例
   tf := &utils.Transfer{
      Conn: CurUser.Conn,
   }
   //6 将 mes 发送给服务器
   err = tf.WritePkg(data)
   if err != nil {
      fmt.Println("SendGroupMes err=", err.Error())
      return
   }
   return
}

chatroom\client\process\userMgr.go

package process

import (
   "chatroom/client/model"
   "chatroom/common/message"
   "fmt"
)

// 客户端要维护的在线用户的 map
var onlineUsers map[int]*message.User = make(map[int]*message.User, 10)
var CurUser model.CurUser // 在用户登录成功后，完成对 CurUser 初始化


// 在客户端显示当前在线的用户
func outputOnlineUser() {
   // 遍历一下 onlineUsers
   fmt.Println("当前在线用户列表:")
   for id, _ := range onlineUsers {
      fmt.Println("用户id:\t", id)
   }
}

// 处理返回的 NotifyUserStatusMes
func updateUserStatus(notifyUserStatusMes *message.NotifyUserStatusMes) {
   user, ok := onlineUsers[notifyUserStatusMes.UserId]
   if !ok {
      user = &message.User{
         UserId: notifyUserStatusMes.UserId,
      }
   }
   user.UserStatus = notifyUserStatusMes.Status
   // 更新在线用户列表
   onlineUsers[notifyUserStatusMes.UserId] = user
   // 显示当前在线用户
   outputOnlineUser()
}

chatroom\client\process\userProcess.go

package process

import (
   "chatroom/client/utils"
   "chatroom/common/message"
   "encoding/binary"
   "encoding/json"
   "fmt"
   "net"
   "os"
)

type UserProcess struct {
   // 暂时不需要字段
}

// 注册
func (this *UserProcess) Register(userId int,
   userPwd string, userName string) (err error) {
   // 1 连接到服务器
   conn, err := net.Dial("tcp", "localhost:8889")
   if err != nil {
      fmt.Println("net.Dial err=", err)
      return
   }
   // 延时关闭
   defer conn.Close()
   // 2 准备要发送的消息
   var mes message.Message
   mes.Type = message.RegisterMesType
   // 3 创建一个 RegisterMes 结构体
   var registerMes message.RegisterMes
   registerMes.User.UserId = userId
   registerMes.User.UserPwd = userPwd
   registerMes.User.UserName = userName
   // 4 将 registerMes 序列化
   data, err := json.Marshal(registerMes)
   if err != nil {
      fmt.Println("json.Marshal err=", err)
      return
   }
   // 5 把 data 赋给 mes.Data 字段
   mes.Data = string(data)
   // 6 将 mes 进行序列化化
   data, err = json.Marshal(mes)
   if err != nil {
      fmt.Println("json.Marshal err=", err)
      return
   }
   // 创建一个Transfer 实例
   tf := &utils.Transfer{
      Conn: conn,
   }
   // 发送 data 给服务器端
   err = tf.WritePkg(data)
   if err != nil {
      fmt.Println("注册发送信息错误 err=", err)
   }
   mes, err = tf.ReadPkg() // mes 就是 RegisterResMes
   if err != nil {
      fmt.Println("readPkg(conn) err=", err)
      return
   }
   // 将 mes 的 Data 部分反序列化成 RegisterResMes
   var registerResMes message.RegisterResMes
   err = json.Unmarshal([]byte(mes.Data), &registerResMes)
   if registerResMes.Code == 200 {
      fmt.Println("注册成功, 请重新登录")
      os.Exit(0)
   } else {
      fmt.Println(registerResMes.Error)
      os.Exit(0)
   }
   return
}

// 用户登录
func (this *UserProcess) Login(userId int, userPwd string) (err error) {
   // 1 连接到服务器
   conn, err := net.Dial("tcp", "localhost:8889")
   if err != nil {
      fmt.Println("net.Dial err=", err)
      return
   }
   // 延时关闭
   defer conn.Close()
   // 2 准备通过 conn 发送消息给服务
   var mes message.Message
   mes.Type = message.LoginMesType
   // 3 创建一个 LoginMes 结构体
   var loginMes message.LoginMes
   loginMes.UserId = userId
   loginMes.UserPwd = userPwd
   // 4 将loginMes 序列化
   data, err := json.Marshal(loginMes)
   if err != nil {
      fmt.Println("json.Marshal err=", err)
      return
   }
   // 5 把data赋给 mes.Data字段
   mes.Data = string(data)
   // 6 将 mes进行序列化
   data, err = json.Marshal(mes)
   if err != nil {
      fmt.Println("json.Marshal err=", err)
      return
   }
   // 7 到这时 data 就是我们要发送的消息
   // 7.1 先把 data 的长度发送给服务器
   // 先获取到 data 的长度，然后转成一个表示长度的 byte 切片
   var pkgLen uint32
   pkgLen = uint32(len(data))
   var buf [4]byte
   binary.BigEndian.PutUint32(buf[0:4], pkgLen)
   // 发送长度
   n, err := conn.Write(buf[:4])
   if n != 4 || err != nil {
      fmt.Println("conn.Write(bytes) fail", err)
      return
   }
   fmt.Printf("客户端，发送消息的长度=%d 内容=%s", len(data), string(data))
   // 7.1 再把 data 的本身发送给服务器
   _, err = conn.Write(data)
   if err != nil {
      fmt.Println("conn.Write(data) fail", err)
      return
   }
   // 创建一个Transfer 实例
   tf := &utils.Transfer{
      Conn: conn,
   }
   mes, err = tf.ReadPkg() // mes 就是返回的消息
   if err != nil {
      fmt.Println("readPkg(conn) err=", err)
      return
   }
   // 将 mes 的 Data 部分反序列化成 LoginResMes
   var loginResMes message.LoginResMes
   err = json.Unmarshal([]byte(mes.Data), &loginResMes)
   if loginResMes.Code == 200 {
      // 初始化 CurUser
      CurUser.Conn = conn
      CurUser.UserId = userId
      CurUser.UserStatus = message.UserOnline
      //fmt.Println("登录成功")
      //可以显示当前在线用户列表,遍历loginResMes.UsersId
      fmt.Println("当前在线用户列表如下:")
      for _, v := range loginResMes.UsersId {
         //如果我们要求不显示自己在线,下面我们增加一个代码
         if v == userId {
            continue
         }

         fmt.Println("用户id:\t", v)
         //完成 客户端的 onlineUsers 完成初始化
         user := &message.User{
            UserId:     v,
            UserStatus: message.UserOnline,
         }
         onlineUsers[v] = user
      }
      fmt.Print("\n\n")


      //这里我们还需要在客户端启动一个协程
      //该协程保持和服务器端的通讯.如果服务器有数据推送给客户端
      //则接收并显示在客户端的终端.
      go serverProcessMes(conn)

      //1. 显示我们的登录成功的菜单[循环]..
      for {
         ShowMenu()
      }
   } else {
      fmt.Println(loginResMes.Error)
   }
   return
}

五 main 包

chatroom\client\main\main.go

package main

import (
   "chatroom/client/process"
   "fmt"
   "os"
)

// 用户 id
var userId int

// 用户密码
var userPwd string

// 用户名
var userName string

func main() {
   // 接收用户的选择
   var key int
   for true {
      fmt.Println("----------------欢迎登陆多人聊天系统------------")
      fmt.Println("\t\t\t 1 登陆聊天室")
      fmt.Println("\t\t\t 2 注册用户")
      fmt.Println("\t\t\t 3 退出系统")
      fmt.Println("\t\t\t 请选择(1-3):")
      fmt.Scanf("%d\n", &key)
      switch key {
      case 1:
         fmt.Println("登陆聊天室")
         fmt.Println("请输入用户的id")
         fmt.Scanf("%d\n", &userId)
         fmt.Println("请输入用户的密码")
         fmt.Scanf("%s\n", &userPwd)
         // 创建一个 UserProcess 的实例
         up := &process.UserProcess{}
         // 用户登录处理
         up.Login(userId, userPwd)
      case 2:
         fmt.Println("注册用户")
         fmt.Println("请输入用户id:")
         fmt.Scanf("%d\n", &userId)
         fmt.Println("请输入用户密码:")
         fmt.Scanf("%s\n", &userPwd)
         fmt.Println("请输入用户名字(nickname):")
         fmt.Scanf("%s\n", &userName)
         //2 调用UserProcess，完成注册的请求
         up := &process.UserProcess{}
         up.Register(userId, userPwd, userName)
      case 3:
         fmt.Println("退出系统")
         os.Exit(0)
      default:
         fmt.Println("你的输入有误，请重新输入")
      }
   }
}

 

chengqiuming
关注
专栏目录
go 实现多人聊天系统服务端代码实现
实践求真知
05-23 1048
一代码结构图 二model包 chatroom\server\model\error.go package model import ( "errors" ) // 根据业务逻辑需要，自定义一些错误。 var ( ERROR_USER_NOTEXISTS = errors.New("用户不存在") ERROR_USER_EXISTS = errors.New("用户已经存在") ERROR_USER_PWD = errors.New("密码不正...
Golang实现的聊天程序服务端和客户端代码分享
01-20
实现逻辑 1、Golang 版本  1.3 2、实现原理： 　　1、主进程建立TCP监听服务，并且初始化一个变量 talkChan := make(map[int]chan string) 　　2、当主进程ACCEPT连接请求后，利用go 启动一个协程A去维持和客户端的连接，把taokChan带入到协程里 　　3、和客户端建立连接的协程A，发送消息给客户端，使其发送自己的用户信息。 　　4、协程A在收到客户端发送的用户信息后，建立一个此用户对应的管道 talkChan[uid] = make(chan string) 　　5、协程A再启动一个协程A1去专门用来读取客户端发送的消息，并且用来判断
GO简易聊天系统后台源码分享
01-27 249
本人是搞移动客户端开发的，业余时间接触到golang这么个可爱的囊地鼠,于是就写了这么个测试项目：简易版的聊天系统，功能包括注册，登陆，群聊和单聊，无需使用mysql,数据都存在了文本里。本人纯粹兴趣，前后就几天搞出来的产物，想到哪里写到哪里，边查手册边写出来的，所以某些地方会有不合理的地方，但测试过没有bug，就当为新手同学们提供个参考吧,也给手贱点进来的老手们提供个笑料吧 >_...
多人在线聊天系统
06-13
多人在线聊天，即时通信
go 语言公共聊天室源码
11-04
这是一款用go语言开发的在线公共聊天，全部代码不到120行，比较适合初学者，大牛勿喷/请绕道
Golang(Gin框架)+websocket 实现的多人聊天室+代码+详细文档
最新发布
05-13
在本文中，我们将深入探讨如何使用Golang的Gin框架结合Websocket技术来构建一个功能完备的多人聊天室。Gin是一个高效的、基于MVC模式的web开发框架，而Websocket则是一种允许服务器与客户端进行全双工通信的协议，...
（十三）客户端实现
weixin_46272577的博客
09-28 426
真正操作时候还是需要实现一个客户端进行操作的，总不能一直手写数据。
chat.go:Go的简单聊天机器人框架
05-17
Chat.go 多平台支持和（试用）是一个通用的chaetbot框架。 结构 描述chat.go项目的结构。 设想 在chat.go中定义聊天机器人的工作流程时使用的单位。 定义如下： type Scenario interface { Next ( Object ) ( Scenario , Object ) } 只需接收对象作为输入，然后给出下一个方案和要执行的对象即可。 这种简单的特性使您可以自由创建和重用自己的方案。 将收集并提供chat.go中经常使用的方案。 现在实施的方案包括： CondScenario：给定一个条件和一个行为作为一对，如果条件为true，则执行相应的行为。 目的 它是在chat.go中的方案之间交换信息的单元。 定义如下： type Object interface { MarshalJSON () ([] byte , e
[go] 聊天室服务器端八--模拟客户端发送消息
dkaily1314的专栏
04-17 365
源码地址: https://github.com/JianBiHua/go_line_chat 网上有一个TCP/UDP测试工具叫SocketTool，支持MAC/Window, 自己百度下载下。 我们先下载上面的代码，如果直接运行，本机测试，则IP为127.0.0.1，端口为8888；用socketTool创建一个Tcp Client 如下图为连接状态，说明服务端已启动: 然后我们模拟发送...
Go_实现聊天室
ParisCutie的博客
06-30 192
聊天通讯系统 需求分析 用户注册 用户登陆 显示在线用户列表 群聊 界面设计 rooms/client/main.go实现 根据接收用户的选择，是登录、注册，还是退出，登录和注册都需要按要求给出相应的用户信息 var userID int var userPwd string var userName string func main() { //接收选择 var key int for true { fmt.Println("---------欢迎登陆---------") fmt.
高并发模拟多个用户同时访问
07-09
高并发模拟多个用户同时访问所写接口，用于测试接口所需要的的并发，和接口的最多承受用户量，适用于一些简单的压力测试。
Go语言服务器开发实现最简单HTTP的GET与POST接口
09-22
主要介绍了Go语言服务器开发实现最简单HTTP的GET与POST接口,实例分析了Go语言http包的使用技巧,需要的朋友可以参考下
chat:基于golang 的im 聊天项目
04-15
郑重声明 本系统只能用作学习使用，不得用作生产环境。如因无视本声明，将本系统代码部署到生产环境，导致出现各种损失，本人不承担任何责任！ 先上效果 安装方法 本系统升级到golang1.12,请开启如下支持 #开启go mod支持 export GO111MODULE=on #使用代理 export GOPROXY=https://goproxy.io 1.下载项目 git clone https://github.com/winlion/chat.git 2.项目配置，非常重要 2.1 数据库配置 修改service/init.go 中数据库配置文件 const ( driveName = "mysql" //数据库类型,不要动 dsName = "root:root@(127.0.0.1:3306)/tech-chat?charset=utf8" //tech-chat是数
golang基于websocket实现的简易聊天室程序
09-21
主要介绍了golang基于websocket实现的简易聊天室,分析了websocket的下载、安装及使用实现聊天室功能的相关技巧,需要的朋友可以参考下
go-min-chat:一个分布式的聊天系统
03-11
聊天 架构图 使用方法 cd go-min-chat / server /运行server.go 演示 服务器 客户 指令介绍 创建房间xxx创建房间（完成） 显示房间查看房间列表（完成） 使用房间xxx进入房间（完成） 列表查看当前房间的所有用户 @xx
go语言300行代码实现即时通讯聊天室
Ego12138的博客
03-22 1191
学了2年Java，因为工作原因需要转Golang，3天时间学习了下go的基本语法，做这样一个聊天室小项目来巩固串联一下语法。 实现的功能：公聊，私聊，修改用户名 只用到了四个类: main.go：用来启动服务器 server.go：服务器相关代码 client.go：客户端相关代码，用户可以直接操作的可视化界面 user.go：用户类，用来封装用户的业务逻辑 架构图 完整代码 server.go package main import ( "fmt" "io" "net" "sync" "
网络编程03：BIO chat room客户端
qq_43378019的博客
03-07 125
实现客户端：ChatClient 先完成主线程：将消息发送给服务器，接收服务器返回的消息 ChatClient.java： public class ChatClient { private String DEFAULT_SERVER_HOST = "127.0.0.1"; private int DEFAULT_SERVER_PORT = 8888; private final String QUIT = "quit"; private Socket socket;
GolangChat:聊天系统
03-11
高朗聊天 聊天系统 1.0版本已实现实现单撩实现群撩实现用户上线的全网通知实现用户昵称实现聊天日志的存储和查看 2.0版本等待
C语言实现--基于UDP的多人在线聊天室
m0_68210771的博客
10-13 2554
基于UDP协议，完成一个功能比较完善的在线的聊天室项目，该项目涉及到的知识主要有C语言，数据结构，网络编程，进程等。
Go语言实现多人聊天室：功能与代码解析
"Go语言多人聊天室项目实战" 在本文中，我们将探讨如何使用Go语言构建一个多人聊天室项目。这个项目旨在提供一个实时通信平台，让多个用户能够进行一对一（单撩）或群体（群撩）聊天，同时支持用户上线通知、昵称...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值