用Java代码实现区块链技术

Posted 2023-04-04 ikt4435

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

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

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

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

简言之，区块链

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

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

不变性

区块链是不可变的，因为为交易计算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测试结合在一起。

最后的想法

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

只用120行Java代码写一个自己的区块链

区块链是目前最热门的话题，广大读者都听说过比特币，或许还有智能合约，相信大家都非常想了解这一切是如何工作的。这篇文章就是帮助你使用 Java 语言来实现一个简单的区块链，用不到 120 行代码来揭示区块链的原理！

“用不到120行 Java 代码就能实现一个自己的区块链！” 听起来不可思议吧？有什么能比开发一个自己的区块链更好的学习实践方法呢？那我们就一起来实践下！

 因为我们是一家从事互联网金融的科技公司，所以我们采用虚拟资产金额作为这篇文章中的示例数据。大家可以先为自己想一个数字，后面我们会用到。

 通过本文，你将可以做到：

• 创建自己的区块链
• 理解 hash 函数是如何保持区块链的完整性的
• 如何创造并添加新的块
• 多个节点如何竞争生成块
• 通过浏览器来查看整个链
• 所有其他关于区块链的基础知识

但是，对于比如工作量证明算法（PoW）以及权益证明算法（PoS）这类的共识算法文章中将不会涉及。同时为了让你更清楚得查看区块链以及块的添加，我们将网络交互的过程简化了，关于 P2P 网络比如“对等网络”等内容将在将来的文章中讲解。

让我们开始吧！

设置

我们假设你已经具备一点 Java 语言的开发经验，以及maven项目构建经验。在安装和配置 Java 开发环境后之后，我们新建maven项目，在pom中增加一些依赖：

<!-- 超小型web框架 -->        <dependency>            <groupId>com.sparkjava</groupId>            <artifactId>spark-core</artifactId>            <version>${spark.version}</version>        </dependency>

Spark-web Framework是一个基于jetty的超小型框架，我们用它来写http访问的请求处理。

<dependency>            <groupId>commons-codec</groupId>            <artifactId>commons-codec</artifactId>            <version>${commons.codec.version}</version>        </dependency>

这个通用包拥有几乎所有加解密算法及常规操作

<dependency>            <groupId>com.google.code.gson</groupId>            <artifactId>gson</artifactId>            <version>2.8.2</version>        </dependency>

Google的json包，当然你可以使用你喜欢的其他json包。

最后，增加log相关的包

<!-- log start -->        <dependency>            <groupId>log4j</groupId>            <artifactId>log4j</artifactId>            <version>${log4j.version}</version>        </dependency>        <dependency>            <groupId>org.slf4j</groupId>            <artifactId>slf4j-api</artifactId>            <version>${slf4j.version}</version>        </dependency>        <dependency>            <groupId>org.slf4j</groupId>            <artifactId>slf4j-log4j12</artifactId>            <version>${slf4j.version}</version>        </dependency>        <!-- log end -->

相关版本属性设置

<properties>        <commons.codec.version>1.9</commons.codec.version>        <spark.version>2.6.0</spark.version>        <slf4j.version>1.6.6</slf4j.version>         <log4j.version>1.2.17</log4j.version>        <gson.version>2.8.2</gson.version> </properties>

 

接下来，我们创建一个 SparkWeb.java文件。之后我们的大部分工作都围绕这个文件，让我开始编码吧！

数据模型

我们来定义一个Block类，它代表组成区块链的每一个块的数据模型：

public class Block {     /**是这个块在整个链中的位置*/     private int index;     /**显而易见就是块生成时的时间戳*/     private String timestamp;     /**虚拟资产。我们要记录的数据*/     private int vac;     /**是这个块通过 SHA256 算法生成的散列值*/     private String hash;     /**指向前一个块的 SHA256 散列值*/     private String prevHash;         /** getters and setters**/  }

 

接着，我们再定义一个结构表示整个链，最简单的表示形式就是一个 Block 的 顺序表：

ArrayList<Block> blockChain

 

我们使用散列算法（SHA256）来确定和维护链中块和块正确的顺序，确保每一个块的 PrevHash 值等于前一个块中的 Hash 值，这样就以正确的块顺序构建出链：

 [ index:0| hash:"xxxw"| preHash:""] - [ index:1| hash:"xxxx"| preHash:"xxxw"] - [ index2| hash:"xxxy"| preHash:"xxxx"]

散列和生成块

我们为什么需要散列？主要是两个原因：

