使用 Kotlin 实现一个简单的区块链

1. 概述

本文将带你用 Kotlin 实现一个简易的区块链系统。

我们将构建一个类似比特币的基础链结构，帮助理解区块链的核心机制。虽然示例代码使用 Kotlin 编写，但其中的设计思想是通用的，不依赖特定语言，你完全可以迁移到 Java 或其他语言中复用思路。

2. 区块链技术原理简析

我们先快速回顾一下区块链的基本概念。不会深入所有理论细节，只聚焦于实现所需的核心逻辑。

区块链是一种去中心化（或分布式）的数据存储系统，由多个区块串联而成。每个区块都包含前一个区块的哈希值，从而形成链式结构。这种设计保证了数据不可篡改：一旦某个区块被修改，其哈希变化会导致后续所有区块校验失败。

⚠️ 注意：你不能随意添加区块。必须通过“挖矿”来生成新区块。

所谓挖矿，本质上就是不断尝试求解一个计算密集型难题。谁先解出来，谁就有权把新区块加入链中。比特币网络正是通过这种方式实现共识。

此外，挖矿难度会动态调整，以控制出块速度。例如比特币平均每 10 分钟产出一个区块，系统会根据全网算力自动调节难度。

下图展示了一个包含四个区块的区块链结构：

可以看到：

✅ 每个区块保存了前一个区块的哈希，构成链式连接
✅ 区块内包含实际数据（payload），比如比特币中的交易记录（发送方、接收方、金额）
✅ Nonce 字段用于调节挖矿难度 —— 算力越多，nonce 调整越频繁，维持稳定的出块节奏

接下来我们就动手实现它。

3. 使用 Kotlin 实现区块链核心组件

3.1. 定义区块结构

首先定义 Block 数据类，作为区块链的基本单元。每个区块应包含：

前一个区块的哈希
时间戳
业务数据
Nonce（随机数）
当前区块的哈希

data class Block(
    val previousHash: String,
    val data: String,
    val timestamp: Long = System.currentTimeMillis(),
    val nonce: Int = 0
) {
    val hash: String by lazy { calculateHash() }

    fun calculateHash(): String {
        val input = "$previousHash$data$timestamp$nonce"
        return input.sha256()
    }
}

✅ 关键点说明：

使用 Kotlin 的 data class 自动提供 equals()、hashCode() 和 toString()
所有字段均为 val，确保区块一旦创建就不能修改，这是区块链防篡改的基础
hash 使用 by lazy 延迟初始化，在首次访问时计算，避免构造时重复运算

💡 踩坑提醒：如果你在构造函数里直接传入 hash 参数，就失去了“基于内容生成唯一标识”的意义，容易被人伪造数据！

3.2. 实现哈希函数

我们需要一个密码学安全的哈希算法。这里采用和比特币一致的 SHA-256。

fun String.sha256(): String {
    val bytes = this.toByteArray()
    val md = MessageDigest.getInstance("SHA-256")
    val digest = md.digest(bytes)
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}

📌 说明：

将字符串转为字节数组进行摘要
使用 MessageDigest 提供标准 SHA-256 实现
结果格式化为十六进制小写字符串（如 a1b2c3...）

⚠️ 注意：这个扩展函数作用于 String 类型，方便链式调用，但要注意输入长度限制和性能影响。

3.3. 实现挖矿逻辑

挖矿的目标是找到一个满足条件的哈希值，比如以若干个 0 开头。

我们通过不断递增 nonce 来尝试不同的哈希输出，直到命中目标。

fun mineBlock(previousHash: String, data: String, acceptingRegexp: Regex): Block {
    var finalBlock = Block(previousHash, data)
    while (!finalBlock.hash.matches(acceptingRegexp)) {
        finalBlock = finalBlock.copy(nonce = finalBlock.nonce + 1)
    }
    return finalBlock
}

📌 关键逻辑：

使用 copy() 创建新实例（因 data class 不可变）
循环增加 nonce 直到 hash 匹配正则表达式
接收 acceptingRegexp 作为参数，便于外部控制难度

💡 示例：若要求哈希以三个 0 开头，则正则为 ^0{3}.*

4. 构建完整的区块链

现在我们将多个区块组织成链，并加入验证机制。

