区块链之bolt数据库持久化与基本功能完善

文章目录

- bolt数据库安装
- 使用bolt进行持久化存储
- - bolt持久化的基本步骤
  - 创世区块的持久化
  - 新增区块的持久化
- 完善区块链基本功能
- - 创世区块创建
  - 增加区块
  - 遍历区块链

链接：区块链项目github地址
项目目前进度：
![在这里插

bolt数据库安装

bolt数据库介绍：

bolt数据库是一个为go语言提供的轻量化数据集，是一个简单、快速的关系型数据库，其中数据
以[]byte的方式进行存储。索引方式为键/值的方式，即通过关键词去索引数据。

bolt项目地址：link
安装步骤：
1.在项目地址下的终端运行

go get github.com/boltdb/bolt/...

2.当前项目的.mod文件加入语句

require (
github.com/boltdb/bolt v1.3.1 // indirect
golang.org/x/sys v0.3.0 // indirect
)

3.修改mod文件后，需要运行

go mod vendor

进行更新

使用bolt进行持久化存储

相较于之前的区块链程序，使用持久化存储即将区块链存放在数据库中进行保存，进行持久化。相较于之前的未持久化的程序，修改的地方有：
1.将创世区块进行持久化
2.将新增区块进行持久化

bolt持久化的基本步骤

1.创建或打开一个数据库，dbName为数据库的名称，0600说明数据库的权限（0600的二进制码为111，000，000，表示管理员有读、写权限，没有执行权限），nil表示默认操作

	db, err := bolt.Open(dbName, 0600, nil)

2.对数据库进行创建数据表的操作，这里bucket即表示数据表的意思

db.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(blockTableName))
		if b == nil {
			//数据表不存在
			b, err := tx.CreateBucket([]byte(blockTableName))
			if err != nil {
				log.Panicf("create backet [%s] failed %v\n", blockTableName, err)
			}
		}
		return nil
	})

3.增加与插入数据操作，b.get表示通过键去索引值，得到的值为[]byte的格式，b.put表示存储值，其中，数据必须以键值对的方式进行存储。

bc.DB.Update(func(tx *bolt.Tx) error {
		//获取数据库桶
		b := tx.Bucket([]byte(blockTableName))
		if b != nil {
			blockTypes := b.Get(bc.Tip)
			err = b.Put([]byte("l"), newBlock.Hash)
			if err != nil {
				log.Panicf("save the latest block hash failed %v\n", err)
			}
		}
		return nil
	})

创世区块的持久化

原始方式：

func CreateBlockChainWithGenesisBlock() *BlockChain {
	//生成创世区块
	block := CreateGenesisBlock([]byte("the first block"))
	return &BlockChain{[]*Block{block}}
}
// 生成创世区块
func CreateGenesisBlock(data []byte) *Block {
	return NewBlock(nil, 1, data)
}

持久化方式：

db.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(blockTableName))
		if b == nil {
			//数据表不存在
			b, err := tx.CreateBucket([]byte(blockTableName))
			if err != nil {
				log.Panicf("create backet [%s] failed %v\n", blockTableName, err)
			}
			//生成创世区块
			genesisBlock := CreateGenesisBlock([]byte("the first block"))
			//键为区块的哈希，值为区块的序列化
			err = b.Put(genesisBlock.Hash, genesisBlock.Serialize())
			if err != nil {
				log.Panicf("insert the genesis block failed %v\n", err)
			}
			blockHash = genesisBlock.Hash
			//数据库中也存储最新区块的哈希
			err = b.Put([]byte("l"), genesisBlock.Hash)
			if err != nil {
				log.Panicf("save the latest hash of genesis block failed %v\n", err)
			}
		} else {
			//数据表已存在
			blockHash = b.Get([]byte("l"))
		}
		return nil
	})
	if err != nil {
		log.Panicf("create db [%s] failed %v\n", dbName, err)
	}

新增区块的持久化

原始方式：

func (bc *BlockChain) AddBlock(prevBlockHash []byte, height int64, data []byte) {
	var newBlock *Block
	newBlock = NewBlock(prevBlockHash, height, data)
	bc.Blocks = append(bc.Blocks, newBlock)
}

持久化方式：

bc.DB.Update(func(tx *bolt.Tx) error {
		//获取数据库桶
		b := tx.Bucket([]byte(blockTableName))
		if b != nil {
			//获取对应区块
			blockTypes := b.Get(bc.Tip)
			//区块结构反序列化
			latestBlock := DeserializeBlock(blockTypes)
			//新建区块,传入参数：prevBlockHash []byte, height int64, data []byte
			newBlock := NewBlock(latestBlock.Hash, latestBlock.Height+1, data)
			//存入数据库
			bc.Tip = newBlock.Hash
			err := b.Put(newBlock.Hash, newBlock.Serialize())
			if err != nil {
				log.Panicf("insert the new block failed %v\n", err)
			}
			err = b.Put([]byte("l"), newBlock.Hash)
			if err != nil {
				log.Panicf("save the latest block hash failed %v\n", err)
			}
		}
		return nil
	})

完善区块链基本功能

