基于Go写一个极简的通讯demo

window环境

客户端构建：go build -o client.exe .\client.go

服务端构建：go build - go build -o server.exe .\main.go .\server.go .\User.go

定义服务端

Server具体实现

结构体

1
type Server struct {
2
   //服务端的IP地址
3
   Ip string
4
   //服务端的IP端口
5
   Port int
6
   // 在线用户
7
   OnlineUserMap map[string]*User
8
   // 在线用户map的同步锁
9
   mapLock sync.RWMutex
10
   // 消息广播channel
11
   Message chan string
12
}

创建Server接口

1
func NewServer(ip string, port int) *Server {
2
   server := &Server{
3
      Ip:            ip,
4
      Port:          port,
5
      OnlineUserMap: make(map[string]*User),
6
      Message:       make(chan string),
7
   }
8
   return server
9
}

监听用户上线

1
// BroadCast 服务端发送广播消息
2
func (s *Server) BroadCast(user *User, msg string) {
3
   sendMsg := "[" + user.Addr + "]" + user.Name + ":" + msg
4
   s.Message <- sendMsg
5
}
6

7
// ListenMessage 在线用户监听器
8
func (s *Server) ListenMessage() {
9
   for {
10
      msg := <-s.Message
11
      s.mapLock.Lock()
12
      for _, cli := range s.OnlineUserMap {
13
         cli.C <- msg
14
      }
15
      s.mapLock.Unlock()
16
   }
17
}

服务端对用户消息的处理器

1
// Handler handler处理
2
func (s *Server) Handler(conn net.Conn) {
3
   fmt.Print("链接建立成功")
4
   // 加入在线用户集
5
   user := NewUser(conn, s)
6
   user.Online()
7
   fmt.Println("[" + user.Addr + "]" + user.Name + ": online...")
8
   isLive := make(chan bool)
9
   // 广播用户发送信息
10
   go func() {
11
      buf := make([]byte, 4096)
12
      for {
13
         n, err := conn.Read(buf)
14
         if n == 0 {
15
            user.Offline()
16
            fmt.Println("[" + user.Addr + "]" + user.Name + ": offline...")
17
            return
18
         }
19
         if err != nil && err != io.EOF {
20
            fmt.Println("conn Read err:", err)
21
            return
22
         }
23
         fmt.Println("[" + user.Addr + "]" + user.Name + ":" + string(buf))
24
         // 提取用户信息 去除 '\n'         msg := string(buf[:n-1])
25
         user.DoMessage(msg)
26
      }
27
   }()
28
   // 超时强制退出监听检测处理
29
   for {
30
      select {
31
      case <-isLive:
32
      case <-time.After(time.Second * 60):
33
         user.DoMessage("You have been forced offline\n")
34
         fmt.Println("[" + user.Addr + "]" + user.Name + ": have been forced offline")
35
         close(user.C)
36
         err := conn.Close()
37
         if err != nil {
38
            return
39
         }
40
      }
41
   }
42
}

服务端启动器

1
func (s *Server) Start() {
2
   listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", s.Ip, s.Port))
3
   if err != nil {
4
      fmt.Println("net.listener err:", err)
5
      return
6
   }
7
   defer func(listener net.Listener) {
8
      err := listener.Close()
9
      if err != nil {
10
         fmt.Println("net.listener err:", err)
11
      }
12
   }(listener)
13
   // 启动在线用户监听
14
   go s.ListenMessage()
15
   fmt.Println("start success....")
16
   for {
17
      // accept
18
      conn, err := listener.Accept()
19
      if err != nil {
20
         fmt.Println("listener Accept err:", err)
21
         continue
22
      }
23
      // handler
24
      go s.Handler(conn)
25
   }
26
}

主函数启动

1
package main
2

3

4
func main() {
5
   server := NewServer("127.0.0.1", 8888)
6
   server.Start()
7
}

完整代码

server.go

1
package main
2

3
import (
4
   "fmt"
5
   "io"   "net"   "sync"   "time")
6

7
type Server struct {
8
   Ip   string
9
   Port int
10
   // 在线用户
11
   OnlineUserMap map[string]*User
12
   mapLock       sync.RWMutex
13
   // 消息广播channel
14
   Message chan string
15
}
16

