Golang练手------简单聊天系统（数据库）

最新推荐文章于 2024-09-20 09:55:13 发布
最新推荐文章于 2024-09-20 09:55:13 发布
阅读量2.1k 收藏 9
点赞数 2
分类专栏： Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yijiull/article/details/81914274
版权

将之前用文件写的改成了数据库，凭感觉随便加了几把锁也不知道对不对=_=||
主要拿来练习数据库的预习实践了，自己要先建立一个名叫chat的空数据库
还有多重登陆问题暂时不想解决了。。。
还有很多功能可以加，比如查看聊天记录，删除聊天记录等。。。
这里写图片描述

server.go

package main

import (
    "bufio"
    "database/sql"
    "fmt"
    "log"
    "net"
    "sync"
    "time"

    _ "github.com/go-sql-driver/mysql"
)

var mu sync.RWMutex

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)
    db       *sql.DB
)

func main() {
    var err error
    db, err = sql.Open("mysql", "root:123456@/chat?charset=utf8")
    defer db.Close()
    if err != nil {
        log.Fatalln(err)
    }
    //db.Query("create database if not exists chat;")
    db.Query("create table if not exists user(id int auto_increment primary key, userName varchar(20) unique, password varchar(20) not null, tel varchar(20) unique);")
    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 + "\n"
    ch <- help() + "\n"
    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\n"
            } else {
                ch <- "Success register!\n"
            }
        case "login":
            //login
            //TODO 多重登陆问题，做个强制下线？
            client = login(input)
            if client != nil {
                clients[client.userName] = ch
                ch <- "Success login!\n" + "Your new messages:\n"
                client.toRead(ch)
            } else {
                ch <- "Fail login=_=||maybe your userName or password is wrong,please check them carefully:)\n"
            }
        case "logoff":
            if client == nil {
                ch <- "Please login first:)\n"
            } else {
                ch <- "you logoff successfully!\n"
                ch <- help() + "\n"
                clients[client.userName] = nil
                client = nil
            }
        case "add":
            var userName string
            if input.Scan() {
                userName = input.Text()
            }
            if client == nil {
                ch <- "Please login first:)\n"
            } else {
                ok := client.addFriend(userName)
                if ok {
                    ch <- "add successfully!\n"
                } else {
                    ch <- "maybe no such user=_=||\n"
                }
            }
        case "delete":
            var userName string
            if input.Scan() {
                userName = input.Text()
            }
            if client == nil {
                ch <- "Please login first:)\n"
            } else {
                ok := client.deleteFriend(userName)
                if ok {
                    ch <- "delete successfully!\n"
                } else {
                    ch <- "maybe no such user=_=||\n"
                }
            }
        case "list":
            if client == nil {
                ch <- "Please login first:)\n"
            } else {
                ch <- client.list() + "\n"
            }
        case "sendTo":
            if client == nil {
                ch <- "Please login first:)\n"
            } 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 <- "发送成功\n"
                } else {
                    ch <- "发送失败，可能你没有这个好友:)\n"
                }
            }
        case "sendAll":
            if client == nil {
                ch <- "Please login first:)\n"
            } else {
                var content string
                if input.Scan() {
                    content = input.Text()
                }
                client.sendAll(content)
            }
        default:
            ch <- "无法识别的命令=_=||请重新输入正确的命令:)\n"
            ch <- help() + "\n"
        }
        ch <- ">>"
    }
    conn.Close()
}

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

//读取user，判断手机号和用户名是否重复注册
//将注册信息写入user
//如果成功就创建messages、logs、friends表
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()
    }
    mu.Lock()
    defer mu.Unlock()
    stmt, err := db.Prepare("insert user set userName=?,password=?,tel=?")
    if err != nil {
        log.Fatalln("in func register:insert table user")
    }
    res, err := stmt.Exec(userName, password, tel)
    if err != nil {
        fmt.Println("in func register:insert table user went wrong!!")
        return false //插入失败，可能是用户名或者手机号已被注册
    }
    ok, _ := res.RowsAffected()
    if ok != 1 { //其实这里应该不会有问题了
        fmt.Println("in func register:insert table user went wrong!!")
        return false //插入失败，可能是用户名或者手机号已被注册
    }
    fmt.Printf("%s successfully register!\n", userName)
    createInfo(userName)
    return true
}

