go语言模拟区块链step3

持久化存储与命令行的加入

我们要把生成的区块在磁盘上做一个持久化的存储，而且要自由添加区块

持久化存储思路分析

改变BlockChain结构体成员和方法

type BlockChain struct {
	db   *bolt.DB //用于存储数据
	tail []byte   //最后一个区块的哈希值
}

定义一些常量，用于之后的参数

const genesisInfo = "The first block"
const blockchainDBFile = "blockchain.db"
const bucketBlock = "bucketBlock"           //装block的桶
const lastBlockHashKey = "lastBlockHashKey" //用于访问bolt数据库，得到最后一个区块的哈希值

创建区块链的方法

此方法只会执行一次

//创建区块，从无到有：这个函数仅执行一次
func CreateBlockChain() error {
	// 1. 区块链不存在，创建
	db, err := bolt.Open(blockchainDBFile, 0600, nil)
	if err != nil {
		return err
	}

	//不要db.Close，后续要使用这个句柄
	defer db.Close()

	// 2. 开始创建
	err = db.Update(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte(bucketBlock))

		//如果bucket为空，说明不存在
		if bucket == nil {
			//创建bucket
			bucket, err := tx.CreateBucket([]byte(bucketBlock))
			if err != nil {
				return err
			}
			//写入创世块
			//创建BlockChain，同时添加一个创世块
			genesisBlock := NewBlock(genesisInfo, nil)
			//key是区块的哈希值，value是block的字节流
			bucket.Put(genesisBlock.Hash, genesisBlock.Serialize()) //将block序列化
			//更新最后区块哈希值到数据库
			bucket.Put([]byte(lastBlockHashKey), genesisBlock.Hash)
		}
		return nil
	})
	return err //nil
}

因为bolt数据库的key和value都是[]byte类型，所以我们要为区块定义编解码的方法

编解码

//绑定Serialize方法， gob编码
func (b *Block) Serialize() []byte {
	var buffer bytes.Buffer

	//编码器
	encoder := gob.NewEncoder(&buffer)
	//编码
	err := encoder.Encode(b)
	if err != nil {
		fmt.Printf("Encode err:", err)
		return nil
	}

	return buffer.Bytes()
}

//反序列化，输入[]byte，返回block
func Deserialize(src []byte) *Block {
	var block Block

	//解码器
	decoder := gob.NewDecoder(bytes.NewReader(src))
	//解码
	err := decoder.Decode(&block)
	if err != nil {
		fmt.Printf("decode err:", err)
		return nil
	}

	return &block
}

获取区块链实例的方法

//获取区块链实例，用于后续操作, 每一次有业务时都会调用
func GetBlockChainInstance() (*BlockChain, error) {
	var lastHash []byte //内存中最后一个区块的哈希值

	//两个功能：
	// 1. 如果区块链不存在，则创建，同时返回blockchain的示例
	db, err := bolt.Open(blockchainDBFile, 0400, nil) //rwx  0100 => 4
	if err != nil {
		return nil, err
	}

	//不要db.Close，后续要使用这个句柄

	// 2. 如果区块链存在，则直接返回blockchain示例
	db.View(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte(bucketBlock))

		//如果bucket为空，说明不存在
		if bucket == nil {
			return errors.New("bucket不应为nil")
		} else {
			//直接读取特定的key，得到最后一个区块的哈希值
			lastHash = bucket.Get([]byte(lastBlockHashKey))
		}

		return nil
	})

	//5. 拼成BlockChain然后返回
	bc := BlockChain{db, lastHash}
	return &bc, nil
}

添加区块的方法

//提供一个向区块链中添加区块的方法
func (bc *BlockChain) AddBlock(data string) error {

	lashBlockHash := bc.tail //区块链中最后一个区块的哈希值

	//1. 创建区块
	newBlock := NewBlock(data, lashBlockHash)

	//2. 写入数据库
	err := bc.db.Update(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte(bucketBlock))
		if bucket == nil {
			return errors.New("AddBlock时Bucket不应为空")
		}

		//key是新区块的哈希值， value是这个区块的字节流
		bucket.Put(newBlock.Hash, newBlock.Serialize())
		bucket.Put([]byte(lastBlockHashKey), newBlock.Hash)

		//更新bc的tail，这样后续的AddBlock才会基于我们newBlock追加
		bc.tail = newBlock.Hash
		return nil
	})

	return err
}

自定义一个迭代器并实现迭代方法

因为blot数据库默认排序是按照ASCII大小进行排序的，所以我们要实现一个能根据每个区块中的前区块哈希（PrevHash）进行迭代查询的迭代器

//定义迭代器
type Iterator struct {
	db          *bolt.DB
	currentHash []byte //不断移动的哈希值，由于访问所有区块
}


//将Iterator绑定到BlockChain
func (bc *BlockChain) NewIterator() *Iterator {
	it := Iterator{
		db:          bc.db,
		currentHash: bc.tail,
	}

	return &it
}

