简单的代码演示区块链是什么

本文的目的是帮助你真正理解区块链是什么。我们将通过实战学习的方式，用 Java创建一个非常基本的区块链，实现简单的工作量证明系统，并在此基础上 进行扩展。Java源代码保存在Github

(文章是参考最后参考连接文章加一些自己的理解而写的)

创建区块链

区块链就是一串或者是一系列区块的集合，类似于链表的概念，每个区块都指向于后面一个区块，然后顺序的连接在一起。

那么每个区块中的内容是什么呢？在区块链中的每一个区块都存放了很多很有价值的信息，主要包括三个部分：自己的数字签名(什么是数字签名，见最后面的名词解释)，上一个区块的数字签名，还有一切需要加密的数据。

每个数字签名 不但证明了自己是特有的一个区块，而且指向了前一个区块的来源，让所有的区块在链条中可以串起来， 而数据就是一些特定的信息，你可以按照业务逻辑来保存业务数据。

为了简化，把区块内所有数据进行hash(什么是hash见最后面的名词解释)得到的数据为该区块的数字签名。

所以每一个区块不仅包含前一个区块的hash值，同时包含自身的一个hash值，自身的hash值是通过之前的hash值和数据data通过hash计算出来的。如果前一个区块的数据一旦被篡改了，那么前一个区块的hash值也会同样发生变化（因为数据也被计算在内），这样也就导致了所有后续的区块中的hash值会变。所以计算和比对hash值会让我们检查到当前的区块链是否是有效的，也就避免了数据被恶意 篡改的可能性，因为篡改数据就会改变hash值并破坏整个区块链。

定义区块链的类Block：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import java.util.Date;

public class Block {

    public String hash;
    public String previousHash;
    private String data; //our data will be a simple message.
    private long timeStamp; //as number of milliseconds since 1/1/1970.

    //Block Constructor.
    public Block(String data,String previousHash ) {
        this.data = data;
        this.previousHash = previousHash;
        this.timeStamp = new Date().getTime();
    }
}

正如你可以看到我们的基本块包含String hash，它将保存我们的数字签名。变量 previoushash保存前一个块的hash和String data来保存我们的块数据

创建数字签名

熟悉加密算法的朋友们，Java方式可以实现的加密方式有很多，例如BASE、MD、RSA、SHA等等， 我在这里选用了SHA256这种加密方式，SHA（Secure Hash Algorithm）安全散列算法，这种算法 的特点是数据的少量更改会在Hash值中产生不可预知的大量更改，hash值用作表示大量数据的 固定大小的唯一值，而SHA256算法的hash值大小为256位。之所以选用SHA256是因为它的大小正合适， 一方面产生重复hash值的可能性很小，另一方面在区块链实际应用过程中，有可能会产生大量的区块， 而使得信息量很大，那么256位的大小就比较恰当了。

为了简化操作，直接使用codec库的org.apache.commons.codec.digest.DigestUtils类来调用SHA256算法

1
String calculatedhash = DigestUtils.sha256Hex(input);

或许你不完全理解上述代码的含义，但是你只要理解所有的输入调用此方法后均会生成一个独一无二的hash值（数字签名）， 而这个hash值在区块链中是非常重要的。

接下来让我们在Block类中应用sha256方法，其主要的目的就是计算hash值，我们计算的hash值 应该包括区块中所有我们不希望被恶意篡改的数据，在我们上面所列的Block类中就一定包括previousHash，data和timeStamp

1
2
3
4
5
6
7
8
public String calculateHash() {
    String calculatedhash = DigestUtils.sha256Hex( 
            previousHash +
            Long.toString(timeStamp) +
            data 
            );
    return calculatedhash;
}

然后把这个方法加入到Block的构造函数中去

1
2
3
4
5
6
public Block(String data,String previousHash ) {
    this.data = data;
    this.previousHash = previousHash;
    this.timeStamp = new Date().getTime();
    this.hash = calculateHash(); //Making sure we do this after we set the other values.
}

测试

在主方法中让我们创建一些区块，并把其hash值打印出来，来看看是否一切都在我们的预期中。

