Golang网络聊天室案例
Posted 2019ab
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Golang网络聊天室案例相关的知识，希望对你有一定的参考价值。
1.聊天室设计分析
一. 概览
实现 个网络聊天室（群）
功能分析：
- 上线下线
- 聊天，其他人，自己都可以看到聊天消息
- 查询当前聊天室用户名字 who
- 可以修改自己名字 rename | Duke
- 超时踢出
技术点分析：
1 . sock tcp 编程
2 . map结构 （存储当前用户，map遍历，map删除）
3 . go程，channel
4 . select（超时退出，主动退出）
5 . timer定时器
二、实现基础
第一阶段：
tcp socket，建立多个连接
package main
import (
"fmt"
"net"
)
func main()
// 创建服务器
listener,err := net.Listen("tcp",":8088")
if err != nil
fmt.Println("net.Listen err:",err)
return
fmt.Println("服务器启动成功，监听中...")
for
fmt.Println("==>主go程监听中......")
// 监听
conn,err := listener.Accept()
if err != nil
fmt.Println("listener.Accept err:",err)
return
// 建立连接
fmt.Println("建立连接成功！")
// 启动处理业务的go程
go handler(conn)
// 处理具体业务
func handler(conn net.Conn)
for
fmt.Println("启动业务...")
// TODO // 代表这里以后再具体实现
buf := make([]byte,1024)
// 读取客户端发送来的数据
cnt,err := conn.Read(buf)
if err != nil
fmt.Println("listener.Read err:",err)
return
fmt.Println("客户端接收客户端发来的数据为：",string(buf[:cnt-1]),",cnt:",cnt)
go run chatroom.go
启动nc
nc下载地址
2、定义User/map结构
type User struct
// 名字
name string
// 唯一 的 id
id string
// 管道
msg chan string
// 创建一个全局的map结构，用于保存所有的用户
var allUsers = make(map[string]User)
在Handler中调用
// 处理具体业务
func handler(conn net.Conn)
for
fmt.Println("启动业务...")
//
// 客户端与服务器建立连接的时候，公有ip和port --> 当成user的id
clientAddr := conn.RemoteAddr().String()
fmt.Println("clientAddr:",clientAddr)
// 创建user
newUser := User
id:clientAddr,// id 我们不会修改，这个作为map中的key
name:clientAddr,// 可以修改，会提供rename命令修改，建立连接时，初始值与id相同
msg:make(chan string), // 注意需要make空间，否则无法写入数据
// 添加user到map结构
allUsers[newUser.id] = newUser
/
buf := make([]byte,1024)
// 读取客户端发送来的数据
cnt,err := conn.Read(buf)
if err != nil
fmt.Println("listener.Read err:",err)
return
fmt.Println("客户端接收客户端发来的数据为：",string(buf[:cnt-1]),",cnt:",cnt)
3.定义message管道
创建监听广播go程函数
// 向所有的用户广播消息，启动一个全局唯一的go程
func broadcast()
fmt.Println("广播go程启动成功...")
// 1. 从message中读取数据
info := <-message
// 2. 将数据写入到每一个用户的msg管道中
for _,user := range allUsers
user.msg <- info
启动，全局唯一
写入上线数据
当前整体源码
package main
import (
"fmt"
"net"
)
type User struct
// 名字
name string
// 唯一 的 id
id string
// 管道
msg chan string
// 创建一个全局的map结构，用于保存所有的用户
var allUsers = make(map[string]User)
// 定义一个message全局通道，用于接收任何人发送过来消息
var message = make(chan string,10)
func main()
// 创建服务器
listener,err := net.Listen("tcp",":8087")
if err != nil
fmt.Println("net.Listen err:",err)
return
// 启动全局唯一的go程，负责监听message通道，写给所有的用户
go broadcast()
fmt.Println("服务器启动成功，监听中...")
for
fmt.Println("==>主go程监听中......")
// 监听
conn,err := listener.Accept()
if err != nil
fmt.Println("listener.Accept err:",err)
return
// 建立连接
fmt.Println("建立连接成功！")
// 启动处理业务的go程
go handler(conn)
// 处理具体业务
func handler(conn net.Conn)
for
fmt.Println("启动业务...")
// 客户端与服务器建立连接的时候，公有ip和port --> 当成user的id
clientAddr := conn.RemoteAddr().String()
fmt.Println("clientAddr:",clientAddr)
// 创建user
newUser := User
id:clientAddr,// id 我们不会修改，这个作为map中的key
name:clientAddr,// 可以修改，会提供rename命令修改，建立连接时，初始值与id相同
msg:make(chan string,10), // 注意需要make空间，否则无法写入数据
// 添加user到map结构
allUsers[newUser.id] = newUser
// 向message写入数据，当我用户上线的消息，用于通知所有人（广播）
loginInfo := fmt.Sprintf("[%s][%s] ===> |上线了login！！",newUser.id,newUser.name)
message <- loginInfo
buf := make([]byte,1024)
// 读取客户端发送来的数据
cnt,err := conn.Read(buf)
if err != nil
fmt.Println("listener.Read err:",err)
return
fmt.Println("客户端接收客户端发来的数据为：",string(buf[:cnt-1]),",cnt:",cnt)
// 向所有的用户广播消息，启动一个全局唯一的go程
func broadcast()
fmt.Println("广播go程启动成功...")
defer fmt.Println("broadcast 程序退出！")
for
// 1. 从message中读取数据
fmt.Println("broadcast监听message中...")
info := <-message
// 2. 将数据写入到每一个用户的msg管道中
for _,user := range allUsers
// 如果msg是非缓冲，那么会在这里阻塞
user.msg <- info
4.user监听通道go程
每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端
// 每个用户应该还有一个用来监听msg管道的go程，负责将数据返回给客户端
func writeBackToClient(user *User,conn net.Conn)
fmt.Printf("user:%s 的go程正在监听自己的msg管道：\\n",user.name)
for data := range user.msg
fmt.Printf("user:%s 写回给客户端的数据为：%s\\n",user.name,data)
// Write(b []byte)(n int,err error)
_,_ = conn.Write([]byte(data))
当前代码整体为
package main
import (
"fmt"
"net"
)
type User struct
// 名字
name string
// 唯一 的 id
id string
// 管道
msg chan string
// 创建一个全局的map结构，用于保存所有的用户
var allUsers = make(map[string]User)
// 定义一个message全局通道，用于接收任何人发送过来消息
var message = make(chan string,10)
func main()
// 创建服务器
listener,err := net.Listen("tcp",":8087")
if err != nil
fmt.Println("net.Listen err:",err)
return
// 启动全局唯一的go程，负责监听message通道，写给所有的用户
go broadcast()
fmt.Println("服务器启动成功，监听中...")
for
fmt.Println("==>主go程监听中......")
// 监听
conn,err := listener.Accept()
if err != nil
fmt.Println("listener.Accept err:",err)
return
// 建立连接
fmt.Println("建立连接成功！")
// 启动处理业务的go程
go handler(conn)
// 处理具体业务
func handler(conn net.Conn)
fmt.Println("启动业务...")
// 客户端与服务器建立连接的时候，公有ip和port --> 当成user的id
clientAddr := conn.RemoteAddr().String()
fmt.Println("clientAddr:",clientAddr)
// 创建user
newUser := User
id:clientAddr,// id 我们不会修改，这个作为map中的key
name:clientAddr,// 可以修改，会提供rename命令修改，建立连接时，初始值与id相同
msg:make(chan string,10), // 注意需要make空间，否则无法写入数据
// 添加user到map结构
allUsers[newUser.id] = newUser
// 启动go程，负责将msg的信息返回给客户端
go writeBackToClient(&newUser,conn)
// 向message写入数据，当我用户上线的消息，用于通知所有人（广播）
loginInfo := fmt.Sprintf("[%s][%s] ===> |上线了login！！",newUser.id,newUser.name)
message <- loginInfo
for
// 具体业务逻辑
buf := make([]byte,1024)
// 读取客户端发送来的数据
cnt,err := conn.Read(buf)
if err != nil
fmt.Println("listener.Read err:",err)
return
fmt.Println("客户端接收客户端发来的数据为：",string(buf[:cnt-1]),",cnt:",cnt)
// 向所有的用户广播消息，启动一个全局唯一的go程
func broadcast()
fmt.Println("广播go程启动成功...")
defer fmt.Println("broadcast 程序退出！")
for
// 1. 从message中读取数据
fmt.Println("broadcast监听message中...")
info := <-message
// 2. 将数据写入到每一个用户的msg管道中
for _,user := range allUsers
// 如果msg是非缓冲，那么会在这里阻塞
user.msg <- info
// 每个用户应该还有一个用来监听msg管道的go程，负责将数据返回给客户端
func writeBackToClient(user *User,conn net.Conn)
fmt.Printf("user:%s 的go程正在监听自己的msg管道：\\n",user.name)
for data := range user.msg
fmt.Printf("user:%s 写回给客户端的数据为：%s\\n",user.name,data)
// Write(b []byte)(n int,err error)
_,_ = conn.Write([]byte(data))
三、增加功能
- 查询用户
查询命令：who==>将当前所有的登录的用户，展示出来，id，name，返回给当前用户
package main
import (
"fmt"
"net"
"strings"
)
type User struct
// 名字
name string
// 唯一 的 id
id string
// 管道
msg chan string
// 创建一个全局的map结构，用于保存所有的用户
var allUsers = make(map[string]User)
// 定义一个message全局通道，用于接收任何人发送过来消息
var message = make(chan string,10)
func main()
// 创建服务器
listener,err := net.Listen("tcp",":8087")
if err != nil
fmt.Println("net.Listen err:",err)
return
// 启动全局唯一的go程，负责监听message通道，写给所有的用户
go broadcast()
fmt.Println("服务器启动成功，监听中...")
for
fmt.Println("==>主go程监听中......")
// 监听
conn,err := listener.Accept()
if err != nil
fmt.Println("listener.Accept err:",err)
return
// 建立连接
fmt.Println("建立连接成功！")
// 启动处理业务的go程
go handler(conn)
// 处理具体业务
func handler(conn net.Conn)
fmt.Println("启动业务...")
// 客户端与服务器建立连接的时候，公有ip和port --> 当成user的id
clientAddr := conn.RemoteAddr().String()
fmt.Println("clientAddr:",clientAddr)
// 创建user
newUser := User
id:clientAddr,// id 我们不会修改，这个作为map中的key
name:clientAddr,// 可以修改，会提供rename命令修改，建立连接时，初始值与id相同
msg:make(chan string,10), // 注意需要make空间，否则无法写入数据
// 添加user到map结构
allUsers[newUser.id] = newUser
// 启动go程，负责将msg的信息返回给客户端
go writeBackToClient(&newUser,conn)
// 向message写入数据，当我用户上线的消息，用于通知所有人（广播）
loginInfo := fmt.Sprintf("[%s][%s] ===> |上线了login！！",newUser.id,newUser.name)
message <- loginInfo
for
// 具体业务逻辑
buf := make([]byte,1024)
// 读取客户端发送来的数据
cnt,err := conn.Read(buf)
if err != nil
fmt.Println("listener.Read err:",err)
return
fmt.Println("客户端接收客户端发来的数据为：",string(buf[:cnt-1]),",cnt:",cnt)
// -------------业务逻辑处理 开始-------------
// 1.查询当前所有的用户 who
// a. 先判断接收的数据是不是who ==》 长度&&字符串
userInput := string(buf[:cnt-1]) // 这是用户输入的数据，最后一个是回车，我们去掉他
if len(userInput) == 3 && userInput == "who"
// b.遍历allUser这个map（key：userid value：user 本身）。将id和name拼接成一个字符，返回给客户端
fmt.Println("用户即将查询所有用户信息!")
// 这个切片包含所有的用户信息
var userInfos []string
for _,user := range allUsers
userInfo := fmt.Sprintf("userid:%s,username:%s",user.id,user.name)
userInfos = append(userInfos,userInfo)
// 最终写入到通道中，一定是一个字符串
r := strings.Join(userInfos,"\\n")
// 将数据返回到客户端
newUser.msg <- r
else
// 如果不是用户输入的命令，只是聊天信息，那么只需要写到广播中即可，由其他的go程常规转发
message <- userInput
// -------------业务逻辑处理 结束-------------
// 向所有的用户广播消息，启动一个全局唯一的go程
func broadcast()
fmt.Println("广播go程启动成功...")
defer fmt.Println("broadcast 程序退出！")
for
// 1. 从message中读取数据
fmt.Println("broadcast监听message中...")
info := <-message
// 2. 将数据写入到每一个用户的msg管道中
for _,user := range allUsers
// 如果msg是非缓冲，那么会在这里阻塞
user.msg <- info
// 每个用户应该还有一个用来监听msg管道的go程，负责将数据返回给客户端
func writeBackToClient(user *User,conn net.Conn)
fmt.Printf("user:%s 的go程正在监听自己的msg管道：\\n",user.name)
for data := range user.msg
fmt.Printf("user:%s 写回给客户端的数据为：%s\\n",user.name,data)
// Write(b []byte)(n int,err error)
_,_ = conn.以上是关于Golang网络聊天室案例的主要内容，如果未能解决你的问题，请参考以下文章