java区块链代码

咔咔今天 1 抢沙发

默认

摘要： 核心概念回顾在开始编码前,我们先快速回顾一下我们将要实现的核心概念：区块: 区块是区块链的基本构建单元,它包含以下信息：index: 区块在链中的位置，timestamp: 区块创...

核心概念回顾

在开始编码前,我们先快速回顾一下我们将要实现的核心概念：

区块: 区块是区块链的基本构建单元,它包含以下信息：
- index: 区块在链中的位置。
- timestamp: 区块创建的时间戳。
- data: 区块存储的数据（在我们的例子中，是交易信息）。
- previousHash: 前一个区块的哈希值,这是链接各个区块的关键。
- hash: 当前区块通过特定算法计算出的哈希值,用于验证区块的完整性。
- nonce: 一个随机数,用于工作量证明算法。
链: 由区块按顺序链接而成的列表，区块链的安全性依赖于链的完整性，任何对历史区块数据的篡改都会导致该区块及其之后所有区块的哈希值发生变化,从而被网络识别为无效链。
哈希: 一个将任意长度的输入数据转换为固定长度输出的加密算法，我们使用 SHA-256,它有两个关键特性：
- 单向性: 无法从哈希值反推原始数据。
- 抗碰撞性: 极难找到两个不同的输入能产生相同的哈希值。
工作量证明: 一种共识机制，为了“挖出”一个新的区块，矿工必须解决一个复杂的数学难题，这个难题的设计是：找到一个 nonce 值，使得区块的哈希值满足特定的条件（哈希值以一定数量的零开头），这需要大量的计算能力（“工作”）,但验证结果却非常容易。
交易: 区块中实际记录的数据，在我们的简单实现中，一个交易包含发送方、接收方和金额。

Java 实现

我们将创建以下几个 Java 类：

Transaction.java: 定义交易数据结构。
Block.java: 定义区块数据结构,并包含计算哈希和挖矿的方法。
Blockchain.java: 管理整个区块链，包括添加新区块、验证链的有效性等。
BlockChainDemo.java: 主程序，演示如何创建、挖矿和验证一条简单的区块链。

Transaction.java (交易类)

这个类非常简单，只是一个 POJO (Plain Old Java Object),用于封装交易信息。

// Transaction.java
public class Transaction {
    private String sender;
    private String receiver;
    private double amount;
    public Transaction(String sender, String receiver, double amount) {
        this.sender = sender;
        this.receiver = receiver;
        this.amount = amount;
    }
    @Override
    public String toString() {
        return "Transaction{" +
                "sender='" + sender + '\'' +
                ", receiver='" + receiver + '\'' +
                ", amount=" + amount +
                '}';
    }
}

Block.java (区块类)

这是区块链的核心，它包含了区块的所有属性，以及计算哈希和执行“挖矿”的逻辑。

// Block.java
import java.util.Date;
import java.security.MessageDigest;
public class Block {
    private int index;
    private long timestamp;
    private Transaction data;
    private String previousHash;
    private String hash;
    private int nonce; // Nonce for Proof of Work
    // Constructor for the genesis block
    public Block(int index, Transaction data, String previousHash) {
        this.index = index;
        this.timestamp = new Date().getTime();
        this.data = data;
        this.previousHash = previousHash;
        this.hash = calculateHash();
        this.nonce = 0;
    }
    // Calculates the hash of the block
    public String calculateHash() {
        String dataToHash = index + previousHash + Long.toString(timestamp) + data.toString() + nonce;
        return applySha256(dataToHash);
    }
    // Applies SHA256 to a string and returns the hash
    public static String applySha256(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes("UTF-8"));
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    // Proof of Work mechanism
    public void mineBlock(int difficulty) {
        String target = new String(new char[difficulty]).replace('\0', '0');
        while (!hash.substring(0, difficulty).equals(target)) {
            nonce++;
            hash = calculateHash();
        }
        System.out.println("Block Mined!!! : " + hash);
    }
    // Getters
    public String getHash() {
        return hash;
    }
    public String getPreviousHash() {
        return previousHash;
    }
    @Override
    public String toString() {
        return "Block #" + index +
                "\nTimestamp: " + new Date(timestamp) +
                "\nData: " + data +
                "\nPrevious Hash: " + previousHash +
                "\nHash: " + hash +
                "\nNonce: " + nonce;
    }
}

Blockchain.java (区块链类)

这个类负责管理所有区块,并提供添加新区块和验证链完整性的方法。

