1、网络

1. 分层

2. socket

3. http

编写web的语言：

  1. java
  2. php ==> 现在用go重写
  3. python ，豆瓣
  4. go ===> beego,gin主流的web框架

https协议：浏览器发送的就是http请求

  1. http是应用层的协议，底层还是依赖传输层：tcp（短连接），网络层（ip）
  2. 无状态的，每次请求都是独立的，下次请求需要重新建立连接
  3. https：
    1. http是标准协议，明文传输，不安全
    2. https不是标准协议，https：http + ssl（非对称加密，数字证书）
    3. 现在所有网站都会尽量要求使用https开发：安全

1、http的请求报文格式

Go-网络 - 图1

一个http可以分为4部分：

  1. 请求行：包含3部分
    1. 格式：方法 + URL + 协议版本号
    2. 请求方法
      1. GET：获取数据
      2. POST：上传数据（表单格式，json格式）
      3. PUT：修改数据
      4. DELETE：删除数据
  2. 请求头
    1. 格式：key ：value
    2. 可以包含多个键值对（包含协议自带，也包含用户自定义的）
    3. 常见重要的头：
      1. Accept：接收数据格式
      2. User-agent：描述用户浏览器信息
      3. Connection：Keep-Alive（长链接），Close（短连接）
      4. Accept-Encoding：gzip.. 描述可以接收的编码
      5. Cookie：由服务器设置的key=value数据，客户端下次请求的时候可以携带过来
      6. Content-Type：application/-from（表示上传的是表单）；application/json（表示body是json格式的）
      7. 用户自定义的：
        1. name：Duke
        2. age：18
  3. 空行
    1. 告诉服务器请求头结束了，用于分割
  4. 请求包体（可选的）
    1. 一般在post方法时会配套提供请求包体
    2. 在GET的时候也可以提供BODY，但是容易制造混淆（不建议）
    3. 上传两种格式：
      1. 表单：姓名、性别、年龄
      2. json格式数据

2. http-client

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "net/http"
  7. )
  9. func main() {
  10.     //http包
  11.     client := http.Client{}
  13.     response, err := client.Get("https://www.baidu.com")
  14.     if err != nil {
  15.         fmt.Println("client.Get err:", err)
  16.     }
  18.     //获取响应体 -  内容很多放在最上面
  19.     body := response.Body
  20.     readBodyAll, err := ioutil.ReadAll(body)
  21.     if err != nil {
  22.         fmt.Println("body string:", err)
  23.     }
  25.     fmt.Println(readBodyAll)
  27.     //获取响应请求头信息
  28.     ct := response.Header.Get("Content-Type")
  29.     date := response.Header.Get("Date")
  30.     server := response.Header.Get("Server")
  32.     fmt.Println("ct:", ct)
  33.     fmt.Println("date:", date)
  34.     fmt.Println("server:", server)
  36.     url := response.Request.URL
  37.     code := response.StatusCode
  38.     status := response.Status
  39.     fmt.Println("url:", url)
  40.     fmt.Println("code:", code)
  41.     fmt.Println("status:", status)
  43. }

3. http-server

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "net/http"
  7. )
  9. func main() {
  10.     //注册路由：匹配不通的信息处理不同的逻辑
  11.     //xxx/user ===> func1
  12.     //xxx/name ===> func2
  13.     //xxx/id   ===> func3
  15.     //func()是回调函数，用于路由的响应，原型是固定的
  16.     //https://127.0.0.1:8080/user
  17.     http.HandleFunc("/user", func(writer http.ResponseWriter, request *http.Request) {
  18.         //request：包含客户端发送来的数据
  19.         fmt.Println("用户请求详情：", request)
  21.         //这里是具体的处理业务逻辑
  23.         //writer：通过writer将数据返回
  24.         _, _ = io.WriteString(writer, "这是/user请求返回的数据\n")
  25.     })
  27.     //https://127.0.0.1:8080/name
  28.     http.HandleFunc("/name", func(writer http.ResponseWriter, request *http.Request) {
  29.         _, _ = io.WriteString(writer, "这是/name请求返回的数据\n")
  30.     })
  32.     //https://127.0.0.1:8080/id
  33.     http.HandleFunc("/id", func(writer http.ResponseWriter, request *http.Request) {
  34.         _, _ = io.WriteString(writer, "这是/id请求返回的数据\n")
  35.     })
  37.     fmt.Println("Server start ...")
  38.     if err := http.ListenAndServe("127.0.0.1:8080", nil); err != nil {
  39.         fmt.Println("http.ListentAndServer err:", err)
  40.         return
  41.     }
  43. }

