• [go学习笔记.第十六章.TCP编程] 2.项目-海量用户即时通讯系统

    一.项目介绍

    1.项目开发流程

    需求分析->设计阶段->编码实现->测试阶段->实施阶段

    2.需求分析 

    (1).用户注册

    (2).用户登录

    (3).显示在线用户列表

    (4).群聊(广播)

    (5).点对点聊天

    (6).离线留言

    3.示意图

     4.项目开发前技术准备 

    项目要保存用户信息和消息数据,因此需要数据库(mysql或者redis),这里使用redis进行数据的保存

    二.项目开发 

    1.实现功能:显示客户端登录菜单

    功能:

            能够正确地显示客户端的菜单

    界面如下:

     代码如下:

      client/login.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5. )
    6.  
    7. //写一个函数, 完成登录
    8. func login(userId int, userPwd string) (err error) {
    9.     //下一步 开始定协议
    10.     fmt.Printf("userId = %d， userPwd = %s \n", userId, userPwd)
    11.     return
    12. }

    client/main.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "os"
    6. )
    7.  
    8. //定义两个全局变量,一个用户id,一个用户密码
    9. var userId int
    10. var userPwd string
    11.  
    12. func main()  {
    13.     //接收用户的选择
    14.     var key int
    15.     //判断是否还继续显示菜单
    16.     var loop = true
    17.  
    18.     for loop {
    19.         fmt.Println("-------------------欢迎登录多人聊天系统-------------------")
    20.         fmt.Println("\t\t\t\t 1 登录聊天室")
    21.         fmt.Println("\t\t\t\t 2 注册用户")
    22.         fmt.Println("\t\t\t\t 3 退出系统")
    23.         fmt.Println("\t\t\t\t 请选择(1~3):")
    24.         fmt.Scanf("%d\n", &key)
    25.         switch key {
    26.             case 1 : 
    27.                 fmt.Println("登录聊天室")
    28.                 loop = false
    29.             case 2 : 
    30.                 fmt.Println("注册用户")
    31.                 loop = false
    32.             case 3 :  
    33.                 fmt.Println("退出系统")
    34.                 os.Exit(0)
    35.             default:
    36.                 fmt.Println("输入有误,请重新输入")
    37.         }
    38.     }
    39.  
    40.     //根据用户的输入,显示新的提示信息
    41.     if key == 1 {
    42.         //说明用户要登录
    43.         fmt.Println("请输入用户的id:")
    44.         fmt.Scanf("%d\n", &userId)
    45.         fmt.Println("请输入用户的密码:")
    46.         fmt.Scanf("%s\n", &userPwd)
    47.         //先把登录的函数写到另一个文件,比如:login.go
    48.         err := login(userId, userPwd)
    49.         if err != nil {
    50.             fmt.Println("登录失败")
    51.         } else {
    52.             fmt.Println("登录成功")
    53.         }
    54.     } else if key == 2{
    55.         fmt.Println("注册")
    56.     }
    57. }

    2.实现功能:完成用户登录

    要求: 

            先完成指定用户的验证，用户 id = 100 ，密码 pw =123456 可以登录，其它用户不能登录, 这里需要先说明一个 Message的组成（示意图），并发送一个 Message 的流程

    1).完成客户端可以发送消息长度，服务器端可以正常收到该长度值

    分析思路

    (1).先确定消息 Message 的格式和结构

    (2).根据上图的分析完成代码

    (3).示意图如下

     server/main.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6. )
    7.  
    8. //处理和客户端通讯
    9. func process(conn net.Conn)  {
    10.     //这里需要延时关闭
    11.     defer conn.Close()
    12.  
    13.     //读取客户端发送的消息    
    14.     for {
    15.         buf := make([]byte, 8096)
    16.         fmt.Println("读取客户端发送的数据...") 
    17.         n, err := conn.Read(buf[:4])
    18.         if err != nil || n != 4 {
    19.             fmt.Printf(" conn read err = %v\n", err)
    20.             return
    21.         }
    22.         fmt.Printf("读到的buf= %v\n", buf[:4])
    23.     }
    24. }
    25.  
    26. func main()  {
    27.     //提示信息
    28.     fmt.Println("服务器正在监听8889端口...")
    29.     listen, err := net.Listen("tcp", "127.0.0.1:8889")
    30.     //这里需要延时关闭
    31.     defer listen.Close()
    32.  
    33.     if err != nil {
    34.         fmt.Printf("net listen err = %v\n", err)
    35.         return
    36.     }
    37.     //一旦监听成功,就等待客户端来连接服务器
    38.     for {
    39.         fmt.Println("等待客户端来连接服务器...")
    40.         conn, err := listen.Accept()
    41.         if err != nil {
    42.             fmt.Printf("listen accept err = %v\n", err)
    43.             return
    44.         }
    45.         //一旦连接成功,则启动一个协程,保持和客户端通讯
    46.         go process(conn)
    47.     }
    48. }

     common/message/message.go

    1. package message
    2.  
    3. //定义消息类型
    4. const (
    5.     LoginMesType = "LoginMes"
    6.     LoginResMesType = "LoginResMes"
    7. )
    8.  
    9. type Message struct {
    10.     Type string `json:"type"` // 消息类型
    11.     Data string `json:"data"` //消息内容
    12. }
    13.  
    14. //定义需要的消息
    15.  
    16. type LoginMes struct {
    17.     UserId int `json:"userId"`//用户id
    18.     UserPwd string `json:"userPwd"` //用户密码
    19.     UserName string `json:"userName"` //用户名
    20. }
    21.  
    22. type LoginResMes struct {
    23.     Code int `json:"code"` //返回状态码: 200 登录成功, 500 用户未注册
    24.     Error string `json:"error"` //返回错误信息
    25. }

    client/main.go 和前面代码一样,没有发生修改

    clent/login.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "encoding/binary"
    7.     "encoding/json"
    8.     "go_code/chatroom/common/message"
    9. )
    10.  
    11. //写一个函数, 完成登录
    12. func login(userId int, userPwd string) (err error) {
    13.     // //下一步 开始定协议
    14.     // fmt.Printf("userId = %d， userPwd = %s \n", userId, userPwd)
    15.     // return
    16.  
    17.     //1.连接到服务器端
    18.     conn, err := net.Dial("tcp", "127.0.0.1:8889")
    19.     if err != nil {
    20.         fmt.Printf("net dial err = %v\n", err)
    21.         return
    22.     }
    23.     //延时关闭
    24.     defer conn.Close()  
    25.     
    26.     //2.准备通过conn发送消息给服务端
    27.     var mes message.Message
    28.     mes.Type = message.LoginMesType
    29.     //3.创建一个LoginMes结构体
    30.     var loginMes message.LoginMes
    31.     loginMes.UserId = userId
    32.     loginMes.UserPwd = userPwd
    33.     //4.将loginMes序列化
    34.     data, err := json.Marshal(loginMes)
    35.     if err != nil {
    36.         fmt.Printf("json marshal err = %v\n", err)
    37.         return
    38.     }
    39.     //5.将序列化后的loginMes byte切片赋给mes.Data
    40.     mes.Data = string(data)
    41.     //6.将mes序列化
    42.     data, err = json.Marshal(mes)
    43.     if err != nil {
    44.         fmt.Printf("json marshal err = %v\n", err)
    45.         return
    46.     }
    47.     //7.这个时候data就是要发送的消息
    48.     //7.1先把data的长度发送给服务器
    49.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    50.     var pkgLen uint32
    51.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    52.     var buf [4]byte
    53.     binary.BigEndian.PutUint32(buf[0:4], pkgLen)
    54.     //发送长度
    55.     n, err := conn.Write(buf[:4])
    56.     if err != nil || n != 4 {
    57.         fmt.Printf(" conn write err = %v\n", err)
    58.         return
    59.     }
    60.  
    61.     fmt.Printf("客户端发送消息长度=%d,内容=%s\n", len(data), string(data)) 
    62.     return
    63. }

    2).完成客户端可以发送消息本身，服务器端可以正常接收到消息，并根据客户端发送的消息(LoginMes)，判断用户的合法性，并返回相应的LoginResMes

    思路分析：

    (1).让客户端发送消息本身

    (2).服务器端接受到消息，然后反序列话化成对应的消息结构体

    (3).服务器端根据反序列化成对应的消意,判断登录用户是合法，返回LoginResMes

    (4).客户端解析返回的LoginResMes ，显示对应界面

    (5).这里需要做函数的封装

    client/login.go做了点修改 

    1.  
    2.     // fmt.Printf("客户端发送消息长度=%d,内容=%s\n", len(data), string(data)) 
    3.     //发送消息本身
    4.     _, err = conn.Write(data)
    5.     if err != nil {
    6.         fmt.Printf(" conn write err = %v\n", err)
    7.         return
    8.     }
    9.  
    10.     //休眠20s
    11.     time.Sleep(20 * time.Second)
    12.     fmt.Println("休眠20s...")
    13.     //处理服务端返回的消息
    14.  
    15.     return
    16. }

    server/main.go做了改动

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "go_code/chatroom/common/message"
    7.     "encoding/binary"
    8.     "encoding/json"
    9.     _"errors"
    10.     "io"
    11. )
    12.  
    13. //处理和客户端通讯
    14. func process(conn net.Conn)  {
    15.     //这里需要延时关闭
    16.     defer conn.Close()
    17.     
    18.     //读取客户端发送的消息    
    19.     for {
    20.         //将读取数据包直接封装成一个函数readPkg(),返回messag,error
    21.         mes, err := readPkg(conn)
    22.         if err != nil {
    23.             if err == io.EOF {
    24.                 fmt.Println("客户端退出了,服务器端也跟着退出")
    25.             } else {
    26.                 fmt.Printf(" readPkg err = %v\n", err)
    27.             }
    28.             
    29.             return
    30.         }
    31.         fmt.Printf("mes= %v\n", mes)
    32.     }
    33. }
    34.  
    35. //读取数据包直接封装成一个函数readPkg()
    36. func readPkg(conn net.Conn) (mes message.Message, err error)  {
    37.     //创建一个切片,用于后续conn.Read()
    38.     buf := make([]byte, 8096)
    39.     fmt.Println("读取客户端发送的数据...") 
    40.     //conn.Read在conn没有被关闭的情况下,才会阻塞
    41.     //如果客户端关闭了conn,则不会阻塞
    42.     _, err = conn.Read(buf[:4])
    43.     if err != nil {
    44.         // err = errors.New("read pkg header error")
    45.         return
    46.     }
    47.     //根据buf[:4]转成一个uint32类型
    48.     var pkgLen uint32
    49.     pkgLen = binary.BigEndian.Uint32(buf[0:4])
    50.     //根据pkgLen读取消息内容
    51.     n, err := conn.Read(buf[:pkgLen])
    52.     if n != int(pkgLen) || err != nil {
    53.         // err = errors.New("read pkg body error")
    54.         return
    55.     }
    56.     //把pkgLen反序列化成message.Message
    57.     err = json.Unmarshal(buf[:pkgLen], &mes)
    58.     if err != nil {
    59.         // err = errors.New("read pkg json.Unmarshal error")
    60.         return
    61.     }
    62.     return
    63. }
    64.  
    65. func main()  {
    66.     //提示信息
    67.     fmt.Println("服务器正在监听8889端口...")
    68.     listen, err := net.Listen("tcp", "127.0.0.1:8889")
    69.     //这里需要延时关闭
    70.     defer listen.Close()
    71.  
    72.     if err != nil {
    73.         fmt.Printf("net listen err = %v\n", err)
    74.         return
    75.     }
    76.     //一旦监听成功,就等待客户端来连接服务器
    77.     for {
    78.         fmt.Println("等待客户端来连接服务器...")
    79.         conn, err := listen.Accept()
    80.         if err != nil {
    81.             fmt.Printf("listen accept err = %v\n", err)
    82.             return
    83.         }
    84.         //一旦连接成功,则启动一个协程,保持和客户端通讯
    85.         go process(conn)
    86.     }
    87. }

    能够完成登录,并提示相应信息 

    server/server.go修改

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "go_code/chatroom/common/message"
    7.     "encoding/binary"
    8.     "encoding/json"
    9.     _"errors"
    10.     "io"
    11. )
    12.  
    13. //处理和客户端通讯
    14. func process(conn net.Conn)  {
    15.     //这里需要延时关闭
    16.     defer conn.Close()
    17.     //读取客户端发送的消息    
    18.     for {
    19.         //将读取数据包直接封装成一个函数readPkg(),返回messag,error
    20.         mes, err := readPkg(conn)
    21.         if err != nil {
    22.             if err == io.EOF {
    23.                 fmt.Println("客户端退出了,服务器端也跟着退出")
    24.             } else {
    25.                 fmt.Printf(" readPkg err = %v\n", err)
    26.             }
    27.             return
    28.         }
    29.         err = serverProcessMes(conn, &mes)
    30.         if err != nil {
    31.             return
    32.         } 
    33.     }
    34. }
    35.  
    36. //编写一个函数serverProcessLogin函数,专门处理登录请求
    37. func serverProcessLogin(conn net.Conn, mes *message.Message) (err error)  {
    38.     //先从mes中取出mes.Data,并直接反序列化成LoginMes
    39.     var loginMes message.LoginMes
    40.     err = json.Unmarshal([]byte(mes.Data), &loginMes)
    41.     if err != nil {
    42.         fmt.Printf("json.Unmarshal fail, err = %v\n", err)
    43.         return
    44.     }
    45.     //1.声明一个resMes
    46.     var resMes message.Message
    47.     resMes.Type = message.LoginResMesType
    48.     //2.再声明一个loginResMes,并完成赋值
    49.     var loginResMes message.LoginResMes
    50.     //如果用户id=100,密码=123456,则合法,不然,则不合法
    51.     if loginMes.UserId == 100 && loginMes.UserPwd == "123456" {
    52.         //合法
    53.         loginResMes.Code = 200
    54.     } else {
    55.         //不合法
    56.         loginResMes.Code = 500  //500 表示不存在
    57.         loginResMes.Error = "该用户不存在,请注册后使用"
    58.     }
    59.     //3.将loginResMes序列化
    60.     data, err := json.Marshal(loginResMes)
    61.     if err != nil {
    62.         fmt.Printf("json.Marshal fail, err = %v\n", err)
    63.         return
    64.     }
    65.     //4.将data赋值给resMes
    66.     resMes.Data = string(data)
    67.     //5.对resMes序列化,准备发送
    68.     data, err = json.Marshal(resMes)
    69.     if err != nil {
    70.         fmt.Printf("json.Marshal fail, err = %v\n", err)
    71.         return
    72.     }
    73.     //6.发送data,将其封装到writePkg函数中
    74.     err = writePkg(conn, data)
    75.     return
    76. }   
    77.  
    78. func writePkg(conn net.Conn, data []byte) (err error)  {
    79.     //先发送一个长度给对方
    80.     //先把data的长度发送给对方
    81.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    82.     var pkgLen uint32
    83.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    84.     var buf [4]byte
    85.     binary.BigEndian.PutUint32(buf[0:4], pkgLen)
    86.     //发送长度
    87.     n, err := conn.Write(buf[:4])
    88.     if err != nil || n != 4 {
    89.         fmt.Printf(" conn write err = %v\n", err)
    90.         return
    91.     }
    92.     //发送data本身
    93.     n, err = conn.Write(data)
    94.     if err != nil || n != int(pkgLen) {
    95.         fmt.Printf(" conn write err = %v\n", err)
    96.     }
    97.     return
    98. }
    99.  
    100. //编写一个ServerProcessMes函数
    101. //功能:根据客户端发送消息类型不同,决定调用哪个函数来处理
    102. func serverProcessMes(conn net.Conn, mes *message.Message) (err error)  {
    103.     switch mes.Type {
    104.         case message.LoginMesType : 
    105.             //处理登录消息
    106.             err = serverProcessLogin(conn, mes)
    107.         case message.RegisterMesType : 
    108.             //处理注册
    109.         default :
    110.             fmt.Println("消息类型不存在, 无法处理...")
    111.     }
    112.     return
    113. }
    114.  
    115. //读取数据包直接封装成一个函数readPkg()
    116. func readPkg(conn net.Conn) (mes message.Message, err error)  {
    117.     //创建一个切片,用于后续conn.Read()
    118.     buf := make([]byte, 8096)
    119.     fmt.Println("读取客户端发送的数据...") 
    120.     //conn.Read在conn没有被关闭的情况下,才会阻塞
    121.     //如果客户端关闭了conn,则不会阻塞
    122.     _, err = conn.Read(buf[:4])
    123.     if err != nil {
    124.         return
    125.     }
    126.     //根据buf[:4]转成一个uint32类型
    127.     var pkgLen uint32
    128.     pkgLen = binary.BigEndian.Uint32(buf[0:4])
    129.     //根据pkgLen读取消息内容
    130.     n, err := conn.Read(buf[:pkgLen])
    131.     if n != int(pkgLen) || err != nil {
    132.         // err = errors.New("read pkg body error")
    133.         return
    134.     }
    135.     //把pkgLen反序列化成message.Message
    136.     err = json.Unmarshal(buf[:pkgLen], &mes)
    137.     if err != nil {
    138.         return
    139.     }
    140.     return
    141. }
    142.  
    143. func main()  {
    144.     //提示信息
    145.     fmt.Println("服务器正在监听8889端口...")
    146.     listen, err := net.Listen("tcp", "127.0.0.1:8889")
    147.     //这里需要延时关闭
    148.     defer listen.Close()
    149.     if err != nil {
    150.         fmt.Printf("net listen err = %v\n", err)
    151.         return
    152.     }
    153.     //一旦监听成功,就等待客户端来连接服务器
    154.     for {
    155.         fmt.Println("等待客户端来连接服务器...")
    156.         conn, err := listen.Accept()
    157.         if err != nil {
    158.             fmt.Printf("listen accept err = %v\n", err)
    159.             return
    160.         }
    161.         //一旦连接成功,则启动一个协程,保持和客户端通讯
    162.         go process(conn)
    163.     }
    164. }

    client/utils/utils.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "encoding/binary"
    7.     "encoding/json"
    8.     "go_code/chatroom/common/message"
    9. )
    10.  
    11. //读取数据包直接封装成一个函数readPkg()
    12. func readPkg(conn net.Conn) (mes message.Message, err error)  {
    13.     //创建一个切片,用于后续conn.Read()
    14.     buf := make([]byte, 8096)
    15.     fmt.Println("读取客户端发送的数据...") 
    16.     //conn.Read在conn没有被关闭的情况下,才会阻塞
    17.     //如果客户端关闭了conn,则不会阻塞
    18.     _, err = conn.Read(buf[:4])
    19.     if err != nil {
    20.         // err = errors.New("read pkg header error")
    21.         return
    22.     }
    23.     //根据buf[:4]转成一个uint32类型
    24.     var pkgLen uint32
    25.     pkgLen = binary.BigEndian.Uint32(buf[0:4])
    26.     //根据pkgLen读取消息内容
    27.     n, err := conn.Read(buf[:pkgLen])
    28.     if n != int(pkgLen) || err != nil {
    29.         // err = errors.New("read pkg body error")
    30.         return
    31.     }
    32.     //把pkgLen反序列化成message.Message
    33.     err = json.Unmarshal(buf[:pkgLen], &mes)
    34.     if err != nil {
    35.         // err = errors.New("read pkg json.Unmarshal error")
    36.         return
    37.     }
    38.     return
    39. }
    40.  
    41. func writePkg(conn net.Conn, data []byte) (err error)  {
    42.     //先发送一个长度给对方
    43.     //先把data的长度发送给对方
    44.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    45.     var pkgLen uint32
    46.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    47.     var buf [4]byte
    48.     binary.BigEndian.PutUint32(buf[0:4], pkgLen)
    49.     //发送长度
    50.     n, err := conn.Write(buf[:4])
    51.     if err != nil || n != 4 {
    52.         fmt.Printf(" conn write err = %v\n", err)
    53.         return
    54.     }
    55.     //发送data本身
    56.     n, err = conn.Write(data)
    57.     if err != nil || n != int(pkgLen) {
    58.         fmt.Printf(" conn write err = %v\n", err)
    59.     }
    60.     return
    61. }

    client/client.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     _"time"
    7.     "encoding/binary"
    8.     "encoding/json"
    9.     "go_code/chatroom/common/message"
    10. )
    11.  
    12. //写一个函数, 完成登录
    13. func login(userId int, userPwd string) (err error) {
    14.     // //下一步 开始定协议
    15.     // fmt.Printf("userId = %d， userPwd = %s \n", userId, userPwd)
    16.     // return
    17.  
    18.     //1.连接到服务器端
    19.     conn, err := net.Dial("tcp", "127.0.0.1:8889")
    20.     if err != nil {
    21.         fmt.Printf("net dial err = %v\n", err)
    22.         return
    23.     }
    24.     //延时关闭
    25.     defer conn.Close()  
    26.  
    27.     //2.准备通过conn发送消息给服务端
    28.     var mes message.Message
    29.     mes.Type = message.LoginMesType
    30.     //3.创建一个LoginMes结构体
    31.     var loginMes message.LoginMes
    32.     loginMes.UserId = userId
    33.     loginMes.UserPwd = userPwd
    34.     //4.将loginMes序列化
    35.     data, err := json.Marshal(loginMes)
    36.     if err != nil {
    37.         fmt.Printf("json marshal err = %v\n", err)
    38.         return
    39.     }
    40.     //5.将序列化后的loginMes byte切片赋给mes.Data
    41.     mes.Data = string(data)
    42.     //6.将mes序列化
    43.     data, err = json.Marshal(mes)
    44.     if err != nil {
    45.         fmt.Printf("json marshal err = %v\n", err)
    46.         return
    47.     }
    48.     //7.这个时候data就是要发送的消息
    49.     //7.1先把data的长度发送给服务器
    50.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    51.     var pkgLen uint32
    52.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    53.     var buf [4]byte
    54.     binary.BigEndian.PutUint32(buf[0:4], pkgLen)
    55.     //发送长度
    56.     n, err := conn.Write(buf[:4])
    57.     if err != nil || n != 4 {
    58.         fmt.Printf(" conn write err = %v\n", err)
    59.         return
    60.     }
    61.     // fmt.Printf("客户端发送消息长度=%d,内容=%s\n", len(data), string(data)) 
    62.     //发送消息本身
    63.     _, err = conn.Write(data)
    64.     if err != nil {
    65.         fmt.Printf(" conn write err = %v\n", err)
    66.         return
    67.     }
    68.  
    69.     //休眠20s
    70.     // time.Sleep(20 * time.Second)
    71.     // fmt.Println("休眠20s...")
    72.     //处理服务端返回的消息
    73.     mes, err = readPkg(conn)
    74.     if err != nil {
    75.         fmt.Println("readPkg(conn) err = ", err)
    76.         return
    77.     }
    78.     //将mes中的Data反序列化成LoginResMes
    79.     var loginResMes message.LoginResMes
    80.     err = json.Unmarshal([]byte(mes.Data), &loginResMes)
    81.     if err != nil {
    82.         fmt.Println("json.Unmarshal err = ", err)
    83.         return
    84.     }
    85.     if loginResMes.Code == 200 {
    86.         fmt.Println("登录成功") 
    87.     } else if loginResMes.Code == 500 {
    88.         fmt.Println(loginResMes.Error)
    89.     }
    90.  
    91.     return
    92. }

    程序结构的改进，前面的程序虽然完成了功能，但是没有结构，系统的可读性、扩展性和维护性都不好，因此需要对程序的结构进行改进

    1).先改进服务端．先画出程序的框架图，再写代码

    2).步骤

    (1).先把分析出来的文件,创建好,然后把对应的代码放入到相应的文件夹(包) 

    (2).根据各个文件,完成的任务不同,将main.go的代码剥离到对应的文件中即可

    server/main/main.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6. )
    7.  
    8. //处理和客户端通讯
    9. func process(conn net.Conn)  {
    10.     //这里需要延时关闭
    11.     defer conn.Close()
    12.     //这里调用总控,创建一个总控实例
    13.     processor := &Processor{
    14.         Conn: conn,
    15.     }
    16.     err := processor.ProcessMain()
    17.     if err != nil {
    18.         fmt.Printf("客户端和服务器端的协程出问题了,err= %v\n", err)
    19.         return
    20.     }
    21. }
    22.  
    23. func main()  {
    24.     //提示信息
    25.     fmt.Println("服务器[新结构]正在监听8889端口...")
    26.     listen, err := net.Listen("tcp", "127.0.0.1:8889")
    27.     //这里需要延时关闭
    28.     defer listen.Close()
    29.     if err != nil {
    30.         fmt.Printf("net listen err = %v\n", err)
    31.         return
    32.     }
    33.     //一旦监听成功,就等待客户端来连接服务器
    34.     for {
    35.         fmt.Println("等待客户端来连接服务器...")
    36.         conn, err := listen.Accept()
    37.         if err != nil {
    38.             fmt.Printf("listen accept err = %v\n", err)
    39.             return
    40.         }
    41.         //一旦连接成功,则启动一个协程,保持和客户端通讯
    42.         go process(conn)
    43.     }
    44. }

     server/main/processor.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "io"
    7.     "go_code/chatroom/common/message"
    8.     "go_code/chatroom/server/utils"
    9.     "go_code/chatroom/server/processBlock"
    10. )
    11.  
    12. //创建一个Processor的结构体
    13. type Processor struct {
    14.     Conn net.Conn
    15. }
    16.  
    17. //编写一个ServerProcessMes函数
    18. //功能:根据客户端发送消息类型不同,决定调用哪个函数来处理
    19. func (this *Processor) serverProcessMes(mes *message.Message) (err error)  {
    20.     switch mes.Type {
    21.         case message.LoginMesType : 
    22.             //处理登录消息
    23.             //创建一个UserProcess
    24.             up := &processBlock.UserProcess{
    25.                 Conn: this.Conn,
    26.             }
    27.             err = up.ServerProcessLogin(mes)
    28.         case message.RegisterMesType : 
    29.             //处理注册
    30.         default :
    31.             fmt.Println("消息类型不存在, 无法处理...")
    32.     }
    33.     return
    34. }
    35.  
    36. func (this *Processor) ProcessMain() (err error) {
    37.     //读取客户端发送的消息    
    38.     for {
    39.         //将读取数据包直接封装成一个函数readPkg(),返回messag,error
    40.         //创建一个Transfer,完成读包的任务
    41.         tf := &utils.Transfer{
    42.             Conn: this.Conn,
    43.         }
    44.         mes, err := tf.ReadPkg()
    45.         if err != nil {
    46.             if err == io.EOF {
    47.                 fmt.Println("客户端退出了,服务器端也跟着退出")
    48.             } else {
    49.                 fmt.Printf(" readPkg err = %v\n", err)
    50.             }
    51.             return err
    52.         }
    53.         err = this.serverProcessMes(&mes)
    54.         if err != nil {
    55.             return err
    56.         } 
    57.     }
    58. }

     server/utils/utils.go

    1. package utils
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "go_code/chatroom/common/message"
    7.     "encoding/binary"
    8.     "encoding/json"
    9. )
    10.  
    11. //将方法关联到结构体中
    12. type Transfer struct {
    13.     Conn net.Conn
    14.     Buf [8096]byte  //传输时,使用的缓冲
    15. }
    16.  
    17. func (this *Transfer) WritePkg(data []byte) (err error)  {
    18.     //先发送一个长度给对方
    19.     //先把data的长度发送给对方
    20.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    21.     var pkgLen uint32
    22.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    23.     binary.BigEndian.PutUint32(this.Buf[0:4], pkgLen)
    24.     //发送长度
    25.     n, err := this.Conn.Write(this.Buf[:4])
    26.     if err != nil || n != 4 {
    27.         fmt.Printf(" conn write err = %v\n", err)
    28.         return
    29.     }
    30.     //发送data本身
    31.     n, err = this.Conn.Write(data)
    32.     if err != nil || n != int(pkgLen) {
    33.         fmt.Printf(" conn write err = %v\n", err)
    34.     }
    35.     return
    36. }
    37.  
    38. //读取数据包直接封装成一个函数readPkg()
    39. func (this *Transfer) ReadPkg() (mes message.Message, err error)  {
    40.     fmt.Println("读取客户端发送的数据...") 
    41.     //conn.Read在conn没有被关闭的情况下,才会阻塞
    42.     //如果客户端关闭了conn,则不会阻塞
    43.     _, err = this.Conn.Read(this.Buf[:4])
    44.     if err != nil {
    45.         return
    46.     }
    47.     //根据buf[:4]转成一个uint32类型
    48.     var pkgLen uint32
    49.     pkgLen = binary.BigEndian.Uint32(this.Buf[0:4])
    50.     //根据pkgLen读取消息内容
    51.     n, err :=  this.Conn.Read(this.Buf[:pkgLen])
    52.     if n != int(pkgLen) || err != nil {
    53.         // err = errors.New("read pkg body error")
    54.         return
    55.     }
    56.     //把pkgLen反序列化成message.Message
    57.     err = json.Unmarshal(this.Buf[:pkgLen], &mes)
    58.     if err != nil {
    59.         return
    60.     }
    61.     return
    62. }

    server/processBlock/userProcess.go

    1. package processBlock
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "go_code/chatroom/common/message"
    7.     "go_code/chatroom/server/utils"
    8.     "encoding/json"
    9. )
    10.  
    11. type UserProcess struct {
    12.     Conn net.Conn
    13. }
    14.  
    15. //编写一个函数serverProcessLogin函数,专门处理登录请求
    16. func (this *UserProcess) ServerProcessLogin(mes *message.Message) (err error)  {
    17.     //先从mes中取出mes.Data,并直接反序列化成LoginMes
    18.     var loginMes message.LoginMes
    19.     err = json.Unmarshal([]byte(mes.Data), &loginMes)
    20.     if err != nil {
    21.         fmt.Printf("json.Unmarshal fail, err = %v\n", err)
    22.         return
    23.     }
    24.     //1.声明一个resMes
    25.     var resMes message.Message
    26.     resMes.Type = message.LoginResMesType
    27.     //2.再声明一个loginResMes,并完成赋值
    28.     var loginResMes message.LoginResMes
    29.     //如果用户id=100,密码=123456,则合法,不然,则不合法
    30.     if loginMes.UserId == 100 && loginMes.UserPwd == "123456" {
    31.         //合法
    32.         loginResMes.Code = 200
    33.     } else {
    34.         //不合法
    35.         loginResMes.Code = 500  //500 表示不存在
    36.         loginResMes.Error = "该用户不存在,请注册后使用"
    37.     }
    38.     //3.将loginResMes序列化
    39.     data, err := json.Marshal(loginResMes)
    40.     if err != nil {
    41.         fmt.Printf("json.Marshal fail, err = %v\n", err)
    42.         return
    43.     }
    44.     //4.将data赋值给resMes
    45.     resMes.Data = string(data)
    46.     //5.对resMes序列化,准备发送
    47.     data, err = json.Marshal(resMes)
    48.     if err != nil {
    49.         fmt.Printf("json.Marshal fail, err = %v\n", err)
    50.         return
    51.     }
    52.     //6.发送data,将其封装到writePkg函数中
    53.     //因为使用了分层模式(mvc),先创建Transfer实例,然后读取
    54.     tf := &utils.Transfer{
    55.         Conn: this.Conn,
    56.     }
    57.     err = tf.WritePkg(data)
    58.     return
    59. }

    修改客户端,先画出程序框架图,再写代码

    client/main.go

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "os"
    6.     "go_code/chatroom/client/processBlock"
    7. )
    8.  
    9. //定义两个全局变量,一个用户id,一个用户密码
    10. var userId int
    11. var userPwd string
    12.  
    13. func main()  {
    14.     //接收用户的选择
    15.     var key int
    16.  
    17.     for true {
    18.         fmt.Println("-------------------欢迎登录多人聊天系统-------------------")
    19.         fmt.Println("\t\t\t\t 1 登录聊天室")
    20.         fmt.Println("\t\t\t\t 2 注册用户")
    21.         fmt.Println("\t\t\t\t 3 退出系统")
    22.         fmt.Println("\t\t\t\t 请选择(1~3):")
    23.         fmt.Scanf("%d\n", &key)
    24.         switch key {
    25.             case 1 : 
    26.                 fmt.Println("登录聊天室")
    27.                 //说明用户要登录
    28.                 fmt.Println("请输入用户的id:")
    29.                 fmt.Scanf("%d\n", &userId)
    30.                 fmt.Println("请输入用户的密码:")
    31.                 fmt.Scanf("%s\n", &userPwd)
    32.                 //先把登录的函数写到另一个文件,比如:login.go
    33.                 //因为使用了分层模式(mvc),故调用分层模式中processBlock.UserProcess.Login()处理
    34.                 up := &processBlock.UserProcess{}
    35.                 up.Login(userId, userPwd)
    36.             case 2 : 
    37.                 fmt.Println("注册用户")
    38.             case 3 :  
    39.                 fmt.Println("退出系统")
    40.                 os.Exit(0)
    41.             default:
    42.                 fmt.Println("输入有误,请重新输入")
    43.         }
    44.     }
    45. }

    client/utils/utils.go

    1. package utils
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "go_code/chatroom/common/message"
    7.     "encoding/binary"
    8.     "encoding/json"
    9. )
    10.  
    11. //将方法关联到结构体中
    12. type Transfer struct {
    13.     Conn net.Conn
    14.     Buf [8096]byte  //传输时,使用的缓冲
    15. }
    16.  
    17. func (this *Transfer) WritePkg(data []byte) (err error)  {
    18.     //先发送一个长度给对方
    19.     //先把data的长度发送给对方
    20.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    21.     var pkgLen uint32
    22.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    23.     binary.BigEndian.PutUint32(this.Buf[0:4], pkgLen)
    24.     //发送长度
    25.     n, err := this.Conn.Write(this.Buf[:4])
    26.     if err != nil || n != 4 {
    27.         fmt.Printf(" conn write err = %v\n", err)
    28.         return
    29.     }
    30.     //发送data本身
    31.     n, err = this.Conn.Write(data)
    32.     if err != nil || n != int(pkgLen) {
    33.         fmt.Printf(" conn write err = %v\n", err)
    34.     }
    35.     return
    36. }
    37.  
    38. //读取数据包直接封装成一个函数readPkg()
    39. func (this *Transfer) ReadPkg() (mes message.Message, err error)  {
    40.     fmt.Println("读取客户端发送的数据...") 
    41.     //conn.Read在conn没有被关闭的情况下,才会阻塞
    42.     //如果客户端关闭了conn,则不会阻塞
    43.     _, err = this.Conn.Read(this.Buf[:4])
    44.     if err != nil {
    45.         return
    46.     }
    47.     //根据buf[:4]转成一个uint32类型
    48.     var pkgLen uint32
    49.     pkgLen = binary.BigEndian.Uint32(this.Buf[0:4])
    50.     //根据pkgLen读取消息内容
    51.     n, err :=  this.Conn.Read(this.Buf[:pkgLen])
    52.     if n != int(pkgLen) || err != nil {
    53.         // err = errors.New("read pkg body error")
    54.         return
    55.     }
    56.     //把pkgLen反序列化成message.Message
    57.     err = json.Unmarshal(this.Buf[:pkgLen], &mes)
    58.     if err != nil {
    59.         return
    60.     }
    61.     return
    62. }

    client/processBlock/server.go

    1. package processBlock
    2.  
    3. import (
    4.     "fmt"
    5.     "os"
    6.     "net"
    7.     "go_code/chatroom/client/utils"
    8. )
    9.  
    10. //显示登录成功后的界面
    11. func ShowMenu()  {
    12.     fmt.Println("--------恭喜xxx登录成功--------")
    13.     fmt.Println("--------1.显示在线用户列表--------")
    14.     fmt.Println("--------2.发送消息--------")
    15.     fmt.Println("--------3.信息列表--------")
    16.     fmt.Println("--------4.退出系统--------")
    17.     fmt.Println("-------请选择(1~4):----")
    18.     var key int
    19.     fmt.Scanf("%d\n", &key)
    20.     switch key {
    21.         case 1:
    22.             fmt.Println("显示在线用户列表")
    23.         case 2:
    24.             fmt.Println("发送消息")
    25.         case 3:
    26.             fmt.Println("信息列表")
    27.         case 4:
    28.             fmt.Println("退出了系统")
    29.             os.Exit(0)
    30.         default:
    31.             fmt.Println("输入错误,请重新输入")
    32.     }
    33. }
    34.  
    35. //和服务端端保持通讯
    36. func ServerProcessMes(conn net.Conn)  {
    37.     //创建一个Transfer实例,让它不停地读取服务器发送的消息
    38.     tf := &utils.Transfer {
    39.         Conn: conn,
    40.     }
    41.     for {
    42.         fmt.Println("客户端正在等待读取服务器发送的消息")
    43.         mes, err := tf.ReadPkg()
    44.         if err != nil {
    45.             fmt.Println("tf.readpkg err =", err)
    46.             return
    47.         }
    48.         //如果读取到消息,则进行下一步逻辑处理
    49.         fmt.Printf("mes=%v\n", mes)
    50.     }
    51. }

    client/processBlock/userProcess.go

    1. package processBlock
    2.  
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "encoding/binary"
    7.     "encoding/json"
    8.     "go_code/chatroom/common/message"
    9.     "go_code/chatroom/client/utils"
    10. )
    11.  
    12. type UserProcess  struct {
    13.  
    14. }
    15.  
    16. //写一个函数, 完成登录
    17. func (this *UserProcess) Login(userId int, userPwd string) (err error) {
    18.     // //下一步 开始定协议
    19.     // fmt.Printf("userId = %d， userPwd = %s \n", userId, userPwd)
    20.     // return
    21.  
    22.     //1.连接到服务器端
    23.     conn, err := net.Dial("tcp", "127.0.0.1:8889")
    24.     if err != nil {
    25.         fmt.Printf("net dial err = %v\n", err)
    26.         return
    27.     }
    28.     //延时关闭
    29.     defer conn.Close()  
    30.  
    31.     //2.准备通过conn发送消息给服务端
    32.     var mes message.Message
    33.     mes.Type = message.LoginMesType
    34.     //3.创建一个LoginMes结构体
    35.     var loginMes message.LoginMes
    36.     loginMes.UserId = userId
    37.     loginMes.UserPwd = userPwd
    38.     //4.将loginMes序列化
    39.     data, err := json.Marshal(loginMes)
    40.     if err != nil {
    41.         fmt.Printf("json marshal err = %v\n", err)
    42.         return
    43.     }
    44.     //5.将序列化后的loginMes byte切片赋给mes.Data
    45.     mes.Data = string(data)
    46.     //6.将mes序列化
    47.     data, err = json.Marshal(mes)
    48.     if err != nil {
    49.         fmt.Printf("json marshal err = %v\n", err)
    50.         return
    51.     }
    52.     //7.这个时候data就是要发送的消息
    53.     //7.1先把data的长度发送给服务器
    54.     //先获取到data的长度,然后把长度转换成一个表示长度的byte切片
    55.     var pkgLen uint32
    56.     pkgLen = uint32(len(data))  //把data的长度转换成uint32,供后续转成byte切片长度使用
    57.     var buf [4]byte
    58.     binary.BigEndian.PutUint32(buf[0:4], pkgLen)
    59.     //发送长度
    60.     n, err := conn.Write(buf[:4])
    61.     if err != nil || n != 4 {
    62.         fmt.Printf(" conn write err = %v\n", err)
    63.         return
    64.     }
    65.     // fmt.Printf("客户端发送消息长度=%d,内容=%s\n", len(data), string(data)) 
    66.     //发送消息本身
    67.     _, err = conn.Write(data)
    68.     if err != nil {
    69.         fmt.Printf(" conn write err = %v\n", err)
    70.         return
    71.     }
    72.  
    73.     //休眠20s
    74.     // time.Sleep(20 * time.Second)
    75.     // fmt.Println("休眠20s...")
    76.     //处理服务端返回的消息
    77.     //创建一个Transfer实例
    78.     tf := &utils.Transfer{
    79.         Conn: conn,
    80.     }
    81.     mes, err = tf.ReadPkg()
    82.     if err != nil {
    83.         fmt.Println("readPkg(conn) err = ", err)
    84.         return
    85.     }
    86.     //将mes中的Data反序列化成LoginResMes
    87.     var loginResMes message.LoginResMes
    88.     err = json.Unmarshal([]byte(mes.Data), &loginResMes)
    89.     if err != nil {
    90.         fmt.Println("json.Unmarshal err = ", err)
    91.         return
    92.     }
    93.     if loginResMes.Code == 200 {
    94.         // fmt.Println("登录成功") 
    95.         //这里需要启动一个协程,保持和服务器通讯,如果服务器有数据,则推送给客户端,客户端接收后显示在终端
    96.         go ServerProcessMes(conn)
    97.         //1.显示登录成功的菜单[循环显示]
    98.         for {
    99.             ShowMenu()
    100.         }
    101.     } else if loginResMes.Code == 500 {
    102.         fmt.Println(loginResMes.Error)
    103.     }
    104.  
    105.     return
    106. }

    [上一节][go学习笔记.第十六章.TCP编程] 1.基本介绍以及入门案例

    [下一节][go学习笔记.第十六章.TCP编程] 3.项目-海量用户即时通讯系统-redis介入,用户登录,注册 

  • 相关阅读:
    数据结构（Java）：力扣&牛客 二叉树面试OJ题
    Java - 由ReflectionFactory引发的对final关键字的思考
    网盘项目分析
    复制远程连接到Linux使用VIM打开的内容到Windows
    Android通过JNI操作GPIO
    vue3中使用vue-i18n(ts中使用$t, vue3不用this)
    基于python的数据结构与算法——线性表
    共同富裕-三大维度-各省份、城市、农村基尼系数-附带多种计算方法
    CENTURY模型应用
    如何在vector中插入和删除元素？
  • 原文地址：https://blog.csdn.net/zhoupenghui168/article/details/127908847