05-Database
本章的主题是重中之重!大多数应用都需要持久化存储数据,并高效地执行的增删查改的操作,数据库 为此而生。
我们将第一次引入第三方库 Gorm 来帮助我们实现 ORM
本章的GitHub链接为: Source, Diff, Zip

数据库及ORM选择

数据库被划分为两大类,遵循关系模型的一类是 关系数据库,另外的则是 非关系数据库,简称 NoSQL,表现在它们不支持流行的关系查询语言SQL。这里我们打算使用的是 mysql, 这是一种非常流行的关系型数据库,也应该是应用最广泛的数据库了。
ORM我们选用Gorm, 应该是因为它的Star数遥遥领先吧。
首先我们利用下面的命令安装 Gorm
1
go get -u github.com/jinzhu/gorm
Copied!

数据库模型

定义数据库中一张表及其字段的类,通常叫做数据模型。ORM (Gorm) 会将类的实例关联到数据库表中的数据行,并翻译相关操作
id字段通常存在于所有模型并用作主键。每个用户都会被数据库分配一个id值,并存储到这个字段中。大多数情况下,主键都是数据库自动赋值的,我只需要提供id字段作为主键即可。
    user表: username,email和password_hash字段被定义为字符串(数据库术语中的VARCHAR),并指定其最大长度,以便数据库可以优化空间使用率。 username和email字段的用途不言而喻,password_hash字段值得提一下。 我想确保我正在构建的应用采用安全最佳实践,因此我不会将用户密码明文存储在数据库中。 明文存储密码的问题是,如果数据库被攻破,攻击者就会获得密码,这对用户隐私来说可能是毁灭性的。 如果使用哈希密码,这就大大提高了安全性。 这将是另一章的主题,所以现在不需分心。
    post表: 将具有必须的id、用户动态的body和timestamp字段。 除了这些预期的字段之外,我还添加了一个user_id字段,将该用户动态链接到其作者。 你已经看到所有用户都有一个唯一的id主键, 将用户动态链接到其作者的方法是添加对用户id的引用,这正是user_id字段所在的位置。 这个user_id字段被称为外键。 上面的数据库图显示了外键作为该字段和它引用的表的id字段之间的链接。 这种关系被称为一对多,因为“一个”用户写了“多”条动态。
另外 我们后续还会有粉丝这种多对多的关系
model/user.go
1
package model
2
3
// User struct
4
type User struct {
5
ID int `gorm:"primary_key"`
6
Username string `gorm:"type:varchar(64)"`
7
Email string `gorm:"type:varchar(120)"`
8
PasswordHash string `gorm:"type:varchar(128)"`
9
Posts []Post
10
Followers []*User `gorm:"many2many:follower;association_jointable_foreignkey:follower_id"`
11
}
Copied!
Notice: 此处应该是gorm:"type:varchar(64)" 当时写的Github源码有错,不过只影响建表时的varchar size,请注意
model/post.go
1
package model
2
3
import (
4
"time"
5
)
6
7
// Post struct
8
type Post struct {
9
ID int `gorm:"primary_key"`
10
UserID int
11
User User
12
Body string `gorm:"type:varchar(180)"`
13
Timestamp *time.Time `sql:"DEFAULT:current_timestamp"`
14
}
Copied!
model/g.go
1
package model
2
3
import (
4
"log"
5
6
"github.com/bonfy/go-mega-code/config"
7
"github.com/jinzhu/gorm"
8
)
9
10
var db *gorm.DB
11
12
// SetDB func
13
func SetDB(database *gorm.DB) {
14
db = database
15
}
16
17
// ConnectToDB func
18
func ConnectToDB() *gorm.DB {
19
connectingStr := config.GetMysqlConnectingString()
20
log.Println("Connet to db...")
21
db, err := gorm.Open("mysql", connectingStr)
22
if err != nil {
23
panic("Failed to connect database")
24
}
25
db.SingularTable(true)
26
return db
27
}
Copied!
其实如果作为演示项目,我们可以将connectingStr := config.GetMysqlConnectingString() 直接写入实际的演示数据库地址,不过为了追求和实际项目中的将配置文件单独放置的效果,我们还是将实际项目中的方法演示给大家。
多引入一个第三方package github.com/spf13/viper
1
go get -u github.com/spf13/viper
Copied!
设置 config 文件, config.yml, 可以放在项目目录下 (实际 Source Code 中 git ignore 了实际的 config.yml, 存放了 config.yml.sample)
config.yml
1
mysql:
2
charset: utf8
3
db: go-mega
4
host: localhost
5
password: password
6
user: root
Copied!
config/g.go
1
package config
2
3
import (
4
"fmt"
5
6
"github.com/spf13/viper"
7
)
8
9
func init() {
10
projectName := "go-mega"
11
getConfig(projectName)
12
}
13
14
func getConfig(projectName string) {
15
viper.SetConfigName("config") // name of config file (without extension)
16
17
viper.AddConfigPath(".") // optionally look for config in the working directory
18
viper.AddConfigPath(fmt.Sprintf("$HOME/.%s", projectName)) // call multiple times to add many search paths
19
viper.AddConfigPath(fmt.Sprintf("/data/docker/config/%s", projectName)) // path to look for the config file in
20
21
err := viper.ReadInConfig() // Find and read the config file
22
if err != nil { // Handle errors reading the config file
23
panic(fmt.Errorf("Fatal error config file: %s", err))
24
}
25
}
26
27
// GetMysqlConnectingString func
28
func GetMysqlConnectingString() string {
29
usr := viper.GetString("mysql.user")
30
pwd := viper.GetString("mysql.password")
31
host := viper.GetString("mysql.host")
32
db := viper.GetString("mysql.db")
33
charset := viper.GetString("mysql.charset")
34
35
return fmt.Sprintf("%s:%[email protected](%s:3306)/%s?charset=%s&parseTime=true", usr, pwd, host, db, charset)
36
}
Copied!
由于 Go 是编译型语言,我们不能像 Python 那样可以逐行的调试演示,我们就直接编写个程序,初始化表
cmd/db_init/main.go
1
package main
2
3
import (
4
"log"
5
6
"github.com/bonfy/go-mega-code/model"
7
_ "github.com/jinzhu/gorm/dialects/mysql"
8
)
9
10
func main() {
11
log.Println("DB Init ...")
12
db := model.ConnectToDB()
13
defer db.Close()
14
model.SetDB(db)
15
16
db.DropTableIfExists(model.User{}, model.Post{})
17
db.CreateTable(model.User{}, model.Post{})
18
}
Copied!
我们先在mysql中创建 go-mega 的数据库
1
$ mysql -u root -p
2
输入密码后
3
mysql> create DATABASE go-mega;
Copied!
然后运行
1
go run cmd/db_init/main.go
Copied!
tables
本小节 Diff

