逐行读取gob文件的方法详解

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《逐行读取gob文件的方法详解》，以下内容主要包含等知识点，如果你正在学习或准备学习Golang，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

我使用 gob 序列化将 message （下面定义的结构）存储在文件内。

type message struct {
    message string `json:"message"`
    from    string `json:"from"`
}

我设法将 message 放入使用 gob 序列化的切片中，然后将此序列化切片存储在文件中。

但是，通过这种方式，我需要从文件中加载整个序列化切片，对其进行解码，附加新的 message，对切片进行编码并将其再次保存在文件中。 这对我来说似乎很复杂并且没有得到很好的优化..

我用来编码/解码和写入/读取的函数

func (m message) encode() ([]byte, error) {
    var res bytes.buffer
    encoder := gob.newencoder(&res)
    err := encoder.encode(m)

    if err != nil {
        return []byte{}, err
    }
    return res.bytes(), nil
}

func (m message) write(path string) error {
    messages, err := read(path)
    if err != nil {
        return err
    }

    messages = append(messages, m)

    f, err := os.openfile(path, os.o_wronly|os.o_create, 0644)
    if err != nil {
        return err
    }
    defer f.close()

    encoder := gob.newencoder(f)
    encoder.encode(messages)

    return nil
}

func read(path string) ([]message, error) {
    f, err := os.openfile(path, os.o_rdwr, 0644)
    if err != nil {
        return []message{}, err
    }
    defer f.close()

    m := []message{}
    decoder := gob.newdecoder(f)

    if err = decoder.decode(&m); err != nil {
        if err == io.eof {
            return []message{}, nil
        }
        return []message{}, err
    }

    return m, nil
}

解决方案是将序列化的 message 直接存储在文件内，并在末尾简单地附加新的 message。

我通过使用 os.o_append 附加而不是覆盖整个文件来实现：

f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)

我还进行了其他基本更改，例如将 []message 替换为 message 等等。

现在我可以将 message 存储在我的文件中，并且只需在文件末尾附加新消息，而无需每次都重写整个文件。

但我必须知道如何读取存储在文件内的 message 。

前面的代码只读取第一条消息并忽略文件的其余部分

我找到了许多逐行读取文件的解决方案，但似乎没有一个适用于 gob 序列化对象

是否可以逐行读取存储gob序列化对象的文件？或者我是否必须保留当前的解决方案，即存储序列化切片？

注意：我发现这个主题（通过追加多次检索写入文件的 gob）看起来描述了相同类型的问题，但它几乎是 7 年前的+描述了一个更复杂的问题

正确答案

我将此作为“答案”发布，但我的问题尚未解决，如果您认为这更合适，我可以将其移至我的第一篇文章中。

我从我在这里找到的代码（Retrieving gobs written to file by appending several times）开始进行了一些测试，并尝试考虑答案。

我编写了 2 个新函数，用于在文件中写入 gob 并从文件中读取给定数量的 gob ：

func write(enc *gob.encoder, m message) {
    err := enc.encode(m)
    if err != nil {
        panic(err)
    }
}

func read(filename string, to_load int) {
    f, err := os.openfile(filename, os.o_rdwr, 0644)
    defer f.close()
    if err != nil {
        panic(err)
    }

    dec := gob.newdecoder(f)

    for i := 0; i < to_load; i++ {
        var m message
        err = dec.decode(&m)
        if err != nil {
            panic(err)
        }
        fmt.println("loaded struct:", m)
    }
}

我从答案（https://stackoverflow.com/a/36386843/17070383）中“理解”的一点是，如果所有这些 gob 都是用 gob.encoder 的不同实例编写的，那么从同一个文件读取许多 gob 可能会很复杂。

所以我编写了一个生成并返回 gob.encoder 的函数

func getencoder(filename string) (*gob.encoder, *os.file) {
    file, err := os.openfile(filename, os.o_create|os.o_append|os.o_wronly, 0666)
    if err != nil {
        panic(err)
    }

    return gob.newencoder(file), file
}

