Golang 持久化

持久化

程序可以定义为算法+数据。算法是我们的代码逻辑，代码逻辑处理数据。数据的存在形式并不单一，可以存在数据库，文件。无论存在什么地方，处理数据的时候都需要把数据读入内存。如果直接存在内存中，不就可以可以直接读了么？的确，数据可以存在内存中。涉及数据存储的的过程称之为持久化。下面golang中的数据持久化做简单的介绍。主要包括内存存储，文件存储和数据库存储。

内存存储

所谓内存存储，即定义一些数据结构，数组切片，图或者其他自定义结构，把需要持久化的数据存储在这些数据结构中。使用数据的时候可以直接操作这些结构。

type Post struct {
    Id      int
    Content string
    Author  string
}

var PostById map[int]*Post
var PostsByAuthor map[string][]*Post

func store(post Post) {
    PostById[post.Id] = &post
    PostsByAuthor[post.Author] = append(PostsByAuthor[post.Author], &post)
}
func main() {
    PostById = make(map[int]*Post)
    PostsByAuthor = make(map[string][]*Post)

    post1 := Post{Id: 1, Content: "Hello World!", Author: "Sau Sheong"}
    post2 := Post{Id: 2, Content: "Bonjour Monde!", Author: "Pierre"}
    post3 := Post{Id: 3, Content: "Hola Mundo!", Author: "Pedro"}
    post4 := Post{Id: 4, Content: "Greetings Earthlings!", Author: "Sau Sheong"}

    store(post1)
    store(post2)
    store(post3)
    store(post4)

    fmt.Println(PostById[1])
    fmt.Println(PostById[2])

    for _, post := range PostsByAuthor["Sau Sheong"] {
        fmt.Println(post)
    }

    for _, post := range PostsByAuthor["Pedro"] {
        fmt.Println(post)
    }
}

我们定义了两个map的结构PostById，PostByAuthor，store方法会把post数据存入这两个结构中。当需要数据的时候，再从这两个内存结构读取即可。

内存持久化比较简单，严格来说这也不算是持久化，比较程序退出会清空内存，所保存的数据也会消失。这种持久化只是相对程序运行时而言。想要程序退出重启还能读取所存储的数据，这时就得依赖文件或者数据库（非内存数据库）。

文件存储

文件存储，顾名思议，就是将需要存储的数据写入文件中，然后文件保存在硬盘中。需要读取数据的时候，再载入文件，把数据读取到内存中。所写入的数据和创建的文件可以自定义，例如一个存文本，格式化文本，甚至是二进制文件都可以。无非就是编码写入，读取解码的两个过程。

下面我们介绍三种常用的文件存储方式，纯文本文件，csv文件或二进制文件。

纯文本

纯文本文件是最简单的一种文件存储方式，只需要将保存的字符串写入文本保存即可。golang提供了ioutil库用于读写文件，也提供了os相关的文件创建，写入，保存的工具函数。

func main()  {
    data := []byte("Hello World!\n")
    fmt.Println(data)
    err := ioutil.WriteFile("data1", data, 0644)
    if err != nil{
        panic(err)
    }

    read1, _ := ioutil.ReadFile("data1")
    fmt.Println(string(read1))
}

我先创建了一个byte类型的数组，Hello World!\n一共13个字符，对应的切片为[72 101 108 108 111 32 87 111 114 108 100 33 10]。调用ioutil的WriteFile方法，即可创建一个data1的文件。并且文件存储的是文本字符串。使用ReadFile方法可以读取文本字符串内容，注意，读取的数据也是一个byte类型的切片，因此需要使用string转换成文本。

除了ioutil库，还可以使用os库的函数进行文件读写操作。

func main()  {
    
    data := []byte("Hello World!\n")

    file1, _ := os.Create("data2")
    defer file1.Close()

    bytes, _ := file1.Write(data)
    fmt.Printf("Wrote %d bytes to file \n", bytes)

    file2, _:= os.Open("data2")
    defer file2.Close()

    read2 := make([]byte, len(data))

    bytes, _ = file2.Read(read2)

    fmt.Printf("Read %d bytes from file\n", bytes)
    fmt.Println(read2, string(read2))
}

使用os的Create方法，创建一个文件，返回一个文件句柄结构。对于文件这种资源结构，及时定义defer资源清理是一个好习惯。使用Write将数据写入文件。文件的写入完毕。

读取的时候略显麻烦，使用Open函数打开文件句柄，创建一个空的byte切片，然后使用Read方法读取数据，并赋值给切片。如果想要文本字符，还需要调用string转换格式。

csv

csv文件是一种以逗号分割单元数据的文件，类似表格，但是很轻量。对于存储一些结构化的数据很有用。golang提供了专门处理csv的库。

和纯文本文件读写类似，csv文件需要通过os创建一个文件句柄，然后调用相关的csv函数读写数据：

type Post struct {
    Id      int
    Content string
    Author  string
}