第一个块称为创世块，因为它是头区块，所以我们只需输入“0”作为前一个块的previous hash。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class NoobChain {

    public static void main(String[] args) {

        Block genesisBlock = new Block("Hi im the first block", "0");
        System.out.println("Hash for block 1 : " + genesisBlock.hash);

        Block secondBlock = new Block("Yo im the second block",genesisBlock.hash);
        System.out.println("Hash for block 2 : " + secondBlock.hash);

        Block thirdBlock = new Block("Hey im the third block",secondBlock.hash);
        System.out.println("Hash for block 3 : " + thirdBlock.hash);

    }
}

打印输出结果：

1
2
3
Hash for block 1 : 4aa62fc026afbceb8b3f48d6add75abd02c05fb5f166a4e4d2ed3a80f2c05212
Hash for block 2 : 2e4ec6d0e8633dc424bd873aa641887bfedee455b458373a92d534f61b8f6f33
Hash for block 3 : 62c3851a213fafe8c4977b24c8f026f93c5df1a6e767d5cf1549f956d5cbb70d

每一个区块都必须要有自己的数据签名即hash值，这个hash值依赖于自身的信息（data）和上 一个区块的数字签名（previousHash），但这个还不是区块链，下面让我们存储区块到数组中， 这里我会引入gson包，目的是可以用json方式查看整个一条区块链结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.ArrayList;
import com.google.gson.GsonBuilder;

public class NoobChain {

    public static ArrayList<Block> blockchain = new ArrayList<Block>(); 

    public static void main(String[] args) {    
        //add our blocks to the blockchain ArrayList:
        blockchain.add(new Block("Hi im the first block", "0"));        
        blockchain.add(new Block("Yo im the second block",blockchain.get(blockchain.size()-1).hash)); 
        blockchain.add(new Block("Hey im the third block",blockchain.get(blockchain.size()-1).hash));

        String blockchainJson = new GsonBuilder().setPrettyPrinting().create().toJson(blockchain);      
        System.out.println(blockchainJson);
    }

}

输出的结果可能是

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[
  {
    "hash": "53bc5a7a8f965f12f4b7de48f239c136f8ad308f4699c88d192cb09b8b3495f8",
    "previousHash": "0",
    "data": "Hi im the first block",
    "timeStamp": 1536200207563,
    "nonce": 0
  },
  {
    "hash": "a11c319cfaf1aa0c4fe9a22958e68e1605b4a66a13d56d9cd5aea2b6b808a6e3",
    "previousHash": "53bc5a7a8f965f12f4b7de48f239c136f8ad308f4699c88d192cb09b8b3495f8",
    "data": "Yo im the second block",
    "timeStamp": 1536200207578,
    "nonce": 0
  },
  {
    "hash": "ffcdd49c394aff0be445e6cd842fea0c3c7e5ce23fa29ea241b77ef0587a2bf8",
    "previousHash": "a11c319cfaf1aa0c4fe9a22958e68e1605b4a66a13d56d9cd5aea2b6b808a6e3",
    "data": "Hey im the third block",
    "timeStamp": 1536200207578,
    "nonce": 0
  }
]

这样的输出结构就更类似于我们所期待的区块链的样子。

检查区块链的完整性

在主方法中增加一个isChainValid()方法，目的是循环区块链中的所有区块并且比较hash值，这个方法用来检查hash值是否是于计算出来的hash值相等，同时previousHash值是否和前一个区块的hash值相等。或许你会产生如下的疑问，我们就在一个主函数中创建区块链中的区块，所以不存在被修改的可能性，但是你要注意的是，区块链中的一个核心概念就是去中心化， 每一个区块可能是在网络中的某一个节点中产生的，所以很有可能某个节点把自己节点中的 数据修改了，那么根据上述的理论数据改变会导致整个区块链的破裂，也就是区块链就无效了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static Boolean isChainValid() {
    Block currentBlock; 
    Block previousBlock;

    //loop through blockchain to check hashes:
    for(int i=1; i < blockchain.size(); i++) {
        currentBlock = blockchain.get(i);
        previousBlock = blockchain.get(i-1);
        //compare registered hash and calculated hash:
        if(!currentBlock.hash.equals(currentBlock.calculateHash()) ){
            System.out.println("Current Hashes not equal");         
            return false;
        }
        //compare previous hash and registered previous hash
        if(!previousBlock.hash.equals(currentBlock.previousHash) ) {
            System.out.println("Previous Hashes not equal");
            return false;
        }
    }
    return true;
}