初始化数据库数据

model/utils.go
1
package model
2
3
import (
4
"crypto/md5"
5
"encoding/hex"
6
)
7
8
// GeneratePasswordHash : Use MD5
9
func GeneratePasswordHash(pwd string) string {
10
hasher := md5.New()
11
hasher.Write([]byte(pwd))
12
pwdHash := hex.EncodeToString(hasher.Sum(nil))
13
return pwdHash
14
}
Copied!
model/user.go
1
...
2
// SetPassword func: Set PasswordHash
3
func (u *User) SetPassword(password string) {
4
u.PasswordHash = GeneratePasswordHash(password)
5
}
6
7
// CheckPassword func
8
func (u *User) CheckPassword(password string) bool {
9
return GeneratePasswordHash(password) == u.PasswordHash
10
}
11
12
// GetUserByUsername func
13
func GetUserByUsername(username string) (*User, error) {
14
var user User
15
if err := db.Where("username=?", username).Find(&user).Error; err != nil {
16
return nil, err
17
}
18
return &user, nil
19
}
Copied!
model/post.go
1
// GetPostsByUserID func
2
func GetPostsByUserID(id int) (*[]Post, error) {
3
var posts []Post
4
if err := db.Preload("User").Where("user_id=?", id).Find(&posts).Error; err != nil {
5
return nil, err
6
}
7
return &posts, nil
8
}
Copied!
Notice: 特别注意这里的 Preload, 相当于预先的 Join Table,不然取得的 posts 就没有 User 信息
cmd/db_init/main.go
1
package main
2
3
import (
4
"log"
5
6
"github.com/bonfy/go-mega-code/model"
7
_ "github.com/jinzhu/gorm/dialects/mysql"
8
)
9
10
func main() {
11
log.Println("DB Init ...")
12
db := model.ConnectToDB()
13
defer db.Close()
14
model.SetDB(db)
15
16
db.DropTableIfExists(model.User{}, model.Post{})
17
db.CreateTable(model.User{}, model.Post{})
18
19
users := []model.User{
20
{
21
Username: "bonfy",
22
PasswordHash: model.GeneratePasswordHash("abc123"),
23
Posts: []model.Post{
24
{Body: "Beautiful day in Portland!"},
25
},
26
},
27
{
28
Username: "rene",
29
PasswordHash: model.GeneratePasswordHash("abc123"),
30
31
Posts: []model.Post{
32
{Body: "The Avengers movie was so cool!"},
33
{Body: "Sun shine is beautiful"},
34
},
35
},
36
}
37
38
for _, u := range users {
39
db.Debug().Create(&u)
40
}
41
}
Copied!
运行
1
$ go run cmd/db_init/main.go
Copied!
user表
post表
本小节 Diff

完善view

现在我们的数据库里有了数据,我们就可以直接从数据库中取得数据,生成 index 的 viewmodel 了
修改 vm/index.go 的 GetVM func, 从数据库中获得数据
vm/index.go
1
...
2
// GetVM func
3
func (IndexViewModelOp) GetVM() IndexViewModel {
4
u1, _ := model.GetUserByUsername("rene")
5
posts, _ := model.GetPostsByUserID(u1.ID)
6
v := IndexViewModel{BaseViewModel{Title: "Homepage"}, *u1, *posts}
7
return v
8
}
Copied!
main.go
1
package main
2
3
import (
4
"net/http"
5
6
"github.com/bonfy/go-mega-code/controller"
7
"github.com/bonfy/go-mega-code/model"
8
_ "github.com/jinzhu/gorm/dialects/mysql"
9
)
10
11
func main() {
12
// Setup DB
13
db := model.ConnectToDB()
14
defer db.Close()
15
model.SetDB(db)
16
17
// Setup Controller
18
controller.Startup()
19
20
http.ListenAndServe(":8888", nil)
21
}
Copied!
main.go 要初始化数据库连接,不然会报错。
另外 import _ "github.com/jinzhu/gorm/dialects/mysql" 确定你要使用的是 mysql 的 dialect
1
go run main.go
Copied!
本小节 Diff
Notice: 由于 Gorm 的 auto migration 并不像 SQLAlchemy 那么强大,我们在使用的时候要十分小心,这里我就直接没有使用(一般项目会预先定义好数据结构,而且后期修改也可以通过SQL操作),如果有兴趣的同学可以去看下 Gorm 的文档,还是有部分的 Migration 的能力的。

Links