怎么用java代碼實現(xiàn)區(qū)塊鏈

本篇內(nèi)容介紹了“怎么用java代碼實現(xiàn)區(qū)塊鏈”的有關(guān)知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領(lǐng)大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠?qū)W有所成！

創(chuàng)建區(qū)塊鏈

區(qū)塊鏈就是一串或者是一系列區(qū)塊的集合，類似于鏈表的概念，每個區(qū)塊都指向于后面一個區(qū)塊， 然后順序的連接在一起。那么每個區(qū)塊中的內(nèi)容是什么呢？在區(qū)塊鏈中的每一個區(qū)塊都存放了很多 很有價值的信息，主要包括三個部分：自己的數(shù)字簽名，上一個區(qū)塊的數(shù)字簽名，還有一切需要 加密的數(shù)據(jù)（這些數(shù)據(jù)在比特幣中就相當于是交易的信息，它是加密貨幣的本質(zhì)）。每個數(shù)字簽名 不但證明了自己是特有的一個區(qū)塊，而且指向了前一個區(qū)塊的來源，讓所有的區(qū)塊在鏈條中可以串起來， 而數(shù)據(jù)就是一些特定的信息，你可以按照業(yè)務邏輯來保存業(yè)務數(shù)據(jù)。

這里的hash指的就是數(shù)字簽名

所以每一個區(qū)塊不僅包含前一個區(qū)塊的hash值，同時包含自身的一個hash值，自身的hash值是通過 之前的hash值和數(shù)據(jù)data通過hash計算出來的。如果前一個區(qū)塊的數(shù)據(jù)一旦被篡改了，那么前一個 區(qū)塊的hash值也會同樣發(fā)生變化（因為數(shù)據(jù)也被計算在內(nèi)），這樣也就導致了所有后續(xù)的區(qū)塊中的 hash值。所以計算和比對hash值會讓我們檢查到當前的區(qū)塊鏈是否是有效的，也就避免了數(shù)據(jù)被惡意 篡改的可能性，因為篡改數(shù)據(jù)就會改變hash值并破壞整個區(qū)塊鏈。

定義區(qū)塊鏈的類Block：

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，它將保存我們的數(shù)字簽名。變量 previoushash保存前一個塊的hash和String data來保存我們的塊數(shù)據(jù)

創(chuàng)建數(shù)字簽名

熟悉加密算法的朋友們，Java方式可以實現(xiàn)的加密方式有很多，例如BASE、MD、RSA、SHA等等， 我在這里選用了SHA256這種加密方式，SHA（Secure Hash Algorithm）安全散列算法，這種算法 的特點是數(shù)據(jù)的少量更改會在Hash值中產(chǎn)生不可預知的大量更改，hash值用作表示大量數(shù)據(jù)的 固定大小的唯一值，而SHA256算法的hash值大小為256位。之所以選用SHA256是因為它的大小正合適， 一方面產(chǎn)生重復hash值的可能性很小，另一方面在區(qū)塊鏈實際應用過程中，有可能會產(chǎn)生大量的區(qū)塊， 而使得信息量很大，那么256位的大小就比較恰當了。

下面我創(chuàng)建了一個StringUtil方法來方便調(diào)用SHA256算法

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);
        }
    }   
}

或許你不完全理解上述代碼的含義，但是你只要理解所有的輸入調(diào)用此方法后均會生成一個獨一無二的hash值（數(shù)字簽名）， 而這個hash值在區(qū)塊鏈中是非常重要的。

接下來讓我們在Block類中應用 方法 applySha256 方法，其主要的目的就是計算hash值，我們計算的hash值 應該包括區(qū)塊中所有我們不希望被惡意篡改的數(shù)據(jù)，在我們上面所列的Block類中就一定包括previousHash，data和timeStamp，

public String calculateHash() {
    String calculatedhash = StringUtil.applySha256( 
            previousHash +
            Long.toString(timeStamp) +
            data 
            );
    return calculatedhash;
}

然后把這個方法加入到Block的構(gòu)造函數(shù)中去

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.
    }

測試

在主方法中讓我們創(chuàng)建一些區(qū)塊，并把其hash值打印出來，來看看是否一切都在我們的掌控中。

第一個塊稱為創(chuàng)世塊，因為它是頭區(qū)塊，所以我們只需輸入“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);

    }
}

打印輸出結(jié)果：

Hash for block 1: f6d1bc5f7b0016eab53ec022db9a5d9e1873ee78513b1c666696e66777fe55fb
Hash for block 2: 6936612b3380660840f22ee6cb8b72ffc01dbca5369f305b92018321d883f4a3
Hash for block 3: f3e58f74b5adbd59a7a1fc68c97055d42e94d33f6c322d87b29ab20d3c959b8f