//创建表
func createInfo(userName string) {
    stmt, _ := db.Prepare("create table friendsOf" + userName + "(id int primary key auto_increment, userName varchar(20) unique)")
    stmt.Exec()
    stmt, _ = db.Prepare("create table logsOf" + userName + "(id int primary key auto_increment, wtime datetime, fromwho varchar(20), towho varchar(20), msg text)")
    stmt.Exec()
    stmt, _ = db.Prepare("create table messagesOf" + userName + "(id int primary key auto_increment, wtime datetime, fromwho varchar(20), msg text)")
    stmt.Exec()
}

//读取user,判断是否有这个用户以及密码是否正确
//上线后自动查看收件箱，显示未读消息
func login(cin *bufio.Scanner) *Client {
    var userName, password string
    if cin.Scan() {
        userName = cin.Text()
    }
    if cin.Scan() {
        password = cin.Text()
    }
    mu.RLock()
    defer mu.RUnlock()
    rows, err := db.Query("select * from user where userName=? and password=?", userName, password)
    if err != nil {
        log.Fatalln(err)
    }
    if rows.Next() {
        var client Client
        client.userName = userName
        //  client.ch = make(chan string)
        //  go clientWriter(conn, client.ch)
        //  clients[userName] = client.ch
        return &client
    }
    rows.Close()
    return nil
}

func (c *Client) toRead(ch chan string) {
    mu.Lock() //写日志加锁
    defer mu.Unlock()
    messages := "messagesOf" + c.userName
    logs := "logsOf" + c.userName
    rows, err := db.Query("select wtime, fromwho, msg from " + messages)
    defer rows.Close()
    if err != nil {
        log.Fatalln("in func toRead: ", err)
    }
    stmt, err := db.Prepare("insert " + logs + " set wtime = ?, fromwho = ?, towho = ?, msg = ?")
    for rows.Next() {
        var t, who, msg string
        err := rows.Scan(&t, &who, &msg)
        if err != nil {
            log.Fatalln("in func toRead:", err)
        }
        temp := t + " " + who + " " + msg
        ch <- temp + "\n"
        _, err = stmt.Exec(t, who, c.userName, msg)
        if err != nil {
            log.Fatalln("fail to insert into logsOf"+c.userName, err)
        }
    }
    stmt, _ = db.Prepare("delete from " + messages)
    _, err = stmt.Exec()
    if err != nil {
        log.Fatalln(err)
    }
}

