Go语言实现区块链（三）
一、保存区块链
为了能够永久保存区块链数据，这里引入bolt数据库。
（1）改写BlockChain结构体
type BlockChain struct {
//Blocks []*Block // 保存所有区块
Db *bolt.DB
Tail []byte // 最后区块的hash
}（2）改写NewBlockChain方法，把创世块数据以及最后区块的哈希写入数据库中。
const dbName = "blockchain.db"
const bucketName = "bucket"
const last = "lastBlockHash"
// 创建方法
func NewBlockChain() *BlockChain {
/*// 创建创世块
genericBlock := NewBlock([]byte(genesisInfo), []byte{})
// 创建BlockChain
bc := BlockChain{[]*Block{genericBlock}}
return &bc*/
var db *bolt.DB
var lastHash []byte
// 1. 打开数据库
db, err := bolt.Open(dbName, 0600, nil)
if err != nil {
panic("bolt.Open err!")
}
db.Update(func(tx *bolt.Tx) error {
// 2. 打开抽屉Bucket
bucket := tx.Bucket([]byte(bucketName))
// 3. 如果Bucket是否为nil，则创建一个Bucket
if bucket == nil {
bucket, err = tx.CreateBucket([]byte(bucketName))
if err != nil {
panic("tx.CreateBucket err!")
}
// 创建创世块
genericBlock := NewBlock([]byte(genesisInfo), []byte{})
// 把创世块保存在bucket中
bucket.Put(genericBlock.Hash, genericBlock.Serialize())
// 把创世块的hash保存在last中
bucket.Put([]byte(last), genericBlock.Hash)
// 记录lastHash
lastHash = genericBlock.Hash
} else {
// 4. 如果Bucket不为nil，记录lastHash
lastHash = bucket.Get([]byte(last))
}
return nil
})
return &BlockChain{db, lastHash}
}（3）定义序列化和反序列化函数
// 序列化block
func (block *Block) Serialize() []byte {
// 创建Encoder
var buffer bytes.Buffer
encoder := gob.NewEncoder(&buffer)
// 加密操作
err := encoder.Encode(block)
if err != nil {
panic("encoder.Encode err!")
}
return buffer.Bytes()
}
// 反序列化
func Deserialize(data []byte) *Block {
var block *Block
var buffer bytes.Buffer
_, err := buffer.Write(data)
if err != nil {
panic("buffer.Write err!")
}
// 创建Decoder
decoder := gob.NewDecoder(&buffer)
// 加密操作
err = decoder.Decode(&block)
if err != nil {
panic("decoder.Decode err!")
}
return block
}（4）修改AddBlock方法，把新区块序列化后保存到数据库中，并且更新最后区块的哈希。
// 添加区块
func (bc *BlockChain) AddBlock(data string) {
/*// 获取最后区块
lastBlock := bc.Blocks[len(bc.Blocks)-1]
// 创建一个新区块
block := NewBlock([]byte(data), lastBlock.Hash)
// 添加新区块
bc.Blocks = append(bc.Blocks, block)*/
// 获取最后区块hash
lastHash := bc.Tail
// 创建区块
block := NewBlock([]byte(data), lastHash)
// 更新操作
bc.Db.Update(func(tx *bolt.Tx) error {
bucket := tx.Bucket([]byte(bucketName))
if bucket == nil {
panic("bucket should not be nil!")
}
// 向bolt数据库添加新区块
bucket.Put(block.Hash, block.Serialize())
// 更新数据库的last
bucket.Put([]byte(last), block.Hash)
// 更新bc.Tail
bc.Tail = block.Hash
return nil
})
}（5）修改main函数，把打印语句注释。
func main() {
bc := NewBlockChain()
bc.AddBlock("1111")
bc.AddBlock("2222")
/*for i, block := range bc.Blocks {
fmt.Println("======== block height : ", i, "=======")
fmt.Printf("Version : %d\n", block.Version)
fmt.Printf("PreHash : %x\n", block.PrevHash)
fmt.Printf("MerKleRoot : %x\n", block.MerKleRoot)
fmt.Printf("TimeStamp : %d\n", block.TimeStamp)
fmt.Printf("Difficulty : %d\n", block.Difficulty)
fmt.Printf("Nonce : %d\n", block.Nonce)
fmt.Printf("Hash : %x\n", block.Hash)
fmt.Printf("Data : %s\n", block.Data)
}*/
}（6）编译运行，并查看数据库文件大小。
> go build -o block.exe .
> block
> dir/a blockchain.db
二、遍历区块链
（1）定义迭代器结构体
type BlockChainIterator struct {
Db *bolt.DB
Index []byte // 迭代器指针的索引值
}（2）提供创建方法
// 创建迭代器
func (bc *BlockChain) NewIterator() *BlockChainIterator {
itr := BlockChainIterator{
bc.Db,
bc.Tail,
}
return &itr
}（3）定义迭代函数
// 遍历上一个区块
func (itr *BlockChainIterator) Prev() *Block {
var block *Block
itr.Db.View(func(tx *bolt.Tx) error {
bucket := tx.Bucket([]byte(bucketName))
if bucket == nil {
panic("bucket shoud not be nil!")
}
// 获取最后区块
blockBytes := bucket.Get(itr.Index)
// 反序列化
block = Deserialize(blockBytes)
// 移动指针
itr.Index = block.PrevHash
return nil
})
return block
}（4）改写main函数
func main() {
bc := NewBlockChain()
bc.AddBlock("1111")
bc.AddBlock("2222")
// 定义迭代器
itr := bc.NewIterator()
for {
// 调用迭代器函数，返回当前block，并且向左移动
block := itr.Prev()
fmt.Println("========================")
fmt.Printf("Version : %d\n", block.Version)
fmt.Printf("PreHash : %x\n", block.PrevHash)
fmt.Printf("MerKleRoot : %x\n", block.MerKleRoot)
fmt.Printf("TimeStamp : %d\n", block.TimeStamp)
fmt.Printf("Difficulty : %d\n", block.Difficulty)
fmt.Printf("Nonce : %d\n", block.Nonce)
fmt.Printf("Hash : %x\n", block.Hash)
fmt.Printf("Data : %s\n", block.Data)
// 退出条件
if len(block.PrevHash) == 0 {
break
}
}
}三、命令行
（1）定义命令行结构体
type Cli struct {
bc *BlockChain
}
（2）定义Run函数，用于与用户进行交互。
const Usage = `
block addBlock --data DATA "添加新区块"
block printChain "打印区块链"
block getBalance --address ADDRESS "查询账户余额"
block send FROM TO AMOUNT MINER DATA "由FROM给TO转AMOUNT个比特币，并指定MINER为矿工"
block newWallet "创建一个钱包"
block listAddress "列出所有钱包地址"
`
func (cli *Cli) Run() {
args := os.Args
if len(args) < 2 {
fmt.Println(Usage)
return
}
// 获取命令名称
command := args[1]
switch command {
case "addBlock":
if len(os.Args) == 4 && os.Args[2] == "--data" {
data := os.Args[3]
if data == "" {
fmt.Println("data should not be empty!")
return
}
cli.addBlock(data)
}
case "printChain":
cli.PrintChain()
default:
fmt.Println(Usage)
}
}（3）提供AddBlock函数
// 添加区块
func (cli *Cli) addBlock(data string) {
cli.bc.AddBlock(data)
}（4）提供PrintChain函数
// 打印区块
func (cli *Cli) printChain() {
bc := cli.bc
// 定义迭代器
itr := bc.NewIterator()
for {
// 调用迭代器函数，返回当前block，并且向左移动
block := itr.Prev()
fmt.Println("========================")
fmt.Printf("Version : %d\n", block.Version)
fmt.Printf("PreHash : %x\n", block.PrevHash)
fmt.Printf("MerKleRoot : %x\n", block.MerKleRoot)
fmt.Printf("TimeStamp : %d\n", block.TimeStamp)
fmt.Printf("Difficulty : %d\n", block.Difficulty)
fmt.Printf("Nonce : %d\n", block.Nonce)
fmt.Printf("Hash : %x\n", block.Hash)
fmt.Printf("Data : %s\n", block.Data)
// 退出条件
if len(block.PrevHash) == 0 {
break
}
}
}（5）修改main函数
func main() {
bc := NewBlockChain()
cli := Cli{bc}
cli.Run()
}（6）创建运行脚本
@del blockchain.db
@go build -o block.exe .
@block