4. json

json编码解码

在网络传输的时候，把结构体，编码成json字符串：传输 ==> 结构体 ===> 字符串 ===> 编码

在对端接收字符串，需要将字符串转换成结构体，然后操作 ==> 字符串 ==> 结构体 ==> 解码

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. //结构体
  9. type Student struct {
  10.     Id     int
  11.     Name   string
  12.     Age    int
  13.     gender string //注意小写，小写字母开头的，在json编码解码时会被忽略
  14. }
  16. func main() {
  17.     // 在网络传输的时候，把结构体，编码成json字符串：传输 ==> 结构体 ===> 字符串 ===> 编码
  18.     // 在对端接收字符串，需要将字符串转换成结构体，然后操作 ==> 字符串 ==> 结构体 ==> 解码
  20.     lily := Student{
  21.         Id:     1,
  22.         Name:   "lily",
  23.         Age:    21,
  24.         gender: "女",
  25.     }
  27.     //编码：序列化 ，结构体==> 字符串
  28.     encodeInfo, err := json.Marshal(&lily)
  29.     if err != nil {
  30.         fmt.Println("json.Marshal err", err)
  31.         return
  32.     }
  33.     fmt.Println("encodeInfo:", string(encodeInfo))
  35.     //在对端解码：
  36.     var lily2 Student
  37.     if err := json.Unmarshal([]byte(encodeInfo), &lily2); err != nil {
  38.         fmt.Println("json.Unmarshal err:", err)
  39.         return
  40.     }
  42.     fmt.Println("name:", lily2.Name)
  43.     fmt.Println("id:", lily2.Id)
  44.     fmt.Println("age:", lily2.Age)
  45.     fmt.Println("gender:", lily2.gender)
  47. }
  • 由于gender字段在结构体中是小写，所以被忽略了

Go-网络 - 图2

结构体标签

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. //结构体
  9. type Teacher struct {
  10.     Id      int
  11.     Name    string `json:"-"`                 //==> 在使用json编码时，这个字段不参与编码
  12.     Subject string `json:"Sub_name"`          //==> 别名
  13.     Age     int    `json:"age,string"`        //==> 别名，并转换数据类型（一定要两个字段：名字，数据类型）
  14.     Address string `json:"address,omitempty"` //==>如果这个字段是空的，那么忽略掉，不参与编码
  15.     gender  string //注意小写，小写字母开头的，在json编码解码时会被忽略
  16. }
  18. func main() {
  19.     t1 := Teacher{
  20.         Id:      1,
  21.         Name:    "lily",
  22.         Subject: "Go语言",
  23.         Age:     21,
  24.         gender:  "男",
  25.         // Address: "兰州",
  26.     }
  28.     fmt.Println("ti:", t1)
  30.     encodeInfo, _ := json.Marshal(&t1)
  31.     fmt.Println("encodeInfo:", string(encodeInfo))
  32. }

Go-网络 - 图3

总结：

  1. 编码时，字段首字母必须大写，否则无法编码（被忽略）
  2. 如果json格式要求key小写，可以通过标签（tag）来解决（别名）
  3. tag细节
  1.     Name    string `json:"-"`                 //==> 在使用json编码时，这个字段不参与编码
  2.     Subject string `json:"Sub_name"`          //==> 别名
  3.     Age     int    `json:"age,string"`        //==> 别名，并转换数据类型（一定要两个字段：名字，数据类型）
  4.     Address string `json:"address,omitempty"` //==>如果这个字段是空的，那么忽略掉，不参与编码
  5.     gender  string //注意小写，小写字母开头的，在json编码解码时会被忽略

4. 聊天室-模拟

4.1 概述

  • 实现一个网络聊天室（群）：功能分析
    • 上线下线
    • 聊天，其他人都可以看到消息
    • 查看当前聊天室用户名字
    • 可以修改自己的名字
    • 超时提出（潜水）

