用Go构建一个简单的区块链

栏目: Go · 发布时间: 5年前

内容简介：在本教程中，我将尝试通过帮助你在Go中编写简单的区块链来揭开区块链的广义概念。在本教程中，你应该能够：

在本教程中，我将尝试通过帮助你在 Go 中编写简单的区块链来揭开区块链的广义概念。

用Go构建一个简单的区块链

在本教程中，你应该能够：

  • 理解区块链术语。
  • 创建自己的简单区块链。
  • 了解什么是区块以及如何创建块。
  • 了解如何维护区块链的完整性。

区块链：一种数字分类帐，以较小的集合排列，称为块。这些块通过加密hash相互链接。每个块包含指向前一个块的哈希。区块链对于加密货币很有用，因为它具有去中心化的特性，这意味着存储的数据不在一个位置，而是每个人都可以访问，同时也是任何人都不可信的。

构建一个简单的区块链

在本教程中，我们将为图书馆系统创建一个示例区块链。我们的区块链将存储包含图书结账活动数据的区块。此实现的流程如下：

  • 添加一本新书。
  • 为书创建Genesis块。
  • 将Checkout数据添加到区块链。

这是一个单节点，非复杂的区块链，在运行时将所有内容存储在内存中。

块

在区块链中，块存储有价值的信息。此信息可以是实现区块链的系统所需的交易或一些其他信息，例如交易时间戳或来自前一个块的哈希。我们将继续为每个块定义数据模型，以及构成区块链的结账信息：

package main

// Block contains data that will be written to the blockchain.
type Block struct {
  Pos       int
  Data      BookCheckout
  Timestamp string
  Hash      string
  PrevHash  string
}

// BookCheckout contains data for a checked out book
type BookCheckout struct {
  BookID       string `json:"book_id"`
  User         string `json:"user"`
  CheckoutDate string `json:"checkout_date"`
  IsGenesis    bool   `json:"is_genesis"`
}

// Book contains data for a sample book
type Book struct {
  ID          string `json:"id"`
  Title       string `json:"title"`
  Author      string `json:"author"`
  PublishDate string `json:"publish_date"`
  ISBN        string `json:"isbn:`
}

从 Block 结构中， Pos 保持链中数据的位置。数据是块中包含的有价值信息（在这种情况下是结帐项目）。时间戳保存块创建的当前时间戳。哈希是块的生成哈希。 PrevHash 存储前一个块的哈希值。

在定义了 Block 结构的情况下，我们需要考虑对块进行哈希。哈希用于以正确的顺序识别和保持块。计算哈希值是区块链的一个非常重要的特征。计算哈希值是一项困难的操作（计算方面）。创建哈希的难度是经过深思熟虑的体系结构设计决策，因为它会增加新块的难度，防止在添加后进行可变操作。

哈希和生成块

我们将从一个简单的哈希方法开始，并编写一个函数 calculateHash 来连接块字段并创建一个SHA-256哈希： 

func (b *Block) generateHash() {
  // get string val of the Data
  bytes, _ := json.Marshal(b.Data)
  // concatenate the dataset
  data := string(b.Pos) + b.Timestamp + string(bytes) + b.PrevHash
  hash := sha256.New()
  hash.Write([]byte(data))
  b.Hash = hex.EncodeToString(hash.Sum(nil))
}

接下来，让我们编写另一个函数 CreateBlock 来创建一个新块。 

func CreateBlock(prevBlock *Block, checkoutItem BookCheckout) *Block {
  block := &Block{}
  block.Pos = prevBlock.Pos + 1
  block.Timestamp = time.Now().String()
  block.Data = checkoutItem
  block.PrevHash = prevBlock.Hash
  block.generateHash()
  
  return block
}

CreateBlock 函数完全按照它的状态执行，它创建一个新的Block。它需要两个参数才能实现，前一个块和要添加的结帐项目。如果你已经注意到，我们不会对参数进行任何形式的检查，只是为了简单起见。

