0
0

【启程Golang之旅】并发编程构建简易聊天系统

欢迎来到Golang的世界！在当今快节奏的软件开发领域，选择一种高效、简洁的编程语言至关重要。而在这方面，Golang（又称Go）无疑是一个备受瞩目的选择。在本文中，带领您探索Golang的世界，一步步地了解这门语言的基础知识和实用技巧。

在这篇文章中，我们将用Go语言实现一个简易网络聊天应用，重点探讨Socket编程、map结构用于管理用户、goroutines与channels实现并发通信、select语句处理超时与主动退出，以及timer定时器的应用。这些概念将帮助我们构建高效且实用的聊天系统。让我们开始吧！

socket-server建立

socket-server的作用是实现网络通信的基础，允许不同设备（如客户端和服务器）通过网络交换数据，下面我们模拟TCP服务器能够接收多个客户端的连接请求，并在每个连接上启动一个新的goroutine进行数据处理。每当有数据从客户端发送到服务器时，服务器会读取并打印这些数据：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. func main() {
  9.     // 01 创建服务器
  10.     listener, err := net.Listen("tcp", ":8080")
  11.     if err != nil {
  12.         fmt.Println("net.listen err:", err)
  13.         return
  14.     } else {
  15.         fmt.Println("服务器启动成功...")
  16.     }
  17.     for {
  18.         fmt.Println("主go程监听中...")
  19.         // 02 监听服务器
  20.         connect, err := listener.Accept()
  21.         if err != nil {
  22.             fmt.Println("listener.accept err:", err)
  23.             return
  24.         }
  25.         fmt.Println("建立连接成功...")
  26.         // 03 启动处理业务的go程
  27.         go handler(connect)
  28.     }
  30. }
  32. func handler(conn net.Conn) {
  33.     for {
  34.         fmt.Println("启动处理业务")
  35.         // TODO
  36.         // 读取客户端发送的数据
  37.         buf := make([]byte, 1024)
  38.         cnt, err := conn.Read(buf)
  39.         if err != nil {
  40.             fmt.Println("conn.read err:", err)
  41.             return
  42.         } else {
  43.             fmt.Println("服务器接收客户端发送过来的数据为:", string(buf[:cnt-1]), "cnt:", cnt)
  44.         }
  45.     }
  47. }

这种设计使得服务器具有并发处理能力，可以同时处理多个客户端的请求，这里我们借助nc工具来模拟请你，不了解工具的可以参考我之前的文章：地址 ，具体如下所示：

创建msg广播通道

要知道我们程度当中是有很多用户的，当一个用户发送消息能让所有的用户看到的话是需要有一个进行全局广播的管道：message，如下所示全局广播的message获取到“hello”，然后遍历所有的用户并向用户msg管道发送hello，在go程中每一个用户连接一个需要再启动一个go程，读取message数据之后发送给客户端：

接下来我们开始创建User结构，用于管理每次创建用户的结构：

  1. // User 定义用户结构体
  2. type User struct {
  3.     id   string
  4.     name string
  5.     msg  chan string
  6. }
  8. // 创建全局的map结构，用于保存所有的用户
  9. var allUsers = make(map[string]User)

然后我们再每次创建go程的时候以连接的key作为唯一添加到用户的map结构当中：

接下来我们定义全局的管道，用于接收任何人发送过来的消息：

  1. // 定义一个message全局通道，用于接收任何人发送过来的消息
  2. var message = make(chan string, 10)

接下来再每次创建新用户上线的时候，写入message：

接下来创建一个全局唯一的广播通道用于通知用户消息，然后在main函数中调用一次下面的go程即可：

  1. // 向所有的用户广播消息，启动全局唯一go程
  2. func broadcast() {
  3.     fmt.Println("启动广播go程...")
  4.     defer fmt.Println("broadcast程序结束...") // 程序结束，关闭广播go程
  5.     for {
  6.         fmt.Println("广播go程监听中...")
  7.         // 01 从message通道中读取消息
  8.         info := <-message
  9.         // 02 遍历map结构，向每个用户发送消息
  10.         for _, user := range allUsers {
  11.             // 03 向每个用户发送消息
  12.             user.msg <- info
  13.         }
  14.     }
  15. }

