Golang练手------简单聊天系统（文件）

最新推荐文章于 2025-02-05 10:51:03 发布
最新推荐文章于 2025-02-05 10:51:03 发布
阅读量2.5k 收藏 4
点赞数
分类专栏： Golang 文章标签： Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yijiull/article/details/81676961
版权

为了看Fabric的源码，前几天开始学了Go语言，看得是《Go语言圣经》，基本看了一遍，感觉还是比较容易上手，不过因为grpc和一些Go的库我都还不熟悉，现在看源码还是有点费劲，到现在也没怎么看。
不过Go语言学了就得练一下，不写代码估计过几天就跟没学一样了，（就像前几天学的js一样=_=||
所以今天找时间做了个聊天系统，比较简单，主要拿来熟悉一下Go语言…
过几天有空会试着用grpc写一下，再把文件改成数据库试试～

Created with Raphaël 2.1.2 client client server server register（注册） login（登录） logoff（注销登录） exit（退出系统） add（添加好友） delete（删除好友） list（获取好友列表） sendTo（向好友发消息） sendAll（群发消息）

TODO：

  • 客户端多重登陆问题

客户端：client.go

package main

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

func main() {

    //cinq := bufio.NewScanner(os.Stdin)
    //if cinq.Scan() {
    //  fmt.Printf(cinq.Text())
    //}
    //if cinq.Scan() {
    //  fmt.Printf(cinq.Text())
    //}
    //if cinq.Scan() {
    //  fmt.Printf(cinq.Text())
    //}

    conn, err := net.Dial("tcp", "localhost:8000")
    defer conn.Close()
    if err != nil {
        log.Fatal(err)
    }
    done := make(chan struct{})
    go func() {
        io.Copy(os.Stdout, conn) // NOTE: ignoring errors
        log.Println("done")
        done <- struct{}{} // signal the main goroutine
    }()
    ch := make(chan string)
    go clientWriter(conn, ch)
    cin := bufio.NewScanner(os.Stdin)
    for cin.Scan() {
        switch cin.Text() {
        case "register":
            ch <- "register"
            var userName, password, tel string
            fmt.Print("请输入用户名：")
            if cin.Scan() {
                userName = cin.Text()
            }
            fmt.Print("请输入密码：")
            if cin.Scan() {
                password = cin.Text()
            }
            fmt.Print("请输入手机号：")
            if cin.Scan() {
                tel = cin.Text()
            }
            ch <- userName
            ch <- password
            ch <- tel
        case "login":
            ch <- "login"
            var userName, password string
            fmt.Print("请输入用户名：")
            if cin.Scan() {
                userName = cin.Text()
            }
            fmt.Print("请输入密码：")
            if cin.Scan() {
                password = cin.Text()
            }
            ch <- userName
            ch <- password
        case "logoff":
            ch <- "logoff"
        case "exit":
            os.Exit(0)
        case "add":
            var userName string
            fmt.Print("请输入要添加好友的用户名：")
            if cin.Scan() {
                userName = cin.Text()
            }
            ch <- "add"
            ch <- userName
        case "delete":
            fmt.Print("请输入要删除好友的用户名：")
            var userName string
            if cin.Scan() {
                userName = cin.Text()
            }
            ch <- "delete"
            ch <- userName
        case "list":
            ch <- "list"
        case "sendTo":
            var userName, content string
            fmt.Print("请输入好友用户名：")
            if cin.Scan() {
                userName = cin.Text()
            }
            fmt.Print("请输入消息：")
            if cin.Scan() {
                content = cin.Text()
            }
            ch <- "sendTo"
            ch <- userName
            ch <- content
        case "sendAll":
            var content string
            fmt.Print("请输入消息：")
            if cin.Scan() {
                content = cin.Text()
            }
            ch <- "sendAll"
            ch <- content
        default:
            ch <- "none"
        }

    }
    //conn.Close() //前面用了defer
    <-done // wait for background goroutine to finish
}
func mustCopy(conn net.Conn, src io.Reader) {
    if _, err := io.Copy(conn, src); err != nil {
        log.Fatal(err)
    }
}

