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数据操作。

本文来自:简书

感谢作者:人世间

查看原文:Golang 持久化

• 编辑
• 预览