每一個區(qū)塊都必須要有自己的數(shù)據(jù)簽名即hash值，這個hash值依賴于自身的信息（data）和上 一個區(qū)塊的數(shù)字簽名（previousHash），但這個還不是區(qū)塊鏈，下面讓我們存儲區(qū)塊到數(shù)組中， 這里我會引入gson包，目的是可以用json方式查看整個一條區(qū)塊鏈結(jié)構(gòu)。

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);
    }

}

這樣的輸出結(jié)構(gòu)就更類似于我們所期待的區(qū)塊鏈的樣子。

檢查區(qū)塊鏈的完整性

在主方法中增加一個isChainValid()方法，目的是循環(huán)區(qū)塊鏈中的所有區(qū)塊并且比較hash值， 這個方法用來檢查hash值是否是于計算出來的hash值相等，同時previousHash值是否和前一個 區(qū)塊的hash值相等?；蛟S你會產(chǎn)生如下的疑問，我們就在一個主函數(shù)中創(chuàng)建區(qū)塊鏈中的區(qū)塊， 所以不存在被修改的可能性，但是你要注意的是，區(qū)塊鏈中的一個核心概念就是去中心化， 每一個區(qū)塊可能是在網(wǎng)絡中的某一個節(jié)點中產(chǎn)生的，所以很有可能某個節(jié)點把自己節(jié)點中的 數(shù)據(jù)修改了，那么根據(jù)上述的理論數(shù)據(jù)改變會導致整個區(qū)塊鏈的破裂，也就是區(qū)塊鏈就無效了。

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;
}

任何區(qū)塊鏈中區(qū)塊的一絲一毫改變都會導致這個函數(shù)返回false，也就證明了區(qū)塊鏈無效了。

在比特幣網(wǎng)絡中所有的網(wǎng)絡節(jié)點都分享了它們各自的區(qū)塊鏈，然而最長的有效區(qū)塊鏈是被 全網(wǎng)所統(tǒng)一承認的，如果有人惡意來篡改之前的數(shù)據(jù)，然后創(chuàng)建一條更長的區(qū)塊鏈并全網(wǎng) 發(fā)布呈現(xiàn)在網(wǎng)絡中，我們該怎么辦呢？這就涉及到了區(qū)塊鏈中另外一個重要的概念工作量證明， 這里就不得不提及一下hashcash，這個概念最早來自于Adam Back的一篇論文，主要應用于郵件 過濾和比特幣中防止雙重支付。

挖礦

這里我們要求挖礦者做工作量證明，具體的方式是在區(qū)塊中嘗試不同的參數(shù)值直到它的hash 值是從一系列的0開始的。讓我們添加一個名為nonce的int類型以包含在我們的calculatehash（） 方法中，以及需要的mineblock（）方法

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.
    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.
    }

    //Calculate new hash based on blocks contents
    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'); //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分鐘左右，當然根據(jù)所有網(wǎng)絡中的計算能力，難度也會不斷的進行修改。

我們在NoobChain類 中增加difficulty這個靜態(tài)變量。

public static int difficulty = 5;

這樣我們必須修改主方法中讓創(chuàng)建每個新區(qū)塊時必須觸發(fā)mineBlock()方法，而isChainValid()方法用來檢查每 個區(qū)塊的hash值是否正確，整個區(qū)塊鏈是否是有效的。

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;
    }
}

打?。?/p>

Connected to the target VM, address: '127.0.0.1:61863', transport: 'socket'
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
  }
]

經(jīng)過測試增加一個新的區(qū)塊即挖礦必須花費一定時間，大概是3秒左右，你可以提高difficulty難度來看， 它是如何影響數(shù)據(jù)難題所花費的時間的

如果有人在你的區(qū)塊鏈系統(tǒng)中惡意篡改數(shù)據(jù)：

• 他們的區(qū)塊鏈是無效的。

• 他們無法創(chuàng)建更長的區(qū)塊鏈

• 網(wǎng)絡中誠實的區(qū)塊鏈會在長鏈中更有時間的優(yōu)勢

因為篡改的區(qū)塊鏈將無法趕上長鏈和有效鏈，除非他們比你網(wǎng)絡中所有的節(jié)點擁有更大的計算速度， 可能是未來的量子計算機或者是其他什么。

“怎么用java代碼實現(xiàn)區(qū)塊鏈”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識可以關(guān)注億速云網(wǎng)站，小編將為大家輸出更多高質(zhì)量的實用文章！