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.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这个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 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)
}
}
感谢大家观看，我们下次见