技术点分析：

  1. socket tcp编程 - 建立多个连接
  2. map结构
    1. 存储所有用户
    2. map遍历
    3. map删除
  3. go程、channel
  4. select 监听（超时退出，主动退出）
  5. timer 定时器

4.2 实现思路

阶段一：

  1. 思路分析
    1. tcp socket：建立多个连接
  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. //
  9. func main() {
  10.     //创建服务器
  11.     listen, err := net.Listen("tcp", ":8000")
  12.     if err != nil {
  13.         fmt.Println("net.Listen err:", err)
  14.         return
  15.     }
  16.     fmt.Println("服务器启动成功，监听中...")
  18.     for {
  19.         fmt.Println("主go程监听中...")
  21.         //监听
  22.         conn, err := listen.Accept()
  23.         if err != nil {
  24.             fmt.Println("listen.Accepet err:", err)
  25.             return
  26.         }
  27.         //建立连接
  28.         fmt.Println("建立连接成功...")
  30.         //启动处理业务go程
  31.         go handler(conn)
  32.     }
  33. }
  35. //处理具体业务
  36. func handler(conn net.Conn) {
  37.     for {
  38.         fmt.Println("业务go程监听中...")
  39.         //TODO //代码这里以后再具体实现，当前保留
  41.         buf := make([]byte, 1024)
  42.         //读取客户端发送过来的请求数据
  43.         cnt, err := conn.Read(buf)
  44.         if err != nil {
  45.             fmt.Println("conn.Read err:", err)
  46.             return
  47.         }
  48.         //cnt-1：去掉最后的回车
  49.         fmt.Println("客户端接收发送过来的数据：", string(buf[:cnt-1]), "cnt:", cnt)
  50.     }
  51. }

Go-网络 - 图4

  1. 分析

Go-网络 - 图5

数据流向：

Go-网络 - 图6

  1. 定义User结构
  1. //定义User
  2. type User struct {
  3.     //唯一Id
  4.     id   string
  5.     name string
  6.     //管道
  7.     msg chan string
  8. }
  10. //创建全局的map结构，用于保存所有的用户
  11. var allUsers = make(map[string]User)

在handler中调用

  1. //TODO //代码这里以后再具体实现，当前保留
  3.         clientAddr := conn.RemoteAddr().String()
  4.         //创建User：客户端和服务器建立连接时，会有ip和port ==> 当成User的id
  5.         newUser := User{
  6.             name: clientAddr,            //可以修改，会提供rename修改，简历连接时，初始值和id相同
  7.             id:   clientAddr,            //id，我们不会修改，作为map中key
  8.             msg:  make(chan string, 10), //注意分配空间，否则无法写入数据
  9.         }
  11.         //添加User 到map结构
  12.         allUsers[newUser.id] = newUser

Go-网络 - 图7

  1. 定义message通道
  1. //定义massage全局通道，接收所有用户发送的数据
  2. var message = make(chan string, 10)
  4. //向所有用户广播消息，启动一个全局唯一的go程
  5. func broadcast() {
  6.     fmt.Println("广播go程启动成功...")
  8.     //1. 从message读取数据
  9.     info := <-message
  10.     //将数据写入每一个用户的msg管道
  11.     for _, user := range allUsers {
  12.         user.msg <- info
  13.     }
  14. }

上线通知：

Go-网络 - 图8

bug修复-for循环

  1. //向所有用户广播消息，启动一个全局唯一的go程
  2. func broadcast() {
  3.     fmt.Println("广播go程启动成功...")
  4.     defer fmt.Println("broadcast程序退出！")
  6.     for {
  7.         fmt.Println("broadcast监听message中...")
  8.         //1. 从message读取数据
  9.         info := <-message
  10.         //将数据写入每一个用户的msg管道
  11.         for _, user := range allUsers {
  12.             //如果msg是非缓冲的，将会阻塞
  13.             user.msg <- info
  14.         }
  15.     }
  16. }
  1. User监听通道go程