17
// NewServer 创建Server接口
18
func NewServer(ip string, port int) *Server {
19
   server := &Server{
20
      Ip:            ip,
21
      Port:          port,
22
      OnlineUserMap: make(map[string]*User),
23
      Message:       make(chan string),
24
   }
25
   return server
26
}
27

28
func (s *Server) BroadCast(user *User, msg string) {
29
   sendMsg := "[" + user.Addr + "]" + user.Name + ":" + msg
30
   s.Message <- sendMsg
31
}
32

33
func (s *Server) ListenMessage() {
34
   for {
35
      msg := <-s.Message
36
      s.mapLock.Lock()
37
      for _, cli := range s.OnlineUserMap {
38
         cli.C <- msg
39
      }
40
      s.mapLock.Unlock()
41
   }
42

43
}
44

45
// Handler handler处理
46
func (s *Server) Handler(conn net.Conn) {
47
   fmt.Print("链接建立成功")
48
   // 加入在线用户集
49
   user := NewUser(conn, s)
50
   user.Online()
51
   fmt.Println("[" + user.Addr + "]" + user.Name + ": online...")
52
   isLive := make(chan bool)
53
   // 广播用户发送信息
54
   go func() {
55
      buf := make([]byte, 4096)
56
      for {
57
         n, err := conn.Read(buf)
58
         if n == 0 {
59
            user.Offline()
60
            fmt.Println("[" + user.Addr + "]" + user.Name + ": offline...")
61
            return
62
         }
63
         if err != nil && err != io.EOF {
64
            fmt.Println("conn Read err:", err)
65
            return
66
         }
67
         fmt.Println("[" + user.Addr + "]" + user.Name + ":" + string(buf))
68
         // 提取用户信息 去除 '\n'         msg := string(buf[:n-1])
69
         user.DoMessage(msg)
70
      }
71
   }()
72
   // 超时强制退出监听检测处理
73
   for {
74
      select {
75
      case <-isLive:
76
      case <-time.After(time.Second * 60):
77
         user.DoMessage("You have been forced offline\n")
78
         fmt.Println("[" + user.Addr + "]" + user.Name + ": have been forced offline")
79
         close(user.C)
80
         err := conn.Close()
81
         if err != nil {
82
            return
83
         }
84
      }
85
   }
86
}
87

88
// Start 启动服务器接口
89
func (s *Server) Start() {
90
   listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", s.Ip, s.Port))
91
   if err != nil {
92
      fmt.Println("net.listener err:", err)
93
      return
94
   }
95
   defer func(listener net.Listener) {
96
      err := listener.Close()
97
      if err != nil {
98
         fmt.Println("net.listener err:", err)
99
      }
100
   }(listener)
101
   // 启动在线用户监听
102
   go s.ListenMessage()
103
   fmt.Println("start success....")
104
   for {
105
      // accept
106
      conn, err := listener.Accept()
107
      if err != nil {
108
         fmt.Println("listener Accept err:", err)
109
         continue
110
      }
111
      // handler
112
      go s.Handler(conn)
113
   }
114
}

User具体实现

用户结构体

1
type User struct {
2
   // 用户名
3
   Name string
4
   // 用户IP地址
5
   Addr string
6
   // chan
7
   C    chan string
8
   // 链接
9
   conn net.Conn
10
   // 所属的服务
11
   server *Server
12
}

创建一个User

1
func NewUser(c net.Conn, server *Server) *User {
2
   userAddr := c.RemoteAddr().String()
3
   user := &User{
4
      Name: userAddr,
5
      Addr: userAddr,
6
      C:    make(chan string),
7
      conn: c,
8

9
      server: server,
10
   }
11
   go user.ListenMessage()
12
   return user
13
}

监听用户状态

1
func (u *User) ListenMessage() {
2
   for {
3
      msg := <-u.C
4
      _, err := u.conn.Write([]byte(msg + "\n"))
5
      if err != nil {
6
         fmt.Println("write err:", err)
7
         return
8
      }
9
   }
10
}
11

12
// SendMsg 给客户端发送消息
13
func (u *User) SendMsg(msg string) {
14
   _, err := u.conn.Write([]byte(msg))
15
   if err != nil {
16
      fmt.Println("send Msg err:", err)
17
   }
18
}

具体实现用户的上下线