func (c *Client) addFriend(userName string) bool {
    mu.RLock()
    rows, _ := db.Query("select userName from user where userName = ?", userName)
    mu.RUnlock()
    defer rows.Close()
    if rows.Next() {
        //这个应该不用锁，只有自己读写
        stmt, err := db.Prepare("insert friendsOf" + c.userName + " set userName = ?")
        if err != nil {
            log.Fatalln(err)
        }
        _, err = stmt.Exec(userName)
        if err != nil {
            log.Fatalln(err)
        }
        return true
    }
    return false
}
func (c *Client) deleteFriend(userName string) bool {
    rows, err := db.Query("select userName from friendsOf"+c.userName+" where userName = ?", userName)
    defer rows.Close()
    if err != nil {
        log.Fatalln(err)
    }
    if rows.Next() {
        stmt, _ := db.Prepare("delete from friendsOf" + c.userName + " where userName = ?")
        _, err := stmt.Exec(userName)
        if err != nil {
            log.Fatalln(err)
        }
        return true
    }
    return false

}
func (c *Client) list() string {
    res := "Your friends list:"
    rows, _ := db.Query("select userName from friendsOf" + c.userName)
    var userName string
    for rows.Next() {
        rows.Scan(&userName)
        res += "\n\t" + userName
    }
    return res
}
func (c *Client) sendTo(userName, content string) bool {
    mu.Lock()
    defer mu.Unlock()
    err := db.QueryRow("select userName from friendsOf"+c.userName+" where userName = ?", userName).Scan(&userName)
    if err != nil {
        return false
    }
    t := time.Now().Format("2006-01-02 15:04:05")
    msg := "\n" + t + " " + c.userName + " " + content
    if clients[userName] != nil {
        clients[userName] <- msg + "\n"
        clients[userName] <- ">>"
        stmt, err := db.Prepare("insert logsOf" + userName + " set wtime=?, fromwho=?, towho=?, msg=?")
        _, err = stmt.Exec(t, c.userName, userName, content)
        if err != nil {
            log.Fatalln("in func sendTo: table(logsOf"+userName+"): ", err)
        }

    } else {
        stmt, err := db.Prepare("insert messagesOf" + userName + " set wtime=?, fromwho=?, msg=?")
        _, err = stmt.Exec(t, c.userName, content)
        if err != nil {
            log.Fatalln("in func sendTo: table(messagesOf"+userName+"): ", err)
        }
    }
    stmt, err := db.Prepare("insert logsOf" + c.userName + " set wtime=?, fromwho=?, towho=?, msg=?")
    _, err = stmt.Exec(t, c.userName, userName, content)
    if err != nil {
        log.Fatalln("in func sendTo: table(logsOf"+c.userName+"): ", err)
    }
    return true
}
func (c *Client) sendAll(content string) bool {
    mu.Lock()
    defer mu.Unlock()
    t := time.Now().Format("2006-01-02 15:04:05")
    msg := "\n" + t + " " + c.userName + " " + content
    rows, _ := db.Query("select userName from friendsOf" + c.userName)
    defer rows.Close()
    var userName string
    for rows.Next() {
        rows.Scan(&userName)
        if clients[userName] != nil {
            clients[userName] <- msg + "\n"
            clients[userName] <- ">>"
            stmt, err := db.Prepare("insert logsOf" + userName + " set wtime=?, fromwho=?, towho=?, msg=?")
            _, err = stmt.Exec(t, c.userName, userName, content)
            if err != nil {
                log.Fatalln("in func sendAll: insert logsOf: ", err)
            }
        } else {
            stmt, err := db.Prepare("insert messagesOf" + userName + " set wtime=?, fromwho=?, msg=?")
            _, err = stmt.Exec(t, c.userName, userName, content)
            if err != nil {
                log.Fatalln("in func sendAll: insert messagesOf: ", err)
            }
        }
        stmt, err := db.Prepare("insert logsOf" + c.userName + " set wtime=?, fromwho=?, towho=?, msg=?")
        _, err = stmt.Exec(t, c.userName, userName, content)
        if err != nil {
            log.Fatalln("in func sendAll: insert logsOfsender: ", err)
        }
    }
    return true
}

client.go

package main

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

var ch = make(chan string)
var cin = bufio.NewScanner(os.Stdin)

func main() {
    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
    }()
    go clientWriter(conn, ch)
    for cin.Scan() {
        op := cin.Text()
        op = strings.Replace(op, " ", "", -1)
        switch op {
        case "register":
            register()
        case "login":
            login()
        case "logoff":
            ch <- "logoff"
        case "exit":
            os.Exit(0)
        case "add":
            add()
        case "delete":
            delete()
        case "list":
            ch <- "list"
        case "sendTo":
            sendTo()
        case "sendAll":
            sendAll()
        default:
            ch <- "none"
        }

    }
    //conn.Close() //前面用了defer
    <-done // wait for background goroutine to finish
}
func clientWriter(conn net.Conn, ch <-chan string) {
    for msg := range ch {
        fmt.Fprintln(conn, msg)
    }
}
func 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
}