任何区块链中区块的一丝一毫改变都会导致这个函数返回false，也就证明了区块链无效了

在比特币网络中所有的网络节点都分享了它们各自的区块链，然而最长的有效区块链是被全网所统一承认的，如果有人恶意来篡改之前的数据，然后创建一条更长的区块链并全网布呈现在网络中，我们该怎么办呢？这就涉及到了区块链中另外一个重要的概念工作量证明, 这里就不得不提及一下hashcash，这个概念最早来自于AdamBack的一篇论文，主要应用于邮件过滤和比特币中防止双重支付。

挖矿

这里我们要求挖矿者做工作量证明，具体的方式是在区块中尝试不同的参数值直到它的hash值是从一系列的0开始的。让我们添加一个名为nonce的int类型以包含在我们的calculatehash（） 方法中，以及需要的mineblock（）方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.util.Date;

import org.apache.commons.codec.digest.DigestUtils;

public class Block {

    public String hash;
    public String previousHash;
    private String data; //our data will be a simple message.
    private long timeStamp; //as number of milliseconds since 1/1/1970.

    private int nonce;

    //Block Constructor.
    public Block(String data,String previousHash ) {
        this.data = data;
        this.previousHash = previousHash;
        this.timeStamp = new Date().getTime();
        this.hash = calculateHash(); //Making sure we do this after we set the other values.
    }
    public String calculateHash() {
        String calculatedhash = DigestUtils.sha256Hex( 
                previousHash +
                Long.toString(timeStamp) +
                Long.toString(nonce) +
                data 
                );
        return calculatedhash;
    }
    public void mineBlock(int difficulty) {
        String target = new String(new char[difficulty]).replace('\0', '0'); //Create a string with difficulty * "0" 
        while(!hash.substring( 0, difficulty).equals(target)) {
            nonce ++;
            hash = calculateHash();
        }
        System.out.println("Block Mined!!! : " + hash);
    }
}

mineBlock()方法中引入了一个int值称为difficulty难度，低的难度比如1和2，普通的电脑基本都可以马上计算出来， 我的建议是在4-6之间进行测试，普通电脑大概会花费3秒时间，在莱特币中难度大概围绕在442592左右，而在 比特币中每一次挖矿都要求大概在10分钟左右，当然根据所有网络中的计算能力，难度也会不断的进行修改。

我们在NoobChain类 中增加difficulty这个静态变量。

1
public static int difficulty = 5;

这样我们必须修改主方法中让创建每个新区块时必须触发mineBlock()方法，而isChainValid()方法用来检查每个区块的hash值是否正确，整个区块链是否是有效的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import java.util.ArrayList;
import com.google.gson.GsonBuilder;

public class NoobChain {

    public static ArrayList<Block> blockchain = new ArrayList<Block>();
    public static int difficulty = 5;

    public static void main(String[] args) {    
        //add our blocks to the blockchain ArrayList:

        blockchain.add(new Block("Hi im the first block", "0"));
        System.out.println("Trying to Mine block 1... ");
        blockchain.get(0).mineBlock(difficulty);

        blockchain.add(new Block("Yo im the second block",blockchain.get(blockchain.size()-1).hash));
        System.out.println("Trying to Mine block 2... ");
        blockchain.get(1).mineBlock(difficulty);

        blockchain.add(new Block("Hey im the third block",blockchain.get(blockchain.size()-1).hash));
        System.out.println("Trying to Mine block 3... ");
        blockchain.get(2).mineBlock(difficulty);    

        System.out.println("\nBlockchain is Valid: " + isChainValid());

        String blockchainJson = new GsonBuilder().setPrettyPrinting().create().toJson(blockchain);
        System.out.println("\nThe block chain: ");
        System.out.println(blockchainJson);
    }