1
// Online 广播用户上线通知
2
func (u *User) Online() {
3
   u.server.mapLock.Lock()
4
   u.server.OnlineUserMap[u.Name] = u
5
   u.server.mapLock.Unlock()
6
   u.server.BroadCast(u, "online...")
7
}
8

9
// Offline 广播用户下线通知
10
func (u *User) Offline() {
11
   u.server.mapLock.Lock()
12
   delete(u.server.OnlineUserMap, u.Name)
13
   u.server.mapLock.Unlock()
14
   u.server.BroadCast(u, "offline...")
15
}

解析用户的消息

1
func (u *User) DoMessage(message string) {
2
   if len(message) > 0 {
3
      msg := strings.Split(message, "|")
4
      if len(msg) > 1 {
5
         switch msg[0] {
6
         case "rename":
7
            newName := msg[1]
8
            _, ok := u.server.OnlineUserMap[newName]
9
            if ok {
10
               u.SendMsg("this name is already used\n")
11
               return
12
            }
13
            u.server.mapLock.Lock()
14
            u.server.OnlineUserMap[newName] = u
15
            delete(u.server.OnlineUserMap, u.Name)
16
            u.server.mapLock.Unlock()
17
            u.Name = newName
18
            u.SendMsg("update newName success\n")
19
            break
20
         case "to":
21
            // to|用户名|消息
22
            if len(msg) < 3 {
23
               u.server.BroadCast(u, "Command format error\n")
24
               return
25
            }
26
            remoteUer, ok := u.server.OnlineUserMap[msg[1]]
27
            if !ok {
28
               u.server.BroadCast(u, msg[1]+" not found\n")
29
               return
30
            }
31
            remoteUer.SendMsg(msg[2])
32
         }
33
      } else {
34
         switch message {
35
         case "who":
36
            u.server.mapLock.Lock()
37
            for _, user := range u.server.OnlineUserMap {
38
               onlineMsg := "[" + user.Addr + "]" + user.Name + ":online\n"
39
               u.SendMsg(onlineMsg)
40
            }
41
            u.server.mapLock.Unlock()
42
            break
43
         default:
44
            u.server.BroadCast(u, message)
45
         }
46
      }
47
   }
48
}

完整代码

1
package main
2

3
import (
4
   "fmt"
5
   "net"   "strings")
6

7
type User struct {
8
   Name string
9
   Addr string
10
   C    chan string
11
   conn net.Conn
12

13
   server *Server
14
}
15

16
func NewUser(c net.Conn, server *Server) *User {
17
   userAddr := c.RemoteAddr().String()
18
   user := &User{
19
      Name: userAddr,
20
      Addr: userAddr,
21
      C:    make(chan string),
22
      conn: c,
23

24
      server: server,
25
   }
26
   go user.ListenMessage()
27
   return user
28
}
29

30
// Online 广播用户上线通知
31
func (u *User) Online() {
32
   u.server.mapLock.Lock()
33
   u.server.OnlineUserMap[u.Name] = u
34
   u.server.mapLock.Unlock()
35
   u.server.BroadCast(u, "online...")
36
}
37

38
// Offline 广播用户下线通知
39
func (u *User) Offline() {
40
   u.server.mapLock.Lock()
41
   delete(u.server.OnlineUserMap, u.Name)
42
   u.server.mapLock.Unlock()
43
   u.server.BroadCast(u, "offline...")
44
}
45

46
func (u *User) DoMessage(message string) {
47
   if len(message) > 0 {
48
      msg := strings.Split(message, "|")
49
      if len(msg) > 1 {
50
         switch msg[0] {
51
         case "rename":
52
            newName := msg[1]
53
            _, ok := u.server.OnlineUserMap[newName]
54
            if ok {
55
               u.SendMsg("this name is already used\n")
56
               return
57
            }
58
            u.server.mapLock.Lock()
59
            u.server.OnlineUserMap[newName] = u
60
            delete(u.server.OnlineUserMap, u.Name)
61
            u.server.mapLock.Unlock()
62
            u.Name = newName
63
            u.SendMsg("update newName success\n")
64
            break
65
         case "to":
66
            // to|用户名|消息
67
            if len(msg) < 3 {
68
               u.server.BroadCast(u, "Command format error\n")
69
               return
70
            }
71
            remoteUer, ok := u.server.OnlineUserMap[msg[1]]
72
            if !ok {
73
               u.server.BroadCast(u, msg[1]+" not found\n")
74
               return
75
            }
76
            remoteUer.SendMsg(msg[2])
77
         }
78
      } else {
79
         switch message {
80
         case "who":
81
            u.server.mapLock.Lock()
82
            for _, user := range u.server.OnlineUserMap {
83
               onlineMsg := "[" + user.Addr + "]" + user.Name + ":online\n"
84
               u.SendMsg(onlineMsg)
85
            }
86
            u.server.mapLock.Unlock()
87
            break
88
         default:
89
            u.server.BroadCast(u, message)
90
         }
91
      }
92
   }
93
}
94

