Go后端开发 -- 即时通信系统
Go后端开发 – 即时通信系统
文章目录
- Go后端开发 -- 即时通信系统
- 一、即时通信系统
-
- 1.整体框架介绍
- 2.基础server构建
- 3.用户上线及广播功能
- 4.用户消息广播机制
- 5.用户业务封装
- 6.用户在线查询
- 7.修改用户名
- 8.超时强踢
- 9.私聊功能
- 10.完整代码
- 二、客户端实现
-
- 1.建立连接
- 2.命令行解析
- 3.菜单显示
- 4.更新用户名
- 5.公聊模式
- 6.私聊模式
- 7.完整代码
一、即时通信系统
1.整体框架介绍
- 虚线框内：server是服务器，user是用户
- server中：online map用来记录当前那些用户在线；channel用于进行广播；
- user中：一个用户对应两个go程，一个go程用于阻塞地从channel中读取消息，若有消息，会立即会写给客户端；另一个go程会阻塞等待客户端发消息；这是读写分离模型
2.基础server构建
server.go
- 定义Server结构体，成员有IP和Port；
- 定义NewServer函数，用于创建Server接口并返回；
- 定义Server的成员函数Start，用于启动服务：
- 监听套接字：
需要使用net.Listen()函数，network参数传入网络类型（tcp，udp），address参数传入监听的服务端地址，是IP:potr形式（可以使用fmt.Sprintf()进行格式化打印并返回字符串）；返回Listener监听套接字对象和error错误信息；
- 关闭listen socket
在创建完listen socket后，直接defer listener.Close()，关闭listen socket - accpet：
需要使用net.Listener.Accept()函数，返回一个Conn连接（可以进行读写）和error错误信息，若accept成功，Conn就是连接的读写套接字；
- 业务处理：
使用go程来进行业务处理；
- 监听套接字：
package main
import (
"fmt"
"net"
)
type Server struct {
IP string
Port int
}
// 创建一个server的接口
func NewServer(ip string, port int) *Server {
server := &Server{
IP: ip,
Port: port,
}
return server
}
func (svr *Server) Handler(conn net.Conn) {
//当前链接的任务
fmt.Println("链接建立成功")
}
// 启动服务器的接口
func (svr *Server) Start() {
// socket listen
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", svr.IP, svr.Port))
if err != nil {
fmt.Println("listen error :", err)
return
}
//close listen socket
defer listener.Close()
//accept
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("accpet error :", err)
continue
}
// do handler
go svr.Handler(conn)
}
}
main.go
- main函数创建Server对象，并启动服务
package main
func main() {
server := NewServer("127.0.0.1", 8888)
server.Start()
}
编译运行：
使用Linux原生nc指令模拟连接：
nc 127.0.0.1 8888
3.用户上线及广播功能
user.go
- 每个user都有一个channel，每个user都创建一个go程，监听channel是否有消息
- 定义User结构体，包含用户名、地址、channel、连接成员
- 定义ListenMessage为User的成员方法，用于监听当前User channel，一旦有消息，就直接发送给客户端
- 定义NewUser方法，用于创建User对象，启动go程调用当前User的ListenMessage方法
package main
import "net"
type User struct {
Name string
Addr string
C chan string //用户channel
conn net.Conn //与客户端的链接
}
func NewUser(conn net.Conn) *User {
//以地址名作为用户名
userAddr := conn.RemoteAddr().String()
user := &User{
Name: userAddr,
Addr: userAddr,
C: make(chan string),
conn: conn,
}
//启动监听当前User channel消息的goroutine
go user.ListenMessage()
return user
}
// 监听当前User channel的方法，一旦有消息，就直接发送给客户端
func (usr *User) ListenMessage() {
for {
msg := <-usr.C
usr.conn.Write([]byte(msg + "\n")) //使用二进制数组形式写入消息
}
}
server.go
- 需要补充两个属性：online map和message channel
- online map用于记录当前有哪些用户在线，并创建一个用于同步的读写锁
- go中关于同步的机制全在sync包中
- message channel用于广播消息
- Handler函数中，每有一个go程执行Handler函数，就代表有一个用户登陆了，现在Handler函数中创建该用户，再通过读写锁将新用户写入online map，然后广播该用户上线的消息；
- 定义BroadCast为Server的成员函数，在Handler函数中调用，用于将该用户上线的消息发送到当前Server的Message channel
- 定义ListenMessage函数为Server的成员函数，用于不断监听Message channel，一旦有数据就会发送给所有的用户channel，该函数在Start中创建一个goroutine执行；
package main
import (
"fmt"
"net"
"sync"
)
type Server struct {
IP string
Port int
//在线用户列表
OnlineMap map[string]*User
//读写锁
mapLock sync.RWMutex //go中同步的机制全在sync包中
//消息广播的channel
Message chan string
}
// 创建一个server的接口
func NewServer(ip string, port int) *Server {
server := &Server{
IP: ip,
Port: port,
OnlineMap: make(map[string]*User),
Message: make(chan string),
}
return server
}
// 不断监听Message channel的goroutine，一旦有消息就发送给全部的User
func (svr *Server) ListenMessage() {
for {
//从Message channel中读取数据
msg := <-svr.Message
//遍历onlinemap，将消息发送给所有的在线User
svr.mapLock.Lock()
for _, cli := range svr.OnlineMap {
cli.C <- msg
}
svr.mapLock.Unlock()
}
}
// 广播消息的方法
func (svr *Server) BroadCast(user *User, msg string) {
sendMsg := "[" + user.Addr + "]" + user.Name + ":" + msg
svr.Message <- sendMsg
}
func (svr *Server) Handler(conn net.Conn) {
//当前链接的任务
//fmt.Println("链接建立成功")
user := NewUser(conn)
//用户上线，加入到onlinemap中
svr.mapLock.Lock()
svr.OnlineMap[user.Name] = user
svr.mapLock.Unlock()
//广播当前用户上线消息
svr.BroadCast(user, "已上线")
//当前Handler阻塞，否则go程就结束了
select {}
}
// 启动服务器的接口
func (svr *Server) Start() {
// socket listen
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", svr.IP, svr.Port))
if err != nil {
fmt.Println("listen error :", err)
return
}
//close listen socket
defer listener.Close()
//循环监听Message的go程
go svr.ListenMessage()
//accept
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("accpet error :", err)
continue
}
//accept成功后，代表有个用户上线了
// do handler
go svr.Handler(conn)
}
}
编译运行：
用户上线广播功能已实现
4.用户消息广播机制
Server.go
- 在Handler函数中，增加接收用户消息的go程，由一个字节数组类型的缓冲区接收，使用
net.Conn.Read()函数接收链接发送的数据，该函数输入参数是一个字节类型数组，输出数据的长度和错误信息，接收完数据后，再进行广播
func (svr *Server) Handler(conn net.Conn) {
//当前链接的任务
//fmt.Println("链接建立成功")
user := NewUser(conn)
//用户上线，加入到onlinemap中
svr.mapLock.Lock()
svr.OnlineMap[user.Name] = user
svr.mapLock.Unlock()
//广播当前用户上线消息
svr.BroadCast(user, "已上线")
//接收用户发送的消息
go func() {
buf := make([]byte, 4096)
for {
n, err := user.conn.Read(buf)
//如果读取的消息长度为0，就代表当前用户已下线
if n == 0 {
svr.BroadCast(user, "已下线")
return
}
// err不是文件末尾
if err != nil && err != io.EOF {
fmt.Println("Conn read error:", err)
return
}
// 读取消息成功，提取用户消息，去除\n，然后广播
msg := string(buf[:n-1])
svr.BroadCast(user, msg)
}
}()
//当前Handler阻塞，否则go程就结束了
select {}
}
用户消息广播：
用户下线（ctrl + c）：
5.用户业务封装
调整Server和User的业务划分：
- 用户上线、下线和处理消息的功能都应该属于User的业务，我们将这三个业务调整到User业务中
- 用户上/下线：
需要向Server的OnlineMap中写入用户，因此当前User需要知道其属于哪个Server，需要在User成员中加入*Server指针 - 用户处理消息
也需要放在User的业务中，
Server.go
package main
import (
"fmt"
"io"
"net"
"sync"
)
type Server struct {
IP string
Port int
//在线用户列表
OnlineMap map[string]*User
//读写锁
mapLock sync.RWMutex //go中同步的机制全在sync包中
//消息广播的channel
Message chan string
}
// 创建一个server的接口
func NewServer(ip string, port int) *Server {
server := &Server{
IP: ip,
Port: port,
OnlineMap: make(map[string]*User),
Message: make(chan string),
}
return server
}
// 不断监听Message channel的goroutine，一旦有消息就发送给全部的User
func (svr *Server) ListenMessage() {
for {
//从Message channel中读取数据
msg := <-svr.Message
//遍历onlinemap，将消息发送给所有的在线User
svr.mapLock.Lock()
for _, cli := range svr.OnlineMap {
cli.C <- msg
}
svr.mapLock.Unlock()
}
}
// 广播消息的方法
func (svr *Server) BroadCast(user *User, msg string) {
sendMsg := "[" + user.Addr + "]" + user.Name + ":" + msg
svr.Message <- sendMsg
}
func (svr *Server) Handler(conn net.Conn) {
//创建新用户
user := NewUser(conn, svr)
//用户上线
user.Online()
//接收用户发送的消息
go func() {
buf := make([]byte, 4096)
for {
n, err := user.conn.Read(buf)
//如果读取的消息长度为0，就代表当前用户已下线
if n == 0 {
user.Offline()
return
}
// err不是文件末尾
if err != nil && err != io.EOF {
fmt.Println("Conn read error:", err)
return
}
// 读取消息成功，提取用户消息，去除\n，然后广播
msg := string(buf[:n-1])
user.DoMessage(msg)
}
}()
//当前Handler阻塞，否则go程就结束了
select {}
}
// 启动服务器的接口
func (svr *Server) Start() {
// socket listen
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", svr.IP, svr.Port))
if err != nil {
fmt.Println("listen error :", err)
return
}
//close listen socket
defer listener.Close()
//循环监听Message的go程
go svr.ListenMessage()
//accept
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("accpet error :", err)
continue
}
//accept成功后，代表有个用户上线了
// do handler
go svr.Handler(conn)
}
}
User.go
package main
import "net"
type User struct {
Name string
Addr string
C chan string //用户channel
conn net.Conn //与客户端的链接
svr *Server //当前用户属于哪个Server
}
func NewUser(connect net.Conn, server *Server) *User {
//以地址名作为用户名
userAddr := connect.RemoteAddr().String()
user := &User{
Name: userAddr,
Addr: userAddr,
C: make(chan string),
conn: connect,
svr: server,
}
//启动监听当前User channel消息的goroutine
go user.ListenMessage()
return user
}
// 监听当前User channel的方法，一旦有消息，就直接发送给客户端
func (usr *User) ListenMessage() {
for {
msg := <-usr.C
usr.conn.Write([]byte(msg + "\n")) //使用二进制数组形式写入消息
}
}
// 用户上线
func (usr *User) Online() {
//用户上线，加入到onlinemap中
usr.svr.mapLock.Lock()
usr.svr.OnlineMap[usr.Name] = usr
usr.svr.mapLock.Unlock()
//广播当前用户上线消息
usr.svr.BroadCast(usr, "已上线")
}
// 用户下线
func (usr *User) Offline() {
//用户上线，加入到onlinemap中
usr.svr.mapLock.Lock()
delete(usr.svr.OnlineMap, usr.Name)
usr.svr.mapLock.Unlock()
//广播当前用户上线消息
usr.svr.BroadCast(usr, "已下线")
}
// 用户处理消息
func (usr *User) DoMessage(msg string) {
usr.svr.BroadCast(usr, msg)
}
6.用户在线查询
- 查询用户在线功能是User的业务，可以在User处理消息的DoMessage函数中进行处理，特定的指令下触发
- 在查询到当前的在线用户后，需要将该条信息发送给当前User的客户端，因此还需要一个单发当前用户的方法
User.go
// 给当前User对应的客户端发消息(单发)
func (usr *User) SendMsg(msg string) {
usr.conn.Write([]byte(msg))
}
// 用户处理消息
func (usr *User) DoMessage(msg string) {
if msg == "who" {
//用户想查询所有在线用户
usr.svr.mapLock.Lock()
for _, user := range usr.svr.OnlineMap {
onlineUser := "[" + user.Addr + "]" + user.Name + ":" + "在线...\n"
usr.SendMsg(onlineUser)
}
usr.svr.mapLock.Unlock()
} else {
usr.svr.BroadCast(usr, msg)
}
}
7.修改用户名
- 修改用户名是User的业务，同样是在DoMessage中以特定的消息格式进行触发
- 首先以
rename|...格式作为用户名修改的消息格式 - 从msg中分离出新的用户名，使用
strings.Split(msg, "|")函数，该函数会按第二个参数来分割msg字符串，返回一个字符串数组 - 再查询online map中该用户是否已经存在，若存在，提醒用户；若不存在，则将原User在Online Map中删除，在加入新的名字的User
User.go
// 用户处理消息
func (usr *User) DoMessage(msg string) {
if msg == "who" {
//用户想查询所有在线用户
usr.svr.mapLock.Lock()
for _, user := range usr.svr.OnlineMap {
onlineUser := "[" + user.Addr + "]" + user.Name + ":" + "在线...\n"
usr.SendMsg(onlineUser)
}
usr.svr.mapLock.Unlock()
} else if len(msg) > 7 && msg[:7] == "rename|" {
//修改指令是 rename|...
newName := strings.Split(msg, "|")[1]
//首先查询onlinemap中是否存在该用户名
_, ok := usr.svr.OnlineMap[newName]
if ok {
fmt.Println("当前用户名已经被使用！")
} else {
//删除原用户名对应的user，并加入新的用户名
usr.svr.mapLock.Lock()
delete(usr.svr.OnlineMap, usr.Name)
usr.svr.OnlineMap[newName] = usr
usr.svr.mapLock.Unlock()
//更新User的用户名
usr.Name = newName
usr.SendMsg("您已更改用户名为:" + newName + "\n")
}
} else {
usr.svr.BroadCast(usr, msg)
}
}
8.超时强踢
- 用户长时间不活跃，就强制关闭链接，是Server的业务
- 在每个用户的Handler中，加入一个定时器
time.After(10 * time.Second)，该定时器经过10s后会触发，定时器本质是一个channel，在出发后里面是有数据可读的；当再次执行该函数时，定时器就会被重置； - 用户每发一次消息，定时器应当被重置，定义一个监听用户是否活跃的channel，用户每发一次消息，都会向该channel中写入数据
- 重置定时器用到了select语句的一个小技巧，在select监听语句中，将从监听用户是否活跃的channel
isLive中读数据的case写在定时器的case上面，每当isLive的case触发，select语句就会触发，下面的case也会尝试执行，进而重置了定时器
Server.go
func (svr *Server) Handler(conn net.Conn) {
//创建新用户
user := NewUser(conn, svr)
//用户上线
user.Online()
//监听用户是否活跃的channel
isLive := make(chan bool)
//接收用户发送的消息
go func() {
buf := make([]byte, 4096)
for {
//从链接中读取消息
n, err := user.conn.Read(buf)
//如果读取的消息长度为0，就代表当前用户已下线
if n == 0 {
user.Offline()
return
}
// err不是文件末尾
if err != nil && err != io.EOF {
fmt.Println("Conn read error:", err)
return
}
// 读取消息成功，提取用户消息，去除\n，然后广播
msg := string(buf[:n-1])
user.DoMessage(msg)
//每当用户发一次消息，就代表活跃
isLive <- true
}
}()
//当前Handler阻塞，否则go程就结束了
for {
select {
case <-isLive:
//当从isLive中读到数据时，下面的case也会执行一次，就重置了定时器
//不作任何处理，只是为了更新定时器
case <-time.After(10 * time.Second):
//该case触发，表明超时
//将当前的User强制关闭
user.SendMsg("你被踢了")
//销毁用户资源
close(user.C)
//关闭链接
conn.Close()
//退出当前Handler
return //或者runtime.Goexit()
}
}
}
9.私聊功能
- User的业务，在DoMessage中处理特定消息，定义消息格式为
to|张三|张三你好...
User.go
func (usr *User) DoMessage(msg string) {
if msg == "who" {
//用户想查询所有在线用户
usr.svr.mapLock.Lock()
for _, user := range usr.svr.OnlineMap {
onlineUser := "[" + user.Addr + "]" + user.Name + ":" + "在线...\n"
usr.SendMsg(onlineUser)
}
usr.svr.mapLock.Unlock()
} else if len(msg) > 7 && msg[:7] == "rename|" {
//修改指令是 rename|...
newName := strings.Split(msg, "|")[1]
//首先查询onlinemap中是否存在该用户名
_, ok := usr.svr.OnlineMap[newName]
if ok {
fmt.Println("当前用户名已经被使用！")
} else {
//删除原用户名对应的user，并加入新的用户名
usr.svr.mapLock.Lock()
delete(usr.svr.OnlineMap, usr.Name)
usr.svr.OnlineMap[newName] = usr
usr.svr.mapLock.Unlock()
//更新User的用户名
usr.Name = newName
usr.SendMsg("您已更改用户名为:" + newName + "\n")
}
} else if len(msg) > 4 && msg[:3] == "to|" {
//消息格式：to|张三|张三你好...
//获取对方用户名
remoteName := strings.Split(msg, "|")[1]
if remoteName == "" {
usr.SendMsg("私聊消息格式不正确，请使用\"to|张三|张三你好...\"格式\n")
return
}
//根据用户名找到User对象
remoteUser, ok := usr.svr.OnlineMap[remoteName]
if !ok {
usr.SendMsg(remoteName + "用户不存在\n")
return
}
//获取消息内容，通过User对象发送给对方
privateMsg := strings.Split(msg, "|")[2]
remoteUser.SendMsg(usr.Name + " : " + privateMsg)
} else {
usr.svr.BroadCast(usr, msg)
}
}
10.完整代码
现在基本的聊天功能已经实现，以下是完整代码：
server.go
package main
import (
"fmt"
"io"
"net"
"sync"
"time"
)
type Server struct {
IP string
Port int
//在线用户列表
OnlineMap map[string]*User
//读写锁
mapLock sync.RWMutex //go中同步的机制全在sync包中
//消息广播的channel
Message chan string
}
// 创建一个server的接口
func NewServer(ip string, port int) *Server {
server := &Server{
IP: ip,
Port: port,
OnlineMap: make(map[string]*User),
Message: make(chan string),
}
return server
}
// 不断监听Message channel的goroutine，一旦有消息就发送给全部的User
func (svr *Server) ListenMessage() {
for {
//从Message channel中读取数据
msg := <-svr.Message
//遍历onlinemap，将消息发送给所有的在线User
svr.mapLock.Lock()
for _, cli := range svr.OnlineMap {
cli.C <- msg
}
svr.mapLock.Unlock()
}
}
// 广播消息的方法
func (svr *Server) BroadCast(user *User, msg string) {
sendMsg := "[" + user.Addr + "]" + user.Name + ":" + msg
svr.Message <- sendMsg
}
func (svr *Server) Handler(conn net.Conn) {
//创建新用户
user := NewUser(conn, svr)
//用户上线
user.Online()
//监听用户是否活跃的channel
isLive := make(chan bool)
//接收用户发送的消息
go func() {
buf := make([]byte, 4096)
for {
//从链接中读取消息
n, err := user.conn.Read(buf)
//如果读取的消息长度为0，就代表当前用户已下线
if n == 0 {
user.Offline()
return
}
// err不是文件末尾
if err != nil && err != io.EOF {
fmt.Println("Conn read error:", err)
return
}
// 读取消息成功，提取用户消息，去除\n，然后广播
msg := string(buf[:n-1])
user.DoMessage(msg)
//每当用户发一次消息，就代表活跃
isLive <- true
}
}()
//当前Handler阻塞，否则go程就结束了
for {
select {
case <-isLive:
//当从isLive中读到数据时，下面的case也会执行一次，就重置了定时器
//不作任何处理，只是为了更新定时器
case <-time.After(60 * time.Second):
//该case触发，表明超时
//将当前的User强制关闭
user.SendMsg("你被踢了")
//销毁用户资源
close(user.C)
//关闭链接
conn.Close()
//退出当前Handler
return //或者runtime.Goexit()
}
}
}
// 启动服务器的接口
func (svr *Server) Start() {
// socket listen
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", svr.IP, svr.Port))
if err != nil {
fmt.Println("listen error :", err)
return
}
//close listen socket
defer listener.Close()
//循环监听Message的go程
go svr.ListenMessage()
//accept
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("accpet error :", err)
continue
}
//accept成功后，代表有个用户上线了
// do handler
go svr.Handler(conn)
}
}
user.go
package main
import (
"fmt"
"net"
"strings"
)
type User struct {
Name string
Addr string
C chan string //用户channel
conn net.Conn //与客户端的链接
svr *Server //当前用户属于哪个Server
}
func NewUser(connect net.Conn, server *Server) *User {
//以地址名作为用户名
userAddr := connect.RemoteAddr().String()
user := &User{
Name: userAddr,
Addr: userAddr,
C: make(chan string),
conn: connect,
svr: server,
}
//启动监听当前User channel消息的goroutine
go user.ListenMessage()
return user
}
// 监听当前User channel的方法，一旦有消息，就直接发送给客户端
func (usr *User) ListenMessage() {
for {
msg := <-usr.C
usr.conn.Write([]byte(msg + "\n")) //使用二进制数组形式写入消息
}
}
// 用户上线
func (usr *User) Online() {
//用户上线，加入到onlinemap中
usr.svr.mapLock.Lock()
usr.svr.OnlineMap[usr.Name] = usr
usr.svr.mapLock.Unlock()
//广播当前用户上线消息
usr.svr.BroadCast(usr, "已上线")
}
// 用户下线
func (usr *User) Offline() {
//用户上线，加入到onlinemap中
usr.svr.mapLock.Lock()
delete(usr.svr.OnlineMap, usr.Name)
usr.svr.mapLock.Unlock()
//广播当前用户上线消息
usr.svr.BroadCast(usr, "已下线")
}
// 给当前User对应的客户端发消息(单发)
func (usr *User) SendMsg(msg string) {
usr.conn.Write([]byte(msg))
}
// 用户处理消息
func (usr *User) DoMessage(msg string) {
if msg == "who" {
//用户想查询所有在线用户
usr.svr.mapLock.Lock()
for _, user := range usr.svr.OnlineMap {
onlineUser := "[" + user.Addr + "]" + user.Name + ":" + "在线...\n"
usr.SendMsg(onlineUser)
}
usr.svr.mapLock.Unlock()
} else if len(msg) > 7 && msg[:7] == "rename|" {
//修改指令是 rename|...
newName := strings.Split(msg, "|")[1]
//首先查询onlinemap中是否存在该用户名
_, ok := usr.svr.OnlineMap[newName]
if ok {
fmt.Println("当前用户名已经被使用！")
} else {
//删除原用户名对应的user，并加入新的用户名
usr.svr.mapLock.Lock()
delete(usr.svr.OnlineMap, usr.Name)
usr.svr.OnlineMap[newName] = usr
usr.svr.mapLock.Unlock()
//更新User的用户名
usr.Name = newName
usr.SendMsg("您已更改用户名为:" + newName + "\n")
}
} else if len(msg) > 4 && msg[:3] == "to|" {
//消息格式：to|张三|张三你好...
//获取对方用户名
remoteName := strings.Split(msg, "|")[1]
if remoteName == "" {
usr.SendMsg("私聊消息格式不正确，请使用\"to|张三|张三你好...\"格式\n")
return
}
//根据用户名找到User对象
remoteUser, ok := usr.svr.OnlineMap[remoteName]
if !ok {
usr.SendMsg(remoteName + "用户不存在\n")
return
}
//获取消息内容，通过User对象发送给对方
privateMsg := strings.Split(msg, "|")[2]
remoteUser.SendMsg(usr.Name + " : " + privateMsg)
} else {
usr.svr.BroadCast(usr, msg)
}
}
main.go
package main
func main() {
server := NewServer("127.0.0.1", 8888)
server.Start()
}
二、客户端实现
1.建立连接
- 定义Client结构体，基本属性有：Server的IP、端口、用户名、链接套接字
- 定义NewClient函数用于创建客户端对象，并连接服务器；
使用net.Dial()函数连接服务器，输入参数是协议类型和服务器地址（ip:port），输出链接套接字和错误信息
client.go
package main
import (
"fmt"
"net"
)
type Client struct {
ServerIP string
ServerPort int
ClientName string
conn net.Conn
}
func NewClient(serverIP string, serverPotr int) *Client {
//创建客户端对象
client := &Client{
ServerIP: serverIP,
ServerPort: serverPotr,
}
//链接server
conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPotr))
if err != nil {
fmt.Println("net.Dial error:", err)
return nil
}
client.conn = conn
//返回对象
return client
}
func main() {
client := NewClient("127.0.0.1", 8888)
if client == nil {
fmt.Println(">>>>>>>>链接服务器失败>>>>>>>>")
return
}
fmt.Println(">>>>>>>>链接服务器成功>>>>>>>>>")
//启动客户端业务
select {}
}
2.命令行解析
- go解析命令行需要借助flag库函数：
flag.StringVar()函数用来将命令行参数绑定string变量，输入参数p为要写入的string类型的变量，name为当前命令行参数的提示符，value为当前参数的默认值，usage是对当前参数的说明；同理int类型参数写入需要使用flag.IntVar() - 参数绑定的操作在
init()函数中实现，在main()函数中调用flag.Parse()函数进行命令行解析，检测执行该程序时，命令行是否有参数 - 参数绑定一定要在进程之前，可以在
init()函数中实现，也可以在main()函数的第一行实现，之后调用flag.Parse()进行命令行解析
client.go
package main
import (
"flag"
"fmt"
"net"
)
type Client struct {
ServerIP string
ServerPort int
ClientName string
conn net.Conn
}
func NewClient(serverIP string, serverPotr int) *Client {
//创建客户端对象
client := &Client{
ServerIP: serverIP,
ServerPort: serverPort,
}
//链接server
conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPotr))
if err != nil {
fmt.Println("net.Dial error:", err)
return nil
}
client.conn = conn
//返回对象
return client
}
var serverIP string
var serverPort int
func init() {
flag.StringVar(&serverIP, "ip", "127.0.0.1", "设置服务器IP地址(默认为127.0.0.1)")
flag.IntVar(&serverPort, "port", 8888, "设置服务器端口号(默认为8888)")
}
func main() {
//命令行解析
flag.Parse()
client := NewClient("127.0.0.1", 8888)
if client == nil {
fmt.Println(">>>>>>>>链接服务器失败>>>>>>>>")
return
}
fmt.Println(">>>>>>>>链接服务器成功>>>>>>>>>")
//启动客户端业务
select {}
}
3.菜单显示
- 定义Client的成员函数
menu()，用于菜单显示 - 定义Client的成员函数
Run()，用于客户端的启动
package main
import (
"flag"
"fmt"
"net"
)
type Client struct {
ServerIP string
ServerPort int
ClientName string
conn net.Conn
flag int // 当前客户端的模型
}
func NewClient(serverIP string, serverPotr int) *Client {
//创建客户端对象
client := &Client{
ServerIP: serverIP,
ServerPort: serverPort,
flag: 999,
}
//链接server
conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPotr))
if err != nil {
fmt.Println("net.Dial error:", err)
return nil
}
client.conn = conn
//返回对象
return client
}
func (clt *Client) menu() bool {
var flag int
fmt.Println("*****************************")
fmt.Println("**********1.公聊模式**********")
fmt.Println("**********2.私聊模式**********")
fmt.Println("**********3.更新用户名********")
fmt.Println("**********0.退出**************")
fmt.Println("******************************")
fmt.Scanln(&flag) // 输入flag
if flag >= 0 && flag <= 3 {
clt.flag = flag
return true
} else {
fmt.Println(">>>>>>请输入合法的flag!<<<<<<")
return false
}
}
func (clt *Client) Run() {
for clt.flag != 0 {
//模式不对就一直循环菜单
for clt.menu() == false {
}
//根据不同的模式处理不同的业务
switch clt.flag {
case 1:
//公聊模式
fmt.Println("公聊模式")
case 2:
//私聊模式
fmt.Println("私聊模式")
case 3:
//更新用户名
fmt.Println("更新用户名")
}
}
}
var serverIP string
var serverPort int
func init() {
flag.StringVar(&serverIP, "ip", "127.0.0.1", "设置服务器IP地址(默认为127.0.0.1)")
flag.IntVar(&serverPort, "port", 8888, "设置服务器端口号(默认为8888)")
}
func main() {
//命令行解析
flag.Parse()
client := NewClient("127.0.0.1", 8888)
if client == nil {
fmt.Println(">>>>>>>>链接服务器失败>>>>>>>>")
return
}
fmt.Println(">>>>>>>>链接服务器成功>>>>>>>>>")
//启动客户端业务
client.Run()
}
4.更新用户名
- 定义Client的成员函数
UpdateName，用于处理用户名更新业务，将新的用户名封装成更改用户名的指令，并通过conn.Write()函数直接发送给客户端进行处理； - 客户端还需要接受服务端返回的消息，由于当前客户端go程阻塞在这个业务处，无法再从连接中读取消息，因此应该由另外的go程来从链接中读取消息
- 定义Client的成员函数
DealResponse，用于不断阻塞读取服务端的回执消息，直接使用io.Copy()函数将套接字conn的数据拷贝到标准输出；该函数在main中以新的go程执行
上面的一行代码等价于下面的代码功能：
package main
import (
"flag"
"fmt"
"io"
"net"
"os"
)
type Client struct {
ServerIP string
ServerPort int
ClientName string
conn net.Conn
flag int // 当前客户端的模型
}
func NewClient(serverIP string, serverPotr int) *Client {
//创建客户端对象
client := &Client{
ServerIP: serverIP,
ServerPort: serverPort,
flag: 999,
}
//链接server
conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPotr))
if err != nil {
fmt.Println("net.Dial error:", err)
return nil
}
client.conn = conn
//返回对象
return client
}
func (clt *Client) menu() bool {
var flag int
fmt.Println("*****************************")
fmt.Println("**********1.公聊模式**********")
fmt.Println("**********2.私聊模式**********")
fmt.Println("**********3.更新用户名********")
fmt.Println("**********0.退出**************")
fmt.Println("******************************")
fmt.Scanln(&flag) // 输入flag
if flag >= 0 && flag <= 3 {
clt.flag = flag
return true
} else {
fmt.Println(">>>>>>请输入合法的flag!<<<<<<")
return false
}
}
func (clt *Client) Run() {
for clt.flag != 0 {
//模式不对就一直循环菜单
for clt.menu() == false {
}
//根据不同的模式处理不同的业务
switch clt.flag {
case 1:
//公聊模式
fmt.Println("公聊模式")
case 2:
//私聊模式
fmt.Println("私聊模式")
case 3:
//更新用户名
clt.UpdateName()
}
}
}
func (clt *Client) UpdateName() bool {
fmt.Println(">>>>请输入用户名：")
fmt.Scanln(&clt.ClientName)
sendMsg := "rename|" + clt.ClientName + "\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
return false
}
return true
}
func (clt *Client) DealResponse() {
//不断阻塞等待套接字conn的数据，并copy到stdout中
//一旦clt.conn有数据，就直接拷贝到stdout中，是永久阻塞的
io.Copy(os.Stdout, clt.conn)
//上面的一行代码等价于下面的代码
// for {
// buf := make([]byte, 4096)
// clt.conn.Read(buf)
// fmt.Println(buf)
// }
}
var serverIP string
var serverPort int
func init() {
flag.StringVar(&serverIP, "ip", "127.0.0.1", "设置服务器IP地址(默认为127.0.0.1)")
flag.IntVar(&serverPort, "port", 8888, "设置服务器端口号(默认为8888)")
}
func main() {
//命令行解析
flag.Parse()
client := NewClient("127.0.0.1", 8888)
if client == nil {
fmt.Println(">>>>>>>>链接服务器失败>>>>>>>>")
return
}
fmt.Println(">>>>>>>>链接服务器成功>>>>>>>>>")
//单独开启一个goroutine，去处理server的回执消息
go client.DealResponse()
//启动客户端业务
client.Run()
}
5.公聊模式
- 定义Client的成员函数
PublicChat，用于处理公聊业务，用户的信息打包发送给服务端
func (clt *Client) Run() {
for clt.flag != 0 {
//模式不对就一直循环菜单
for clt.menu() == false {
}
//根据不同的模式处理不同的业务
switch clt.flag {
case 1:
//公聊模式
fmt.Println(">>>>>>公聊模式,输入exit退出")
clt.PublicChat()
case 2:
//私聊模式
fmt.Println("私聊模式")
case 3:
//更新用户名
clt.UpdateName()
}
}
}
func (clt *Client) PublicChat() {
var chatMsg string
fmt.Println(">>>>>请输入聊天内容:")
fmt.Scanln(&chatMsg)
for chatMsg != "exit" {
//消息不为空则发送给服务器
if len(chatMsg) != 0 {
sendMsg := chatMsg + "\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
break
}
}
chatMsg = ""
fmt.Println(">>>>>请输入聊天内容:")
fmt.Scanln(&chatMsg)
}
}
6.私聊模式
- 私聊模式的流程：先查询哪些用户在线，在提示用户选择另一个用户进行私聊
- 定义Client的成员函数
PrivateChat，用于处理私聊业务 - 定义Client的成员函数
SelectUsers()，用于返回在线用户
func (clt *Client) Run() {
for clt.flag != 0 {
//模式不对就一直循环菜单
for clt.menu() == false {
}
//根据不同的模式处理不同的业务
switch clt.flag {
case 1:
//公聊模式
fmt.Println(">>>>>>公聊模式,输入exit退出")
clt.PublicChat()
case 2:
//私聊模式
fmt.Println(">>>>>>私聊模式,输入exit退出")
clt.PrivateChat()
case 3:
//更新用户名
clt.UpdateName()
}
}
}
// 查询在线用户
func (clt *Client) SelectUsers() {
sendMsg := "who\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
return
}
}
func (clt *Client) PrivateChat() {
clt.SelectUsers()
var remoteName string
var chatMsg string
fmt.Println(">>>>>>请输入聊天对象(用户名),输入exit退出:")
fmt.Scanln(&remoteName)
for remoteName != "exit" {
fmt.Println(">>>>>>请输入消息内容,输入exit退出:")
fmt.Scanln(&chatMsg)
for chatMsg != "exit" {
//消息不为空则发送给服务器
if len(chatMsg) != 0 {
sendMsg := "to|" + remoteName + "|" + chatMsg + "\n\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
break
}
}
chatMsg = ""
fmt.Println(">>>>>请输入消息内容,输入exit退出:")
fmt.Scanln(&chatMsg)
}
clt.SelectUsers()
fmt.Println(">>>>>>请输入聊天对象(用户名),输入exit退出:")
fmt.Scanln(&remoteName)
}
}
7.完整代码
client.go
package main
import (
"flag"
"fmt"
"io"
"net"
"os"
)
type Client struct {
ServerIP string
ServerPort int
ClientName string
conn net.Conn
flag int // 当前客户端的模型
}
func NewClient(serverIP string, serverPotr int) *Client {
//创建客户端对象
client := &Client{
ServerIP: serverIP,
ServerPort: serverPort,
flag: 999,
}
//链接server
conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", serverIP, serverPotr))
if err != nil {
fmt.Println("net.Dial error:", err)
return nil
}
client.conn = conn
//返回对象
return client
}
func (clt *Client) menu() bool {
var flag int
fmt.Println("*****************************")
fmt.Println("**********1.公聊模式**********")
fmt.Println("**********2.私聊模式**********")
fmt.Println("**********3.更新用户名********")
fmt.Println("**********0.退出**************")
fmt.Println("******************************")
fmt.Scanln(&flag) // 输入flag
if flag >= 0 && flag <= 3 {
clt.flag = flag
return true
} else {
fmt.Println(">>>>>>请输入合法的flag!<<<<<<")
return false
}
}
func (clt *Client) Run() {
for clt.flag != 0 {
//模式不对就一直循环菜单
for clt.menu() == false {
}
//根据不同的模式处理不同的业务
switch clt.flag {
case 1:
//公聊模式
fmt.Println(">>>>>>公聊模式,输入exit退出")
clt.PublicChat()
case 2:
//私聊模式
fmt.Println(">>>>>>私聊模式,输入exit退出")
clt.PrivateChat()
case 3:
//更新用户名
clt.UpdateName()
}
}
}
func (clt *Client) UpdateName() bool {
fmt.Println(">>>>请输入用户名：")
fmt.Scanln(&clt.ClientName)
sendMsg := "rename|" + clt.ClientName + "\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
return false
}
return true
}
func (clt *Client) DealResponse() {
//不断阻塞等待套接字conn的数据，并copy到stdout中
//一旦clt.conn有数据，就直接拷贝到stdout中，是永久阻塞的
io.Copy(os.Stdout, clt.conn)
//上面的一行代码等价于下面的代码
// for {
// buf := make([]byte, 4096)
// clt.conn.Read(buf)
// fmt.Println(buf)
// }
}
func (clt *Client) PublicChat() {
var chatMsg string
fmt.Println(">>>>>请输入聊天内容:")
fmt.Scanln(&chatMsg)
for chatMsg != "exit" {
//消息不为空则发送给服务器
if len(chatMsg) != 0 {
sendMsg := chatMsg + "\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
break
}
}
chatMsg = ""
fmt.Println(">>>>>请输入聊天内容:")
fmt.Scanln(&chatMsg)
}
}
// 查询在线用户
func (clt *Client) SelectUsers() {
sendMsg := "who\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
return
}
}
func (clt *Client) PrivateChat() {
clt.SelectUsers()
var remoteName string
var chatMsg string
fmt.Println(">>>>>>请输入聊天对象(用户名),输入exit退出:")
fmt.Scanln(&remoteName)
for remoteName != "exit" {
fmt.Println(">>>>>>请输入消息内容,输入exit退出:")
fmt.Scanln(&chatMsg)
for chatMsg != "exit" {
//消息不为空则发送给服务器
if len(chatMsg) != 0 {
sendMsg := "to|" + remoteName + "|" + chatMsg + "\n\n"
_, err := clt.conn.Write([]byte(sendMsg))
if err != nil {
fmt.Println("conn.Write error:", err)
break
}
}
chatMsg = ""
fmt.Println(">>>>>请输入消息内容,输入exit退出:")
fmt.Scanln(&chatMsg)
}
clt.SelectUsers()
fmt.Println(">>>>>>请输入聊天对象(用户名),输入exit退出:")
fmt.Scanln(&remoteName)
}
}
var serverIP string
var serverPort int
func init() {
flag.StringVar(&serverIP, "ip", "127.0.0.1", "设置服务器IP地址(默认为127.0.0.1)")
flag.IntVar(&serverPort, "port", 8888, "设置服务器端口号(默认为8888)")
}
func main() {
//命令行解析
flag.Parse()
client := NewClient("127.0.0.1", 8888)
if client == nil {
fmt.Println(">>>>>>>>链接服务器失败>>>>>>>>")
return
}
fmt.Println(">>>>>>>>链接服务器成功>>>>>>>>>")
//单独开启一个goroutine，去处理server的回执消息
go client.DealResponse()
//启动客户端业务
client.Run()
}