接下来每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端：

  1. // 每个用户监听自己的msg通道，负责将数据返回给客户端
  2. func writeBackToClient(user *User, conn net.Conn) {
  3.     fmt.Println("启动用户", user.name, "的writeBackToClient go程...")
  4.     for data := range user.msg {
  5.         fmt.Printf("user: %s 写回给客户端的数据为: %s\n", user.name, data)
  6.         _, _ = conn.Write([]byte(data))
  7.     }
  8. }

查询用户与重命名

查询用户：当用户输入查询命令who，则将当前所有登录的用户展示出来，id与name返回给当前用户：

  1. // 01 查询当前所有的用户 who
  2. if len(buf[:cnt-1]) == 3 && string(buf[:cnt-1]) == "who" {
  3.     var userInfos []string
  4.     // 遍历map结构，获取所有的用户信息
  5.     for _, user := range allUsers {
  6.         userInfo := fmt.Sprintf("userid:%s, username: %s", user.id, user.name)
  7.         userInfos = append(userInfos, userInfo)
  8.     }
  9.     // 最终写到管道中
  10.     message <- strings.Join(userInfos, "\n")
  11. }

重命名：这里我们可以设置一个规则：rename | Duke，使用竖线进行分割获取竖线后面的部分作为名字，通过设置 newUser.name = Duke，然后通知客户端更新名字成功，为了避免想输入命令作为消息，这里我们对命令做一个处理：

  1. // 01 查询当前所有的用户 who
  2. if len(buf[:cnt-1]) == 4 && string(buf[:cnt-1]) == "\\who" {
  3.     var userInfos []string
  4.     // 遍历map结构，获取所有的用户信息
  5.     for _, user := range allUsers {
  6.         userInfo := fmt.Sprintf("userid:%s, username: %s", user.id, user.name)
  7.         userInfos = append(userInfos, userInfo)
  8.     }
  9.     // 最终写到管道中
  10.     newUser.msg <- strings.Join(userInfos, "\n")
  11. } else if len(buf[:cnt-1]) > 9 && string(buf[:7]) == "\\rename" {
  12.     // 更新名字
  13.     newUser.name = strings.Split(string(buf[:cnt-1]), "|")[1]
  14.     allUsers[newUser.id] = newUser // 更新map结构中的用户信息
  15.     // 通知客户端更新成功
  16.     newUser.msg <- fmt.Sprintf("改名成功, 新的名字为: %s", newUser.name)
  17. } else {
  18.     message <- string(buf[:cnt-1])
  19. }

用户主动退出聊天

接下来我们通过使用ctrl+c的方式进行退出程序，用户退出还需要做一下清理工作，需要从map当中删除用户信息，还需要将对应的conn连接进行close，具体如下所示：

  1. // 启动一个go程，负责监听退出信号，通知所有go程退出
  2. func watch(user *User, conn net.Conn, isQuit chan bool) {
  3.     fmt.Println("启动用户", user.name, "的watch go程...")
  4.     defer fmt.Println("watch程序结束...") // 程序结束，关闭监听go程
  5.     for {
  6.         select {
  7.         case <-isQuit: // 收到退出信号，通知所有go程退出
  8.             delete(allUsers, user.id)
  9.             fmt.Println("删除当前用户：", user.name)
  10.             message <- fmt.Sprintf("[%s][%s]下线了", user.id, user.name)
  11.             _ = conn.Close()
  12.         }
  13.     }
  14. }

在handler中启动go watch并传入对应信息：

然后在read之后，通过读取cnt判断用户是否退出，向isQuit中写入信息：

最终实现的效果如下所示：

用户超时退出聊天

