概述
MerkleTree被广泛的应用在比特币技术中，本文旨在通过代码实现一个简单的MerkleTree，并计算出Merkle tree的 TreeRoot。
Merkle Tree 是一种数据结构，用于验证在计算机之间和之间存储，处理和传输的任何类型的数据。
目前，Merkle树的主要用途是确保从对等网络中接收的数据块未受损和未改变，和检查其他对等网络没有撒谎发送假数据块。
Merkle Tree应用举例
比特币
GitA
mazon's Dynamo
Gassandra
比特币中的应用
比特币中每个块中都包含了所有交易的集合签名，这个签名就是用Merkle tree实现的，Merkle树用于比特币以汇总块中的所有事务，产生整个事务集合的整体数字指纹，提供非常有效的过程来验证事务是否包括在块中。
Merkle树一个很重要的用处是检查块中是否包含指定的交易，Merkle树是通过递归哈希节点对来构造的，直到只有一个哈希。
Merkle tree 代码实现
哈希树的跟节点称为Merkle根，Merkle树可以仅用log2(N)的时间复杂度检查任何一个数据元素是否包含在树中：
package test;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
public class MerkleTrees {
// transaction List
List txList;
// Merkle Root
String root;
/**
* constructor
* @param txList transaction List 交易List
*/
public MerkleTrees(List txList) {
this.txList = txList;
root = "";
}
/**
* execute merkle_tree and set root.
*/
public void merkle_tree() {
List tempTxList = new ArrayList();
for (int i = 0; i < this.txList.size(); i++) {
tempTxList.add(this.txList.get(i));
}
List newTxList = getNewTxList(tempTxList);
while (newTxList.size() != 1) {
newTxList = getNewTxList(newTxList);
}
this.root = newTxList.get(0);
}
/**
* return Node Hash List.
* @param tempTxList
* @return
*/
private List getNewTxList(List tempTxList) {
List newTxList = new ArrayList();
int index = 0;
while (index < tempTxList.size()) {
// left
String left = tempTxList.get(index);
index++;
// right
String right = "";
if (index != tempTxList.size()) {
right = tempTxList.get(index);
}
// sha2 hex value
String sha2HexValue = getSHA2HexValue(left + right);
newTxList.add(sha2HexValue);
index++;
}
return newTxList;
}
/**
* Return hex string
* @param str
* @return
*/
public String getSHA2HexValue(String str) {
byte[] cipher_byte;
try{
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(str.getBytes());
cipher_byte = md.digest();
StringBuilder sb = new StringBuilder(2 * cipher_byte.length);
for(byte b: cipher_byte) {
sb.append(String.format("%02x", b&0xff) );
}
return sb.toString();
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
/**
* Get Root
* @return
*/
public String getRoot() {
return this.root;
}
}
数据准备
我们将交易的数据，放入到List中：
List tempTxList = new ArrayList();
tempTxList.add("a");
tempTxList.add("b");
tempTxList.add("c");
tempTxList.add("d");
tempTxList.add("e");
实现过程
准备交易数据
计算出每个数据的hash值，从左到右逐步组成树的左右节点
执行循环知道最后只剩下一个数据
private List getNewTxList(List tempTxList) {
List newTxList = new ArrayList();
int index = 0;
while (index < tempTxList.size()) {
// left
String left = tempTxList.get(index);
index++;
// right
String right = "";
if (index != tempTxList.size()) {
right = tempTxList.get(index);
}
// sha2 hex value
String sha2HexValue = getSHA2HexValue(left + right);
newTxList.add(sha2HexValue);
index++;
}
测试
package test;
import java.util.ArrayList;
import java.util.List;
public class App {
public static void main(String [] args) {
List tempTxList = new ArrayList();
tempTxList.add("a");
tempTxList.add("b");
tempTxList.add("c");
tempTxList.add("d");
tempTxList.add("e");
MerkleTrees merkleTrees = new MerkleTrees(tempTxList);
merkleTrees.merkle_tree();
System.out.println("root : " + merkleTrees.getRoot());
}
}
执行结果
本文从简单二叉树的形式实现了简单的MerkleTree，计算出TreeRoot，但是实际上的的MerkleTree不拘谨与二叉树还可能是多叉树。

 存档日期：2018年2月5日 | 上次更新时间：2017年3月30日 | 首次发布：2017年3月15日 
 区块链正在改变互联网上商业交易的方式。 在本教程中，您将安装一个区块链网络并运行以Java语言编写的chaincode智能合约。 
 此内容不再被更新或维护。 全文以PDF格式“按原样”提供。 随着技术的飞速发展，某些内容，步骤或插图可能已更改。 
 查看PDF文件 
翻译自: https://www.ibm.com/developerworks/java/library/j-chaincode-for-java-developers/index.html

如果你明白了原理其实挺简单的。
加密算法是python自带的
需要导入hashlib
import hashlib as hash
sha = hasher.sha256()
sha.update('your content')
print sha.hexdigest()
输出：baca6a6db216faf43b107e5f00e20eaf22edc75e922de5ccc08c16b91b9eb3bd
如果内容变成（索引+时间戳+内容+上次加密的hash内容）这个没有问题吧
然后创建一个类，把这些内容保存起来，放入到列表里。
下面贴出源代码

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import hashlib as hasher
import datetime as date

class Block:
    def __init__(self, index, timestamp, data, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.hash_block()

    def hash_block(self):
        sha = hasher.sha256()
        sha.update(str(self.index) +
                   str(self.timestamp) +
                   str(self.data) +
                   str(self.previous_hash))
        return sha.hexdigest()

def create_genesis_block():
  return Block(0, date.datetime.now(), "Block Data", "0")

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)


blockchain = [create_genesis_block()]
previous_block = blockchain[0]

#生成20个为例
num_of_blocks_to_add = 20

for i in range(0, num_of_blocks_to_add):
    block_to_add = next_block(previous_block)
    blockchain.append(block_to_add)
    previous_block = block_to_add
    # Tell everyone about it!
    print "Block #{} has been added to the blockchain!".format(block_to_add.index)
    print "Hash: {}\n".format(block_to_add.hash)

结果：
Block #1 has been added to the blockchain!
Hash: b871f17f63685be10f35820bb380f53aabc2ffeed683a7d6de9787194391b1a0
Block #2 has been added to the blockchain!
Hash: df74f5d23e0772a281a0ffbc0802e4f84abcefc6be59d8af0813413d322b8e68
Block #3 has been added to the blockchain!
Hash: e9cad108bbd80eafa33d61e9cd10a37f9c5ccacac6b1293a9e0b0d3648d1d343
Block #4 has been added to the blockchain!
Hash: 10ad66a24dfa08d52034f3c366d49634cc9b1e3e614d13de9be41eed550838e6
Block #5 has been added to the blockchain!
Hash: 7d96771e2c1ef0721aca7ceb1a599550bc33d07020c419e4c1513e4f8d420a13
Block #6 has been added to the blockchain!
Hash: 08f7e29c8c9641705caa15deab28db75dd5dd66d8d98b7eb5187f40ce31dee65
Block #7 has been added to the blockchain!
Hash: e624c681afc1f6f2e785b89275bce8f5c1ac3e5b94c34ac7a0363dbdc76da41a
Block #8 has been added to the blockchain!
Hash: 6d3129403393864ec54df6e94ddfe72d6efed98383c362eedf51a0548f0f9d74
Block #9 has been added to the blockchain!
Hash: 141202a42c71ff911a829df5685737eba74d008304113381fe1fca6b3d9217be
Block #10 has been added to the blockchain!
Hash: b45029d2a40f5d691d2ce871bb7ac7d4aabab8a766349a9996c9cec07a7f2450
Block #11 has been added to the blockchain!
Hash: e24c5eefb57fe754a8f75b4b17c7d17e3fdcb8efb0713ba8ec57270d4321b139
Block #12 has been added to the blockchain!
Hash: df445b248db7b0540fbae61773a925323cccb072126a126aaf178800eca1d683
Block #13 has been added to the blockchain!
Hash: 0ffa6e5b54d2bc738afe636fd253f4afd7b13995f59ac43b992d10944f0da934
Block #14 has been added to the blockchain!
Hash: 4d45a38b7b10267c195efe8371b26e825018c32db5e2d24f174388798fedf35f
Block #15 has been added to the blockchain!
Hash: 7caae5e46a187481534f870a2fb39f6f1169162db9264273b4376665925d4d7f
Block #16 has been added to the blockchain!
Hash: 54770c9fff28e34218663812cf3234cb390715cbc24b85df236d2bb0e1e88cd5
Block #17 has been added to the blockchain!
Hash: 8a3ae9c8599c6663e6171ebca9ec6a94a1629d73a2ef91ead27447327bc741b8
Block #18 has been added to the blockchain!
Hash: 09f6c1e7b4b7a5ffee15929605c365054671447a84cbf2a0e326d43004c74ad4
Block #19 has been added to the blockchain!
Hash: 64d38c2df1190b24f68127c9d6158e1aa23c6edec0baf3280245befbbc104e7c
Block #20 has been added to the blockchain!
Hash: 4387beb245f1bb48938da280416ab5c21f17623377dd67915d6441ea47385899
转载于:https://www.cnblogs.com/gide/p/8484794.html

概述
MerkleTree被广泛的应用在比特币技术中，本文旨在通过代码实现一个简单的MerkleTree，并计算出Merkle tree的 TreeRoot。
Merkle Tree 是一种数据结构，用于验证在计算机之间和之间存储，处理和传输的任何类型的数据。
目前，Merkle树的主要用途是确保从对等网络中接收的数据块未受损和未改变，和检查其他对等网络没有撒谎发送假数据块。
Merkle Tree应用举例
比特币
GitA
mazon's Dynamo
Gassandra
比特币中的应用
比特币中每个块中都包含了所有交易的集合签名，这个签名就是用Merkle tree实现的，Merkle树用于比特币以汇总块中的所有事务，产生整个事务集合的整体数字指纹，提供非常有效的过程来验证事务是否包括在块中。
Merkle树一个很重要的用处是检查块中是否包含指定的交易，Merkle树是通过递归哈希节点对来构造的，直到只有一个哈希。
Merkle tree 代码实现
哈希树的跟节点称为Merkle根，Merkle树可以仅用log2(N)的时间复杂度检查任何一个数据元素是否包含在树中：
package test;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
public class MerkleTrees {
// transaction List
List txList;
// Merkle Root
String root;
/**
* constructor
* @param txList transaction List 交易List
*/
public MerkleTrees(List txList) {
this.txList = txList;
root = "";
}
/**
* execute merkle_tree and set root.
*/
public void merkle_tree() {
List tempTxList = new ArrayList();
for (int i = 0; i < this.txList.size(); i++) {
tempTxList.add(this.txList.get(i));
}
List newTxList = getNewTxList(tempTxList);
while (newTxList.size() != 1) {
newTxList = getNewTxList(newTxList);
}
this.root = newTxList.get(0);
}
/**
* return Node Hash List.
* @param tempTxList
* @return
*/
private List getNewTxList(List tempTxList) {
List newTxList = new ArrayList();
int index = 0;
while (index < tempTxList.size()) {
// left
String left = tempTxList.get(index);
index++;
// right
String right = "";
if (index != tempTxList.size()) {
right = tempTxList.get(index);
}
// sha2 hex value
String sha2HexValue = getSHA2HexValue(left + right);
newTxList.add(sha2HexValue);
index++;
}
return newTxList;
}
/**
* Return hex string
* @param str
* @return
*/
public String getSHA2HexValue(String str) {
byte[] cipher_byte;
try{
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(str.getBytes());
cipher_byte = md.digest();
StringBuilder sb = new StringBuilder(2 * cipher_byte.length);
for(byte b: cipher_byte) {
sb.append(String.format("%02x", b&0xff) );
}
return sb.toString();
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
/**
* Get Root
* @return
*/
public String getRoot() {
return this.root;
}
}
数据准备
我们将交易的数据，放入到List中：
List tempTxList = new ArrayList();
tempTxList.add("a");
tempTxList.add("b");
tempTxList.add("c");
tempTxList.add("d");
tempTxList.add("e");
实现过程
准备交易数据
计算出每个数据的hash值，从左到右逐步组成树的左右节点
执行循环知道最后只剩下一个数据
private List getNewTxList(List tempTxList) {
List newTxList = new ArrayList();
int index = 0;
while (index < tempTxList.size()) {
// left
String left = tempTxList.get(index);
index++;
// right
String right = "";
if (index != tempTxList.size()) {
right = tempTxList.get(index);
}
// sha2 hex value
String sha2HexValue = getSHA2HexValue(left + right);
newTxList.add(sha2HexValue);
index++;
}
测试
package test;
import java.util.ArrayList;
import java.util.List;
public class App {
public static void main(String [] args) {
List tempTxList = new ArrayList();
tempTxList.add("a");
tempTxList.add("b");
tempTxList.add("c");
tempTxList.add("d");
tempTxList.add("e");
MerkleTrees merkleTrees = new MerkleTrees(tempTxList);
merkleTrees.merkle_tree();
System.out.println("root : " + merkleTrees.getRoot());
}
}
执行结果
本文从简单二叉树的形式实现了简单的MerkleTree，计算出TreeRoot，但是实际上的的MerkleTree不拘谨与二叉树还可能是多叉树。