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

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

不变性

区块链是不可变的，因为为交易计算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());

}

示例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测试结合在一起。