func clientWriter(conn net.Conn, ch <-chan string) {
    for msg := range ch {
        fmt.Fprintln(conn, msg)
    }
}

服务器端：server.go

package main

import (
    "bufio"
    "fmt"
    "io/ioutil"
    "log"
    "net"
    "os"
    "time"
)

func help() string {
    return (`
    please choose options:
        - register : 注册。            格式:"register"
        - login    : 登录。            格式:"login"
        - logoff   : 注销登录。         格式:"logoff"
        - exit     : 退出系统。         格式:"exit"
        - add      : 添加好友。         格式:"add"
        - delete   : 删除好友。         格式:"delete"
        - list     : 查看好友列表。      格式:"list"
        - sendTo   : 给某位好友发送消息。 格式:"sendTo"
        - sendAll  : 给全部好友发送消息。 格式:"sendAll"
        `)
}

/*
Client is a demo
*/
type Client struct {
    userName string
}
type userCH chan<- string

var (
    messages = make(chan string)
    entering = make(chan userCH)
    leaving  = make(chan userCH)
    clients  = make(map[string]userCH)
)

func main() {
    listener, err := net.Listen("tcp", "localhost:8000")
    if err != nil {
        log.Fatal(err)
    }
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Print(err)
            continue
        }
        go handle(conn)
    }
}

func handle(conn net.Conn) {
    var client *Client
    ch := make(chan string)
    go clientWriter(conn, ch)
    who := conn.RemoteAddr().String()
    ch <- "welcome! " + who
    ch <- help()
    ch <- ">>"
    input := bufio.NewScanner(conn)
    for input.Scan() {
        var op = input.Text()
        fmt.Println(op)
        switch op {
        case "register":
            //register
            ok := register(input)
            if !ok {
                ch <- "Fail register=_=||\nmaybe your userName or phoneNumber is invalid"
            } else {
                ch <- "Success register!"
            }
        case "login":
            //login
            client = login(input)
            if client != nil {
                clients[client.userName] = ch
                ch <- "Success logi!\n" + "Your new messages:"
                client.toRead(ch)
            } else {
                ch <- "Fail login=_=||maybe your userName or password is wrong,please check them carefully:)"
            }
        case "logoff":
            if client == nil {
                ch <- "Please login first:)"
            } else {
                ch <- "you logoff successfully!"
                clients[client.userName] = nil
                client = nil
            }
        case "add":
            var userName string
            if input.Scan() {
                userName = input.Text()
            }
            if client == nil {
                ch <- "Please login first:)"
            } else {
                ok := client.addFriend(userName)
                if ok {
                    ch <- "add successfully!"
                } else {
                    ch <- "maybe no such user=_=||"
                }
            }
        case "delete":
            var userName string
            if input.Scan() {
                userName = input.Text()
            }
            if client == nil {
                ch <- "Please login first:)"
            } else {
                ok := client.deleteFriend(userName)
                if ok {
                    ch <- "delete successfully!"
                } else {
                    ch <- "maybe no such user=_=||"
                }
            }
        case "list":
            if client == nil {
                ch <- "Please login first:)"
            } else {
                ch <- client.list()
            }
        case "sendTo":
            if client == nil {
                ch <- "Please login first:)"
            } else {
                var userName, content string
                if input.Scan() {
                    userName = input.Text()
                }
                if input.Scan() {
                    content = input.Text()
                }
                ok := client.sendTo(userName, content)
                if ok {
                    ch <- "发送成功"
                } else {
                    ch <- "发送失败，可能你没有这个好友:)"
                }
            }
        case "sendAll":
            if client == nil {
                ch <- "Please login first:)"
            } else {
                var content string
                if input.Scan() {
                    content = input.Text()
                }
                client.sendAll(content)
            }
        default:
            ch <- "无法识别的命令=_=||请重新输入正确的命令:)"
            ch <- help()
        }
        ch <- ">>"
    }
    conn.Close()
}

