Go语言多人聊天室项目实战

本文为大家分享了go语言多人聊天室项目实战，供大家参考，具体内容如下

功能需求

• 实现单撩
• 实现群撩
• 实现用户上线的全网通知
• 实现用户昵称
• 实现聊天日志的存储和查看
  

服务端实现

type client struct {
 conn net.conn
 name string
 addr string
}

var (
 //客户端信息,用昵称为键
 //clientsmap = make(map[string]net.conn)
 clientsmap = make(map[string]client)
)

func shandleerror(err error, why string) {
 if err != nil {
 fmt.println(why, err)
 os.exit(1)
 }
}

func main() {

 //建立服务端监听
 listener, e := net.listen("tcp", "127.0.0.1:8888")
 shandleerror(e, "net.listen")
 defer func() {
 for _, client := range clientsmap {
 client.conn.write([]byte("all:服务器进入维护状态，大家都洗洗睡吧！"))
 }
 listener.close()
 }()

 for {
 //循环接入所有女朋友
 conn, e := listener.accept()
 shandleerror(e, "listener.accept")
 clientaddr := conn.remoteaddr()

 //todo:接收并保存昵称
 buffer := make([]byte, 1024)
 var clientname string
 for {
 n, err := conn.read(buffer)
 shandleerror(err, "conn.read(buffer)")
 if n > 0 {
 clientname = string(buffer[:n])
 break
 }
 }
 fmt.println(clientname + "上线了")

 //todo:将每一个女朋友丢入map
 client := client{conn, clientname, clientaddr.string()}
 clientsmap[clientname] = client

 //todo:给已经在线的用户发送上线通知——使用昵称
 for _, client := range clientsmap {
 client.conn.write([]byte(clientname + "上线了"))
 }

 //在单独的协程中与每一个具体的女朋友聊天
 go iowithclient(client)
 }

 //设置优雅退出逻辑

}

//与一个client做io
func iowithclient(client client) {
 //clientaddr := conn.remoteaddr().string()
 buffer := make([]byte, 1024)

 for {
 n, err := client.conn.read(buffer)
 if err != io.eof {
 shandleerror(err, "conn.read")
 }

 if n > 0 {
 msg := string(buffer[:n])
 fmt.printf("%s:%s\n", client.name, msg)

 //将客户端说的每一句话记录在【以他的名字命名的文件里】
 writemsgtolog(msg, client)

 strs := strings.split(msg, "#")
 if len(strs) > 1 {
 //all#hello
 //zqd#hello

 //要发送的目标昵称
 targetname := strs[0]
 targetmsg := strs[1]

 //todo:使用昵称定位目标客户端的conn
 if targetname == "all" {
  //群发消息
  for _, c := range clientsmap {
  c.conn.write([]byte(client.name + ":" + targetmsg))
  }
 } else {
  //点对点消息
  for key, c := range clientsmap {
  if key == targetname {
  c.conn.write([]byte(client.name + ":" + targetmsg))

  //在点对点消息的目标端也记录日志
  go writemsgtolog(client.name + ":" + targetmsg,c)
  break
  }
  }
 }

 } else {

 //客户端主动下线
 if msg == "exit" {
  //将当前客户端从在线用户中除名
  //向其他用户发送下线通知
  for name, c := range clientsmap {
  if c == client {
  delete(clientsmap, name)
  } else {
  c.conn.write([]byte(name + "下线了"))
  }
  }
 }else if strings.index(msg,"log@")==0 {
  //log@all
  //log@张全蛋
  filtername := strings.split(msg, "@")[1]
  //向客户端发送它的聊天日志
  go sendlog2client(client,filtername)
 } else {
  client.conn.write([]byte("已阅：" + msg))
 }

 }

 }
 }

}

//向客户端发送它的聊天日志
func sendlog2client(client client,filtername string) {
 //读取聊天日志
 logbytes, e := ioutil.readfile("d:/bjblockchain1801/demos/w4/day1/01chatroomii/logs/" + client.name + ".log")
 shandleerror(e,"ioutil.readfile")

 if filtername != "all"{
 //查找与某个人的聊天记录
 //从内容中筛选出带有【filtername#或filtername:】的行，拼接起来
 logstr := string(logbytes)
 targetstr := ""
 lineslice := strings.split(logstr, "\n")
 for _,linestr := range lineslice{
 if len(linestr)>20{
 contentstr := linestr[20:]
 if strings.index(contentstr,filtername+"#")==0 || strings.index(contentstr,filtername+":")==0{
  targetstr += linestr+"\n"
 }
 }
 }
 client.conn.write([]byte(targetstr))
 }else{
 //查询所有的聊天记录
 //向客户端发送
 client.conn.write(logbytes)
 }

}

//将客户端说的一句话记录在【以他的名字命名的文件里】
func writemsgtolog(msg string, client client) {
 //打开文件
 file, e := os.openfile(
 "d:/bjblockchain1801/demos/w4/day1/01chatroomii/logs/"+client.name+".log",
 os.o_create|os.o_wronly|os.o_append,
 0644)
 shandleerror(e, "os.openfile")
 defer file.close()

 //追加这句话
 logmsg := fmt.sprintln(time.now().format("2006-01-02 15:04:05"), msg)
 file.write([]byte(logmsg))
}

客户端实现

