1. 上版本存在問題

沒有對區塊進行持久化，而是將區塊鏈存放在記憶體當中，那么程式一旦退出，所有的內容都會消失，所以需要對區塊鏈進行持久化，位元幣使用的是LevelDB，而我們使用的是blot, 因為bolt更輕便、簡潔并且能夠滿足我們的需求，

2. bolt常用操作

在此只對bolt進行簡單說明使用，深入學習可以去bolt的github網站，有更加詳細的使用說明，bolt github 鏈接

2.1 打開資料庫

//函式原型：func Open(path string, mode os.FileMode, options *Options) (*DB, error) {}
//引數說明：
//	path ：要打開的資料庫檔案，沒有就會創建一個
//	mode ：打開資料庫檔案時的權限，0600為讀寫
// 	options ：；連接資料庫的一些設定，可選
db, err := bolt.Open("my.db", 0600, nil)
if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
}

2.2 讀寫資料庫

//函式原型：func (db *DB) Update(fn func(*Tx) error) error {}
//引數說明：
//	函式：作為引數的函式可以看作一個事務，當回傳值為nil時，會自動提交事務，當回傳值為err時，會回滾事務，
err := db.Update(func(tx *bolt.Tx) error {
	...
	return nil
})

2.3 讀取資料庫

//函式原型：func (db *DB) View(fn func(*Tx) error) error {}
//引數說明：
//	在引數函式中，只能在只讀事務中檢索存盤區，檢索值并復制資料庫
err := db.View(func(tx *bolt.Tx) error {
	...
	return nil
})

2.4 創建bucket

bucket的作用：bucket里面存放鍵值對，就是我們要存放進資料庫的資料

//函式原型：func (tx *Tx) CreateBucket(name []byte) (*Bucket, error) {}
//引數說明：
//	[]byte: 要創建bucket的名稱，
b, err := tx.CreateBucket([]byte("MyBucket"))

2.5 取值和存值

//put和get之前一定要有bucket
b := tx.Bucket([]byte("MyBucket"))

//put函式原型：func (b *Bucket) Put(key []byte, value []byte) error {}
err := b.Put([]byte("answer"), []byte("42"))

//get函式原型：func (b *Bucket) Get(key []byte) []byte {}
v := b.Get([]byte("answer"))

3. 持久化

3.1 修改區塊鏈結構

type BlockChain struct {
	//使用資料庫代替陣列
	
	//區塊鏈中有兩個屬性：
	//資料庫檔案，key是區塊的hash值，value為區塊的位元組流
	db *bolt.DB
	//存盤最后一個區塊的哈希,方便找到最后一個區塊哈希
	tail []byte
}

修改區塊鏈存盤方式后，每次添加區塊要做兩件事：

添加區塊結構
更新tail的值

3.2 修改創建區塊鏈方法

func NewBlockChain () *BlockChain{

	//最后一個區塊的哈希,從資料庫中讀出來的
	var lastHash []byte

	//打開資料庫
	db, err := bolt.Open(blockChianDb, 0600, nil)
	defer db.Close()
	if err != nil{
		log.Panic(err)
	}

	//寫資料
	db.Update(func(tx *bolt.Tx) error {
		//找到bucket,(如果沒有就創建，沒有要找的bucket就代表要對一個新鏈進行操作，否則就是已有的鏈，進行追加即可)
		bucket := tx.Bucket([]byte(blockBucket))
		if bucket == nil {
			//沒有bucket，創建
			bucket, err = tx.CreateBucket([]byte(blockBucket))
			if err != nil {
				log.Panic("創建bucket(blockBucket)失敗")
			}

			//定義創世塊
			genesisBlock := GenesisBlock()
			//把創世塊加入到資料庫檔案中
			//block的哈希作為key，block的位元組流作為value
			bucket.Put(genesisBlock.Hash, genesisBlock.Serialize())
			//修改最后一個區塊的哈希
			bucket.Put([]byte("LastHashKey"), genesisBlock.Hash)
			lastHash = genesisBlock.Hash
		}else {
			//有資料庫檔案就直接參考
			lastHash = bucket.Get([]byte("LastHashKey"))
		}
		//return nil代表整個事務操作完成，不需要回滾
		return nil
	})

	//回傳剛剛操作的區塊鏈
	return &BlockChain{
		db:   db,
		tail: lastHash,
	}
}

3.3 修改添加區塊方法