func clientWriter(conn net.Conn, ch chan string) {
    for msg := range ch {
        fmt.Fprintln(conn, msg)
    }
}

//读取文件user.txt，判断手机号和用户名是否重复注册
//将注册信息写入user.txt
//如果成功就创建messages、logs、friends等.txt文件
func register(cin *bufio.Scanner) bool {
    var userName, password, tel string
    if cin.Scan() {
        userName = cin.Text()
    }
    if cin.Scan() {
        password = cin.Text()
    }
    if cin.Scan() {
        tel = cin.Text()
    }
    file, err := os.OpenFile("user.txt", os.O_RDWR|os.O_CREATE, 0644)
    defer file.Close()
    if err != nil {
        fmt.Println("in func register: open user.txt")
    }
    for {
        var name, pwd, phone string
        _, err := fmt.Fscan(file, &name, &pwd, &phone) //读取三个string
        if err != nil {
            break
        }
        fmt.Println(userName, name, tel, phone)
        if userName == name && tel == phone {
            return false
        }
    }
    file.Write([]byte("\n" + userName + " " + password + " " + tel))
    createInfo(userName)
    return true
}

func createInfo(userName string) {
    file, err := os.OpenFile("friendsOf"+userName+".txt", os.O_CREATE, 0664)
    if err != nil {
        log.Fatalln("in func createInfo: ---")
    }
    file.Close()
    file, err = os.OpenFile("messagesOf"+userName+".txt", os.O_CREATE, 0664)
    file.Close()
    file, err = os.OpenFile("logsOf"+userName+".txt", os.O_CREATE, 0664)
    file.Close()
}

//读取user.txt,判断是否有这个用户以及密码是否正确
//上线后自动查看收件箱，显示未读消息
func login(cin *bufio.Scanner) *Client {
    var userName, password string
    if cin.Scan() {
        userName = cin.Text()
    }
    if cin.Scan() {
        password = cin.Text()
    }
    file, err := os.Open("user.txt")
    defer file.Close()
    if err != nil {
        fmt.Println("func register: open user.txt")
    }
    for {
        var name, pwd, phone string
        _, err := fmt.Fscan(file, &name, &pwd, &phone) //读取三个string
        if err != nil {
            fmt.Println(err)
            break
        }
        if userName == name && pwd == password {
            var client Client
            client.userName = userName
            //  client.ch = make(chan string)
            //  go clientWriter(conn, client.ch)
            //  clients[userName] = client.ch
            return &client
        }
    }
    return nil
}

func (c *Client) toRead(ch chan string) {
    messages := "messagesOf" + c.userName + ".txt"
    logs := "logsOf" + c.userName + ".txt"
    msgsfile, err := os.OpenFile(messages, os.O_RDWR, 0666) //读写
    defer msgsfile.Close()
    logsfile, err := os.OpenFile(logs, os.O_APPEND|os.O_WRONLY, 0666)
    defer logsfile.Close()
    if err != nil {
        log.Fatalln("func toRead, fail to open file")
    }
    for {
        //格式 ： 时间、好友名字、信息内容
        var t, n, content string
        _, err := fmt.Fscan(msgsfile, &t, &n, &content)
        if err != nil {
            //log.Fatalln("messagesfuserName.txt went wrong! in to read")
            fmt.Println(err)
            break
        }
        temp := t + " " + n + " " + content
        //fmt.Println(temp)
        _, err = logsfile.Write([]byte("\n" + t + " " + n + " " + c.userName + " " + content))
        if err != nil {
            fmt.Println("write logs wrong! in func toRead")
        }
        ch <- temp
    }
    msgsfile.Seek(0, 0)  //second para: (0:begin) (1:cur) (2:end)
    msgsfile.Truncate(0) //清空未读消息
}

