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

浏览:
字体:
发布时间:2019-08-02 10:38:34
来源:互联网

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

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

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

 通过本文,你将可以做到:

1、创建自己的区块链

2、理解 hash 函数是如何保持区块链的完整性的

3、如何创造并添加新的块

4、多个节点如何竞争生成块

5、通过浏览器来查看整个链

6、所有其他关于区块链的基础知识

但是,对于比如工作量证明算法(PoW)以及权益证明算法(PoS)这类的共识算法文章中将不会涉及。

同时为了让你更清楚得查看区块链以及块的添加,我们将网络交互的过程简化了,关于 P2P 网络比如“对等网络”等内容将在将来的文章中讲解。

让我们开始吧!

设置

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


 
  1. <!-- 超小型web框架 --> 
  2.        <dependency>  
  3.            <groupId>com.sparkjava</groupId>  
  4.            <artifactId>spark-core</artifactId>  
  5.            <version>${spark.version}</version>  
  6.        </dependency> 

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


 
  1. <dependency>  
  2.            <groupId>commons-codec</groupId>  
  3.            <artifactId>commons-codec</artifactId>  
  4.            <version>${commons.codec.version}</version>  
  5.        </dependency> 

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


 
  1. <dependency>  
  2.            <groupId>com.google.code.gson</groupId>  
  3.            <artifactId>gson</artifactId>  
  4.            <version>2.8.2</version>  
  5.        </dependency> 

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

***,增加log相关的包


 
  1. <!-- log start -->  
  2.        <dependency>  
  3.            <groupId>log4j</groupId>  
  4.            <artifactId>log4j</artifactId>  
  5.            <version>${log4j.version}</version>  
  6.        </dependency>  
  7.        <dependency>  
  8.            <groupId>org.slf4j</groupId>  
  9.            <artifactId>slf4j-api</artifactId>  
  10.            <version>${slf4j.version}</version>  
  11.        </dependency>  
  12.        <dependency>  
  13.            <groupId>org.slf4j</groupId>  
  14.            <artifactId>slf4j-log4j12</artifactId>  
  15.            <version>${slf4j.version}</version>  
  16.        </dependency>  
  17.        <!-- log end --> 

相关版本属性设置


 
  1. <properties>  
  2.        <commons.codec.version>1.9</commons.codec.version>  
  3.        <spark.version>2.6.0</spark.version>  
  4.        <slf4j.version>1.6.6</slf4j.version>  
  5.         <log4j.version>1.2.17</log4j.version>  
  6.        <gson.version>2.8.2</gson.version>  
  7. </properties> 

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

数据模型

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


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

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


 
  1. ArrayList<Block> blockChain 

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

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

散列和生成块

我们为什么需要散列?主要是两个原因:

1、在节省空间的前提下去唯一标识数据。散列是用整个块的数据计算得出,在我们的例子中,将整个块的数据通过 SHA256 计算成一个定长不可伪造的字符串。

2、维持链的完整性。通过存储前一个块的散列值,我们就能够确保每个块在链中的正确顺序。任何对数据的篡改都将改变散列值,同时也就破坏了链。以我们从事的医疗健康领域为例,比如有一个恶意的第三方为了调整“人寿险”的价格,而修改了一个或若干个块中的代表不健康的 VAC 值,那么整个链都变得不可信了。

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


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

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


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

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

校验块

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


 
  1. public static boolean isBlockValid(Block newBlock, Block oldBlock) {  
  2.        if (oldBlock.getIndex() + 1 != newBlock.getIndex()) {  
  3.            return false;  
  4.        }  
  5.        if (!oldBlock.getHash().equals(newBlock.getPrevHash())) {  
  6.            return false;  
  7.        }  
  8.        if (!calculateHash(newBlock).equals(newBlock.getHash())) {  
  9.            return false;  
  10.        }  
  11.        return true;  
  12.     } 

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

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

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

通常来说,更长的链表示它的数据(状态)是更加新的,所以我们需要一个函数能帮我们将本地的过期的链切换成***的链:


 
  1. public void replaceChain(ArrayList<Block> newBlocks) {  
  2.        if (newBlocks.size() > blockChain.size()) {  
  3.            blockChain = newBlocks;  
  4.        }  
  5.     } 

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

Web 服务

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

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


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

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

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

GET 请求的 handler:


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

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

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


 
  1. public class Message {  
  2.     private int vac;  
  3. //getters and setters  

再看看 handler 的实现:


 
  1. post("/", (q, a) -> {  
  2. String body = request.body();  
  3.               Message m = gson.fromJson(body, Message.class);  
  4.               if (m == null) {  
  5.                   return "vac is NULL";  
  6.               }  
  7.               int vac = m.getVac();  
  8.               Block lastBlock = blockChain.get(blockChain.size() - 1);  
  9.               Block newBlock = generateBlock(lastBlock, vac);  
  10.               if (isBlockValid(newBlock, lastBlock)) {  
  11.                   blockChain.add(newBlock);  
  12.                   LOGGER.debug(gson.toJson(blockChain));  
  13.               } else {  
  14.                   return "HTTP 500: Invalid Block Error";  
  15.               }  
  16.               return "success!";  
  17. }); 

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

{"vac":7500}

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

除此之外,你也可以:

1、使用new GsonBuilder().setPrettyPrinting().create()这个函数可以以非常美观和方便阅读的方式将数据json化打印在控制台里,方便调试。

2、测试 POST 请求时,可以使用 POSTMAN 这个 chrome 插件,相比 curl它更直观和方便。也可以使用RESTClient这个FireFox插件。

快要大功告成了

接下来,我们把这些关于区块链的函数,web 服务的函数“组装”起来:最重要的是,我们需要产生***个块(创世块),来作为区块链的头。


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

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

哦耶!完成了

让我们来启动它:

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


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

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


 
  1. {  
  2. "index": 0,  
  3. "timestamp": "2018-02-08 10:58:25",  
  4. "vac": 0,  
  5. "hash": "7c2d2db62a82ac8aa3d843ff837c604d8bd17800f4c466d472c5df185b8967fa",  
  6. "prevHash": ""  

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

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

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

源码:https://github.com/Mignet/blockchain

更多信息来自:东方联盟网 vm888.com

>更多相关文章
24小时热门资讯
24小时回复排行
资讯 | QQ | 安全 | 编程 | 数据库 | 系统 | 网络 | 考试 | 站长 | 关于东联 | 安全雇佣 | 搞笑视频大全 | 微信学院 |
关于我们 | 联系我们 | 广告服务 | 免责申明 | 作品发布 | 网站地图 | 官方微博 | 技术培训
Copyright © 2007 - 2019 Vm888.Com. All Rights Reserved
粤公网安备 44060402001498号 粤ICP备19097316号 请遵循相关法律法规,内容来自互联网,仅供用于技术学习.东方联盟
');})();