兄弟连区块链培训教程分享持久化：数据库选型、直到现在，我们的区块链实现中还没有用到数据库，我们只是把每次启动程序计算得到的区块储存在内存中。我们不能复用一个之前生成的区块链，也不能与他人分享，因此，现在我们要把它存在磁盘上。
那该选择什么样的数据库？其实任何一种都可以。在比特币文档中，没有说要一个具体的数据库，所以这取决于开发者。Bitcoin Core用的是LevelDB。本篇教程中使用BoltDB。
BoltDB
BoltDB有如下特性：
1. 小而简约
2. 使用Go实现
3. 不需要单独部署
4. 支持我们的数据结构
它的Github中这样描述
Bolt is a pure Go key/value store inspired by Howard Chu’s LMDB project. The goal of the project is to provide a simple，fast, and reliable database for projects that don’t require a full database server such as Postgres or MySQL.
Bolt受Howard Chu的LMDB项目启发，纯Golang编写的key/value数据库。应运只需要简单、快速、可靠，不需要全数据库（如Mysql）功能的项目而生。
Since Bolt is meant to be used as such a low-level piece of functionality, simplicity is key. The API will be small and only focus on getting values and setting values. That’s it.
使用Bolt意味着只需要用到很少的（数据库）功能，所以足够简单是关键。而它的API只专注于值的读写。
是吧，我们只要这些功能。再稍稍多赘述一点它的信息。
BoltDB是基于key/value存储，即是没有像SQL关系性数据库（MySQL、PG）那样的的表，也没有行、列。而数据只存在于Key-value结构中（和Golang的maps很像）。Key-value存放在和SQL的表功能差不多的桶（buckets）中，所以要得到值，就得知道“桶”和“key”。
还有一点比较重要的是，BoltDB是没有数据类型的，key和value都是byte型的数组。因为我们要存储Golang的结构体（比如Block），所以会把这些结构体序列化。我们会使用encoding/gob来序列/解序列化结构体，当然也可以使用 JSON、XML、Protocol Buffers等方案，使用它主要是简单，而且它也是Golang库标准的一部分。
数据结构
在实现持久化之前，我们得先搞清楚要怎么存储，先看看Bitcoin Core是怎么搞的。
简单而言，Bitcoin Core用了两个“buckets”来储存数据：
1. blocks 存储了该链中所有的区块的元数据
2. chainstate 存储链的状态，储存当前未完成的事务信息及其它一些元数据。
各区块是存储在磁盘上独立的文件当中。这么做的机制是为了保证读取一个区块不会加载所有（或部分）区块到内存中。这个特性我们现在也不去实现它。
在 blocks 中，key->value对有：
1. ‘b’ + 32-byte block hash -> block index record
2. ‘f’ + 4-byte file number -> file information record
3. ‘l’ -> 4-byte file number: the last block file number used
4. ‘R’ -> 1-byte boolean: whether we’re in the process of reindexing
5. ‘F’ + 1-byte flag name length + flag name string -> 1 byte boolean: various flags that can be on or off
6. ‘t’ + 32-byte transaction hash -> transaction index record
翻译一下
1. ‘b’ + 32-byte 该块的hash码 -> 块索引记录
2. ‘f’ + 4-byte 文件编号 -> 文件信息记录
3. ‘l’ -> 4-byte 文件编号: 最后一块文件的编号
4. ‘R’ -> 1-byte 布尔值: 标记是否正在重置索引
5. ‘F’ + 1-byte 标记名长度 + 标记名 -> 1 byte boolean: 各种可关可开的标记
6. ‘t’ + 32-byte 交易的hash值 -> 交易的索引记录
在 chainstate, key->value对有：
1. ‘c’ + 32-byte transaction hash -> unspent transaction output record for that transaction
2. ‘B’ -> 32-byte block hash: the block hash up to which the database represents the unspent transaction outputs
翻译一下
1. ‘c’ + 32-byte 交易的hash值 -> 未完成的交易记录
2. ‘B’ -> 32-byte 块hash值: 数据库记录的未使用的交易的output的块hash
因为我们现在还没有交易，所以暂时只有 Blocks，还有就是现在我们不把区块各自存在独立的文件中，而把整个DB当作一个文件存储Blocks。所以我们不需要任何关联到文件的数字。
所以，Blocks就简化成这样：
1. 32-byte block-hash -> Block structure (serialized)
2. ‘l’ -> the hash of the last block in a chain
下面开始实现持久化机制
序列化
由于BoltDB只能存储byte数组，所以先给Block实现序列化方法。
func (b *Block) Serialize() []byte {
var result bytes.Buffer
...
encoder := gob.NewEncoder(&result)
err := encoder.Encode(b)
...
return result.Bytes()
}
再实现解序列化方法
func DeserializeBlock(d []byte) *Block {
var block Block
...
decoder := gob.NewDecoder(bytes.NewReader(d))
err := decoder.Decode(&block)
...
return &block
}
持久化
我们先从优化 NewBlockchain 方法开始。之前这个方法只能创建新的区块链再增加创世区块到链中。现在它加上以下这些能力：
1. 打开DB文件
2. 检测是否已经有区块链存在
3. 如果存在
1. 创建新区块链实例
2. 把刚建的这个区块链信息的作为最后一块区块hash塞到DB中。
4. 如果不存在
1. 创建新的创世区块
2. 存储到DB中
3. 把创世区块的hash作为末端hash
4. 创建新的区块链，把它的信息指向创世区块
转化为代码：
func NewBlockchain() *Blockchain {
var tip []byte
db, err := bolt.Open(dbFile, 0600, nil)
...
err = db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blocksBucket))
if b == nil {
genesis := NewGenesisBlock()
b, err := tx.CreateBucket([]byte(blocksBucket))
err = b.Put(genesis.Hash, genesis.Serialize())
err = b.Put([]byte("l"), genesis.Hash)
tip = genesis.Hash
} else {
tip = b.Get([]byte("l"))
}
return nil
})
bc := Blockchain{tip, db}
return &bc
}
分析一下代码
db, err := bolt.Open(dbFile, 0600, nil)
这是打开BoltDB数据库文件的标准方式，切记：即使没有找到文件，也不会返回错误
err = db.Update(func(tx *bolt.Tx) error {
...
})
操作BoltDB需要使用一个参数为事务的回调函数。这里的事务有两种类型–read-only，read-write。因为我们会把创世区块放到DB中，所以我们使用read-write的事务，也就是db.Update(...)
b := tx.Bucket([]byte(blocksBucket))
if b == nil {
genesis := NewGenesisBlock()
b, err := tx.CreateBucket([]byte(blocksBucket))
err = b.Put(genesis.Hash, genesis.Serialize())
err = b.Put([]byte("l"), genesis.Hash)
tip = genesis.Hash
} else {
tip = b.Get([]byte("l"))
}
这一段是核心，先获取一个Bucket用来存储区块：如果桶存在，那么读取 l值；如果不存在，则创建创世区块，再创建桶，然后把块扔到桶里，把块的hash值设为 l 值。
还有注意新建区块链的方式：
bc := Blockchain{tip, db}
这里不再把所有的区块放到区块链中，而是只设置区块的提示信息和db的连接（因为在整个程序运行时，区块链会一直保持与数据库的连接）。所以，区块链的结构会被改成：
type Blockchain struct {
tip []byte
db *bolt.DB
}
下一步是修改 AddBlock方法，增加新的区块不再像之前直接把数据传过去那么简单了，现在要把区块存储到db中：
func (bc *Blockchain) AddBlock(data string) {
var lastHash []byte
err := bc.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blocksBucket))
lastHash = b.Get([]byte("l"))
return nil
})
newBlock := NewBlock(data, lastHash)
err = bc.db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blocksBucket))
err := b.Put(newBlock.Hash, newBlock.Serialize())
err = b.Put([]byte("l"), newBlock.Hash)
bc.tip = newBlock.Hash
return nil
})
}
逐段分析一下：
err := bc.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blocksBucket))
lastHash = b.Get([]byte("l"))
return nil
})
这里使用的是 read-only事务的 Get 方法，从l中读取最后一块区块的编码，我们挖下一新块时会作为参数用到。
newBlock := NewBlock(data, lastHash)
b := tx.Bucket([]byte(blocksBucket))
err := b.Put(newBlock.Hash, newBlock.Serialize())
err = b.Put([]byte("l"), newBlock.Hash)
bc.tip = newBlock.Hash
在挖出新块，将其序列化存储到数据库后，把最新的区块hash值更新到 l 值中。
检查区块
到这一步，区块都保存到数据库了，现在可以把区块链重新加载然后把新块加到里面。但是现在不能再打印区块链中的区块了，因为已经不是把区块保存在数组中了。现在修复这个缺陷。
BoltDB支持遍历一个桶中的所有key，但是这些key都是基于byte-sorted顺序排序的，而我们需要让它们按在区块中的顺序打印出来，我们也不加载所有的区块到内存中（区块可能会很大，没有必要加载完，或者，假装加载完了），先一个一个读取。现在需要一个blockchain的遍历器：
type BlockchainIterator struct {
currentHash []byte
db *bolt.DB
}
在每次我们要去遍历整个区块链中的区块时会创建一个该遍历器。遍历器会保存当前遍历到的区块hash和保持与数据库的链接，后者也使得遍历器和该区块链在逻辑上是结合的，因为遍历器数据库连接用的是区块链的同一个，所以，Blockchain 会负责创建遍历器：
func (bc *Blockchain) Iterator() *BlockchainIterator {
bci := &BlockchainIterator{bc.tip, bc.db}
return bci
}
注意遍历器用区块链的顶端tip初始化，因此，区块是从顶端到末端，也就是从最老的区块到最新区块。事实上，选择这个tip意味着给区块链“投票”。一个区块链会有很多分支，而最长的那支会被认为是主分支。在获致到tip（可以是该区块链中的任何一个区块）之后，就可以重建整个区块链，算出它的长度和重建这个区块的工作量。所以，tip也可以认为是区块链的一个标识符。
BlockchainIterator 只做一件事：它负责返回区块链中的下一个区块：
func (i *BlockchainIterator) Next() *Block {
var block *Block
err := i.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blocksBucket))
encodedBlock := b.Get(i.currentHash)
block = DeserializeBlock(encodedBlock)
return nil
})
i.currentHash = block.PrevBlockHash
return block
}
本篇文章出自兄弟连区块链培训教程：更多区块链视频教程/源码/课件/学习资料-企鹅QUN：591-229-276
有疑问加站长微信联系（非本文作者）