创建区块链

我们已经为Block创建了 struct ，并创建了一个创建一个的函数。我们将实现一个区块链来保存这些区块的列表，以及一个将区块链添加到区块链的功能。 

// Blockchain is an ordered list of blocks
type Blockchain struct {
  blocks []*Block
}

// BlockChain is a global variable that'll return the mutated Blockchain struct
var BlockChain *Blockchain

// AddBlock adds a Block to a Blockchain
func (bc *Blockchain) AddBlock (data BookCheckout) {
  // get previous block
  prevBlock := bc.blocks[len(bc.blocks)-1]
  // create new block
  block := CreateBlock(prevBlock, data)
  bc.blocks = append(bc.blocks, block)
}

Genesis块

在区块链中，Genesis Block是链中的第一个项目。要添加新块，我们必须首先检查现有块。如果没有，则创建Genesis Block。让我们编写一个函数来创建一个新的Genesis Block。

func GenesisBlock() *Block {
  return CreateBlock(&Block{}, BookCheckout{IsGenesis: true})
}
We also need to write a function to create a new blockchain:
func NewBlockchain() *Blockchain {
  return &Blockchain{[]*Block{GenesisBlock()}}
}

NewBlockchain 函数返回带有Genesis Block的Blockchain结构。由于我们没有考虑区块链的测量数据持久性，因为这将超出本教程的范围，所以我们总是从一个新的组开始，通过在程序运行时生成Genesis Block。

验证

在我们运行区块链应用程序之前，我们需要以某种方式实现验证，以便在已经发生变异时不保存块。我们将创建一个辅助函数 validBlock 并在附加到Blockchain结构的 AddBlock 方法中使用它： 

func validBlock(block, prevBlock *Block) bool {
  // Confirm the hashes
  if prevBlock.Hash != block.PrevHash {
    return false
  }
  // confirm the block's hash is valid
  if !block.validateHash(block.Hash) {
    return false
  }
  // Check the position to confirm its been incremented
  if prevBlock.Pos+1 != block.Pos {
    return false
  }
  return true
}

func (b *Block) validateHash(hash string) bool {
  b.generateHash()
  if b.Hash != hash {
    return false
  }
  return true
}

我们的 AddBlock 方法应如下所示： 

func (bc *Blockchain) AddBlock (data BookCheckout) {
  // get previous block
  prevBlock := bc.blocks[len(bc.blocks)-1]
  // create new block
  block := CreateBlock(prevBlock, data)
  // validate integrity of blocks 
  if validBlock(block, prevBlock) {
    bc.blocks = append(bc.blocks, block)
  }
}

到目前为止，我们已经编写了区块链的主要部分！让我们创建一个Web服务器，以便我们可以与区块链进行通信并进行测试。

在我们的main函数中，我们将编写创建Web服务器所需的代码，并注册与区块链方法通信的路由。我们将使用Gorilla Mux来路由和创建服务器mux：

func main() {
  // register router
  r := mux.NewRouter()
  r.HandleFunc("/", getBlockchain).Methods("GET")
  r.HandleFunc("/", writeBlock).Methods("POST")
  r.HandleFunc("/new", newBook).Methods("POST")
  
  log.Println("Listening on port 3000")
  
  log.Fatal(http.ListenAndServe(":3000", r))
}

在我们的主要功能中，我们有一个路由器和三个路由、处理程序定义。我们现在将创建这些处理程序。

getBlockchain 处理程序将简单地将区块链作为JSON字符串写回浏览器： 

func getBlockchain(w http.ResponseWriter, r *http.Request) {
  jbytes, err := json.MarshalIndent(BlockChain.blocks, "", " ")
  if err != nil {
    w.WriteHeader(http.StatusInternalServerError)
    json.NewEncoder(w).Encode(err)
    return
  }
  // write JSON string
  io.WriteString(w, string(jbytes))
}