这里我们可以设置使用定时器来进行超时管理，如果60s内没有发送任何消息的情况下就直接将这个连接关闭掉：

  1. // 启动一个go程，负责监听退出信号，通知所有go程退出
  2. func watch(user *User, conn net.Conn, isQuit chan bool, resTimer chan bool) {
  3.     fmt.Println("启动用户", user.name, "的watch go程...")
  4.     defer fmt.Println("watch程序结束...") // 程序结束，关闭监听go程
  5.     for {
  6.         select {
  7.         case <-isQuit: // 收到退出信号，通知所有go程退出
  8.             delete(allUsers, user.id)
  9.             fmt.Println("删除当前用户：", user.name)
  10.             message <- fmt.Sprintf("[%s][%s]下线了\n", user.id, user.name)
  11.             _ = conn.Close()
  12.             return
  13.         case <-time.After(10 * time.Second):
  14.             fmt.Println("删除当前用户：", user.name)
  15.             delete(allUsers, user.id)
  16.             message <- fmt.Sprintf("[%s]用户超时下线了\n", user.name)
  17.             _ = conn.Close()
  18.             return
  19.         case <-resTimer:
  20.             fmt.Printf("连接%s 重置计数器！\n", user.name)
  21.         }
  22.     }
  23. }

这里我们定义一个重置的管道，只要用户不断输入就不会超时，如果用户没有输入超过10s就会触发超时退出的操作：

  1. // 创建一个用于重置计算器的管道，用于告知watch函数当前用户正在输入
  2. var resTimer = make(chan bool)
  3. // 启动go程，负责监听用户退出
  4. go watch(&newUser, conn, isQuit, resTimer)

