区块

你可以看到，我们的基础 Block 类包含一个 String hash，它代表了数字签名。previousHash 变量为前一个区块的 hash 值，它和 String data 组成了这个区块的数据。

有很多加密算法可供我们选择，当然 SHA256 算法正好适合我们这个例子，使用这个算法来生成数字签名

import java.util.Date;
public class Block {
    public String hash;
    public String previousHash;
    private String data; //我们的数据是一条简单的消息
    private long timeStamp; //从 1/1/1970 起至现在的总毫秒数.
    //Block 类的构造方法.
    public Block(String data,String previousHash ) {
        this.data = data;
        this.previousHash = previousHash;
        this.timeStamp = new Date().getTime();
    }
}

计算hash

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

第一个区块被命名为起始区块，由于它前面没有区块，所以我们用 “0” 作为其前一个区块的 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 值

如何阻止某人篡改旧区块中的数据？

区块高度

区块高度(Block height)是指一个区块的高度是指在区块链中它和创世区块之间的块数

挖

public void mineBlock(int difficulty) {
    String target = new String(new char[difficulty]).replace('\0', '0'); //创建一个用 difficulty * "0" 组成的字符串
    while(!hash.substring( 0, difficulty).equals(target)) {
        nonce ++;
        hash = calculateHash();
    }
    System.out.println("Block Mined!!! : " + hash);
}

完整代码

import java.util.Date;
public class Block {
    public String hash;
    public String previousHash; 
    private String data; //我们的数据是一条简单的消息
    private long timeStamp; //从 1/1/1970 起至现在的总毫秒数.
    private int nonce;
    //Block 类构造方法.  
    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 值
    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'); //创建一个用 difficulty * "0" 组成的字符串
        while(!hash.substring( 0, difficulty).equals(target)) {
            nonce ++;
            hash = calculateHash();
        }
        System.out.println("Block Mined!!! : " + hash);
    }
}

运行

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) {    
        //将我们的区块添加至区块链 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');
        //循环区块链来检查 hash 值的合法性：
        for(int i=1; i < blockchain.size(); i++) {
            currentBlock = blockchain.get(i);
            previousBlock = blockchain.get(i-1);
            //比较当前区块存储的 hash 值和计算出来的 hash 值：
            if(!currentBlock.hash.equals(currentBlock.calculateHash()) ){
                System.out.println("Current Hashes not equal");            
                return false;
            }
            //比较前一个区块存储的 hash 值和当前区块存储的 previousHash 值：
            if(!previousBlock.hash.equals(currentBlock.previousHash) ) {
                System.out.println("Previous Hashes not equal");
                return false;
            }
            //检查 hash 值是否已经存在
            if(!currentBlock.hash.substring( 0, difficulty).equals(hashTarget)) {
                System.out.println("This block hasn't been mined");
                return false;
            }
        }
        return true;
    }
}

基本概念

应用层面，区块链是一个分布式的共享账本和数据库

从技术层面来看，区块链是由包含交易信息的区块按照时间顺序从后向前有序链接起来的数据结构。

区块中的交易集合记录的是一些特定的信息，在BTC网络中主要记录的是交易信息，

在其他区块链网络中可以按照业务逻辑来保存相应的业务数据，如审计信息、版权信息、票据信息等，这也是区块链经常用来当做共享账本的原因。

网络

区块链系统由多个区块链节点组成

每个节点都运行着相同一套区块链主干网络的副本

各个节点间通过P2P网络进行交互

当某一个区块链节点产生新的区块时，会通过广播的方式告诉其他节点，其他节点通过网络接收到该区块信息时，会对这个区块信息进行验证，当有一定数量的节点都验证通过后，各个节点会把该区块更新到各自现有的区块链上，最终使得整个区块链网络中的各个节点信息保持一致，这也是区块链去中心化、可信任特性的体现

共识算法

较为主流的共识算法有PoW、PoS、DPoS、PBFT等

智能合约

从技术层面讲，智能合约是一段部署在在区块链上的程序代码，当满足程序设定的条件时，它便会在区块链上运行，并得到相应的结果。这种情况有点类似于微信的小程序，区块链提供虚拟机和脚本语言，用户根据脚本语言的语法开发带有一定业务逻辑的程序，部署在区块链上，当满足执行的条件时，智能合约便会被区块链虚拟机解释并运行。

典型的应用便是以太坊平台的智能合约，在这个平台里可以支持用户通过简单的几行代码就能实现他们想要的合约，实现无需人为监督的、不可篡改、自动化运行的合约，买卖房子不需要再找中介、借钱不需要再找公证人……人们可以随时随地根据自身需求发起合约，它的执行不依赖某个人和组织，所有的信任完全基于以太坊区块链平台本身。

技术架构

数据层
数据层是最底层的技术，主要实现了数据存储、账户信息、交易信息等模块

网络层
主要实现网络节点的连接和通讯，又称点对点技术，各个区块链节点通过网络进行通信。

共识层
是通过共识算法，让网络中的各个节点对全网所有的区块数据真实性正确性达成一致，防止出现拜占庭攻击、51攻击等区块链共识算法攻击

共识机制实现

每个节点通过网络交互，实时同步保存着同样的整条区块链数据，那么我们生成的区块，如何才能被其他节点认可，并同步添加到其他所有节点上呢，这个时候我们就需要一套规则，让所有网络节点的参与者达成能够达成共识，接纳并保存新的区块，也就是所谓的“共识机制”

工作量证明（Proof of Work），顾名思义就是对工作量的证明，在基于POW机制构建的区块链网络中，节点通过计算随机哈希散列的数值争夺记账权，求得正确的数值并生成区块的能力是节点算力的具体表现，计算的过程一般被形象地称为“挖矿”。

简单来说就是，区块链系统设定一套计算规则或者说是一套计算题，在新区块生成前，各个节点都投入到这道题的求解计算中，哪个节点先计算出结果，并得到其它节点的验证和认可，这个节点就会获得新区块的记账权，并获得系统相应的奖励，共识结束。

典型的PoW共识机制应用就是BTC网络，在BTC网络中，共识计算的目标是找到满足某个特定要求的区块Hash（哈希值）。这个区块哈希值就是工作结果的一个证明，计算工作的目的就是为了寻找到这个证明值

[
    {
        "hash": "25931395e736653212f0258824df4222ae739ec2d5897310258b0857d4d3870c",
        "index": 1,
        "nonce": 1,
        "timestamp": 1580970554734,
        "transactions": [
            {
                "businessInfo": "这是创世区块",
                "id": "1"
            }
        ]
    }
]