func main() {
    csvFile, err := os.Create("posts.csv")
    if err != nil {
        panic(err)
    }

    defer csvFile.Close()

    allPosts := []Post{
        Post{Id: 1, Content: "Hello World!", Author: "Sau Sheong"},
        Post{Id: 2, Content: "Bonjour Monde!", Author: "Pierre"},
        Post{Id: 3, Content: "Hola Mundo!", Author: "Pedro"},
        Post{Id: 4, Content: "Greetings Earthlings!", Author: "Sau Sheong"},
    }

    writer := csv.NewWriter(csvFile)
    for _, post := range allPosts {
        line := []string{strconv.Itoa(post.Id), post.Content, post.Author}
        fmt.Println(line)
        err := writer.Write(line)
        if err != nil {
            panic(err)
        }
    }
    writer.Flush()

    file, err := os.Open("posts.csv")
    if err != nil {
        panic(err)
    }

    defer file.Close()

    reader := csv.NewReader(file)
    reader.FieldsPerRecord = -1
    record, err := reader.ReadAll()
    if err != nil {
        panic(err)
    }

    var posts []Post
    for _, item := range record {
        id, _ := strconv.ParseInt(item[0], 0, 0)
        post := Post{Id: int(id), Content:item[1], Author: item[2]}
        posts = append(posts, post)
    }

    fmt.Println(posts[0].Id)
    fmt.Println(posts[0].Content)
    fmt.Println(posts[0].Author)

}

创建了文件句柄之后，使用csv的函数NewWriter创建一个可写对象，然后依次遍历数据，写入数据。写完的时候，需要调用Flush方法。

读取csv文件也类似，创建一个NewReader的可读对象，然后读取内容。

gob

无论纯文本还是csv文件的读写，所存储的数据文件是可以直接用文本工具打开的。对于一些不希望被文件工具打开，需要将数据写成二进制。幸好go提供了gob模板用于创建二进制文件。

定义一个函数，用于写入数据

func store(data interface{}, filename string){
    buffer := new(bytes.Buffer)
    encoder := gob.NewEncoder(buffer)
    err := encoder.Encode(data)
    if err != nil{
        panic(err)
    }
    err = ioutil.WriteFile(filename, buffer.Bytes(), 0600)
    if err != nil{
        panic(err)
    }
}

使用NewEncoder方法创建一个encoder对象，然后对数据进行二进制编码，最后将数据写入文件中。因此，读取文件的内容的过程则与之相反即可：

func load(data interface{}, filename string){
    raw, err := ioutil.ReadFile(filename)
    if err != nil{
        panic(err)
    }
    buffer := bytes.NewBuffer(raw)
    dec := gob.NewDecoder(buffer)
    err = dec.Decode(data)
    if err != nil{
        panic(err)
    }
}

先读取文件的内容，然后把这个二进制内容转换成一个buffer对象，最后再解码。调用的过程也很简单：

func main() {
    post := Post{Id:1, Content:"Hello World!", Author: "Vanyarpy"}
    store(post, "post3")
    var postRead Post
    load(&postRead, "post3")
    fmt.Println(postRead)
}

通过上面这些小例子，我们讨论了golang中的基本文件读写操作。基本上涉及的都有纯文本，格式化文本和二进制文本的读写操作。通过文件持久化数据比起内存才是真正的持久化。然而很多应用的开发，持久化更多还是和数据库打交道。

关于数据库，又是一个很大的话题。我们先简单的讨论一下sql。后续再针对mysql的操作做详细的介绍，也有可能介绍nosql的两个代表，redis和mongodb的操作。

sql

sql数据库做持久化是最习以为常的了。把数据写入数据库，根据数据库提供强大的查询工具获取数据。成为很多应用的基本模式。下面介绍一下golang使用mysql数据库的增删改查（CURD）功能。

连接

golang封装了database/sql标准库，它提供了用于处理sql相关的操作的接口。而接口的实现则交给了数据库驱动。这样的设计还是很好，写代码逻辑的时候，不用考虑后端的具体数据库，即使迁移数据库类型的时候，也只需要迁移相应的驱动即可，而不用修改代码。更多关于数据库的用法，我们在后面再讨论。现在先简单的创建一个数据库连接吧：

import (
    "log"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)


var Db *sql.DB

func main() {
    var err error
    Db, err = sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/chitchat?parseTime=true")
    if err != nil {
        log.Fatal(err)
    }
    defer Db.Close()
}

创建数据库连接之前，我们需要安装并导入驱动，这里我们使用了go-sql-driver/mysql的驱动。golang下载和安全第三方包比较方便，运行下面命令即可：

$ go get github.com/go-sql-driver/mysql

命令结束之后，会在$GOPATH/src/github.com 中找到go-sql-driver这个三方mysql驱动。直接import导入就行。

sql.Open方法接收两个参数，第一个书数据库类型，第二个则是数据库的连接方式字串。返回一个 *sql.DB的指针对象。

返回的Db对象只是一个数据库操作的对象，它并不是一个连接。go封装了连接池，不会暴露给开发者。当Db对象开始数据库操作的时候，go的连接池才会惰性的建立连接，查询完毕之后又会释放连接，连接会返回到连接池之中。更多关于数据库的操作，我们将会在后面的mysql专题介绍。