95
func (u *User) ListenMessage() {
96
   for {
97
      msg := <-u.C
98
      _, err := u.conn.Write([]byte(msg + "\n"))
99
      if err != nil {
100
         fmt.Println("write err:", err)
101
         return
102
      }
103
   }
104
}
105

106
// SendMsg 给客户端发送消息
107
func (u *User) SendMsg(msg string) {
108
   _, err := u.conn.Write([]byte(msg))
109
   if err != nil {
110
      fmt.Println("send Msg err:", err)
111
   }
112
}

定义客户端

初始化客户端

客户端结构体

1
type Client struct {
2
   // 服务端ip
3
   ServerIp   string
4
   // 服务端端口
5
   ServerPort int
6
   // 客户端名
7
   Name       string
8
   // 客户端管道
9
   conn       net.Conn
10
   // 客户端模式
11
   flag int
12
}

1
// NewClient 创建一个监听
2
func NewClient(serverIp string, serverPort int) *Client {
3
   client := &Client{
4
      ServerIp:   serverIp,
5
      ServerPort: serverPort,
6
      flag:       999,
7
   }
8
   // 建立tcp长链接
9
   conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", client.ServerIp, client.ServerPort))
10
   if err != nil {
11
      fmt.Println("dial err:", err)
12
      return nil
13
   }
14
   client.conn = conn
15
   return client
16
}

通过参数命令来定义并启动客户端

1
func init() {
2
   // 初始化配置，通过 -ip设置IP地址
3
   flag.StringVar(&serverIp, "i", "127.0.0.1", "设置服务器的IP地址(默认127.0.0.1)")
4
   // 初始化配置，通过 -p设置IP端口
5
   flag.IntVar(&serverPort, "p", 8888, "设置服务器的端口(默认8888)")
6
}
7

8

9
// DealResponse 监听服务端返回的消息
10
func (client *Client) DealResponse() {
11
   _, err := io.Copy(os.Stdout, client.conn)
12
   if err != nil {
13
      return
14
   }
15
}
16

17
// 具体业务的实现
18
func (client *Client) Run() {
19

20
}
21

22

23
func main() {
24
   // 命令行解析
25
   flag.Parse()
26
   client := NewClient(serverIp, serverPort)
27
   if client == nil {
28
      fmt.Println(">>> 链接服务器失败")
29
      return
30
   }
31
   go client.DealResponse()
32
   fmt.Println(">>> 链接服务器成功")
33
   client.Run()
34

35
}

客户端封装功能

封装修改用户名

1
// 包装更新用户名请求
2
func (client *Client) updateUserName() bool {
3
   fmt.Println(">>> 请输入用户名")
4
   _, err := fmt.Scanln(&client.Name)
5
   if err != nil {
6
      return false
7
   }
8
   sendMsg := "rename|" + client.Name + "\n"
9
   _, err = client.conn.Write([]byte(sendMsg))
10
   if err != nil {
11
      fmt.Println(">>> conn write err:", err)
12
      return false
13
   }
14
   return true
15
}

封装查询在线用户

1
func (client *Client) listUser() bool {
2
   sendMsg := "who\n"
3
   _, err := client.conn.Write([]byte(sendMsg))
4
   if err != nil {
5
      fmt.Println(">>> conn write err:", err)
6
      return false
7
   }
8
   return true
9
}

封装广播聊天