class Blockchain(difficulty: Int = 5) {
    val chain = mutableListOf<Block>()
    val acceptanceRegex = "^[0]{$difficulty}.+".toRegex()

    init {
        val genesisBlock = mineBlock("0", "Genesis Block", acceptanceRegex)
        chain.add(genesisBlock)
    }
}

📌 初始化流程：

设置默认难度为 5（即哈希需以五个 0 开头），可根据设备性能调整
自动生成创世区块（Genesis Block），其 previousHash 固定为 "0"
创世区块也需参与挖矿，确保符合规则

4.1. 添加新区块

提供 addBlock() 方法用于追加区块，但必须先校验合法性：

fun addBlock(block: Block) {
    if (isValidBlock(block)) {
        chain.add(block)
    } else {
        throw IllegalArgumentException("Invalid block")
    }
}

校验逻辑如下：

private fun isValidBlock(block: Block): Boolean {
    val lastBlock = chain.last()
    return block.previousHash == lastBlock.hash &&
            block.hash.matches(acceptanceRegex)
}

✅ 校验项包括：

新区块的 previousHash 必须等于当前链尾区块的 hash
新区块自身的 hash 必须满足难度要求（即匹配 acceptanceRegex）

❌ 如果跳过这些检查，攻击者可以插入伪造区块，破坏链完整性。

4.2. 链整体校验

除了单个区块验证，还需支持对整条链做一致性检查：

fun isValid(): Boolean {
    if (chain.size < 2) return true
    
    chain.zipWithNext().forEach { (prev, current) ->
        if (current.previousHash != prev.hash) {
            return false
        }
    }
    return true
}

📌 实现方式：

使用 zipWithNext() 遍历相邻区块对
检查每一个 current.previousHash == prev.hash
只要有一处断裂，即判定链已被篡改

✅ 这个方法可用于节点同步时的链可信度评估

5. 模拟运行区块链

编写主函数测试整个流程：

fun main() {
    val blockchain = Blockchain(3)

    val block1 = mineBlock(blockchain.chain.last().hash, "Block 1 Data", blockchain.acceptanceRegex)
    blockchain.addBlock(block1)

    val block2 = mineBlock(blockchain.chain.last().hash, "Block 2 Data", blockchain.acceptanceRegex)
    blockchain.addBlock(block2)

    val block3 = mineBlock(blockchain.chain.last().hash, "Block 3 Data", blockchain.acceptanceRegex)
    blockchain.addBlock(block3)

    println("Blockchain valid? ${blockchain.isValid()}")

    blockchain.chain.forEach {
        println("Block Data: ${it.data}, Hash: ${it.hash}")
    }
}

运行结果示例：

Blockchain valid? true
Block Data: Genesis Block, Hash: 00000085499efc933ea985f32aeb11b5ee10fc1d161e8a5dea01b0ef49f79546
Block Data: Block 1 Data, Hash: 00000ac71dfc0d648d78ce283d526039eb3023c8d59a95ef58d1c7fa623f6067
Block Data: Block 2 Data, Hash: 000000b095a3492f6f64cf7a8de7854b009ad4385e9a469d08c7e8934b93845e
Block Data: Block 3 Data, Hash: 00000d0fd52e7cc6ada4e198c8682db7bce515a0aad03bdcec62e9f3d3e1c536

✅ 输出表明：

所有区块哈希均以至少三个 0 开头（符合难度 3）
链完整性校验通过
每个区块正确引用前一个区块的哈希

⚠️ 性能提示：随着难度提升，挖矿耗时呈指数增长。建议开发调试时使用 difficulty=2~3，上线再提高。

6. 总结

本文通过 Kotlin 实现了一个极简但功能完整的区块链原型，涵盖了：

区块结构设计
SHA-256 哈希计算
挖矿机制与难度控制
链式结构维护
完整性校验逻辑

虽然离生产级系统还有很大距离（缺少 P2P 网络、共识算法优化、UTXO 模型等），但已足够帮助你理解区块链“不可篡改”、“去中心化”特性的底层原理。

所有源码已托管至 GitHub：

https://github.com/baeldung/kotlin-tutorials/tree/master/kotlin-blockchain

Persistence

REST

Security