然后：

func main() {
    enc, f := getencoder("test.bin")
    defer f.close()

    m1 := message{"bob", "hello"}
    m2 := message{"bob2", "hello2"}
    m3 := message{"bob3", "hello3"}

    write(enc, m1)
    write(enc, m2)
    write(enc, m3)

    fmt.println("read 2 message from file : ")
    read("test.bin", 2)

    m4 := message{"bob4", "hello4"}

    write(enc, m4)

    fmt.println()
    fmt.println("read 4 message from file : ")
    read("test.bin", 4)
}

输出：

read 2 message from file : 
loaded struct: {bob hello}
loaded struct: {bob2 hello2}

read 4 message from file : 
loaded struct: {bob hello}
loaded struct: {bob2 hello2}
loaded struct: {bob3 hello3}
loaded struct: {bob4 hello4}

嗯，看起来效果很好。
现在，如果我重新启动代码，我会尝试读取 8 gob 而不是 4 （4 个由第一次代码执行写入，4 个由第二次执行写入）

read("test.bin", 8)

我有这个输出：

read 2 message from file : 
loaded struct: {bob hello}
loaded struct: {bob2 hello2}

read 4 message from file : 
loaded struct: {bob hello}
loaded struct: {bob2 hello2}
loaded struct: {bob3 hello3}
loaded struct: {bob4 hello4}
panic: gob: duplicate type received

goroutine 1 [running]:
main.read({0x10df092?, 0xc000012018?}, 0x8)
    /{path}/main.go:34 +0x1c8
main.main()
    /{path}/main.go:72 +0x2c5
exit status 2

它读取第一次执行写入的前 4 个 gob，然后在读取第二次执行使用 gob.encoder 的新实例写入的第 5 个元素时发生恐慌

为了验证这一点，我更改了代码，并使用第一个 gob.encoder 写入 3 gob ，最后一个使用另一个编码器写入，然后尝试读取 4 gob ：

func main() {
    enc, f := getencoder("test.bin")
    defer f.close()

    m1 := message{"bob", "hello"}
    m2 := message{"bob2", "hello2"}
    m3 := message{"bob3", "hello3"}

    write(enc, m1)
    write(enc, m2)
    write(enc, m3)

    fmt.println("read 2 message from file : ")
    read("test.bin", 2)

    new_enc := gob.newencoder(f) // new encoder

    m4 := message{"bob4", "hello4"} 

    write(new_enc, m4)// write m4 with new encoder

    fmt.println()
    fmt.println("read 4 message from file : ")
    read("test.bin", 4)
}

注意：我重置了文件“test.bin”

输出：

Read 2 Message from file : 
loaded struct: {Bob Hello}
loaded struct: {Bob2 Hello2}

Read 4 Message from file : 
loaded struct: {Bob Hello}
loaded struct: {Bob2 Hello2}
loaded struct: {Bob3 Hello3}
panic: gob: duplicate type received
...

正如我们所见，第四个（用秒编码器写入）无法读取

结论：

我无法真正解释为什么它会这样工作，但似乎不可能直接在文件内存储（和读取）gob序列化结构，并在每次有新记录要保存时在末尾附加新的gob .

我对 go 确实很陌生，我很高兴能对此有更多解释

我找到了2个解决方案：

1. 每次应用程序启动时，您都会创建一个新文件并实例化一个链接到此文件的新 gob.encoder 以在其中写入您的 gob

2. 与第一个解决方案相同，但您不必每次都创建新文件，您只需加载文件内容并使用新的 gob.encoder 重写同一文件中的内容。然后每次有新记录时，您都可以再次使用此 gob.encoder 将您的 gob 附加到文件中。

这两种解决方案看起来都“糟糕”，因为这意味着您必须在应用程序的整个执行过程中保持流打开（与文件一起）。我对此不熟悉，但它看起来是你应该避免的事情......

请随意用您所有的知识来完成我的帖子！

nem0z

今天关于《逐行读取gob文件的方法详解》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！