golang MySQL数据库操作二

封装查询记录的方法

src/db/conn.go

package mysql
import (
    "database/sql"
    "fmt"
    "log"
    "os"
    _ "github.com/go-sql-driver/mysql"
)
var db *sql.DB
func init() {
    db, _ = sql.Open("mysql", "root:123456@tcp(47.105.170.189:3306)/fileserver?charset=utf8")
    db.SetMaxOpenConns(1000)
    err := db.Ping()
    if err != nil {
        fmt.Println("Failed to connect to mysql, err:" + err.Error())
        os.Exit(1)
    }
}
//DBConn: 返回数据库连接对象
func DBConn() *sql.DB {
    return db
}
//关于ParseRows函数的的作用主要是将从mysql表中查询出来的行数据转换为程序里所定义的对应的结构对象, 具体代码如下：
func ParseRows(rows *sql.Rows) []map[string]interface{} {
    columns, _ := rows.Columns()
    scanArgs := make([]interface{}, len(columns))
    values := make([]interface{}, len(columns))
    for j := range values {
        scanArgs[j] = &values[j]
    }
    record := make(map[string]interface{})
    records := make([]map[string]interface{}, 0)
    for rows.Next() {
    //将行数据保存到record字典
    err := rows.Scan(scanArgs...)
    checkErr(err)
    for i, col := range values {
        if col != nil {
            record[columns[i]] = col
        }
    }
    records = append(records, record)
    }
    return records
}
func checkErr(err error) {
    if err != nil {
        log.Fatal(err)
        panic(err)
    }
}

使用方法:

package db
import (
    mydb "filestore-server/db/mysql"
    "fmt"
)
// User : 用户表model
type User struct {
    Username string
    Email string
    Phone string
    SignupAt string
    LastActiveAt string
    Status int
}
// UserSignin : 判断密码是否一致
func UserSignin(username string, encpwd string) bool {
    stmt, err := mydb.DBConn().Prepare("select * from tbl_user where user_name=? limit 1")
    if err != nil {
        fmt.Println(err.Error())
        return false
    }
    defer stmt.Close()
    rows, err := stmt.Query(username)
    if err != nil {
        fmt.Println(err.Error())
        return false
    } else if rows == nil {
        fmt.Println("username not found: " + username)
        return false
    }
    pRows := mydb.ParseRows(rows)
    if len(pRows) > 0 && string(pRows[0]["user_pwd"].([]byte)) == encpwd {
        return true
    }
    return false
}

实例二: 单行记录查询

src/db/conn.go

package mysql
import (
    "database/sql"
    "fmt"
    "log"
    "os"
    _ "github.com/go-sql-driver/mysql"
)
var db *sql.DB
func init() {
    db, _ = sql.Open("mysql", "root:123456@tcp(47.105.170.189:3306)/fileserver?charset=utf8")
    db.SetMaxOpenConns(1000)
    err := db.Ping()
    if err != nil {
        fmt.Println("Failed to connect to mysql, err:" + err.Error())
        os.Exit(1)
    }
}
//DBConn: 返回数据库连接对象
func DBConn() *sql.DB {
    return db
}

main.go

package main
import (
    "database/sql"
    "fmt"
    mydb "filestore-server/db/mysql"
)
// TableFile : 文件表对应的一些字段, 使用sql内置的数据类型
type TableFile struct {
    FileHash string
    FileName sql.NullString
    FileSize sql.NullInt64
    FileAddr sql.NullString
}
// 从mysql获取文件元信息
func main() {
    var filehash string = "cfe87f8e065f6f12a9ac79eefd78e008a604515b"
    stmt, err := mydb.DBConn().Prepare(
    "select file_sha1,file_addr,file_name,file_size from tbl_file " +
    "where file_sha1=? and status=1 limit 1")
    if err != nil {
        fmt.Println(err.Error())
    }
    defer stmt.Close()
    tfile := TableFile{}
    err = stmt.QueryRow(filehash).Scan(
    &tfile.FileHash, &tfile.FileAddr, &tfile.FileName, &tfile.FileSize)
    if err != nil {
        fmt.Println(err.Error())
    }
    fmt.Println(tfile.FileHash, tfile.FileAddr, tfile.FileName, tfile.FileSize)
    //fmt.Println(tfile)
}

关于数据库访问, Golang 中提供了标准库 database/sql。不过它不是针对某种具体数据库的逻辑实现, 而是一套统一抽象的接口。

正与数据库打交道的, 是各个数据库对应的驱动 Driver；在使用时需要先注册对应的驱动库, 然后就能通过标准库 sql 中定义的接口来统一操作数据库。

创建 sql.DB 连接池

我们来看一下如何创建 sdl.DB 连接池, 以 MySQL 为例:

import (
"log"
"os"
"database/sql"
_ "github.com/go-sql-driver/mysql"
)
?
func main() {
    db, err := sql.Open("mysql",
    "user:pwd@tcp(127.0.0.1:3306)/testdb")
    if err != nil {
        log.Fatal(err)
        os.Exit(1)
    }
    defer db.Close()
    err = db.Ping()
    if err != nil {
    // TODO do something
}
// ...
}

创建数据库连接是一种比较耗资源的操作，先要完成 TCP 三次握手，连接到数据库后需要进行鉴权和分配连接资源，因此建议使用长连接来避免频繁进行此类操作。在我们的 Go 应用中，sql.DB 自身就是会管理连接池的，一般实现为全局的连接池，不用重复进行 open/close 动作。

CRUD 接口

// 1. 返回多行数据，手动关闭结果集 (defer rows.Close())
db.Query()

// 2. 返回单行数据，不须手动关闭结果集
db.QueryRow()

// 3. 预先将一条连接(conn)与一条sql语句绑定起来，供重复使用
stmt, err := db.Prepare(sql)
stmt.Query(args)

// 4. 适用于执行增/删/更新等操作(不需要返回结果集)
db.Exec()

结果集合

Query()方法会返回结果集合, 需要通过 rows.Next(), rows.Scan()方法来遍历结果集合。

事务

// 开始事务
tx := db.Begin()

// 执行事务
db.Exec()
// ...

// 提交事务
tx.Commit()

// 如果失败的话，回滚
tx.Rollback()

小结

用户层面所执行的 sql 语句, 在底层其实是将 sql 语句串编码后传输到数据库服务器端再执行。因此本质上可以看作是 C/S 架构程序。

对于如何访问不同的数据库, Go 的做法是抽离出具体代码逻辑, 将数据库操作分为 database/sql 和 driver 两层。

database/sql 负责提供统一的用户接口, 以及一些不涉及具体数据库的逻辑(如连接池管理); Driver 层负责实际的数据库通信。