1
// PublicChat 公聊模式
2
func (client *Client) publicChat() {
3
   var chatMsg string
4
   fmt.Println(">>> 请输入发送内容，输入exit退出")
5
   _, err := fmt.Scanln(&chatMsg)
6
   if err != nil {
7
      return
8
   }
9
   for chatMsg != "exit" {
10
      if len(chatMsg) != 0 {
11
         sendMsg := chatMsg + "\n"
12
         _, err := client.conn.Write([]byte(sendMsg))
13
         if err != nil {
14
            fmt.Println(">>> conn write err:", err)
15
            break
16
         }
17
      }
18
      // 继续监听下一个发送信息，直到exit
19
      chatMsg = ""
20
      fmt.Println(">>> 请输入发送内容，输入exit退出")
21
      _, err := fmt.Scanln(&chatMsg)
22
      if err != nil {
23
         return
24
      }
25
   }
26
}

封装私聊

1
// PrivateChat 私聊模式
2
func (client *Client) privateChat() {
3
   var remote, chatMsg string
4
   client.listUser()
5
   for remote != "exit" {
6
      fmt.Println(">>> 请输入发送对象，输入exit退出")
7
      _, err := fmt.Scanln(&remote)
8
      if err != nil {
9
         return
10
      }
11
      for chatMsg != "exit" {
12
         if len(chatMsg) != 0 {
13
            // 发送消息到服务端
14
            sendMsg := "to|" + remote + "|" + chatMsg + "\n"
15
            _, err := client.conn.Write([]byte(sendMsg))
16
            if err != nil {
17
               fmt.Println(">>> conn write err:", err)
18
               break
19
            }
20
         }
21
         // 继续监听下一个发送信息，直到exit
22
         chatMsg = ""
23
         fmt.Println(">>> 请输入发送内容，输入exit退出")
24
         _, err := fmt.Scanln(&chatMsg)
25
         if err != nil {
26
            return
27
         }
28
      }
29
      // 内循环退出，继续监听输入内容选择用户，知道exit
30
      remote = ""
31
      fmt.Println(">>> 请输入发送对象，输入exit退出")
32
      _, err = fmt.Scanln(&remote)
33
      if err != nil {
34
         return
35
      }
36
   }
37
}

封装客户端菜单命令

1
// Menu 命令菜单
2
func (client *Client) Menu() bool {
3
   var code int
4
   fmt.Println("1: 公聊模式")
5
   fmt.Println("2: 私聊模式")
6
   fmt.Println("3: 更新用户名")
7
   fmt.Println("0: 退出")
8
   _, err := fmt.Scanln(&code)
9
   if err != nil {
10
      return false
11
   }
12
   if code >= 0 && code <= 3 {
13
      client.flag = code
14
      return true
15
   }
16
   return false
17
}

调整业务函数

1
func (client *Client) Run() {
2
   for client.flag != 0 {
3
      // 过滤非法的菜单code
4
      for !client.Menu() {
5
      }
6
      // 根据菜单code进行功能调度
7
      switch client.flag {
8
      case 1:
9
         client.publicChat()
10
         break
11
      case 2:
12
         client.privateChat()
13
         break
14
      case 3:
15
         client.updateUserName()
16
         break
17
      }
18
   }
19
}

完整代码

1
package main
2

3
import (
4
   "flag"
5
   "fmt"   "io"   "net"   "os")
6

7
var serverIp string
8
var serverPort int
9

10
type Client struct {
11
   ServerIp   string
12
   ServerPort int
13
   Name       string
14
   conn       net.Conn
15

16
   flag int
17
}
18

19
// NewClient 创建一个监听
20
func NewClient(serverIp string, serverPort int) *Client {
21
   client := &Client{
22
      ServerIp:   serverIp,
23
      ServerPort: serverPort,
24
      flag:       999,
25
   }
26
   // 建立tcp长链接
27
   conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", client.ServerIp, client.ServerPort))
28
   if err != nil {
29
      fmt.Println("dial err:", err)
30
      return nil
31
   }
32
   client.conn = conn
33
   return client
34
}
35

36
// Menu 命令菜单
37
func (client *Client) Menu() bool {
38
   var code int
39
   fmt.Println("1: 公聊模式")
40
   fmt.Println("2: 私聊模式")
41
   fmt.Println("3: 更新用户名")
42
   fmt.Println("0: 退出")
43
   _, err := fmt.Scanln(&code)
44
   if err != nil {
45
      return false
46
   }
47
   if code >= 0 && code <= 3 {
48
      client.flag = code
49
      return true
50
   }
51
   return false
52
}
53