func 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
}
func add() {
    var userName string
    fmt.Print("请输入要添加好友的用户名：")
    if cin.Scan() {
        userName = cin.Text()
    }
    ch <- "add"
    ch <- userName
}
func delete() {
    fmt.Print("请输入要删除好友的用户名：")
    var userName string
    if cin.Scan() {
        userName = cin.Text()
    }
    ch <- "delete"
    ch <- userName
}
func 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
}
func sendAll() {
    var content string
    fmt.Print("请输入消息：")
    if cin.Scan() {
        content = cin.Text()
    }
    ch <- "sendAll"
    ch <- content

}
yijiull
关注
专栏目录
15-zinx-Golang-MMO-世界聊天系统
qq23001186的博客
06-02 418
二、世界管理模块 1 - 实现思路 需求分析：因为世界聊天消息需要广播给其他玩家，我们就需要获取到所有的玩家，这里使用世界模块来进行管理 2 - 添加世界管理对象 mmo_game_zinx/core/world_manager.go 三、业务集成世界管理模块 1 - 玩家上线添加到世界管理模块 mmo_game_zinx/main.go 2 - 聊天业务API与实现 实现思路 src/mmo_game_zinx/main.go：玩家上线后绑定一个玩家ID的pid属性 src/m
尹成学院区块链 Go 学习大纲-取得大纲试看视频联系微信yinchengak48
尹成的技术博客
08-21 4790
所处阶段 主讲内容 技术要点 学习目标 第一阶段Go语言开发入门实战 1.Go语言介绍及开发环境搭建 1.Go语言是什么 2.Go语言优势 3.Go语言适合来做什么 4.Go语言安装和设置 5.标准命令概述 6.第一个Go语言程序 课程设计理念： 夯实基础，Go语言作为...
GolangChat:聊天系统
03-11
高朗聊天 聊天系统 1.0版本已实现实现单撩实现群撩实现用户上线的全网通知实现用户昵称实现聊天日志的存储和查看 2.0版本等待
Golang初练手-多线程网站路径爆破
ai74583的博客
02-08 250
以前用Python写过这个工具，前两天看了golang的基础，就想着用这个语言把这个工具重写一遍 先放张图 用法 Example : Buster.exe -u=https://www.baidu.com -d=asp.txt -t=5 Buster是你的程序名字 -u后面填网址参数，格式如上 -d选字典 -t是线程数 当你第一次运行请直...
使用 Go 语言实现简单聊天系统
最新发布
上进！努力！！！
09-20 1269
WebSocket 是一种基于 TCP 的网络协议，允许客户端和服务端建立持久的全双工通信连接。相比于传统的 HTTP 请求-响应模型，WebSocket 更加适合实时通信场景，因此它是实现聊天系统的理想选择。
goLang简单聊天室
a568283992的博客
05-23 1010
有一段时间没写博客了，现在因为工作需要学习了go，做一个小Demo，简单的聊天室。 首先服务端开启监听8889端口，监听每一个客户端。 客户端需要先登录，登录成功后，服务端会发送给每一个客户端一个消息，XXX用户登陆成功，目前程序还没写完全，后续会不断更新~~ message.go: 首先需要一个消息传送的protocol，因为是基于TCP协议，传输过程中会有粘包和拆包问题，因此定义一个协议来保证数据完整性。 package message const ( LoginMesType =.
golang 编程练习项目_编程初学者的练手小项目(前端&Java&其他)
weixin_39914499的博客
11-20 558
上一篇我们盘点了编程初学者关于Python&C/C++的练手项目，今天我们带来剩下的部分内容，包括前端、Java、PHP、Go等其他适合编程新手练习的项目会员课。实验楼在线教育：编程初学者的练手小项目（Python&C/C++）​zhuanlan.zhihu.com前端练手项目HTML网页版2048基于 Canvas 实现放大镜效果基于 HTML5 实现刮刮乐效果CSSCSS3实现...
golang新手练手项目
09-10
以下是一些建议的Golang练手项目： 1. To-Do应用程序：创建一个简单的To-Do应用程序，允许用户添加、删除和更新任务。这个项目可以帮助你熟悉Golang的基本语法和Web开发。 2. 网络爬虫：使用Golang编写一个简单的...
70个python毕设项目_56个具有开创性的Python开源项目-开始使用Python
weixin_39599372的博客
10-21 2396
Python正在蓬勃发展，它的Gistub页面也是如此。今年对于Python来说很棒，我们看到了一些非常强大的python开源项目。今天，我们将列出一些最好的python开源项目；尝试至少对其中一个项目做出贡献，这将有助于提高您的Python技能。关注，转发，私信小编“01”即可免费领取python学习资料！56个Python开源项目下面是56个Python开源项目的详细信息，让我们开始-1.烧瓶...
56个具有开创性的Python开源项目-开始使用Python
python588的博客
11-11 2798
Python正在蓬勃发展，它的Gistub页面也是如此。今年对于Python来说很棒，我们看到了一些非常强大的python开源项目。今天，我们将列出一些最好的python开源项目；尝试至少对其中一个项目做出贡献，这将有助于提高您的Python技能。 56个Python开源项目 下面是56个Python开源项目的详细信息，让我们开始- 1.烧瓶 这是一个用Python编写...
Github 2024-04-01 开源项目月报 Top20
老孙正经胡说
04-01 1299
根据Github Trendings的统计，本月(2024-04-01统计)共有20个项目上榜。
Golang语言基于beego框架的websocket即时聊天
04-12
基于beego框架的websocket即时聊天室。可创建多个聊天室
go-fly:开源客服系统GO语言开发GO-FLY，免费客服系统golang的开源实时客户聊天
03-11
飞 基于GO语言实现的web客服即时通讯与客服管理系统。 1.使用gin http框架实现restful风格的API和模板包的模板语法进行展示界面 2.使用jwt-go配合gin中间件实现无状态的jwt登陆认证 3.数据库实现的rbac权限配合gin中间件实现权限控制 4.通过cobra进行命令行参数解析和执行对应的功能 5.使用go modoule解决依赖问题 6.使用swagger实现文档展示 7.使用go-imap实现邮件的列表展示和重新阅读 8.使用go-smtp实现发送邮件 9.使用github.com/gorilla/websocket实现即时通讯 10.使用gorm配合mysql实现数据存储 11.前端使用elementUI和Vue展示界面 11.充分实践了结构，接口，地图，切片，范围，水泥浆和通道管道等基础知识 项目预览 安装使用 1.先安装并运行mysql> = 5.5
Go-NutsDB是纯Go语言编写一个简单高性能内嵌型持久化的key-value数据库
08-13
NutsDB支持事务，但不是标准的ACID事务（参见限制和警告）。所有的操作都在事务中执行。NutsDB从v0.2.0版本开始支持多种数据结构，如列表(list)、集合(set)、有序集合(sorted set)。
chat:基于golang 的im 聊天项目
04-15
郑重声明 本系统只能用作学习使用，不得用作生产环境。如因无视本声明，将本系统代码部署到生产环境，导致出现各种损失，本人不承担任何责任！ 先上效果 安装方法 本系统升级到golang1.12,请开启如下支持 #开启go mod支持 export GO111MODULE=on #使用代理 export GOPROXY=https://goproxy.io 1.下载项目 git clone https://github.com/winlion/chat.git 2.项目配置，非常重要 2.1 数据库配置 修改service/init.go 中数据库配置文件 const ( driveName = "mysql" //数据库类型,不要动 dsName = "root:root@(127.0.0.1:3306)/tech-chat?charset=utf8" //tech-chat是数
golang实现聊天室
ChangUper的博客
08-25 844
用golang实现聊天室用户上线以及群发消息功能
golang|练手项目|在线聊天室（极简版）
wysjr的博客
07-19 666
现在是凌晨三点，从11点30开始写，刚开始想着30分钟完成，12点睡觉，没想到居然拖到现在。写文章的中间总是参杂着许多细碎的事情，不是去洗衣服，就是吃东西，看微信，抖音，这些与写文章无关的事物。唉，做事总是如此，设立目标，却不贯彻执行，面对有点难度的事情，潜意识反应总是逃避，并顺带找一个看似正当的借口麻痹自己（如：好像有点饿，先吃点东西再看看怎么解决吧），以减轻内心的谴责。但回归理性又何尝不明白，逃避并没有解决问题，不断的逃避，问题就会不断累积，总会有一天会陷入无处可逃的境地。2.遇到困难直面解决！
Go语言学习笔记【8】 实现聊天系统[二]（B站视频）
LC520730的博客
08-07 1032
go语言实现聊天系统（2）
聊天系统服务器,Golang学习笔记之简易聊天系统服务器的搭建
weixin_34696006的博客
07-31 245
下面先列举一下程序使用到的函数,省的大家去找，直接拷贝官方api的解释吧。func DialTCP(net string, laddr, raddr *TCPAddr) (*TCPConn, error)DialTCP在网络协议net上连接本地地址laddr和远端地址raddr。net必须是"tcp"、"tcp4"、"tcp6"；如果laddr不是nil，将使用它作为本地地址，否则自动选择一个本地...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值