增

增加数据就如同文件操作的写一样。对于mysql，增加记录可以使用insert语句。

我们拓展Post结构，通过定义其方法来进行数据操作：

type Post struct {
    Id      int
    Content string
    Author  string
}

func (post *Post) Create() (err error) {
    rs, err := Db.Exec("INSERT INTO posts (content, author) Values (?, ?)", post.Content, post.Author)
    if err != nil {
        log.Fatalln(err)
    }
    id, err := rs.LastInsertId()
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(id)
    return
}

var Db *sql.DB

func main() {
    var err error
    Db, err = sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/chitchat?parseTime=true")
    if err != nil {
        log.Fatal(err)
    }

    post := Post{
        Content:"hello world",
        Author:"vanyarpy",
    }

    post.Create()
    defer Db.Close()
}

Exec的方法会执行一个sql语句。为了避免sql注入，mysql参数则使用?占位符。执行sql后会返回一个result对象，后者有两个方法LastInsertId返回插入后记录的id值，RowsAffected返回影响的行数。

删

删除和插入类似，同样执行Exec方法即可。例如删除刚哥插入的id为1的记录。

func (post *Post) Delete() (err error){
    rs, err := Db.Exec("DELETE FROM posts WHERE id=?", post.Id)
    if err != nil{
        log.Fatalln(err)
    }
    rows, err := rs.RowsAffected()
    if err != nil{
        log.Fatalln(err)
    }
    fmt.Println(rows)
    return
}

改

修改记录与插入删除类似，仍然使用Exec方法即可。

func (post *Post) Update() (err error) {
    rs, err := Db.Exec("UPDATE posts SET author=? WHERE id=?", post.Author, post.Id)
    if err != nil{
        log.Fatalln(err)
    }

    rows, err := rs.RowsAffected()
    if err != nil{
        log.Fatalln(err)
    }
    fmt.Println(rows)
    return
}

var Db *sql.DB

func main() {
    var err error
    Db, err = sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/chitchat?parseTime=true")
    if err != nil {
        log.Fatal(err)
    }

    post := Post{
        Content:"hello world",
        Author: "vanyarpy",
    }
    post.Create()

    post = Post{
        Id:2,
        Author:"rsj217",
    }
    post.Update()
    defer Db.Close()
}

我们新增一条记录，然后再修改该记录。

查

curd中，最后一个就是r，Retrie数据。查询获取数据的方式很多，总体分为两类，一类是获取单条记录，其次就是获取多条记录。

获取单条记录只需要调用query方法即可：

func RetrievePost(id int) (post Post, err error){
    post = Post{}
    err = Db.QueryRow("SELECT id, content, author FROM posts WHERE id=?", id).Scan(
        &post.Id, &post.Content, &post.Author)
    return
}

func main() {
    var err error
    Db, err = sql.Open("mysql", "root:@tcp(127.0.0.1:3306)/chitchat?parseTime=true")
    if err != nil {
        log.Fatal(err)
    }

    post, err := RetrievePost(2)
    fmt.Println(post)
    defer Db.Close()
}

获取单条记录比较简单，只需要定义一个结构。再查询结果后Scan其值就好。这种读取数据的方式，在C语言中很常见。读取多条记录也大同小异，不同在于需要通过迭代才能把多个记录赋值。

func RetrievePost(id int) (post Post, err error){
    post = Post{}
    err = Db.QueryRow("SELECT id, content, author FROM posts WHERE id=?", id).Scan(
        &post.Id, &post.Content, &post.Author)
    return
}

func RetrievePosts()(posts []Post, err error){

    rows, err := Db.Query("SELECT id, content, author FROM posts")
    for rows.Next(){
        post := Post{}
        err := rows.Scan(&post.Id, &post.Content, &post.Author)
        if err != nil{
            log.Println(err)
        }
        posts = append(posts, post)
    }
    rows.Close()
    return
}

迭代rows的过程中，如果因为循环内的代码执行问题导致循环退出，此时数据库连接池并不知道连接的情况，不会自动回收，因此需要手动指定rows.Close方法。

至此，对于sql数据库的基本操作都进行了介绍。golang的sql标准库的内容却远不如此，后面我们还会如何更好的使用sql进行介绍，还会讨论其中练级池，连接释放，prepare语句和事务处理方面的内容。

总结

数据持久化我们介绍了内存，文件和数据库三种持久化方案。其中内存并不是严格意义的持久化，但是对于一些需要频繁操作，并且程序启动后就需要处理的数据，可以考虑内存持久化。对于简单的配置，可以使用文件持久化，更多时候，数据的持久化方案还是依托于数据库。如今数据库种类繁多，无论是sql还是nosql，都需要考虑具体的使用场景。而无论什么场景，对数据的操作都可以归结为基本的CURD。

我们已经学习了很多持久化的内容，接下来我们将更深入的介绍golang的Mysql数据操作。