完整代码如下所示：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6.     "strings"
  7.     "time"
  8. )
  10. // User 定义用户结构体
  11. type User struct {
  12.     id   string
  13.     name string
  14.     msg  chan string
  15. }
  17. // 创建全局的map结构，用于保存所有的用户
  18. var allUsers = make(map[string]User)
  20. // 定义一个message全局通道，用于接收任何人发送过来的消息
  21. var message = make(chan string, 10)
  23. func main() {
  24.     // 01 创建服务器
  25.     listener, err := net.Listen("tcp", ":8080")
  26.     if err != nil {
  27.         fmt.Println("net.listen err:", err)
  28.         return
  29.     } else {
  30.         fmt.Println("服务器启动成功...")
  31.         // 启动全局唯一go程，用于广播消息
  32.         go broadcast()
  33.     }
  34.     for {
  35.         fmt.Println("主go程监听中...")
  36.         // 02 监听服务器
  37.         connect, err := listener.Accept()
  38.         if err != nil {
  39.             fmt.Println("listener.accept err:", err)
  40.             return
  41.         }
  42.         fmt.Println("建立连接成功...")
  43.         // 03 启动处理业务的go程
  44.         go handler(connect)
  45.     }
  47. }
  49. func handler(conn net.Conn) {
  50.     fmt.Println("启动处理业务")
  51.     // 客户端与服务器建立连接的时候，会有ip与port，可以当成user的id
  52.     clientAddr := conn.RemoteAddr().String()
  53.     fmt.Println("客户端地址为:", clientAddr)
  54.     // 创建User
  55.     newUser := User{
  56.         id:   clientAddr,            // id,不会被修改，作为mao中的key
  57.         name: clientAddr,            // 可以修改，会提供rename命令修改，建立连接时初始值与id相同
  58.         msg:  make(chan string, 10), // 消息通道，注意分配空间
  59.     }
  60.     // 添加user到map结构中
  61.     allUsers[newUser.id] = newUser
  62.     // 定义一个退出信号，用于通知所有go程退出
  63.     var isQuit = make(chan bool)
  64.     // 创建一个用于重置计算器的管道，用于告知watch函数当前用户正在输入
  65.     var resTimer = make(chan bool)
  66.     // 启动go程，负责监听用户退出
  67.     go watch(&newUser, conn, isQuit, resTimer)
  68.     // 启动用户自己的writeBackToClient go程
  69.     go writeBackToClient(&newUser, conn)
  70.     // 向message写入消息，用于通知所有人有用户上线
  71.     message <- fmt.Sprintf("[%s][%s]上线了", newUser.id, newUser.name)
  72.     for {
  73.         buf := make([]byte, 1024)
  74.         // 读取客户端发送的数据
  75.         cnt, err := conn.Read(buf)
  76.         if cnt == 0 {
  77.             fmt.Println("客户端主动关闭ctrl+c，准备退出")
  78.             // 在这里不进行真正的退出动作，只是通知所有go程退出
  79.             isQuit <- true
  80.         }
  81.         if err != nil {
  82.             fmt.Println("conn.read err:", err, "cnt", cnt)
  83.             return
  84.         } else {
  85.             fmt.Println("服务器接收客户端发送过来的数据为:", string(buf[:cnt-1]), "cnt:", cnt)
  86.             // -------业务逻辑处理开始-------
  87.             // 01 查询当前所有的用户 who
  88.             if len(buf[:cnt-1]) == 4 && string(buf[:cnt-1]) == "\\who" {
  89.                 var userInfos []string
  90.                 // 遍历map结构，获取所有的用户信息
  91.                 for _, user := range allUsers {
  92.                     userInfo := fmt.Sprintf("userid:%s, username: %s", user.id, user.name)
  93.                     userInfos = append(userInfos, userInfo)
  94.                 }
  95.                 // 最终写到管道中
  96.                 newUser.msg <- strings.Join(userInfos, "\n")
  97.             } else if len(buf[:cnt-1]) > 9 && string(buf[:7]) == "\\rename" {
  98.                 // 更新名字
  99.                 newUser.name = strings.Split(string(buf[:cnt-1]), "|")[1]
  100.                 allUsers[newUser.id] = newUser // 更新map结构中的用户信息
  101.                 // 通知客户端更新成功
  102.                 newUser.msg <- fmt.Sprintf("改名成功, 新的名字为: %s", newUser.name)
  103.             } else {
  104.                 message <- string(buf[:cnt-1])
  105.             }
  106.             resTimer <- true // 发送一个信号，告知watch函数当前用户正在输入
  107.             // -------业务逻辑处理结束-------
  108.         }
  109.     }
  110. }
  112. // 向所有的用户广播消息，启动全局唯一go程
  113. func broadcast() {
  114.     fmt.Println("启动广播go程...")
  115.     defer fmt.Println("broadcast程序结束...") // 程序结束，关闭广播go程
  116.     for {
  117.         fmt.Println("广播go程监听中...")
  118.         // 01 从message通道中读取消息
  119.         info := <-message
  120.         fmt.Println("广播消息为:", info)
  121.         // 02 遍历map结构，向每个用户发送消息
  122.         for _, user := range allUsers {
  123.             // 03 向每个用户发送消息
  124.             user.msg <- info
  125.         }
  126.     }
  127. }
  129. // 每个用户监听自己的msg通道，负责将数据返回给客户端
  130. func writeBackToClient(user *User, conn net.Conn) {
  131.     fmt.Println("启动用户", user.name, "的writeBackToClient go程...")
  132.     for data := range user.msg {
  133.         fmt.Printf("user: %s 写回给客户端的数据为: %s\n", user.name, data)
  134.         _, _ = conn.Write([]byte(data))
  135.     }
  136. }
  138. // 启动一个go程，负责监听退出信号，通知所有go程退出
  139. func watch(user *User, conn net.Conn, isQuit chan bool, resTimer chan bool) {
  140.     fmt.Println("启动用户", user.name, "的watch go程...")
  141.     defer fmt.Println("watch程序结束...") // 程序结束，关闭监听go程
  142.     for {
  143.         select {
  144.         case <-isQuit: // 收到退出信号，通知所有go程退出
  145.             delete(allUsers, user.id)
  146.             fmt.Println("删除当前用户：", user.name)
  147.             message <- fmt.Sprintf("[%s][%s]下线了\n", user.id, user.name)
  148.             _ = conn.Close()
  149.             return
  150.         case <-time.After(10 * time.Second):
  151.             fmt.Println("删除当前用户：", user.name)
  152.             delete(allUsers, user.id)
  153.             message <- fmt.Sprintf("[%s]用户超时下线了\n", user.name)
  154.             _ = conn.Close()
  155.             return
  156.         case <-resTimer:
  157.             fmt.Printf("连接%s 重置计数器！\n", user.name)
  158.         }
  159.     }
  160. }
标签： golang 开发语言 后端
本文转载自: https://blog.csdn.net/qq_53123067/article/details/143454040
版权归原作者 亦世凡华、 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【启程Golang之旅】并发编程构建简易聊天系统”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。