用Java代码实现区块链技术

比特币很热门——这是多么轻描淡写的说法啊。虽然加密货币的未来有些不确定，但用于驱动比特币的区块链技术也非常流行。

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

本文将重点关注区块链体系结构，特别是演示“不可变、仅附加”分布式账本如何与简化的代码示例一起工作。

作为开发人员，与简单地阅读技术文章相比，在理解代码的工作原理时，从代码中看到东西要有用得多。至少对我来说是这样。那么，让我们开始吧！

简言之，区块链

首先让我们快速总结一下区块链。一个块包含一些标题信息和一组或一块任何类型数据的事务。链从第一个（起源）块开始。在添加/追加事务时，将根据一个块中可以存储的事务数量创建新的块。

当超过块阈值大小时，将创建一个新的事务块。新区块与前一区块相连，因此称为区块链。

不变性

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

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

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

请注意，注入的泛型类型是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 链

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

...
public class SimpleBlockchain<T extends Tx> {
	public static final int BLOCK_SIZE = 10;
	public List<Block<T>> chain = new ArrayList<Block<T>>();

	public SimpleBlockchain() {
		// create genesis block
		chain.add(newBlock());
	}

...

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

public Block<T> newBlock() {
		int count = chain.size();
		String previousHash = "root";

		if (count > 0)
			previousHash = blockChainHash();

		Block<T> block = new Block<T>();

		block.setTimeStamp(System.currentTimeMillis());
		block.setIndex(count);
		block.setPreviousHash(previousHash);
		return block;
	}

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

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

public void addAndValidateBlock(Block<T> block) {

		// compare previous block hash, add if valid
		Block<T> current = block;
		for (int i = chain.size() - 1; i >= 0; i--) {
			Block<T> 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<T> 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根将无效。此外，它们还可以帮助以分布式方式传输块，因为该结构只允许添加和验证整个事务块所需的事务哈希的单个分支。

下面是模块中的方法。从事务列表中创建Merkle树的java类。

public List<String> merkleTree() {		
		ArrayList<String> 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<Transaction> chain1 = new SimpleBlockchain<Transaction>();

		chain1.add(new Transaction("A")).add(new Transaction("B")).add(new Transaction("C")).add(new Transaction("D"));

		// get a block in chain
		Block<Transaction> 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根）被散列并连接到其他块。所有节点都可以验证新块，现有块可以很容易地被证明是有效的。因此，一个矿工试图添加一个虚假的区块，或者一个节点试图调整旧的交易，实际上是不可能的，在太阳长成超新星并给所有人一个非常好的棕褐色之前。

采矿工作证明

将交易组合成一个区块，然后提交给链成员验证的过程在比特币领域被称为“挖掘”。

更一般地说，在区块链中，这被称为共识。有不同类型的经验证的分布式一致性算法。使用哪种机制取决于您是否拥有公共区块链或许可区块链。我们的白皮书对此进行了更深入的描述，但本博客的重点是区块链机制，因此本例我们将应用一种工作证明共识机制。

因此，挖掘节点将监听区块链正在执行的交易，并执行一个简单的数学谜题。这个谜题使用一个在每次迭代中都会更改的nonce值生成具有一组预先确定的前导零的块散列，直到找到前导零散列为止。

示例Java项目（https://github.com/in-the-keyhole/khs-blockchain-java-example）有一个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;

	}

同样，这是简化的，但是一旦收到一定数量的事务，miner实现将对块执行工作证明哈希。该算法只是循环并创建块的SHA-256散列，直到产生前导数散列。

这可能需要很多时间，这就是为什么要实现特定的GPU微处理器来尽可能快地执行和解决这个问题。

单元测试

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

最后的想法

希望这篇文章能给你带来足够的兴趣和洞察力，让你继续研究区块链技术。