//给Iterator绑定一个方法：Next
//1. 返回当前所指向的区块
//2. 向左移动（指向前一个区块）
func (it *Iterator) Next() (block *Block) {

	//读取Bucket当前哈希block
	err := it.db.View(func(tx *bolt.Tx) error {
		//读取bucket
		bucket := tx.Bucket([]byte(bucketBlock))
		if bucket == nil {
			return errors.New("Iterator Next时bucket不应为nil")
		}

		blockTmpInfo /*block的字节流*/ := bucket.Get(it.currentHash) //一定要注意，是currentHash
		block = Deserialize(blockTmpInfo)
		it.currentHash = block.PrevHash //游标左移

		return nil
	})
	//哈希游标向左移动

	if err != nil {
		fmt.Printf("iterator next err:", err)
		return nil
	}
	return
}

在main中调用时，应该做出如下修改

//调用迭代器，输出blockChain
	it := bc.NewIterator()
	for {
		//调用Next方法，获取区块，游标左移
		block := it.Next()

		fmt.Printf("\n++++++++++++++++++++++\n")
		fmt.Printf("Version : %d\n", block.Version)
		fmt.Printf("PrevHash : %x\n", block.PrevHash)
		fmt.Printf("MerkleRoot : %x\n", block.MerkleRoot)
		fmt.Printf("TimeStamp : %d\n", block.TimeStamp)
		fmt.Printf("Bits : %d\n", block.Bits)
		fmt.Printf("Nonce : %d\n", block.Nonce)
		fmt.Printf("Hash : %x\n", block.Hash)
		fmt.Printf("Data : %s\n", block.Data)

		pow := NewProofOfWork(block)
		fmt.Printf("IsValid: %v\n", pow.IsValid())

		//退出条件
		if block.PrevHash == nil {
			fmt.Println("区块链遍历结束!")
			break
		}

命令行操作区块链

创建cli.go

简化main函数

//处理用户输入命令，完成具体函数的调用
//cli : command line 命令行
type CLI struct {
	//不需要字段
}

//使用说明，帮助用户正确使用
const Usage = `
Usage :
	./blockchain create "创建区块链"
	./blockchain addBlock <需要写入的的数据> "添加区块"
	./blockchain print "打印区块链"
`

//负责解析命令的方法
func (cli *CLI) Run() {
	cmds := os.Args
	//用户至少输入两个参数
	if len(cmds) < 2 {
		fmt.Println("输入参数无效，请检查!")
		fmt.Println(Usage)
		return
	}

	switch cmds[1] {
	case "create":
		fmt.Println("创建区块被调用!")
        cli.createBlockChain()
	case "addBlock":
		if len(cmd) != 3 {
			fmt.Println("输入参数无效，请检查!")
			fmt.Println(Usage)
			return
		}
		fmt.Println("添加区块被调用!")
		cli.addBlock(cmds[2])
	case "print":
		fmt.Println("打印区块被调用!")
		cli.print()
	default:
		fmt.Println("输入参数无效，请检查!")
		fmt.Println(Usage)
	}
}

创建commandline.go

具体实现方法的调用

func(cli *CLI)createBlockChain(){
	err:=CreateBlockChain()
	if err!=nil{
		fmt.Println("CreateBlockChain failed:", err)
		return
	}
	fmt.Println("创建区块链成功!")
}
func(cli *CLI)addBlock(data string){
	bc,err:=GetBlockChainInstance()
	if err!=nil{
		fmt.Println("GetBlockChainInstance failed:", err)
		return
	}
	err=bc.AddBlock(data)
	if err!=nil{
		fmt.Println("AddBlock failed:", err)
		return
	}
	fmt.Println("添加区块成功!")
}
func(cli *CLI)print(){
	bc,err:=GetBlockChainInstance()
	if err!=nil{
		fmt.Println("GetBlockChainInstance failed:", err)
		return
	}
	it:=bc.NewIterator()
	for{
		block,err:=it.Next()
		if err!=nil{
			return
		}
		fmt.Println("\n+++++++++++++++++++++++++++++++++++++++++++++")
		fmt.Println("版本",block.Version)
		fmt.Printf("交易的根哈希%x\n",block.Data)
		fmt.Println("事件戳",block.TimeStamp)
		fmt.Println("难度值",block.Bits)
		fmt.Println("Nonce",block.Nonce)
		fmt.Printf("前哈希%x\n",block.PrevHash)
		fmt.Printf("哈希%x\n",block.Hash)
		fmt.Printf("数据%s\n",block.Data)
		miner:=NewProofOfWork(block)
		fmt.Printf("ISValid:%v\n",miner.IsValid())
		if block.PrevHash==nil{
			break
		}
	}
}

main函数

func main() {
	cli:=CLI{}
	cli.Run()
}