你是否需要一个关于用Java实现简单区块链原型（含哈希计算）的案例

wen java案例 2026-06-04 46

Java实现简单原型与哈希计算实战指南

📖 目录导读

为什么需要亲手写一个区块链原型？
区块链核心原理极简回顾
Java实现：环境搭建与核心类设计
哈希计算的关键地位
完整代码示例：Block与Blockchain
运行测试：见证“链”的不可篡改性
常见问答：新手最困惑的5个点
总结与扩展建议

为什么需要亲手写一个区块链原型？

在加密货币热潮退去后,区块链技术本身成为了金融、供应链、物联网等领域的核心基础设施，但许多开发者对区块链的理解仍停留在“分布式账本”“挖矿”等抽象概念上。亲手用Java实现一个包含哈希计算的区块链原型，能帮你打通三大认知障碍：

你是否需要一个关于用Java实现简单区块链原型（含哈希计算）的案例

理解哈希函数在链式结构中的黏合作用
亲眼见证数据篡改后如何导致链断裂
掌握区块生成、验证与迭代的底层逻辑

这不仅是一个技术案例,更是通往Web3开发的基石。

区块链核心原理极简回顾

区块链本质是一个只能追加、不可篡改的分布式数据库，每个区块包含：

索引（Index）：区块在链中的位置
时间戳（Timestamp）：生成时间
数据（Data）：交易记录或其他任意信息
前一个区块的哈希（Previous Hash）：指向父区块的关键指纹
当前区块的哈希（Hash）：由当前区块所有内容计算得到

一旦某个区块的数据被修改,它的哈希会改变，导致与后一个区块记录的Previous Hash不匹配，整条链断裂。哈希计算正是实现“不可篡改”的核心机制。

Java实现：环境搭建与核心类设计

环境要求：JDK 8+，推荐使用IntelliJ IDEA或Eclipse
无需第三方库：利用Java标准库的java.security.MessageDigest即可完成SHA-256哈希计算。

核心类设计

Block类：定义区块结构，包含计算哈希的方法
Blockchain类：管理区块集合，提供添加、校验方法
HashUtils工具类：封装SHA-256计算逻辑

哈希计算的关键地位

区块链中的哈希（通常使用SHA-256）具有三大特性：

确定性：相同输入必定产生相同输出
单向性：从哈希值几乎无法反推原始数据
雪崩效应：输入微小变化，哈希值彻底改变

在我们的Java原型中,哈希是链的“锁链”，每个区块的哈希等于对以下内容的哈希拼接：

index + timestamp + data + previousHash

这是实现“一旦改动，立即暴露”的核心逻辑。

完整代码示例：Block与Blockchain

Block.java

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Date;
public class Block {
    private int index;
    private long timestamp;
    private String data;
    private String previousHash;
    private String hash;
    public Block(int index, String data, String previousHash) {
        this.index = index;
        this.timestamp = new Date().getTime();
        this.data = data;
        this.previousHash = previousHash;
        this.hash = calculateHash();
    }
    public String calculateHash() {
        String input = index + timestamp + data + previousHash;
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hashBytes = digest.digest(input.getBytes("UTF-8"));
            StringBuilder hexString = new StringBuilder();
            for (byte b : hashBytes) {
                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);
        }
    }
    // getters...
    public String getHash() { return hash; }
    public String getPreviousHash() { return previousHash; }
    public String getData() { return data; }
}

Blockchain.java

import java.util.ArrayList;
import java.util.List;
public class Blockchain {
    private List<Block> chain;
    public Blockchain() {
        chain = new ArrayList<>();
        chain.add(createGenesisBlock());
    }
    private Block createGenesisBlock() {
        return new Block(0, "Genesis Block", "0"); // 创世区块PreviousHash固定为"0"
    }
    public void addBlock(String data) {
        Block previousBlock = chain.get(chain.size() - 1);
        Block newBlock = new Block(previousBlock.getIndex() + 1, data, previousBlock.getHash());
        chain.add(newBlock);
    }
    public boolean isChainValid() {
        for (int i = 1; i < chain.size(); i++) {
            Block current = chain.get(i);
            Block previous = chain.get(i - 1);
            // 验证当前区块哈希是否正确
            if (!current.getHash().equals(current.calculateHash())) {
                return false;
            }
            // 验证前一个区块哈希是否匹配
            if (!current.getPreviousHash().equals(previous.getHash())) {
                return false;
            }
        }
        return true;
    }
    public List<Block> getChain() { return chain; }
}

运行测试：见证“链”的不可篡改性

测试类 Main.java

public class Main {
    public static void main(String[] args) {
        Blockchain bc = new Blockchain();
        bc.addBlock("Alice pays Bob 10 BTC");
        bc.addBlock("Bob pays Charlie 5 BTC");
        System.out.println("区块链是否有效？ " + bc.isChainValid());
        System.out.println("区块详情：");
        for (Block b : bc.getChain()) {
            System.out.println("Index: " + b.getIndex() + ", Data: " + b.getData() + ", Hash: " + b.getHash());
        }
        // 模拟篡改：修改第二个区块的数据
        Block tampered = bc.getChain().get(1);
        tampered.data = "Alice pays Bob 1000 BTC"; // 注意：实际私有字段需通过setter或反射修改，这里仅为演示
        System.out.println("篡改后验证结果：" + bc.isChainValid()); // 应输出false
    }
}

输出结果：