每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端

  1. //完整逻辑代码
  2. package main
  4. import (
  5.     "fmt"
  6.     "net"
  7. )
  9. //定义User
  10. type User struct {
  11.     //唯一Id
  12.     id   string
  13.     name string
  14.     //管道
  15.     msg chan string
  16. }
  18. //创建全局的map结构，用于保存所有的用户
  19. var allUsers = make(map[string]User)
  21. //定义massage全局通道，接收所有用户发送的数据
  22. var message = make(chan string, 10)
  24. func main() {
  25.     //创建服务器
  26.     listen, err := net.Listen("tcp", ":8000")
  27.     if err != nil {
  28.         fmt.Println("net.Listen err:", err)
  29.         return
  30.     }
  31.     fmt.Println("服务器启动成功，监听中...")
  33.     //启动全局唯一的go程，负责监听message通道，写给所有的用户
  34.     go broadcast()
  36.     for {
  37.         fmt.Println("主go程监听中...")
  39.         //监听
  40.         conn, err := listen.Accept()
  41.         if err != nil {
  42.             fmt.Println("listen.Accepet err:", err)
  43.             return
  44.         }
  45.         //建立连接
  46.         fmt.Println("建立连接成功...")
  48.         //启动处理业务go程
  49.         go handler(conn)
  50.     }
  51. }
  53. //处理具体业务
  54. func handler(conn net.Conn) {
  55.     fmt.Println("业务go程监听中...")
  57.     //TODO //代码这里以后再具体实现，当前保留
  59.     clientAddr := conn.RemoteAddr().String()
  60.     //创建User：客户端和服务器建立连接时，会有ip和port ==> 当成User的id
  61.     newUser := User{
  62.         name: clientAddr,            //可以修改，会提供rename修改，简历连接时，初始值和id相同
  63.         id:   clientAddr,            //id，我们不会修改，作为map中key
  64.         msg:  make(chan string, 10), //注意分配空间，否则无法写入数据
  65.     }
  67.     //添加User 到map结构
  68.     allUsers[newUser.id] = newUser
  70.     //启动go程，将msg返回给客户端
  71.     go writeBackToClient(&newUser, conn)
  73.     //向message写入通知消息，广播当前用户上线通知
  74.     loginInfo := fmt.Sprintf("[%s]:[%s] ===> 上线了login！！", newUser.id, newUser.name)
  75.     message <- loginInfo
  77.     fmt.Println("message接收到的消息是：", loginInfo)
  79.     for {
  80.         //具体业务逻辑
  81.         buf := make([]byte, 1024)
  82.         //读取客户端发送过来的请求数据
  83.         cnt, err := conn.Read(buf)
  84.         if err != nil {
  85.             fmt.Println("conn.Read err:", err)
  86.             return
  87.         }
  88.         //cnt-1：去掉最后的回车
  89.         fmt.Println("客户端接收发送过来的数据：", string(buf[:cnt-1]), "cnt:", cnt)
  90.     }
  91. }
  93. //每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端
  94. func writeBackToClient(user *User, conn net.Conn) {
  95.     //TODO
  96.     fmt.Printf("User：%s的go程正在监听自己的msg管道\n", user.name)
  97.     for data := range user.msg {
  98.         fmt.Printf("user：%s 写回给客户端数据为：%s\n", user.name, data)
  99.         _, _ = conn.Write([]byte(data))
  100.     }
  101. }
  103. //向所有用户广播消息，启动一个全局唯一的go程
  104. func broadcast() {
  105.     fmt.Println("广播go程启动成功...")
  106.     defer fmt.Println("broadcast程序退出！")
  108.     for {
  109.         fmt.Println("broadcast监听message中...")
  110.         //1. 从message读取数据
  111.         info := <-message
  112.         //将数据写入每一个用户的msg管道
  113.         for _, user := range allUsers {
  114.             //如果msg是非缓冲的，将会阻塞
  115.             user.msg <- info
  116.         }
  117.     }
  118. }

4.3 功能

1、查询用户
  • who：—> 将当前所有的用户id，name返回给当前用户（遍历map）
2、重命名
  • 规则：rename | Duke
    • 读取数据判断长度大于8，判断字符是rename
    • 使用 | 分割，获取 | 后面的作为名字
    • 更新用户名字newUser.name = Duke
    • 通知客户端更新成功