func (c *Client) addFriend(userName string) bool {
    userFile := "user.txt"
    file, err := os.Open(userFile)
    defer file.Close()
    if err != nil {
        log.Fatalln("in func addFriend: open user.txt")
    }
    var name, pwd, phone string
    for {
        _, err = fmt.Fscan(file, &name, &pwd, &phone)
        if err != nil { //EOF?? //TODO
            break
        }
        if name == userName {
            friendFile, err := os.OpenFile("friendsOf"+c.userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
            defer friendFile.Close()
            if err != nil {
                log.Fatalln("in func addFriend: open friendsOf" + c.userName + ".txt")
            }
            friendFile.Write([]byte("\n" + userName))
            return true
        }
    }
    return false
}
func (c *Client) deleteFriend(userName string) bool {
    friendFile, err := os.OpenFile("friendsOf"+c.userName+".txt", os.O_RDWR, 0666)
    defer friendFile.Close()
    if err != nil {
        log.Fatalln("in func deleteFriend: open friendsOf" + c.userName + ".txt")
    }
    var name, sum string
    var ok = false
    for {
        _, err := fmt.Fscan(friendFile, &name)
        if err != nil {
            break
        }
        if name == userName {
            ok = true
        } else {
            sum += "\n" + name
        }
    }
    if ok {
        friendFile.Seek(0, 0)
        friendFile.Truncate(0) //这里是截断是不是清除内容待验证 //TODO
        friendFile.Write([]byte(sum))
    }
    return ok
}
func (c *Client) list() string {
    filename := "friendsOf" + c.userName + ".txt"
    file, err := os.Open(filename)
    if err != nil {
        return ""
    }
    res, _ := ioutil.ReadAll(file)
    return string(res)
}
func (c *Client) sendTo(userName, content string) bool {
    msg := "\n" + time.Now().Format("2006-01-02_15:04:05") + " " + c.userName + " " + content
    msglog := "\n" + time.Now().Format("2006-01-02_15:04:05") + " " + c.userName + " " + userName + " " + content
    friendFile, err := os.OpenFile("friendsOf"+c.userName+".txt", os.O_RDONLY, 0666)
    if err != nil {
        log.Fatalln("in func sendAll: open friendsOf" + c.userName + ".txt")
    }
    var friend string
    var ok bool
    for {
        _, err := fmt.Fscan(friendFile, &friend)
        if err != nil {
            break
        }
        if friend == userName {
            ok = true
            break
        }
    }
    friendFile.Close()
    if ok {
        if clients[userName] != nil {
            clients[userName] <- msg
            logsFile, err := os.OpenFile("logsOf"+userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
            if err != nil {
                log.Fatalln("in func sendTo: open logsOf" + userName + ".txt")
            }
            logsFile.Write([]byte(msglog))
            logsFile.Close()
        } else {
            msgsFile, err := os.OpenFile("messagesOf"+userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
            if err != nil {
                log.Fatalln("in func sendTo: open messagesOf" + userName + ".txt")
            }
            msgsFile.Write([]byte(msg))
            msgsFile.Close()
        }
        logsFile, err := os.OpenFile("logsOf"+c.userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
        if err != nil {
            log.Fatalln("in func sendTo: open logsOf" + c.userName + ".txt")
        }
        logsFile.Write([]byte(msglog))
        logsFile.Close()
        return true
    }
    return false
}
func (c *Client) sendAll(content string) bool {
    msg := "\n" + time.Now().Format("2006-01-02_15:04:05") + " " + c.userName + " " + content
    friendFile, err := os.OpenFile("friendsOf"+c.userName+".txt", os.O_RDONLY, 0666)
    if err != nil {
        log.Fatalln("in func sendAll: open friendsOf" + c.userName + ".txt")
    }
    file, err := os.OpenFile("logsOf"+c.userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
    if err != nil {
        log.Fatalln("in func sendAll: open logsOf" + c.userName + ".txt")
    }
    defer file.Close()
    var userName, msglog string
    for {
        _, err := fmt.Fscan(friendFile, &userName)
        if err != nil {
            break
        }
        msglog = "\n" + time.Now().Format("2006-01-02_15:04:05") + " " + c.userName + " " + userName + " " + content
        if clients[userName] != nil {
            clients[userName] <- msg
            logsFile, err := os.OpenFile("logsOf"+userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
            if err != nil {
                log.Fatalln("in func sendAll open logsOf" + userName + ".txt")
            }
            logsFile.Write([]byte(msglog))
            logsFile.Close()
        } else {
            msgsFile, err := os.OpenFile("messagesOf"+userName+".txt", os.O_APPEND|os.O_WRONLY, 0666)
            if err != nil {
                log.Fatalln("in func sendAll: open messagesOf" + userName + ".txt")
            }
            msgsFile.Write([]byte(msg))
            msgsFile.Close()
        }
        file.Write([]byte(msglog))
    }
    return true
}

/*
func readfile(filename string) string {
    //var res []string
    file, err := os.Open(filename)
    if err != nil {
        return ""
    }
    buf, _ := ioutil.ReadAll(file)
    //for {
    //  var name, pwd string
    //  _, err := fmt.Fscan(file, &name, &pwd)
    //  if err != nil {
    //      break
    //  }
    //  res = append(res, name)
    //  res = append(res, pwd)
    //}
    file.Close()
    //file, err = os.OpenFile("user.txt", os.O_APPEND|os.O_WRONLY, 0644)
    //if err != nil {
    //  return nil
    //}
    //name, pwd := "dsfa", "jag"
    //file.Write([]byte("\n" + name))
    //file.Write([]byte(" " + pwd))
    //file.Close()
    return string(buf)
}
*/
Golang实现一个聊天工具
ldxxxxll的博客
04-04 2035
在本教程中，我们详细介绍了如何使用 Golang 和 WebSocket 技术构建一个简单但功能完善的实时聊天工具。我们逐步展示了构建服务器、客户端以及一些进阶功能的基本方法。
70个python毕设项目_56个具有开创性的Python开源项目-开始使用Python
weixin_39599372的博客
10-21 2464
Python正在蓬勃发展，它的Gistub页面也是如此。今年对于Python来说很棒，我们看到了一些非常强大的python开源项目。今天，我们将列出一些最好的python开源项目；尝试至少对其中一个项目做出贡献，这将有助于提高您的Python技能。关注，转发，私信小编“01”即可免费领取python学习资料！56个Python开源项目下面是56个Python开源项目的详细信息，让我们开始-1.烧瓶...
golang 简易聊天
weixin_34186128的博客
04-11 149
client.go ------------------------------ package main import ( "net" "fmt" "bufio" "echo/codec" "time" ) var quitSemaphore chan bool func main() { var tcpAd...
Golang语言练习
临渊-测试开发
02-05 133
ddd
golang快速入门
weixin_33834679的博客
03-21 181
1.打包和工具链 1.1 包 所有 Go 语言的程序都会组织成若干组文件，每组文件被称为一个包。 net/http/ cgi/ cookiejar/ testdata/ fcgi/ httptest/ httputil/ pprof/ testdata/ 在 http 目录下的所有文件都属于 h...
golang聊天室
baixiao9898的博客
03-05 171
golang对并发的支持非常好，就是因为他有一个goroutine机制和channel机制，实现并发场景轻松高效。 下面我们实现一个聊天室程序，代码不多，但是功能很强大 //代码转载自：http://blog.youkuaiyun.com/ygrx/article/details/11773151 package main import ( "fmt" "net" "os...
golang 聊天室
行者游学
07-25 2006
使用golang实现简单的websocket聊天室
go语言练手小项目，聊天室，高并发特性(goroutine+管道)
04-02
Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的编程语言。在本项目中，我们将探讨如何利用Go语言构建一个聊天室，特别是其内置的高并发特性——goroutine和管道（channel）。...
基于gin和gorilla创建websocket匿名聊天go语言练手项目.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： ...
基于golang实现一个web视频聊天后端服务.zip(毕设&课设&实训&大作业&竞赛&项目)
最新发布
02-25
【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目...
尹成学院区块链 Go 学习大纲-取得大纲试看视频联系微信yinchengak48
尹成的技术博客
08-21 4906
所处阶段 主讲内容 技术要点 学习目标 第一阶段Go语言开发入门实战 1.Go语言介绍及开发环境搭建 1.Go语言是什么 2.Go语言优势 3.Go语言适合来做什么 4.Go语言安装和设置 5.标准命令概述 6.第一个Go语言程序 课程设计理念： 夯实基础，Go语言作为...
Go-解决Golang并发性练习
08-13
解决Golang并发性练习
Golang入门 - 语法练习
littlewhitevg的博客
06-02 528
Golang学习笔记 主要就是练练手 主要是流程控制 面对对象 切片熟练使用 问题 方法（this *Customer）与（this Customer）的区别 记账 控制台控制1 2 3 4 import ( "fmt" ) func main() { key := "" loop := true balance := 10000.0 money := 0.0 note := "" details := "收支\t账户金额\t收支金额\t说 明" for { fmt.Pr.
golang 函数练习题
ITdada的专栏
10-27 737
package main import "fmt" // 函数使用练习 func sum(n1,n2 float32) float32{ fmt.Printf("n2 的类型是%T \n",n2) return n1+n2 } //编写一个函数交换两个变量 func swap(n1 *int,n2 *int) { t := *n1 *n1 = *n2 *n2 = t } fun...
golang for练习题
ITdada的专栏
10-03 441
package main // 引包的两种方式，开发中使用第二种方式。 // import "fmt" // import "unsafe" import ( "fmt" ) func main(){ //打印一个矩形 /* **** **** **** */ //i 表示层数 for i :=1; i&lt;= 4;i++ { // j 表示每层打印多少*...
Golang | Go 语言 编程练习 100题
蚂蚁学Python
10-26 2649
怎样判断interface{}所属类型 interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。 我们知道interface的变量里面可以存储任意类型的数值(该类型实现了interface)。那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？ 方法1： Go语言里面有一个语法，可以直接判断是否是该类型的变量： value, ok
Golang 实战演练
qq_40119224的博客
11-04 1607
内容来源于b站及其开源github（小破站牛b！） 练习使用Go Module初始化项目（练习）项目案例——即时通信系统一 构建基础Server二 用户上线功能三 用户消息广播机制四 用户业务层封装五 在线用户查询六 修改用户名七 超时强踢功能八 私聊功能九 客户端实现 使用Go Module初始化项目（练习） Ⅰ. 开启go module go env -w GO111MODULE=on ※ Go Module的开关，推荐go v1.11以上版本都设置为on，它将指向未来版本。 Ⅱ. 初始化项
【GoLang】方法练习题
weixin_43013118的博客
05-31 408
package main import "fmt" /* 1)编写结构体(MethodUtils)，编程一个方法，方法不需要参数，在方法中打印一个10*8的矩形，在main方法中调用该方法。 */ //编写结构体 type MethodUtils struct { } //编写MethodUtils方法 func (mu MethodUtils) Print() { for i := 0; i < 8; i++ { for j := 0; j < 10; j++ { fm
golang 网络编程之聊天
qq_37257194的博客
07-31 247
package main import "fmt" import "net" import "log" import "bufio" func main() { listener, err := net.Listen("tcp", "localhost:8001") if err != nil { log.Fatal(err) } go broa...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值