• 在节省空间的前提下去唯一标识数据。散列是用整个块的数据计算得出，在我们的例子中，将整个块的数据通过 SHA256 计算成一个定长不可伪造的字符串。
• 维持链的完整性。通过存储前一个块的散列值，我们就能够确保每个块在链中的正确顺序。任何对数据的篡改都将改变散列值，同时也就破坏了链。以我们从事的医疗健康领域为例，比如有一个恶意的第三方为了调整“人寿险”的价格，而修改了一个或若干个块中的代表不健康的 VAC 值，那么整个链都变得不可信了。

我们接着写一个函数，用来计算给定的数据的 SHA256 散列值：

public static String calculateHash(Block block) {        String record = (block.getIndex()) + block.getTimestamp() + (block.getVac()) + block.getPrevHash();        return SHA256.crypt(record); }

接下来我们就能得到一个生成块的函数：

public static Block generateBlock(Block oldBlock, int vac) {        Block newBlock = new Block();        newBlock.setIndex(oldBlock.getIndex() + 1);        newBlock.setTimestamp(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));        newBlock.setVac(vac);        newBlock.setPrevHash(oldBlock.getHash());        newBlock.setHash(calculateHash(newBlock));        return newBlock; }

其中，Index 是从给定的前一块的 Index 递增得出，时间戳是直接通过 new Date() 函数来获得的，Hash 值通过前面的 calculateHash 函数计算得出，PrevHash 则是给定的前一个块的 Hash 值。

 

校验块

搞定了块的生成，接下来我们需要有函数帮我们判断一个块是否有被篡改。检查 Index 来看这个块是否正确得递增，检查 PrevHash 与前一个块的 Hash 是否一致，再来通过 calculateHash 检查当前块的 Hash 值是否正确。通过这几步我们就能写出一个校验函数：

public static boolean isBlockValid(Block newBlock, Block oldBlock) {        if (oldBlock.getIndex() + 1 != newBlock.getIndex()) {            return false;        }        if (!oldBlock.getHash().equals(newBlock.getPrevHash())) {            return false;        }        if (!calculateHash(newBlock).equals(newBlock.getHash())) {            return false;        }        return true;     }

 

除了校验块以外，我们还会遇到一个问题：两个节点都生成块并添加到各自的链上，那我们应该以谁为准？这里的细节我们留到下一篇文章，这里先让我们记住一个原则：始终选择最长的链。

 [block 1] -> [block 2] -> [block 3] -> [block 4] -> [block 5] -> 认可

 [block 1] -> [block 2] -> [block 3] -> [block 4] ->  丢弃

通常来说，更长的链表示它的数据（状态）是更加新的，所以我们需要一个函数能帮我们将本地的过期的链切换成最新的链：

public void replaceChain(ArrayList<Block> newBlocks) {        if (newBlocks.size() > blockChain.size()) {            blockChain = newBlocks;        }     }

 

到这一步，我们基本就把所有重要的函数完成了。接下来，我们需要一个方便直观的方式来查看我们的链，包括数据及状态。通过浏览器查看 web 页面可能是最合适的方式。

Web 服务

我猜你一定对传统的 web 服务及开发非常熟悉，所以这部分你肯定一看就会。

借助 Spark Web Framework，来完成我们的 web 服务，代码如下：