writeBlock处理程序添加一个包含已发送数据的新块。

func writeBlock(w http.ResponseWriter, r *http.Request) {
  var checkoutItem BookCheckout
  if err := json.NewDecoder(r.Body).Decode(&checkoutItem); err != nil {
    w.WriteHeader(http.StatusInternalServerError)
    log.Printf("could not write Block: %v", err)
    w.Write([]byte("could not write block"))
    return
  }
  // create block 
  BlockChain.AddBlock(checkoutItem)
  resp, err := json.MarshalIndent(checkoutItem, "", " ")
  if err != nil {
    w.WriteHeader(http.StatusInternalServerError)
    log.Printf("could not marshal payload: %v", err)
    w.Write([]byte("could not write block"))
    return
  }
  w.WriteHeader(http.StatusOK)
  w.Write(resp)
}

我们将编写最后一个处理程序 newBook ，它创建新的Book数据，因此我们将使用生成的ID作为块添加。记住流程：

  • 添加一本新书。
  • 为书创建Genesis块。
  • 将Checkout数据添加到区块链。
func newBook(w http.ResponseWriter, r *http.Request) {
  var book Book
  if err := json.NewDecoder(r.Body).Decode(&book); err != nil {
    w.WriteHeader(http.StatusInternalServerError)
    log.Printf("could not create: %v", err)
    w.Write([]byte("could not create new Book"))
    return
  }
  // We'll create an ID, concatenating the ISDBand publish date
  // This isn't an efficient way but it serves for this tutorial
  h := md5.New()
  io.WriteString(h, book.ISBN+book.PublishDate)
  book.ID = fmt.Sprintf("%x", h.Sum(nil))

  // send back payload
  resp, err := json.MarshalIndent(book, "", " ")
  if err != nil {
    w.WriteHeader(http.StatusInternalServerError)
    log.Printf("could not marshal payload: %v", err)
    w.Write([]byte("could not save book data"))
    return
  }
  w.WriteHeader(http.StatusOK)
  w.Write(resp)
}

编写了所有三个处理程序后，让我们清理我们的主要功能。我们的主要功能应如下所示：

func main() {
  // initialize the blockchain and store in var
  BlockChain = NewBlockchain()
  
  // register router
  r := mux.NewRouter()
  r.HandleFunc("/", getBlockchain).Methods("GET")
  r.HandlerFunc("/", writeBlock).Methods("POST")
  r.HandlerFunc("/new", newBook).Methods("POST")
  
  // dump the state of the Blockchain to the console
  go func() {
    for _, block := range BlockChain.blocks {
      fmt.Printf("Prev. hash: %x\n", block.PrevHash)
      bytes, _ := json.MarshalIndent(block.Data, "", " ")
      fmt.Printf("Data: %v\n", string(bytes))
      fmt.Printf("Hash: %x\n", block.Hash)
      fmt.Println()
    }
  }()
  log.Println("Listening on port 3000")

  log.Fatal(http.ListenAndServe(":3000", r))
}

几乎完成了！

使用我们更新的代码，让我们启动我们的应用程序： go run main.go

用Go构建一个简单的区块链

转到 http://localhost:3000 。你会看到Genesis Block显示：

用Go构建一个简单的区块链

让我们添加一本新书，这样我们就可以在添加块中使用ID。我将从终端使用cURL。Postman也是一个很好的工具：

$ curl -X POST http://localhost:3000/new \
  -H "Content-Type: application/json" \
  -d '{"title": "Sample Book", "author":"John Doe", 
"isbn":"909090","publish_date":"2018-05-26"}'

创建新书后，我们将使用生成的ID获取有效负载。请注意，因为它总是需要创建块。要添加一个将存储在区块链中的结帐记录，我们会向根端点 http://localhost:3000 发送一个POST请求，其中包含结帐项的有效负载： 

