使用golang基础net包构建一个并发聊天室

这里我们运用golang的基础net包构建一个聊天室
这个聊天室，我们做这几个模块

模块简述：

首先是服务器作为主协程，负责监听、接收用户（客户端）连接请求 ， 建立通信关系，同时启动相应的协程处理任务。
其次，我们针对每个用户都使用一个连接协程（HandleConnect ) 来负责 新上线用户的存储，用户消息读取、发送，用户改名、下线处理及超时处理，为了提高并发效率，同时给一个用户维护多个协程来并行处理。
第三，我们构建一个全局的协程Manager来负责在线用户的遍历，用户消息广播发送，需要与HandleConnect协程及用户子协程协作完成。
第四，协程间的应用数据和通信: map:存储所有登录聊天室的用户信息，key：用户的ip+port 。Value: Client 结构体
Client结构体：包含成员 ：用户名Name，网络地址Addr（ip+port），发送消息的通道C（channel）
通道message：协调并发写成间消息的传递。

了解了基本模块，我们接下来就分别按照每个模块的构成来

广播用户上线的构建步骤如下：

1. 主go程中，创建监听套接字，记得defer
2. for循环监听客户端连接请求，Accept（）
3. 有一个客户端连接，创建新go程处理客户端数据HandleConnet(conn) defer conn.Close()
4. 定义全局结构类型 C、Name 、Addr
5. 创建全局map[addr]Client，将地址和客户连接起来；还有全局message通道
6. 实现HandlerConnet,获取客户端Ip+port — RemoteAddr(),初始化新用户结构体信息。Name = Addr
7. 创建manager 管理go程 ----- 在 Accept（）之前
8. 实现manager， 初始化在线用户的map，循环读取全局message( channel )，如果无数据则阻塞，如果有数据，则遍历在线用户并将数据写道用户的C（专属channel）中
9. 将新用户添加到 在线用户map中， key = IP+port value = 新用户结构体
10. 创建WriteMsgToClient go程，专门给当前用户写数据 ---- 来源于用户自带的C中
11. 实现WriteMsgToClient（clnt，conn）。遍历自带的C，读数据，conn.Write到客户端
12. HandleConnet中，结束位置，发送用户上线信息，发送用户上线信息，至全局channel中 ---- Manager 的读就被激活（原先读数据一直在阻塞）
13. 在HandleConnet中，结尾加for{;}

广播用户消息:

1. 封装函数 MakeMsg（）来处理广播、用户消息
2. HandlerConnet中，创建匿名go程，读取用户socket上发送的聊天内容。写到全局channel
3. for 循环 conn.Read 记得检查 n==0 err!=nil
4. 写给全局message — 后续的事，原来广播用户上线模块完成 （Manager、WriteMsgToClient）

查询在线用户 ：

1. 将读取到的用户消息msg结尾的“\n”去掉，用buf[:n-1]
2. 判断是否为“who”命令
3. 如果要是，则遍历在线用户列表，组织显示用户信息，写到socket中
4. 如果不是，写给全局meseage

修改用户名：

1. 将读取到的用户信息msg判断是否包含“rename|”
2. 提取“|”后面的字符串，存入Client 的Name成员中
3. 更新在线用户列表。onlineMap key – Ip+port
4. 提示用户更新完成了， conn.Write

用户退出：

1. 在用户登陆之后，创建一个监听 用户退出的channel（isQuit ：= make(chan bool)）
2. 当conn.Read == 0时，isQuit<- true
3. 在HandlerConnet 结尾的for中，添加select监听 <-isQuit
4. 条件满足，将用户从在线列表移除，组织用户下线消息

超时强踢：

1. 在select中监听定时器，（time.After()）计时到达，将用户从在线列表中移除，组织用户下线消息，写入message
2. 创建监听 用户活跃的channel - hasData
3. 只要用户执行：聊天、改名、who任意一个操作，hasData <- true
4. 在select当中添加监听

package main

import (
	"fmt"
	"net"
	"strings"
	"time"
)
//创建用户结构体类型！
type Client struct {
	C chan string
	Name string
	Addr string
}