public static void main(String[] args) {        // port(5678); //默认端口是4567，你可以设置别的端口 }

OK，完成，对，你没看错，就是一个空的main方法，就可以了。

接下来我们定义不同 endpoint 以及对应的 handler。例如，对“/”的 GET 请求我们可以查看整个链，对“/”的 POST 请求可以创建一个新的块。

 

GET 请求的 handler：

get("/", (q, a) ->{return gson.toJson(blockChain)});

 

为了简化，我们直接以 JSON 格式返回整个链，你可以在浏览器中访问 localhost:4567 或者 127.0.0.1:4567 来查看

POST 请求的 handler 稍微有些复杂，我们先来定义一下 POST 请求的 payload：

public class Message {     private int vac; //getters and setters }

 

再看看 handler 的实现：

post("/", (q, a) -> { String body = request.body();               Message m = gson.fromJson(body, Message.class);               if (m == null) {                   return "vac is NULL";               }               int vac = m.getVac();               Block lastBlock = blockChain.get(blockChain.size() - 1);               Block newBlock = generateBlock(lastBlock, vac);               if (isBlockValid(newBlock, lastBlock)) {                   blockChain.add(newBlock);                   LOGGER.debug(gson.toJson(blockChain));               } else {                   return "HTTP 500: Invalid Block Error";               }               return "success!"; });

 

我们的 POST 请求体中可以使用上面定义的 payload，比如：

{"vac":7500}

还记得前面我们写的 generateBlock 这个函数吗？它接受一个“前一个块”参数，和一个 VAC 值。POST handler 接受请求后就能获得请求体中的 VAC 值，接着借助生成块的函数以及校验块的函数就能生成一个新的块了！

除此之外，你也可以：

• 使用new GsonBuilder().setPrettyPrinting().create()这个函数可以以非常美观和方便阅读的方式将数据json化打印在控制台里，方便调试。
• 测试 POST 请求时，可以使用 POSTMAN 这个 chrome 插件，相比 curl它更直观和方便。也可以使用RESTClient这个FireFox插件。

 

快要大功告成了

接下来，我们把这些关于区块链的函数，web 服务的函数“组装”起来：最重要的是，我们需要产生第一个块（创世块），来作为区块链的头。

//创世块        Block genesisBlock = new Block();        genesisBlock.setIndex(0);        genesisBlock.setTimestamp(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));        genesisBlock.setVac(0);        genesisBlock.setPrevHash("");        genesisBlock.setHash(calculateHash(genesisBlock));        blockChain.add(genesisBlock);

这里的 genesisBlock （创世块）是 main 函数中最重要的部分，通过它来初始化区块链，毕竟要有一个开始，第一个块的 PrevHash 是空的。

 

哦耶！完成了

让我们来启动它：

在终端中，我们可以看到 web 服务器启动的日志信息，并且打印出了创世块的信息：

[INFO ] 2018-02-08 10:58:26 [email protected](SparkWeb.java:132):[ { "index": 0, "timestamp": "2018-02-08 10:58:25", "vac": 0, "hash": "7c2d2db62a82ac8aa3d843ff837c604d8bd17800f4c466d472c5df185b8967fa", "prevHash": "" } ] [INFO ] 2018-02-08 10:58:26 [email protected](Log.java:192):Logging initialized @1267ms to org.eclipse.jetty.util.log.Slf4jLog [INFO ] 2018-02-08 10:58:26 [email protected](EmbeddedJettyServer.java:127):== Spark has ignited ... [INFO ] 2018-02-08 10:58:26 [email protected](EmbeddedJettyServer.java:128):>> Listening on 0.0.0.0:4567 [INFO ] 2018-02-08 10:58:26 [email protected](Server.java:372):jetty-9.4.4.v20170414 [INFO ] 2018-02-08 10:58:26 [email protected](DefaultSessionIdManager.java:364):DefaultSessionIdManager workerName=node0 [INFO ] 2018-02-08 10:58:26 [email protected](DefaultSessionIdManager.java:369):No SessionScavenger set, using defaults [INFO ] 2018-02-08 10:58:26 [email protected](HouseKeeper.java:149):Scavenging every 600000ms [INFO ] 2018-02-08 10:58:27 [email protected](AbstractConnector.java:280):Started [email protected]{HTTP/1.1,[http/1.1]}{0.0.0.0:4567} [INFO ] 2018-02-08 10:58:27 [email protected](Server.java:444):Started @1669ms

 

接着我们打开浏览器，访问 http://localhost:4567 这个地址，我们可以看到页面中展示了当前整个区块链的信息（当然，目前只有一个创世块）：

{ "index": 0, "timestamp": "2018-02-08 10:58:25", "vac": 0, "hash": "7c2d2db62a82ac8aa3d843ff837c604d8bd17800f4c466d472c5df185b8967fa", "prevHash": "" }

接着，我们再通过 RESRClient来发送一些 POST 请求：post http://localhost:4567/  {"vac":15} [send];

或者使用curl命令：curl -X POST -i http://localhost:4567/ --data ‘{"vac":125}‘。

刷新刚才的http://localhost:4567 页面，现在的链中多了一个块，正是我们刚才生成的，同时可以看到，块的顺序和散列值都正确。

 

下一步

 

刚刚我们完成了一个自己的区块链，虽然很简单很简陋，但它具备块生成、散列计算、块校验等基本能力。接下来你就可以继续深入的学习区块链的其他重要知识，比如工作量证明、权益证明这样的共识算法，或者是智能合约、Dapp、侧链等等。当然，最重要的一点，作为去中心化的技术，维护一个在启动时可以连接的对等节点列表，进行peer to peer的通讯也是区块链技术必不可少的核心部分。