由于区块链不支持删除、修改，所以当前项目区块链的功能有创建创世区块，增加区块，遍历区块链这三个功能，以后计划完善交易信息、挖矿等多个功能。相较于之前功能的完善有：1.持久化，2.新增遍历功能，3.新增迭代器

创世区块创建

通过将结构体进行序列化，从而使得区块可以通过（区块哈希–>区块信息）的方式存储到数据库中，为后期得到前一区块哈希后进行索引前一区块提供便利。

// 初始化区块链
func CreateBlockChainWithGenesisBlock() *BlockChain {
	//存储最新区块链哈希
	var blockHash []byte
	//1.创建或打开一个数据库
	db, err := bolt.Open(dbName, 0600, nil)
	//2.创建一个桶,将创世区块存入数据库中
	db.Update(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(blockTableName))
		if b == nil {
			//数据表不存在
			b, err := tx.CreateBucket([]byte(blockTableName))
			if err != nil {
				log.Panicf("create backet [%s] failed %v\n", blockTableName, err)
			}
			//生成创世区块
			genesisBlock := CreateGenesisBlock([]byte("the first block"))
			//键为区块的哈希，值为区块的序列化
			err = b.Put(genesisBlock.Hash, genesisBlock.Serialize())
			if err != nil {
				log.Panicf("insert the genesis block failed %v\n", err)
			}
			blockHash = genesisBlock.Hash
			//数据库中也存储最新区块的哈希
			err = b.Put([]byte("l"), genesisBlock.Hash)
			if err != nil {
				log.Panicf("save the latest hash of genesis block failed %v\n", err)
			}
		}
		return nil
	})
	if err != nil {
		log.Panicf("create db [%s] failed %v\n", dbName, err)
	}
	return &BlockChain{DB: db, Tip: blockHash}
}

Block的序列化代码：

// 区块结构序列化，结构体->字节数组
func (block *Block) Serialize() []byte {
	var buffer bytes.Buffer
	//序列化结构体
	encoder := gob.NewEncoder(&buffer)
	err := encoder.Encode(block)
	if err != nil {
		log.Panicf("serialize the block to byte[] failed %v", err)
	}
	return buffer.Bytes()
}

Block的反序列化代码

// 区块结构反序列化，字节数组->结构体
func DeserializeBlock(blockByte []byte) *Block {
	var block Block
	decoder := gob.NewDecoder(bytes.NewReader(blockByte))
	err := decoder.Decode(&block)
	if err != nil {
		log.Panicf("deserialize the byte[] to block failed %v", err)
	}
	return &block
}

增加区块

func (bc *BlockChain) AddBlock(data []byte) {
	//更新区块数据（insert）
	bc.DB.Update(func(tx *bolt.Tx) error {
		//获取数据库桶
		b := tx.Bucket([]byte(blockTableName))
		if b != nil {
			//获取对应区块
			blockTypes := b.Get(bc.Tip)
			//区块结构反序列化
			latestBlock := DeserializeBlock(blockTypes)
			//新建区块,传入参数：prevBlockHash []byte, height int64, data []byte
			newBlock := NewBlock(latestBlock.Hash, latestBlock.Height+1, data)
			//存入数据库
			bc.Tip = newBlock.Hash
			err := b.Put(newBlock.Hash, newBlock.Serialize())
			if err != nil {
				log.Panicf("insert the new block failed %v\n", err)
			}
			err = b.Put([]byte("l"), newBlock.Hash)
			if err != nil {
				log.Panicf("save the latest block hash failed %v\n", err)
			}
		}
		return nil
	})
}

遍历区块链

这里使用了迭代器对区块链进行优化，改善代码可读性。

func (bc *BlockChain) PrintBlockChain() {
	var curBlock *Block
	var iter *BlockChainIterator = bc.Iterator()
	fmt.Printf("打印区块链完整信息。。。\n")
	//循环读取
	for {
		curBlock = iter.Next()
		fmt.Printf("-------------------------------------------\n")
		fmt.Printf("\tHash : %x\n", curBlock.Hash)
		fmt.Printf("\tPrevBlockHash : %x\n", curBlock.PrevBlockHash)
		fmt.Printf("\tHeight : %x\n", curBlock.Height)
		fmt.Printf("\tData : %v\n", curBlock.Data)
		fmt.Printf("\tNonce : %x\n", curBlock.Nonce)
		fmt.Printf("\tTimeStamp : %x\n", curBlock.TimeStamp)
		//退出条件，由于哈希值的大数特性，需要使用函数进行比较
		var hashInt big.Int
		hashInt.SetBytes(iter.curHash)
		if big.NewInt(0).Cmp(&hashInt) == 0 {
			//遍历到了创世区块
			break
		}
	}

迭代器的实现如下：

// 实现迭代函数next（）
func (iter *BlockChainIterator) Next() *Block {
	var curBlock *Block
	err := iter.DB.View(func(tx *bolt.Tx) error {
		b := tx.Bucket([]byte(blockTableName))
		if b != nil {
			Block := b.Get(iter.curHash)
			curBlock = DeserializeBlock(Block)
			//更新迭代器当前指向结点哈希
			iter.curHash = curBlock.PrevBlockHash
		}
		return nil
	})
	if err != nil {
		log.Panicf("Iterator the db failed%v\n", err)
	} else {
		return curBlock
	}
	return nil
}