//创建全局map,连接地址和客户
var onlineMap map[string]Client

//创建全局 channel 传递用户信息
var message =make(chan string)

func WriteMsgToClient(clientNet Client,conn net.Conn){
	for msg:=range clientNet.C  {
		conn.Write([]byte(msg+"\n"))
	}
}

func MakeMsg(clientNet  Client,msg string) string{
	buf:= "[" +clientNet.Addr+ "]"+ clientNet.Name +"发送 : "+ msg
	return buf
}

func handleConnect(conn net.Conn) {
	defer conn.Close()
	
	hasData:=make(chan bool)  //用于更新select中的计时器
	//获取用户网络地址  ： ip+port
	clNet := conn.RemoteAddr().String()
	//创建新连接用户的结构体
	clientNet := Client{make(chan string),clNet,clNet}

	//将新连接的用户，添加到在线用户map中，key = IP+port    value:client
	onlineMap[clNet] = clientNet

	//创建专门用来给当前用户发送信息的go程序  writeMsgToClient
	go WriteMsgToClient(clientNet,conn)

	//发送 用户上线 消息到 全局 channel中
	message <- "[" +clNet+ "]"+ clientNet.Name +"login"

	//创建一个channel ，用来判断用户推出状态
	isQuit:= make(chan bool)


	//创建一个匿名go程，专门处理用户发送的消息
	go func(){
		buf:= make([]byte,4096)
		for{
			n,err:= conn.Read(buf)
			if n==0{
				isQuit <- true
				fmt.Println("检测到客户端:%s 退出",clientNet.Name)    //channel读端为0
				return
			}
			if err!=nil{
				fmt.Println("conn.Read err:",err)
				return
			}

			//将读到的用户消息保存到msg中 ，一次最多读取到4096字节的数据
			msg := string(buf[:n-1])

			//提取在线用户的列表
			if msg == "who" &&len(msg) ==3{
				conn.Write([]byte("online user list:\n"))
				//遍历当前map ，获取在线用户
				for  _,user:= range onlineMap{
					userInfo := user.Addr  +" : "+user.Name + "\n"
					conn.Write([]byte(userInfo))
				}
				//判断用户发送了改名  命令
			}else if len(msg) >= 8 && msg[:6]=="rename"{        //rename| xxx
				newName := strings.Split(msg,"|")[1]     //msg[8:]
				clientNet.Name = newName      //修改结构体成员name
				onlineMap[clientNet.Addr] = clientNet      //更新onlineMap
				conn.Write([]byte("rename successful\n"))
			} else {
				//将读到的用户消息广播给所有的在线用户
				message <- MakeMsg(clientNet,msg)
			}
			hasData <- true

		}
	}()
	//保证 不退出
	for{
		//select用来监听channel上的数据流动
		select {
			case <-isQuit:
				delete(onlineMap,clientNet.Addr)     //将用户从online移除
				message <- MakeMsg(clientNet,"log Out")    //写入用户退出消息到全局message
				return
			case <-hasData:
			//用于更新下面case的计数器
			case <-time.After(time.Second*60):
				delete(onlineMap,clientNet.Addr)      // 将用户从online中移除
				message <- MakeMsg(clientNet,"log Out")
				return 
		}
	}
}

func Manage() {
	//初始化map
	onlineMap = make(map[string]Client)

	//这里的for是循环从message中读取
	for{
		//循环监听massage通道 ,有数据存储至msg，无数据阻塞
		msg:= <- message

		//循环发送消息给所有的在线用户
		for _,clnt := range onlineMap{
			clnt.C <-msg

		}
	}
}

func main(){
	//创建监听的套接字
	listener,err := net.Listen("tcp","127.0.0.1:8000")
	if err!=nil{
		fmt.Println("net.Listen error :",err)
		return
	}
	defer listener.Close()

	//在用户产生之前创建管理者go程,管理map和全局massage channel
	go Manage()

	//循环监听客户端链接请求
	for {
		conn,err :=listener.Accept()
		if err!=nil{
			fmt.Println("Accept error",err)
			return
		}
		//启动go程序处理客户端的数据请求
		go handleConnect(conn)
	}
}