$ curl -X POST http://localhost:3000 \
  -H "Content-Type: application/json" \
  -d '{"book_id": "generated_id", "user": "Mary Doe", 
"checkout_date":"2018-05-28"}'

刷新浏览器，我们将看到添加了自己的哈希的新项目：

用Go构建一个简单的区块链

我们做到了!!

恭喜，伙计！你走了很长的路。你刚刚写了第一个Blockchain原型！值得注意的是，与我们上面的实现相比，实际的区块链要复杂得多。本教程中的实现使得添加新块变得非常容易，而实际情况并非如此。添加新块需要一些繁重的计算（如工作量证明）。

通过解释的概念，你应该更好地理解区块链。还有其他主题是了解区块链基础的先决条件，如股权证明，工作量证明，智能合约，DApps等。

你可以在此 GitHub Repo 上获取本教程的源代码。

======================================================================

分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程：

  • EOS教程，本课程帮助你快速入门EOS区块链去中心化应用的开发，内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点，最后综合运用各知识点完成一个便签DApp的开发。
  • java以太坊开发教程，主要是针对 java 和android程序员进行区块链以太坊开发的web3j详解。
  • python以太坊，主要是针对 python 工程师使用web3.py进行区块链以太坊开发的详解。
  • php以太坊，主要是介绍使用 php 进行智能合约开发交互，进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。
  • 以太坊入门教程，主要介绍智能合约与dapp应用开发，适合入门。
  • 以太坊开发进阶教程，主要是介绍使用node.js、 mongodb 、区块链、ipfs实现去中心化电商DApp实战，适合进阶。
  • C#以太坊，主要讲解如何使用C#开发基于.Net的以太坊应用，包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。
  • java比特币开发教程，本课程面向初学者，内容即涵盖比特币的核心概念，例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等，同时也详细讲解如何在Java代码中集成比特币支持功能，例如创建地址、管理钱包、构造裸交易等，是Java工程师不可多得的比特币开发学习课程。
  • php比特币开发教程，本课程面向初学者，内容即涵盖比特币的核心概念，例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等，同时也详细讲解如何在Php代码中集成比特币支持功能，例如创建地址、管理钱包、构造裸交易等，是Php工程师不可多得的比特币开发学习课程。
  • tendermint区块链开发详解 ，本课程适合希望使用tendermint进行区块链开发的工程师，课程内容即包括tendermint应用开发模型中的核心概念，例如ABCI接口、默克尔树、多版本状态库等，也包括代币发行等丰富的实操代码，是go语言工程师快速入门区块链开发的最佳选择。

汇智网原创翻译，转载请标明出处。这里是原文 用Go构建一个简单的区块链


以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。

码农书籍
正则表达式必知必会

正则表达式必知必会

Ben Forta / 杨涛、王建桥、杨晓云 / 人民邮电出版社 / 2007 / 29.00元

正则表达式是一种威力无比强大的武器，几乎在所有的程序设计语言里和计算机平台上都可以用它来完成各种复杂的文本处理工作。本书从简单的文本匹配开始，循序渐进地介绍了很多复杂内容，其中包括回溯引用、条件性求值和前后查找，等等。每章都为读者准备了许多简明又实用的示例，有助于全面、系统、快速掌握正则表达式，并运用它们去解决实际问题。 本书适合各种语言和平台的开发人员。一起来看看 《正则表达式必知必会》 这本书的介绍吧!

码农工具
HTML 压缩/解压工具
HTML 压缩/解压工具

在线压缩/解压 HTML 代码

HTML 编码/解码
HTML 编码/解码

HTML 编码/解码

XML、JSON 在线转换
XML、JSON 在线转换

在线XML、JSON转换工具

  • New
  • 文章
  • 话题
  • 教程
    • 关注 码农网 公众号
    版权所有，保留一切权利！© 2018-2024 码农网 粤ICP备17054400号-3