3、主动退出
  • 用户退出：清理工作（输入：\quit、ctrl+c）
    • 从map中删除
    • 对应的conn要close
4、超时退出

定时器进行超时管理

60s内没有发送任何数据，连接关闭

  1. time.After(60 * time.Second) //chan time

5、map读写上锁（bug）

  • map不允许同时读写
  1. var lock sync.RWMutex
  3. lock.Lock()
  5. lock.Unlock()

6、全部代码

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6.     "strings"
  7.     "time"
  8. )
  10. //定义User
  11. type User struct {
  12.     //唯一Id
  13.     id   string
  14.     name string
  15.     //管道
  16.     msg chan string
  17. }
  19. //创建全局的map结构，用于保存所有的用户
  20. var allUsers = make(map[string]User)
  22. //定义massage全局通道，接收所有用户发送的数据
  23. var message = make(chan string, 10)
  25. func main() {
  26.     //创建服务器
  27.     listen, err := net.Listen("tcp", ":8000")
  28.     if err != nil {
  29.         fmt.Println("net.Listen err:", err)
  30.         return
  31.     }
  32.     fmt.Println("服务器启动成功，监听中...")
  34.     //启动全局唯一的go程，负责监听message通道，写给所有的用户
  35.     go broadcast()
  37.     for {
  38.         fmt.Println("主go程监听中...")
  40.         //监听
  41.         conn, err := listen.Accept()
  42.         if err != nil {
  43.             fmt.Println("listen.Accepet err:", err)
  44.             return
  45.         }
  46.         //建立连接
  47.         fmt.Println("建立连接成功...")
  49.         //启动处理业务go程
  50.         go handler(conn)
  51.     }
  52. }
  54. //处理具体业务
  55. func handler(conn net.Conn) {
  56.     fmt.Println("业务go程监听中...")
  58.     //TODO //代码这里以后再具体实现，当前保留
  60.     clientAddr := conn.RemoteAddr().String()
  61.     //创建User：客户端和服务器建立连接时，会有ip和port ==> 当成User的id
  62.     newUser := User{
  63.         name: clientAddr,            //可以修改，会提供rename修改，简历连接时，初始值和id相同
  64.         id:   clientAddr,            //id，我们不会修改，作为map中key
  65.         msg:  make(chan string, 10), //注意分配空间，否则无法写入数据
  66.     }
  68.     //添加User 到map结构
  69.     allUsers[newUser.id] = newUser
  71.     //启动go程，将msg返回给客户端
  72.     go writeBackToClient(&newUser, conn)
  74.     //向message写入通知消息，广播当前用户上线通知
  75.     loginInfo := fmt.Sprintf("[%s]:[%s] ===> 上线了login！！\n", newUser.id, newUser.name)
  76.     message <- loginInfo
  78.     fmt.Println("message接收到的消息是：", loginInfo)
  80.     //创建一个用于重置连接计数器的管道，用于告知watch函数，当前用户正在输入
  81.     var resTimer = make(chan bool)
  83.     //定义退出信号，用于监听client退出
  84.     var isQuit = make(chan bool)
  85.     //启动go程负责监听退出信号
  87.     go watch(&newUser, conn, isQuit, resTimer)
  89.     for {
  90.         //具体业务逻辑
  91.         buf := make([]byte, 1024)
  92.         //读取客户端发送过来的请求数据
  93.         cnt, err := conn.Read(buf)
  94.         if cnt == 0 {
  95.             fmt.Println("客户端ctrl+c，准备退出...")
  96.             //清理，map删除用户、conn close
  97.             //服务器还可以主动退出
  98.             //在这里不进行真正的退出，而是发送一个退出信号，统一做退出处理，可以使用新的管道做信号传递
  99.             isQuit <- true
  100.         }
  102.         if err != nil {
  103.             fmt.Println("conn.Read err:", err)
  104.             return
  105.         }
  106.         //cnt-1：去掉最后的回车
  107.         fmt.Println("客户端接收发送过来的数据：", string(buf[:cnt-1]), "cnt:", cnt)
  109.         //----------业务逻辑代码   开始----------
  110.         //1. 查询当前所有用户：who命令
  111.         //    a. 判断接收的数据是不是who ===> 长度&&字符串
  112.         userInput := buf[:cnt-1] //这是用户输入的数据，去掉回车
  113.         if len(userInput) == 4 && string(userInput) == "\\who" {
  114.             //    b. 遍历allUsers这个map：（key := user.id value := user本身），将id和name拼接成一个字符串，返回给客户端
  115.             fmt.Println("用户查询所有用户：")
  117.             //创建切面用于包含所有的用户信息，以便返回给客户查询(切面服务直接返回的)
  118.             var userInfos []string
  119.             for _, user := range allUsers {
  120.                 userInfo := fmt.Sprintf("userId: %s, userName: %s\n", user.id, user.name)
  121.                 userInfos = append(userInfos, userInfo)
  122.             }
  123.             //最终写入管道中，一定是一个字符串
  124.             r := strings.Join(userInfos, "\n")
  125.             //将数据返回给查询的客户端
  126.             newUser.msg <- r
  127.         } else if len(userInput) > 9 && string(userInput[:7]) == "\\rename" {
  128.             // ● 规则：rename | Duke
  129.             // ○ 读取数据判断长度大于8，判断字符是rename
  130.             // ○ 使用 | 分割，获取 | 后面的作为名字
  131.             fmt.Println("用户修改名称")
  133.             // ○ 更新用户名字newUser.name = Duke
  134.             // array := strings.Split(string(userInput), "|")
  135.             // name := array[1]
  136.             newUser.name = strings.Split(string(userInput), "|")[1]
  137.             //更新map中的user
  138.             allUsers[newUser.id] = newUser
  139.             fmt.Println("用户更新名称后：", allUsers)
  141.             // ○ 通知客户端更新成功
  142.             newUser.msg <- "rename successfuly" + "\n"
  144.         } else {
  145.             //如果不是命令，那么只需要写入广播通道即可，由其他go程进行常规转发
  146.             message <- string(userInput)
  147.         }
  149.         resTimer <- true
  150.         //----------业务逻辑代码   结束----------
  152.     }
  153. }
  155. //每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端
  156. func writeBackToClient(user *User, conn net.Conn) {
  157.     //TODO
  158.     fmt.Printf("User：%s的go程正在监听自己的msg管道\n", user.name)
  159.     for data := range user.msg {
  160.         fmt.Printf("user：%s 写回给客户端数据为：\n%s \n", user.name, data)
  161.         _, _ = conn.Write([]byte(data))
  162.     }
  163. }
  165. //向所有用户广播消息，启动一个全局唯一的go程
  166. func broadcast() {
  167.     fmt.Println("广播go程启动成功...")
  168.     defer fmt.Println("broadcast程序退出！")
  170.     for {
  171.         fmt.Println("broadcast监听message中...")
  172.         //1. 从message读取数据
  173.         info := <-message
  174.         //将数据写入每一个用户的msg管道
  175.         for _, user := range allUsers {
  176.             //如果msg是非缓冲的，将会阻塞
  177.             user.msg <- info + "\n" //返回客户端后光标换行
  178.         }
  179.     }
  180. }
  182. //启动另一个go程，负责监听退出信号，触发后，进行清理工作：delete map，conn close都在这里处理
  183. func watch(user *User, conn net.Conn, isQuit, resTimer <-chan bool) {
  184.     fmt.Println("启动监听退出信号go程...")
  185.     defer fmt.Println("watch退出了...")
  186.     for {
  187.         select {
  188.         case <-isQuit:
  189.             logoutInfo := fmt.Sprintf("%s exit already!（主动） \n", user.name)
  190.             fmt.Println("删除当前用户（主动）：", user.name)
  191.             delete(allUsers, user.id)
  192.             message <- logoutInfo
  193.             conn.Close()
  194.             return
  195.         case <-time.After(5 * time.Second): //超过指定时间退出
  196.             logoutInfo := fmt.Sprintf("%s timeout exit already!（超时） \n", user.name)
  197.             fmt.Println("删除当前用户（超时）：", user.name)
  198.             delete(allUsers, user.id)
  199.             message <- logoutInfo
  200.             conn.Close()
  201.             return
  202.         case <-resTimer:
  203.             fmt.Printf("连接%s重置计数器...\n", user.name)
  204.         }
  205.     }
  206. }