前面两章说了许多关于区块链的理论知识，这一章我们将会将前面的所有的理论知识结合起来，用java简答实现一套区块链。
以下内容转自：https://github.com/longfeizheng/blockchain-java
基于面向对象的思想，首先
1、定义区块链的类块
import java.util.Date;
public class Block {
public String hash;//区块Hash
public String previousHash;//前导Hash
private String data; //可以理解为前面讲到的区块结构里的区块体里打包的交易数据
private long timeStamp; //时间戳
//Block Constructor.
public Block(String data,String previousHash ) {
this.data = data;
this.previousHash = previousHash;
this.timeStamp = new Date().getTime();
}
}
2、创建数字签名
创建一个StringUtil，封装了sha256方法，方便后面调用，因为这是一个工具类，所以我们可以不关心它的具体实现方式，只要知道它是sha256的java实现即可。
import java.security.MessageDigest;
public class StringUtil {
//Applies Sha256 to a string and returns the result.
public static String applySha256(String input){
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
//Applies sha256 to our input,
byte[] hash = digest.digest(input.getBytes("UTF-8"));
StringBuffer hexString = new StringBuffer(); // This will contain hash as hexidecimal
for (int i = 0; i < hash.length; i++) {
String hex = Integer.toHexString(0xff & hash[i]);
if(hex.length() == 1) hexString.append('0');
hexString.append(hex);
}
return hexString.toString();
}
catch(Exception e) {
throw new RuntimeException(e);
}
}
}
接下来让我们在Block类中应用
方法 applySha256
方法，其主要的目的就是计算hash值，我们计算的hash值应该包括区块中所有我们不希望被恶意篡改的数据，再加上preHash，data和timeStamp，这在上面已经演示过了，是一套固定公式，所以这里没有什么争议。
//简化了计算方式
public String calculateHash() {
String calculatedhash = StringUtil.applySha256(
previousHash +
Long.toString(timeStamp) +
data
);
return calculatedhash;
}
然后把这个方法加入到Block的构造函数中去
public Block(String data,String previousHash ) {
this.data = data;
this.previousHash = previousHash;
this.timeStamp = new Date().getTime();
this.hash = calculateHash();
}
3、测试
在主方法中让我们创建一些区块，并把其hash值打印出来，来看看是否一切都在我们的掌控中。
第一个块称为创世纪区块，因为它是头区块，所以我们只需输入“0”作为前一个块的previous hash。
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);
}
}
打印：
Hash for block 1: f6d1bc5f7b0016eab53ec022db9a5d9e1873ee78513b1c666696e66777fe55fb
Hash for block 2: 6936612b3380660840f22ee6cb8b72ffc01dbca5369f305b92018321d883f4a3
Hash for block 3: f3e58f74b5adbd59a7a1fc68c97055d42e94d33f6c322d87b29ab20d3c959b8f
每一个区块都必须要有自己的数据签名即hash值，这个hash值依赖于自身的信息（data）和上一个区块的数字签名（previousHash），但这个还不是区块链，下面让我们存储区块到数组中，这里我会引入gson包，目的是可以用json方式查看整个一条区块链结构。
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);
}
}这样的输出结构就更类似于我们所期待的区块链的样子。
4、检查区块链的完整性
在主方法中增加一个isChainValid()方法，目的是循环区块链中的所有区块并且比较hash值，这个方法用来检查hash值是否是于计算出来的hash值相等，同时previousHash值是否和前一个区块的hash值相等。（第二章讲到过，验证区块的有效性即重新计算区块的Hash值并与链上记录的区块Hash值是否一致，而上一个区块的Hash值—preHash，又影响了当前Hash的计算）
所以我会的验证方法就会这么写：
public static Boolean isChainValid() {
Block currentBlock;
Block previousBlock;
//遍历整个区块链
for(int i=1; i < blockchain.size(); i++) {
currentBlock = blockchain.get(i);
previousBlock = blockchain.get(i-1);
//当重新计算区块Hash发现和链上记录的不相等时
if(!currentBlock.hash.equals(currentBlock.calculateHash()) ){
System.out.println("Current Hashes not equal");
return false;
}
//当上一个区块上的Hash和当前区块记录的preHash不相等时
if(!previousBlock.hash.equals(currentBlock.previousHash) ) {
System.out.println("Previous Hashes not equal");
return false;
}
}
return true;
}
任何区块链中区块的一丝一毫改变都会导致这个函数返回false，也就证明了区块链无效了。
5、挖矿
这里我们要求挖矿者做工作量证明，具体的方式是在区块中尝试不同的参数值直到它的hash值是从一系列的0开始的。让我们添加一个名为nonce的int类型以包含在我们的calculatehash（）方法中，以及需要的mineblock（）方法
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;
//区块的构造
public Block(String data,String previousHash ) {
this.data = data;
this.previousHash = previousHash;
this.timeStamp = new Date().getTime();
this.hash = calculateHash();
}
//基于交易数据信息和其他数据生成当前区块的hash
public String calculateHash() {
String calculatedhash = StringUtil.applySha256(
previousHash +
Long.toString(timeStamp) +
Integer.toString(nonce) +
data
);
return calculatedhash;
}
public void mineBlock(int difficulty) {
String target = new String(new char[difficulty]).replace('\0', '0'); //计算出的Hash要求前面多少个0（理论上前面的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这个静态变量。
public static int difficulty = 5;
这样我们必须修改主方法中让创建每个新区块时必须触发mineBlock()方法，而isChainValid()方法用来检查每个区块的hash值是否正确，整个区块链是否是有效的。
public class NoobChain {
public static ArrayList<Block> blockchain = new ArrayList<Block>();
public static int difficulty = 5;
public static void main(String[] args) {
//手动创建几个区块
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');
//遍历区块，验证有效性
for(int i=1; i < blockchain.size(); i++) {
currentBlock = blockchain.get(i);
previousBlock = blockchain.get(i-1);
//当重新计算区块Hash发现和链上记录的不相等时
if(!currentBlock.hash.equals(currentBlock.calculateHash()) ){
System.out.println("Current Hashes not equal");
return false;
}
//当上一个区块上的Hash和当前区块记录的preHash不相等时
if(!previousBlock.hash.equals(currentBlock.previousHash) ) {
System.out.println("Previous Hashes not equal");
return false;
}
//这里涉及到的其实就挖矿算法，通过不断变化的nonce值来生成Hash值，如果生成的Hash值的前几位的都是0且和target要求的位数一致，代表这个随机数生成的区块是有效的。
if(!currentBlock.hash.substring( 0, difficulty).equals(hashTarget)) {
System.out.println("This block hasn't been mined");
return false;
}
}
return true;
}
}
打印：
Trying to Mine block 1...
Block Mined!!! : 0000016667d4240e9c30f53015310b0ec6ce99032d7e1d66d670afc509cab082
Trying to Mine block 2...
Block Mined!!! : 000002ea55735bea4cac7e358c7b0d8d81e8ca24021f5f85211bf54fd4ac795a
Trying to Mine block 3...
Block Mined!!! : 000000576987e5e9afbdf19b512b2b7d0c56db0e6ca49b3a7e638177f617994b
Blockchain is Valid: true
[
{
"hash": "0000016667d4240e9c30f53015310b0ec6ce99032d7e1d66d670afc509cab082",
"previousHash": "0",
"data": "first",
"timeStamp": 1520659506042,
"nonce": 618139
},
{
"hash": "000002ea55735bea4cac7e358c7b0d8d81e8ca24021f5f85211bf54fd4ac795a",
"previousHash": "0000016667d4240e9c30f53015310b0ec6ce99032d7e1d66d670afc509cab082",
"data": "second",
"timeStamp": 1520659508825,
"nonce": 1819877
},
{
"hash": "000000576987e5e9afbdf19b512b2b7d0c56db0e6ca49b3a7e638177f617994b",
"previousHash": "000002ea55735bea4cac7e358c7b0d8d81e8ca24021f5f85211bf54fd4ac795a",
"data": "third",
"timeStamp": 1520659515910,
"nonce": 1404341
}
]
经过测试增加一个新的区块即挖矿必须花费一定时间，大概是3秒左右，你可以提高difficulty难度来看，它是如何影响数据难题所花费的时间的
如果有人在你的区块链系统中恶意篡改数据：
他们的区块链是无效的。
他们无法创建更长的区块链
网络中诚实的区块链会在长链中更有时间的优势
因为篡改的区块链将无法赶上长链和有效链，除非他们比你网络中所有的节点拥有更大的计算速度，可能是未来的量子计算机或者是其他什么。
如果你耐心的看到这里了，恭喜，我们已经基本创建了属于自己的区块链
它有：
有很多区块组成用来存储数据
有数字签名让你的区块链链接在一起
需要挖矿的工作量证明新的区块
可以用来检查数据是否是有效的同时是未经篡改的
结语：
坦白说，这篇文章更多的是从代码讲解的角度来剖析区块链的工作原理，为的是让大家更好的吸收前面所讲解的知识点，虽然有一些伪代码的成分，但是我们确实完成了区块链所有应该有的功能。当然，真正的区块链实现远不止这么一点，大量的实现细节值得我们去研究、探讨和实现，更多的我们后续会再讲到。