import (
 "net"
 "fmt"
 "os"
 "bufio"
 "io"
 "flag"
)

var (
 chanquit = make(chan bool, 0)
 conn  net.conn
)

func chandleerror(err error, why string) {
 if err != nil {
 fmt.println(why, err)

 os.exit(1)
 }
}

func main() {

 //todo:在命令行参数中携带昵称
 nameinfo := [3]interface{}{"name", "无名氏", "昵称"}
 retvaluesmap := getcmdlineargs(nameinfo)
 name := retvaluesmap["name"].(string)

 //拨号连接，获得connection
 var e error
 conn, e = net.dial("tcp", "127.0.0.1:8888")
 chandleerror(e, "net.dial")
 defer func() {
 conn.close()
 }()

 //在一条独立的协程中输入，并发送消息
 go handlesend(conn,name)

 //在一条独立的协程中接收服务端消息
 go handlereceive(conn)

 //设置优雅退出逻辑
 <-chanquit

}

func handlereceive(conn net.conn) {
 buffer := make([]byte, 1024)
 for {
 n, err := conn.read(buffer)
 if err != io.eof {
 chandleerror(err, "conn.read")
 }

 if n > 0 {
 msg := string(buffer[:n])
 fmt.println(msg)
 }
 }

}

func handlesend(conn net.conn,name string) {
 //todo:发送昵称到服务端
 _, err := conn.write([]byte(name))
 chandleerror(err,"conn.write([]byte(name))")

 reader := bufio.newreader(os.stdin)
 for {
 //读取标准输入
 linebytes, _, _ := reader.readline()

 //发送到服务端
 _, err := conn.write(linebytes)
 chandleerror(err, "conn.write")

 //正常退出
 if string(linebytes) == "exit" {
 os.exit(0)
 }

 }
}

func getcmdlineargs(arginfos ...[3]interface{}) (retvaluesmap map[string]interface{}) {

 fmt.printf("type=%t,value=%v\n", arginfos, arginfos)

 //初始化返回结果
 retvaluesmap = map[string]interface{}{}

 //预定义【用户可能输入的各种类型的指针】
 var strvalueptr *string
 var intvalueptr *int

 //预定义【用户可能输入的各种类型的指针】的容器
 //用户可能输入好几个string型的参数值，存放在好几个string型的指针中，将这些同种类型的指针放在同种类型的map中
 //例如：flag.parse()了以后，可以根据【strvalueptrsmap["cmd"]】拿到【存放"cmd"值的指针】
 var strvalueptrsmap = map[string]*string{}
 var intvalueptrsmap = map[string]*int{}

 /* var floatvalueptr *float32
 var floatvalueptrsmap []*float32
 var boolvalueptr *bool
 var boolvalueptrsmap []*bool*/

 //遍历用户需要接受的所有命令定义
 for _, argarray := range arginfos {

 /*
 先把每个命令的名称和用法拿出来,
 这俩货都是string类型的，所有都可以通过argarray[i].(string)轻松愉快地获得其字符串
 一个叫“cmd”，一个叫“你想干嘛”
 "cmd"一会会用作map的key
 */
 //[3]interface{}
 //["cmd" "未知类型" "你想干嘛"]
 //["gid"  0  "要查询的商品id"]
 //上面的破玩意类型[string 可能是任意类型 string]
 namevalue := argarray[0].(string) //拿到第一个元素的string值,是命令的name
 usagevalue := argarray[2].(string) //拿到最后一个元素的string值，是命令的usage

 //判断argarray[1]的具体类型
 switch argarray[1].(type) {
 case string:
 //得到【存放cmd的指针】，cmd的值将在flag.parse()以后才会有
 //cmdvalueptr = flag.string("cmd", argarray[1].(string), "你想干嘛")
 strvalueptr = flag.string(namevalue, argarray[1].(string), usagevalue)

 //将这个破指针以"cmd"为键，存在【专门放置string型指针的map，即strvalueptrsmap】中
 strvalueptrsmap[namevalue] = strvalueptr

 case int:
 //得到【存放gid的指针】，gid的值将在flag.parse()以后才会有
 //gidvalueptr = flag.string("gid", argarray[1].(int), "商品id")
 intvalueptr = flag.int(namevalue, argarray[1].(int), usagevalue)

 //将这个破指针以"gid"为键，存在【专门放置int型指针的map，即intvalueptrsmap】中
 intvalueptrsmap[namevalue] = intvalueptr
 }

 }

 /*
 程序运行到这里，所有不同类型的【存值指针】都放在对相应类型的map中了
 flag.parse()了以后，可以从map中以参数名字获取出【存值指针】，进而获得【用户输入的值】
 */

 //用户输入完了，解析，【用户输入的值】全都放在对应的【存值指针】中
 flag.parse()

 /*
 遍历各种可能类型的【存值指针的map】
 */
 if len(strvalueptrsmap) > 0 {
 //从【cmd存值指针的map】中拿取cmd的值，还以cmd为键存入结果map中
 for k, vptr := range strvalueptrsmap {
 retvaluesmap[k] = *vptr
 }
 }
 if len(intvalueptrsmap) > 0 {
 //从【gid存值指针的map】中拿取gid的值，还以gid为键存入结果map中
 for k, vptr := range intvalueptrsmap {
 retvaluesmap[k] = *vptr
 }
 }

 //返回结果map
 return
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。