func (bc *BlockChain) AddBlock (data string) {

	//獲取區塊鏈
	db := bc.db
	//獲取最后一個區塊哈希
	lastHash := bc.tail

	db.Update(func(tx *bolt.Tx) error {

		//完成區塊添加
		bucket := tx.Bucket([]byte(blockBucket))
		if bucket == nil {
			log.Panic("bucket 不應該為空，請檢查！")
		}

		//1. 創建新區塊
		block := NewBlock(data, lastHash)

		//2. 添加區塊到資料庫中
		//hash作為key, block的位元組流作為value
		bucket.Put(block.Hash, block.Serialize())
		bucket.Put([]byte("LastHashKey"), block.Hash)

		//3. 更新記憶體中的區塊鏈
		bc.tail = block.Hash

		return nil
	})
}

4. 新增輔助功能

4.1 迭代器遍歷區塊

4.1.1 創建迭代器

type BlockChainIterator struct {
	db *bolt.DB
	//游標
	currentHashPointer []byte
}

func (bc *BlockChain) NewIterator() *BlockChainIterator{
	return &BlockChainIterator{
		db:                 bc.db,
		//最初指向區塊鏈的最后一個區塊，隨著Next的呼叫，不斷變化
		currentHashPointer: bc.tail,
	}
}

func (it *BlockChainIterator) Next() *Block{
	var block Block

	it.db.View(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte(blockBucket))
		if bucket == nil {
			log.Panic("迭代器遍歷時，bucket不應該為空！")
		}

		blockTmp := bucket.Get(it.currentHashPointer)

		//解碼動作
		block = Deserialize(blockTmp)
		//游標左移
		it.currentHashPointer = block.PrevHash

		return nil
	})

	return &block
}

4.1.2 使用迭代器

bc := NewBlockChain()
it := bc.NewIterator()
for{
	//回傳區塊并左移
	block := it.Next()

	fmt.Println("==========================\n")
	fmt.Printf("前區塊哈希: %x\n", block.PrevHash)
	fmt.Printf("區塊哈希: %x\n", block.Hash)
	fmt.Printf("區塊資料: %s\n", block.Data)

	if len(block.PrevHash) == 0 {
		fmt.Printf("區塊遍歷完成！\n")
		break
	}
}

4.2 命令列功能

4.2.1 邏輯處理

type CLI struct {
	bc *BlockChain
}

const Usage = `
	addBlock --data DATA	"add data to blockchain"
	printChain	"print all blockchain data"
`

func (cli *CLI) Run() {

	//1. 獲取命令
	args := os.Args
	//	校驗引數是否準確
	if len(args) < 2 {
		fmt.Printf(Usage)
		return
	}

	//2. 分析命令
	cmd := args[1]
	switch cmd {
	case "addBlock":
		//添加區塊
		fmt.Printf("添加區塊")

		//命令校驗，驗確保引數為4，并且第三個引數為--data
		if len(args) == 4 && args[2] == "--data"{
			//獲取資料
			data := args[3]
			//添加區塊
			cli.AddBlock(data)
		}else {
			fmt.Printf("添加區塊引數使用不當，請檢查！")
		}
	case "printChain":
		//列印區塊
		fmt.Printf("列印區塊\n")
		cli.PrintBlockChain()
	default:
		fmt.Printf("無效命令，請檢查！")
		fmt.Printf(Usage)
		
	}
}

4.2.2 功能實作

func (cli *CLI) AddBlock(data string){
	cli.bc.AddBlock(data)
	fmt.Printf("添加區塊成功！\n")
}

func (cli *CLI) PrintBlockChain(){
	bc := cli.bc
	it := bc.NewIterator()
	for{
		//回傳區塊并左移
		block := it.Next()

		fmt.Println("==========================\n")
		fmt.Printf("版本號: %d\n", block.Version)
		fmt.Printf("前區塊哈希: %x\n", block.PrevHash)
		fmt.Printf("梅克爾根: %x\n", block.MerkelRoot)
		fmt.Printf("時間戳: %d\n", block.TimeStamp)
		fmt.Printf("難度值: %d\n", block.Difficulty)
		fmt.Printf("亂數: %d\n", block.Nonce)
		fmt.Printf("當前區塊哈希: %x\n", block.Hash)
		fmt.Printf("區塊資料: %s\n", block.Data)

		if len(block.PrevHash) == 0 {
			fmt.Printf("區塊遍歷完成！\n")
			break
		}
	}
}