用Java代码实现区块链技术

比特币很热——这是一种轻描淡写的说法。 虽然加密货币的未来有些不确定，但用于为比特币提供动力的区块链技术也非常受欢迎。

区块链的应用范围几乎是无止境的。 可以说，它还有可能破坏企业自动化。 有很多关于区块链如何工作的信息。 我们有介绍区块链技术的免费白皮书（无需注册）。

本文将重点介绍区块链架构，特别是演示“不可变、仅附加”分布式账本如何使用简化的代码示例。

作为一名开发人员，在代码中看到事物比简单地阅读技术文章更有助于理解它是如何工作的。 至少对我来说是这样。 那么，让我们开始吧！

简而言之，区块链

首先让我们快速总结一下区块链。 一个块包含一些头部信息和一组或任何类型数据的交易块。 该链从第一个（创世纪）块开始。 添加/追加交易时，根据一个区块中可存储的交易数量创建新区块。

当超过块阈值大小时，将创建一个新的交易块。 新块链接到以前的块，因此称为区块链。

不变性

区块链是不可变的，因为 SHA-256 哈希是为交易计算的。 块的内容也被散列，提供唯一标识符。 此外，来自链接的前一个块的散列也存储在块头中并散列。

这就是为什么试图篡改区块链区块基本上是不可能的，至少在当前的计算能力下是这样。 下面是显示块属性的部分 Java 类定义。

...
public class Block {
	public long timeStamp;
	private int index;
	private List transactions = new ArrayList();
	private String hash;
	private String previousHash;
	private String merkleRoot;
	private String nonce = "0000";
	