    public static Boolean isChainValid() {
        Block currentBlock; 
        Block previousBlock;
        String hashTarget = new String(new char[difficulty]).replace('\0', '0');

        //loop through blockchain to check hashes:
        for(int i=1; i < blockchain.size(); i++) {
            currentBlock = blockchain.get(i);
            previousBlock = blockchain.get(i-1);
            //compare registered hash and calculated hash:
            if(!currentBlock.hash.equals(currentBlock.calculateHash()) ){
                System.out.println("Current Hashes not equal");         
                return false;
            }
            //compare previous hash and registered previous hash
            if(!previousBlock.hash.equals(currentBlock.previousHash) ) {
                System.out.println("Previous Hashes not equal");
                return false;
            }
            //check if hash is solved
            if(!currentBlock.hash.substring( 0, difficulty).equals(hashTarget)) {
                System.out.println("This block hasn't been mined");
                return false;
            }
        }
        return true;
    }
}

打印

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Trying to Mine block 1... 
Block Mined!!! : 00000b97ccf50c18cc65e5dcb5cd6c60fd62694968cdd9d53fc5b6acc2fa6f74
Trying to Mine block 2... 
Block Mined!!! : 00000b9d828c0c140444dab06ba587e278faa32e70d23f132d7abaa104976c4f
Trying to Mine block 3... 
Block Mined!!! : 00000f70b1bb91a95cbbbd4c5e1cf22cd9538b51ff92f2973a53cc7ffb1a82c0

Blockchain is Valid: true

The block chain: 
[
  {
    "hash": "00000b97ccf50c18cc65e5dcb5cd6c60fd62694968cdd9d53fc5b6acc2fa6f74",
    "previousHash": "0",
    "data": "Hi im the first block",
    "timeStamp": 1536200647658,
    "nonce": 36832
  },
  {
    "hash": "00000b9d828c0c140444dab06ba587e278faa32e70d23f132d7abaa104976c4f",
    "previousHash": "00000b97ccf50c18cc65e5dcb5cd6c60fd62694968cdd9d53fc5b6acc2fa6f74",
    "data": "Yo im the second block",
    "timeStamp": 1536200647782,
    "nonce": 1044781
  },
  {
    "hash": "00000f70b1bb91a95cbbbd4c5e1cf22cd9538b51ff92f2973a53cc7ffb1a82c0",
    "previousHash": "00000b9d828c0c140444dab06ba587e278faa32e70d23f132d7abaa104976c4f",
    "data": "Hey im the third block",
    "timeStamp": 1536200649063,
    "nonce": 404142
  }
]

经过测试增加一个新的区块即挖矿必须花费一定时间，大概是3秒左右，你可以提高difficulty难度来看， 它是如何影响数据难题所花费的时间的

如果有人在你的区块链系统中恶意篡改数据：

  • 他们的区块链是无效的
  • 他们无法创建更长的区块链
  • 网络中诚实的区块链会在长链中更有时间的优势

因为篡改的区块链将无法赶上长链和有效链，除非他们比你网络中所有的节点拥有更大的计算速度， 可能是未来的量子计算机或者是其他什么。

总结

  • 区块中保存上一块的数字签名使区块可以形成链
  • 区块的数字签名由当前数据及上块的数字签名生成，若篡改数据，则签名会变化，无法通过效验
  • 增加计算区块的难度项，使长链中更有时间的优势

依赖

commons-codec与gson

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.10</version>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.7</version>
</dependency>

相关名词的解释

  • 数字签名：这里说数字签名可以理解为一个无法伪造的身份标识，像自己名字的签名，别人无法伪造。
  • hash：又称散列算法、哈希函数，是一种从任何一种数据中创建小的数字“指纹”的方法。

参考

blockchain
#blockchain
简单的代码演示区块链是什么
https://blog.fengcl.com/2018/09/06/simple-blockchain-java-tutorial/
作者
frank
发布于
2018年9月6日
许可协议