54
// 包装更新用户名请求
55
func (client *Client) updateUserName() bool {
56
   fmt.Println(">>> 请输入用户名")
57
   _, err := fmt.Scanln(&client.Name)
58
   if err != nil {
59
      return false
60
   }
61
   sendMsg := "rename|" + client.Name + "\n"
62
   _, err = client.conn.Write([]byte(sendMsg))
63
   if err != nil {
64
      fmt.Println(">>> conn write err:", err)
65
      return false
66
   }
67
   return true
68
}
69

70
// 查询用户信息
71
func (client *Client) listUser() bool {
72
   sendMsg := "who\n"
73
   _, err := client.conn.Write([]byte(sendMsg))
74
   if err != nil {
75
      fmt.Println(">>> conn write err:", err)
76
      return false
77
   }
78
   return true
79
}
80

81
// PrivateChat 私聊模式
82
func (client *Client) privateChat() {
83
   var remote, chatMsg string
84
   client.listUser()
85
   for remote != "exit" {
86
      fmt.Println(">>> 请输入发送对象，输入exit退出")
87
      _, err := fmt.Scanln(&remote)
88
      if err != nil {
89
         return
90
      }
91
      for chatMsg != "exit" {
92
         if len(chatMsg) != 0 {
93
            // 发送消息到服务端
94
            sendMsg := "to|" + remote + "|" + chatMsg + "\n"
95
            _, err := client.conn.Write([]byte(sendMsg))
96
            if err != nil {
97
               fmt.Println(">>> conn write err:", err)
98
               break
99
            }
100
         }
101
         // 继续监听下一个发送信息，直到exit
102
         chatMsg = ""
103
         fmt.Println(">>> 请输入发送内容，输入exit退出")
104
         _, err := fmt.Scanln(&chatMsg)
105
         if err != nil {
106
            return
107
         }
108
      }
109
      // 内循环退出，继续监听输入内容选择用户，知道exit
110
      remote = ""
111
      fmt.Println(">>> 请输入发送对象，输入exit退出")
112
      _, err = fmt.Scanln(&remote)
113
      if err != nil {
114
         return
115
      }
116
   }
117
}
118

119
// PublicChat 公聊模式
120
func (client *Client) publicChat() {
121
   var chatMsg string
122
   fmt.Println(">>> 请输入发送内容，输入exit退出")
123
   _, err := fmt.Scanln(&chatMsg)
124
   if err != nil {
125
      return
126
   }
127
   for chatMsg != "exit" {
128
      if len(chatMsg) != 0 {
129
         sendMsg := chatMsg + "\n"
130
         _, err := client.conn.Write([]byte(sendMsg))
131
         if err != nil {
132
            fmt.Println(">>> conn write err:", err)
133
            break
134
         }
135
      }
136
      // 继续监听下一个发送信息，直到exit
137
      chatMsg = ""
138
      fmt.Println(">>> 请输入发送内容，输入exit退出")
139
      _, err := fmt.Scanln(&chatMsg)
140
      if err != nil {
141
         return
142
      }
143
   }
144
}
145

146
func (client *Client) Run() {
147
   for client.flag != 0 {
148
      // 过滤非法的菜单code
149
      for !client.Menu() {
150
      }
151
      // 根据菜单code进行功能调度
152
      switch client.flag {
153
      case 1:
154
         client.publicChat()
155
         break
156
      case 2:
157
         client.privateChat()
158
         break
159
      case 3:
160
         client.updateUserName()
161
         break
162
      }
163
   }
164
}
165

166
func init() {
167
   // 初始化配置，通过 -ip设置IP地址
168
   flag.StringVar(&serverIp, "i", "127.0.0.1", "设置服务器的IP地址(默认127.0.0.1)")
169
   // 初始化配置，通过 -p设置IP端口
170
   flag.IntVar(&serverPort, "p", 8888, "设置服务器的端口(默认8888)")
171
}
172

173
func (client *Client) DealResponse() {
174
   _, err := io.Copy(os.Stdout, client.conn)
175
   if err != nil {
176
      return
177
   }
178
}
179

180
func main() {
181
   // 命令行解析
182
   flag.Parse()
183
   client := NewClient(serverIp, serverPort)
184
   if client == nil {
185
      fmt.Println(">>> 链接服务器失败")
186
      return
187
   }
188
   go client.DealResponse()
189
   fmt.Println(">>> 链接服务器成功")
190
   client.Run()
191

192
}