// Blockchain.java
import java.util.ArrayList;
import java.util.List;
public class Blockchain {
    private List<Block> chain;
    private int difficulty; // Mining difficulty
    public Blockchain(int difficulty) {
        this.chain = new ArrayList<>();
        this.difficulty = difficulty;
        // Add the genesis block
        addBlock(new Block(0, new Transaction("Genesis", "Satoshi", 0), "0"));
    }
    public void addBlock(Block newBlock) {
        newBlock.mineBlock(this.difficulty); // Mine the block before adding
        this.chain.add(newBlock);
    }
    // Check if the blockchain is valid
    public boolean isChainValid() {
        Block currentBlock;
        Block previousBlock;
        for (int i = 1; i < chain.size(); i++) {
            currentBlock = chain.get(i);
            previousBlock = chain.get(i - 1);
            // Check if hash is correct
            if (!currentBlock.getHash().equals(currentBlock.calculateHash())) {
                System.out.println("Current Hashes not equal");
                return false;
            }
            // Check if previous hash is correct
            if (!currentBlock.getPreviousHash().equals(previousBlock.getHash())) {
                System.out.println("Previous Hashes not equal");
                return false;
            }
        }
        return true;
    }
    // Getters
    public List<Block> getChain() {
        return chain;
    }
}

BlockChainDemo.java (主程序/演示类)

这个类是我们的入口点，它将展示如何创建一条区块链，添加一些交易,并验证其有效性。

// BlockChainDemo.java
public class BlockChainDemo {
    public static void main(String[] args) {
        // Set the difficulty level. Higher number = harder to mine.
        int difficulty = 2;
        System.out.println("Creating the blockchain with difficulty " + difficulty);
        Blockchain myCoin = new Blockchain(difficulty);
        System.out.println("\nMining block 1...");
        myCoin.addBlock(new Block(1, new Transaction("Alice", "Bob", 10.0), myCoin.getChain().get(myCoin.getChain().size() - 1).getHash()));
        System.out.println("\nMining block 2...");
        myCoin.addBlock(new Block(2, new Transaction("Bob", "Charlie", 5.0), myCoin.getChain().get(myCoin.getChain().size() - 1).getHash()));
        System.out.println("\nMining block 3...");
        myCoin.addBlock(new Block(3, new Transaction("Charlie", "Alice", 2.0), myCoin.getChain().get(myCoin.getChain().size() - 1).getHash()));
        System.out.println("\nIs blockchain valid? " + myCoin.isChainValid());
        // Let's tamper with the data in block 2
        System.out.println("\nTampering with block 2...");
        myCoin.getChain().get(2).getData().setAmount(1000.0); // Change transaction amount
        System.out.println("\nIs blockchain valid after tampering? " + myCoin.isChainValid());
    }
}

如何运行

将以上四个类（Transaction.java, Block.java, Blockchain.java, BlockChainDemo.java）保存在同一个目录下。
编译所有 Java 文件：
```
javac *.java
```
运行主程序：
```
java BlockChainDemo
```

预期输出

您会看到类似以下的输出，由于挖矿需要时间，您会看到 "Block Mined!!!" 的消息，并且挖矿难度越高,等待时间越长。

Creating the blockchain with difficulty 2
Block Mined!!! : 00b2a7e0f9b1c4d3a5e6f7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1
Mining block 1...
Block Mined!!! : 002f8c1e3a2b5d7f9e0c4a6b8d1f3e5a7c9b0d2e4f6a8b1c3d5e7f9a0b2c4d6e8f1a3
Mining block 2...
Block Mined!!! : 003e1a2d4f6b8c0a1e3d5f7b9c2e4a6d8f0b1c3e5f7a9b2c4d6e8f0a1b3c5d7e9f2a4
Mining block 3...
Block Mined!!! : 004d2b5e7f9a1c3e6d8f0b2c4a7d9f1e3b5c8a0d2e4f6b1c7d9e2f4a6b8c0d3e5f7a9
Is blockchain valid? true
Tampering with block 2...
Is blockchain valid after tampering? false

代码解释与扩展

Genesis Block (创世区块): 区块链的第一个区块，没有前一个区块，在我们的 Blockchain 构造函数中，我们手动创建了它，并将其 previousHash 设置为 "0"。
mineBlock 方法: 这个方法是工作量证明的核心，它通过不断改变 nonce 的值，重新计算区块的哈希，直到找到一个哈希值满足前 difficulty 个字符都为 "0" 的条件，这个过程是计算密集型的,模拟了真实世界中的挖矿。
isChainValid 方法: 这是区块链安全性的基石，它遍历整个链，检查每个区块的 hash 是否正确，以及当前区块的 previousHash 是否等于前一个区块的 hash，一旦任何区块被篡改,这个检查就会失败。
篡改演示: 在 BlockChainDemo 的最后，我们修改了第二个区块中的交易金额，这导致第二个区块的 hash 发生变化，当 isChainValid 方法检查到第三个区块的 previousHash 与篡改后的第二个区块的 hash 不匹配时，它会立即返回 false,证明了区块链的防篡改特性。