Golang网络聊天室案例
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
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==>将当前所有的登录的用户展示出来idname返回给当前用户
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这个mapkeyuserid valueuser 本身。将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.Write([]byte(data))
}
}
-
重命名
规则rename|Duke
获取数据判断长度7判断字符是rename
使用|进行分割获取|后面的部分作为名字
更新用户名字newUser.name = Duke
通知客户端更新成功 -
主动退出
每个用户都有自己的watch go程仅负责监听退出信号
// 启动一个go程负责监听退出信号触发后进行清零工作delete map,close conn 都在这里处理
func watch(user *User,conn net.Conn,isQuit <-chan bool){
fmt.Println("启动监听信号退出的go程...")
defer fmt.Println("watch go程退出")
for{
select{
case <-isQuit:
logoutInfo := fmt.Sprintf("%s exit already!",user.name)
fmt.Println("删除当前用户",user.name)
delete(allUsers,user.id)
message<-logoutInfo
conn.Close()
return
}
}
}
在handler中启动go watch同时传入相应信息
// 定义一个退出信号用来监听client退出
var isQuit = make(chan bool)
// 启动go程负责监听退出信号
go watch(&newUser,conn,isQuit)
在read之后通过cnt判断用户退出向isQuit写入信号
测试截图
- 超时退出
使用定时器来进行超时管理
如果60s没有发送任何数据那么直接将这个链接关闭
<-time.After(60*time.second)
更新watch函数
// 启动一个go程负责监听退出信号触发后进行清零工作delete map,close conn 都在这里处理
func watch(user *User,conn net.Conn,isQuit,restTimer <-chan bool){
fmt.Println("启动监听信号退出的go程...")
defer fmt.Println("watch go程退出")
for{
select{
case <-isQuit:
logoutInfo := fmt.Sprintf("%s exit already!\n",user.name)
fmt.Println("删除当前用户",user.name)
delete(allUsers,user.id)
message<-logoutInfo
conn.Close()
return
case <-time.After(10*time.Second):
logoutInfo := fmt.Sprintf("%s timeout exit elready!\n",user.name)
fmt.Println("删除当前用户",user.name)
delete(allUsers,user.id)
message<-logoutInfo
conn.Close()
return
case <-restTimer:
fmt.Printf("连接%s 重置计数器\n",user.name)
}
}
}
创建并传入restTimer管道
效果
最终代码
package main
import (
"fmt"
"net"
"strings"
"time"
)
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
// 定义一个退出信号用来监听client退出
var isQuit = make(chan bool)
// 创建一个用于重置计数器的管道用于告知watch函数当前用户正在输入
var restTimer = make(chan bool)
// 启动go程负责监听退出信号
go watch(&newUser,conn,isQuit,restTimer)
// 启动go程负责将msg的信息返回给客户端
go writeBackToClient(&newUser,conn)
// 向message写入数据当我用户上线的消息用于通知所有人广播
loginInfo := fmt.Sprintf("[%s][%s] ===> |上线了login\n",newUser.id,newUser.name)
message <- loginInfo
for{
// 具体业务逻辑
buf := make([]byte,1024)
// 读取客户端发送来的数据
cnt,err := conn.Read(buf)
if cnt == 0 {
fmt.Println("客户端主动关闭ctrl+c,准备退出")
// map 删除用户 conn close掉
// 服务器还可以主动的退出
// 在这里不进行真正的退出动作而是发出一个退出信号统一做退出处理可以使用新的管道来做信号传递
isQuit <- true
}
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这个mapkeyuserid valueuser 本身。将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 if len(userInput) > 8 && userInput[:6] == "rename"{
// 规则rename|Duke
// 获取数据判断长度7判断字符是rename
// 使用|进行分割获取|后面的部分作为名字
// 更新用户名字newUser.name = Duke
newUser.name = strings.Split(userInput,"|")[1]
allUsers[newUser.id] = newUser // 更新map中的user
// 通知客户端更新成功
message <- userInput
}else{
// 如果不是用户输入的命令只是聊天信息那么只需要写到广播中即可由其他的go程常规转发
message <- userInput
}
restTimer <- true
// -------------业务逻辑处理 结束-------------
}
}
// 向所有的用户广播消息启动一个全局唯一的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))
}
}
// 启动一个go程负责监听退出信号触发后进行清零工作delete map,close conn 都在这里处理
func watch(user *User,conn net.Conn,isQuit,restTimer <-chan bool){
fmt.Println("启动监听信号退出的go程...")
defer fmt.Println("watch go程退出")
for{
select{
case <-isQuit:
logoutInfo := fmt.Sprintf("%s exit already!\n",user.name)
fmt.Println("删除当前用户",user.name)
delete(allUsers,user.id)
message<-logoutInfo
conn.Close()
return
case <-time.After(10*time.Second):
logoutInfo := fmt.Sprintf("%s timeout exit elready!\n",user.name)
fmt.Println("删除当前用户",user.name)
delete(allUsers,user.id)
message<-logoutInfo
conn.Close()
return
case <-restTimer:
fmt.Printf("连接%s 重置计数器\n",user.name)
}
}
}
这里还有问题就是上锁问题。记得在操作map的时候加上读锁和写锁
案例
package main
import(
"fmt"
"sync"
"time"
)
var idnames = make(map[int]string)
var lock sync.RwMutex
// map不允许同事读写如果有不同go程同时操作map需要对map上锁
func main(){
go func(){
for{
lock.lock()
idnames[0] = "duke"
lock.Unlock()
}
}()
go func(){
for{
lock.Lock()
name := idnames[0]
fmt.Println("name:",name)
lock.Unlock()
}
}()
for{
fmt.Println("OVER")
time.Sleep(1*time.Second)
}
}
感谢大家观看我们下次见