	// caches Transaction SHA256 hashes
    public Map map = new HashMap();
...

请注意，注入的泛型类型是 Tx 类型。 这允许更改交易数据。 此外，previousHash 属性将引用前一个块的哈希值。 merkleRoot 和 nonce 属性将在后面描述。

块散列

每个区块都可以计算出一个区块哈希。 这本质上是连接在一起的所有块属性的哈希值，包括前一个块的哈希值和生成的 SHA-256 哈希值。

下面是块中定义的方法。 计算哈希值的 Java 类。

...
public void computeHash() {
     Gson parser = new Gson(); // probably should cache this instance
     String serializedData = parser.toJson(transactions);	  
     setHash(SHA256.generateHash(timeStamp + index + merkleRoot + serializedData + nonce + previousHash));
     }
...

区块交易被序列化为 JSON 字符串，在被散列之前附加到区块属性。

链链

区块链通过接受交易来管理区块。 当达到预定阈值时，将创建一个块。 这是一个简单的Chain链。 Java部分实现：

...
public class SimpleBlockchain {
	public static final int BLOCK_SIZE = 10;
	public List> chain = new ArrayList>();
	public SimpleBlockchain() {
		// create genesis block
		chain.add(newBlock());
	}
...

请注意，chain 属性包含使用 Tx 类型键控的区块列表。 此外，在创建链时，无参数构造函数会创建一个初始的“创世纪”块。 下面是 newBlock() 方法的源代码。

public Block newBlock() {
		int count = chain.size();
		String previousHash = "root";
		if (count > 0)
			previousHash = blockChainHash();
		Block block = new Block();
		block.setTimeStamp(System.currentTimeMillis());
		block.setIndex(count);
		block.setPreviousHash(previousHash);
		return block;
	}

这个新的块方法将创建一个新的块实例，用适当的值作为种子，并分配前一个块的哈希值（即链头的哈希值）。 然后它将返回块。

在将块添加到链之前，可以通过将新块的先前哈希与链的最后一个块（标头）进行比较来验证块，以确保它们匹配。 这是一个简单的链。 java方法对此进行了描述。

public void addAndValidateBlock(Block block) {
		// compare previous block hash, add if valid
		Block current = block;
		for (int i = chain.size() - 1; i >= 0; i--) {
			Block b = chain.get(i);
			if (b.getHash().equals(current.getPreviousHash())) {
				current = b;
			} else {
				throw new RuntimeException("Block Invalid");
			}
		}
		this.chain.add(block);
}

整个区块链通过链的循环进行验证，以确保一个块的哈希值仍然与前一个块的哈希值匹配。

这是 SimpleBlockChain.java 的 validate() 方法实现。

public boolean validate() {
		String previousHash = null;
		for (Block block : chain) {
			String currentHash = block.getHash();
			if (!currentHash.equals(previousHash)) {
				return false;
			}
			previousHash = currentHash;
		}
		return true;
	}

你可以看到，试图以任何方式伪造交易数据或任何其他财产都是非常困难的。 而且，随着链条的增长，它继续变得非常非常非常困难，基本上是不可能的。直到量子计算机的出现

添加交易

区块链技术的另一个重要技术点是分布式。 它们被附加的事实仅有助于在参与区块链网络的节点之间复制区块链。 节点通常以点对点的方式进行通信，这就是比特币所做的，但并非必须如此。 其他区块链实施使用分散的方法，例如使用基于 HTTP 的 API。 但是，这是另一个博客的主题。

交易几乎可以代表任何东西。 交易可以包含要执行的代码（即智能合约），或存储和附加有关某种业务交易的信息。

智能合约：一种计算机协议，旨在以数字方式促进、验证或强制执行合同的谈判或履行。

就比特币而言，交易包含从所有者账户到其他账户的金额（即账户之间比特币金额的转移）。 公钥和账户ID也包含在交易中，因此转账是安全的。 但这是比特币特有的。

交易被添加到网络并合并； 它们不在一个区块或链中。

这就是区块链共识机制发挥作用的地方。 这里有许多经过验证的共识算法和模式，超出了本博客的范围。

挖矿是比特币区块链使用的共识机制。 这是本博客进一步讨论的共识类型。 共识机制收集交易，从中构建区块，并将区块添加到链中。 然后，链在将新交易块添加到链之前验证它们。

默克尔树

交易被散列并添加到块中。 创建一个 Merkle 树数据结构来计算 Merkle 根哈希。 每个块将存储 Merkle 树的根，Merkle 树是哈希的平衡二叉树，其中内部节点是两个子哈希的哈希，一直到根哈希，即 Merkle 根。

这棵树用于验证区块交易，如果在任何交易中更改了一位信息，Merkle 根将失效。 此外，它们还可以帮助以分布式方式传输区块，因为该结构只允许添加和验证整个交易区块所需的交易哈希的单个分支。

下面是模块中的方法。 一个 java 类，它根据交易列表创建 Merkle 树。

public List merkleTree() {		
		ArrayList tree = new ArrayList<>();
		// Start by adding all the hashes of the transactions as leaves of the
		// tree.
		for (T t : transactions) {
			tree.add(t.hash());
		}
		int levelOffset = 0; // Offset in the list where the currently processed
								// level starts.
		// Step through each level, stopping when we reach the root (levelSize
		// == 1).
	for (int levelSize = transactions.size(); levelSize > 1; levelSize = (levelSize + 1) / 2) {
			// For each pair of nodes on that level:
			for (int left = 0; left < levelSize; left += 2) {
				// The right hand node can be the same as the left hand, in the
				// case where we don't have enough
				// transactions.
				int right = Math.min(left + 1, levelSize - 1);
				String tleft = tree.get(levelOffset + left);
				String tright = tree.get(levelOffset + right);
				tree.add(SHA256.generateHash(tleft + tright));
			}
			// Move to the next level.
			levelOffset += levelSize;
		}
		return tree;
	}

该方法用于计算块的 Merkle 树根。 配套项目有一个 Merkle 树单元测试，它尝试将交易添加到块并验证 Merkle 根是否已更改。 下面是单元测试的源代码。

@Test
	public void merkleTreeTest() {
		// create chain, add transaction
		SimpleBlockchain chain1 = new SimpleBlockchain();
		chain1.add(new Transaction("A")).add(new Transaction("B")).add(new Transaction("C")).add(new Transaction("D"));
		// get a block in chain
		Block block = chain1.getHead();
		System.out.println("Merkle Hash tree :" + block.merkleTree());
		// get a transaction from block
		Transaction tx = block.getTransactions().get(0);
		// see if block transactions are valid, they should be
		block.transasctionsValid();
		assertTrue(block.transasctionsValid());
		// mutate the data of a transaction
		tx.setValue("Z");
		// block should no longer be valid, blocks MerkleRoot does not match computed merkle tree of transactions
		assertFalse(block.transasctionsValid());
	}

该单元测试模拟验证交易，然后在共识机制之外的块中更改交易，即如果有人试图更改交易数据。

请记住，区块链是仅附加的，并且由于区块链数据结构在节点之间共享，因此块数据结构（包括 Merkle 根）被散列并连接到其他块。 所有节点都可以验证新区块，并且可以轻松证明现有区块的有效性。 因此，在太阳变成超新星并让每个人都晒黑之前，矿工试图添加一个伪造的区块，或者一个节点试图调整旧交易，这实际上是不可能的。

采矿工作证明

将交易组装成一个区块，然后提交给链成员进行验证的过程，在比特币圈子里被称为“挖矿”。

更一般地说比特币区块头存放的数据包括，在区块链中，这被称为共识。 有不同类型的经过验证的分布式共识算法。 使用哪种机制取决于您是否拥有公共区块链或许可区块链。 这在我们的白皮书中有更深入的描述，但本博客的重点是区块链机制，因此对于这个例子，我们将应用工作量证明共识机制。

因此，挖矿节点会监听区块链上正在执行的交易并执行一个简单的数学难题。 这个谜题使用随机数值生成具有一组预先确定的前导零的块哈希，该随机数会更改每次迭代，直到找到前导零哈希。

示例 Java 项目 ( ) 有一个 Miner.java 类，其中包含一个 proofwork(Block) 方法实现，如下所示。

private String proofOfWork(Block block) {
		String nonceKey = block.getNonce();
		long nonce = 0;
		boolean nonceFound = false;
		String nonceHash = "";
		Gson parser = new Gson();
		String serializedData = parser.toJson(transactionPool);
		String message = block.getTimeStamp() + block.getIndex() + block.getMerkleRoot() + serializedData
				+ block.getPreviousHash();
		while (!nonceFound) {
			nonceHash = SHA256.generateHash(message + nonce);
			nonceFound = nonceHash.substring(0, nonceKey.length()).equals(nonceKey);
			nonce++;
		}
		return nonceHash;
	}

同样，这被简化了，但是一旦收到一定数量的交易比特币区块头存放的数据包括，矿工实施将在区块上执行工作量证明哈希。 该算法简单地循环并创建块的 SHA-256 哈希值，直到生成前导数字哈希值。

这可能会花费很多时间，这就是为什么实施特定 GPU 微处理器来尽快执行和解决此问题的原因。

单元测试

您可以在 GitHub 上看到所有这些概念与 Java 示例项目的 JUnit 测试结合在一起。

最后的想法

希望本文给您足够的兴趣和洞察力，让您继续研究区块链技术。