安卓编写区块链的尝试（失败）

private long height;

/**

• 工作量证明计数器

*/

private long nonce;

/**

• 创建新的区块

• @param previousHash

• @param transactions

• @return

*/

public static Block newBlock(String previousHash, List transactions, long height) {

Block block = new Block(“”, previousHash, transactions, Instant.now().getEpochSecond(),height,0);

ProofOfWork pow = ProofOfWork.newProofOfWork(block);

PowResult powResult = pow.run();

block.setHash(powResult.getHash());

block.setNonce(powResult.getNonce());

// block.setHash();

return block;

}

private static final String ZERO_HASH = Hex.encodeHexString(new byte[32]);

/**

• 创建创世区块

• @param coinbase

• @return

*/

public static Block newGenesisBlock(Transaction coinbase) {

List transactions = new ArrayList<>();

transactions.add(coinbase);

return Block.newBlock(ByteUtils.ZERO_HASH, transactions,0);

}

/**

• 对区块中的交易信息进行Hash计算

• @return

*/

public byte[] hashTransaction() {

byte[][] txIdArrays = new byte[this.getTransactions().size()][];

for (int i = 0; i < this.getTransactions().size(); i++) {

txIdArrays[i] = this.getTransactions().get(i).getTxId();

}

return DigestUtils.sha256(ByteUtils.merge(txIdArrays));

}

}

创建ByteUtils.java

该类的作用是将数据转换承byte[]字节数据

package com.example.blockchain;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.lang3.ArrayUtils;

import java.nio.ByteBuffer;

import java.util.Arrays;

import java.util.stream.Stream;

/**

• 字节数组工具类

*/

public class ByteUtils {

public static final String ZERO_HASH = Hex.encodeHexString(new byte[32]);

/**

• 将多个字节数组合并成一个字节数组

• @param bytes

• @return

*/

public static byte[] merge(byte[]… bytes) {

Stream stream = Stream.of();

for (byte[] b : bytes) {

stream = Stream.concat(stream, Arrays.stream(ArrayUtils.toObject(b)));

}

return ArrayUtils.toPrimitive(stream.toArray(Byte[]::new));

}

/**

• long 转化为 byte[]

• @param val

• @return

*/

public static byte[] toBytes(long val) {

return ByteBuffer.allocate(Long.BYTES).putLong(val).array();

}

}

创建Blockchain.java

其中的方法有创建区块链，添加区块Block，区块链遍历，打包交易信息创建区块添加到区块链等

package com.example.blockchain;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import lombok.AllArgsConstructor;

import lombok.Data;

/**

• 区块链

*/

@Data

@AllArgsConstructor

public class Blockchain {

/**

• 最后一个区块的hash

*/

private String lastBlockHash;

/**

• 创建区块链，createBlockchain

• @param address

• @return

*/

public static Blockchain createBlockchain(String address) {

String lastBlockHash = “”;

if (StringUtils.isBlank(lastBlockHash)){

//对应的bucket不存在，说明是第一次获取区块链实例

// 创建 coinBase 交易

Transaction coinbaseTX = Transaction.newCoinbaseTX(address, “”);

Block genesisBlock = Block.newGenesisBlock(coinbaseTX);

lastBlockHash = genesisBlock.getHash();

RocksDBUtils.getInstance().putBlock(genesisBlock);

RocksDBUtils.getInstance().putLastBlockHash(lastBlockHash);

}

return new Blockchain(lastBlockHash);

}

/**

• 根据block，添加区块

• @param block

*/

public void addBlock(Block block) {

RocksDBUtils.getInstance().putLastBlockHash(block.getHash());

RocksDBUtils.getInstance().putBlock(block);

this.lastBlockHash = block.getHash();

}

/**

• 根据data添加区块

• @param data

*/

// public void addBlock(String data) throws Exception{

//

// String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();

// if (StringUtils.isBlank(lastBlockHash)){

// throw new Exception(“还没有数据库，无法直接添加区块。。”);

// }

// this.addBlock(Block.newBlock(lastBlockHash,data));

// }

/**

• 区块链迭代器：内部类

*/

public class BlockchainIterator{

/**

• 当前区块的hash

*/

private String currentBlockHash;

/**

• 构造函数

• @param currentBlockHash

*/

public BlockchainIterator(String currentBlockHash) {

this.currentBlockHash = currentBlockHash;

}

/**

• 判断是否有下一个区块

• @return

*/

public boolean hashNext() {

if (ByteUtils.ZERO_HASH.equals(currentBlockHash)) {

return false;

}

Block lastBlock = RocksDBUtils.getInstance().getBlock(currentBlockHash);

if (lastBlock == null) {

return false;

}

// 如果是创世区块

if (ByteUtils.ZERO_HASH.equals(lastBlock.getPrevBlockHash())) {

return true;

}

return RocksDBUtils.getInstance().getBlock(lastBlock.getPrevBlockHash()) != null;

}

/**

• 迭代获取区块

• @return

*/

public Block next() {

Block currentBlock = RocksDBUtils.getInstance().getBlock(currentBlockHash);

if (currentBlock != null) {

this.currentBlockHash = currentBlock.getPrevBlockHash();

return currentBlock;

}

return null;

}

}

/**

• 添加方法，用于获取迭代器实例

• @return

*/

public BlockchainIterator getBlockchainIterator() {

return new BlockchainIterator(lastBlockHash);

}

/**

• 打包交易，进行挖矿

• @param transactions

*/

public void mineBlock(List transactions) throws Exception {

String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();

Block lastBlock = RocksDBUtils.getInstance().getBlock(lastBlockHash);

if (lastBlockHash == null) {

throw new Exception("ERROR: Fail to get last block hash ! ");

}

Block block = Block.newBlock(lastBlockHash, transactions,lastBlock.getHeight()+1);

this.addBlock(block);

}

/**

• 从交易输入中查询区块链中所有已被花费了的交易输出

• @param address 钱包地址

• @return 交易ID以及对应的交易输出下标地址

• @throws Exception

*/

private Map<String, int[]> getAllSpentTXOs(String address) {

// 定义TxId ——> spentOutIndex[]，存储交易ID与已被花费的交易输出数组索引值

Map<String, int[]> spentTXOs = new HashMap<>();

for (BlockchainIterator blockchainIterator = this.getBlockchainIterator(); blockchainIterator.hashNext(); ) {

Block block = blockchainIterator.next();

for (Transaction transaction : block.getTransactions()) {

// 如果是 coinbase 交易，直接跳过，因为它不存在引用前一个区块的交易输出

if (transaction.isCoinbase()) {

continue;

}

for (TXInput txInput : transaction.getInputs()) {

if (txInput.canUnlockOutputWith(address)) {

String inTxId = Hex.encodeHexString(txInput.getTxId());

int[] spentOutIndexArray = spentTXOs.get(inTxId);

if (spentOutIndexArray == null) {

spentTXOs.put(inTxId, new int[]{txInput.getTxOutputIndex()});

} else {

spentOutIndexArray = ArrayUtils.add(spentOutIndexArray, txInput.getTxOutputIndex());

spentTXOs.put(inTxId, spentOutIndexArray);

}

}

}

}

}

return spentTXOs;

}

/**

• 查找钱包地址对应的所有未花费的交易

• @param address 钱包地址

• @return

*/

private Transaction[] findUnspentTransactions(String address) throws Exception {

Map<String, int[]> allSpentTXOs = this.getAllSpentTXOs(address);

Transaction[] unspentTxs = {};

// 再次遍历所有区块中的交易输出

for (BlockchainIterator blockchainIterator = this.getBlockchainIterator(); blockchainIterator.hashNext(); ) {

Block block = blockchainIterator.next();

for (Transaction transaction : block.getTransactions()) {

String txId = Hex.encodeHexString(transaction.getTxId());

int[] spentOutIndexArray = allSpentTXOs.get(txId);

for (int outIndex = 0; outIndex < transaction.getOutputs().length; outIndex++) {

if (spentOutIndexArray != null && ArrayUtils.contains(spentOutIndexArray, outIndex)) {

continue;

}

// 保存不存在 allSpentTXOs 中的交易

if (transaction.getOutputs()[outIndex].canBeUnlockedWith(address)) {

unspentTxs = ArrayUtils.add(unspentTxs, transaction);

}

}

}

}

return unspentTxs;

}

/**

• 查找钱包地址对应的所有UTXO

• @param address 钱包地址

• @return

*/

public TXOutput[] findUTXO(String address) throws Exception {

Transaction[] unspentTxs = this.findUnspentTransactions(address);

TXOutput[] utxos = {};

if (unspentTxs == null || unspentTxs.length == 0) {

return utxos;

}

for (Transaction tx : unspentTxs) {

for (TXOutput txOutput : tx.getOutputs()) {

if (txOutput.canBeUnlockedWith(address)) {

utxos = ArrayUtils.add(utxos, txOutput);

}

}

}

return utxos;

}

/**

• 寻找能够花费的交易

• @param address 钱包地址

• @param amount 花费金额

*/

public SpendableOutputResult findSpendableOutputs(String address, int amount) throws Exception {

Transaction[] unspentTXs = this.findUnspentTransactions(address);

int accumulated = 0;

Map<String, int[]> unspentOuts = new HashMap<>();

for (Transaction tx : unspentTXs) {

String txId = Hex.encodeHexString(tx.getTxId());

for (int outId = 0; outId < tx.getOutputs().length; outId++) {

TXOutput txOutput = tx.getOutputs()[outId];

if (txOutput.canBeUnlockedWith(address) && accumulated < amount) {

accumulated += txOutput.getValue();

int[] outIds = unspentOuts.get(txId);

if (outIds == null) {

outIds = new int[]{outId};

} else {

outIds = ArrayUtils.add(outIds, outId);

}

unspentOuts.put(txId, outIds);

if (accumulated >= amount) {

break;

}

}

}

}

return new SpendableOutputResult(accumulated, unspentOuts);

}

/**

• 从 DB 从恢复区块链数据

• @return

• @throws Exception

*/

public static Blockchain initBlockchainFromDB() throws Exception {

String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();

if (lastBlockHash == null) {

throw new Exception("ERROR: Fail to init blockchain from db. ");

}

return new Blockchain(lastBlockHash);

}

}

创建ProofOfWork.java（工作量证明）

工作量证明是经过困难的工作，将数据放入区块链中，这样别人就不太可能取修改区块链中的区块，想要修改其中一个块，必须经过大量计算，还要计算这个块之后的块

这里将计算难度设置为16，就是根据nonce计算出来的hash前16位必须为0，这样才能比目标值小，这样添加的区块才能被认可

package com.example.blockchain;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.commons.lang3.StringUtils;

import java.math.BigInteger;

import lombok.AllArgsConstructor;

import lombok.Data;

/**

• 工作量证明

• @author hanru

*/

@Data

@AllArgsConstructor

public class ProofOfWork {

/**

• 难度目标位

• 0000 0000 0000 0000 1001 0001 0000 … 0001

• 256位Hash里面前面至少有16个零

*/

public static final int TARGET_BITS = 16;

/**

• 要验证的区块

*/

private Block block;

/**

• 难度目标值

*/

private BigInteger target;

/**

• 创建新的工作量证明对象

• 对1进行移位运算，将1向左移动 (256 - TARGET_BITS) 位，得到我们的难度目标值

• @param block

• @return

*/

public static ProofOfWork newProofOfWork(Block block) {

/*

1.创建一个BigInteger的数值1.

0000000…00001

2.左移256-bits位

以8 bit为例

0000 0001

0010 0000

8-6

*/

BigInteger targetValue = BigInteger.ONE.shiftLeft((256 - TARGET_BITS));

return new ProofOfWork(block, targetValue);

}

/**

• 运行工作量证明，开始挖矿，找到小于难度目标值的Hash

• @return

*/

public PowResult run() {

long nonce = 0;

String shaHex = “”;

// System.out.printf(“开始进行挖矿：%s \n”, this.getBlock().getData());

System.out.printf(“开始进行挖矿： \n”);

long startTime = System.currentTimeMillis();

while (nonce < Long.MAX_VALUE) {

byte[] data = this.prepareData(nonce);

shaHex = DigestUtils.sha256Hex(data);

System.out.printf(“\r%d: %s”,nonce,shaHex);

if (new BigInteger(shaHex, 16).compareTo(this.target) == -1) {

System.out.println();

System.out.printf(“耗时 Time: %s seconds \n”, (float) (System.currentTimeMillis() - startTime) / 1000);

System.out.printf(“当前区块Hash: %s \n\n”, shaHex);

break;

} else {

nonce++;

}

}

return new PowResult(nonce, shaHex);

}

/**

• 根据block的数据，以及nonce，生成一个byte数组

• 注意：在准备区块数据时，一定要从原始数据类型转化为byte[]，不能直接从字符串进行转换

• @param nonce

• @return

*/

private byte[] prepareData(long nonce) {

byte[] prevBlockHashBytes = {};

if (StringUtils.isNoneBlank(this.getBlock().getPrevBlockHash())) {

prevBlockHashBytes = new BigInteger(this.getBlock().getPrevBlockHash(), 16).toByteArray();

}

return ByteUtils.merge(

prevBlockHashBytes,

// this.getBlock().getData().getBytes(),

this.getBlock().hashTransaction(),

ByteUtils.toBytes(this.getBlock().getTimeStamp()),

ByteUtils.toBytes(TARGET_BITS),

ByteUtils.toBytes(nonce)

);

}

/**

• 验证区块是否有效

• @return

*/

public boolean validate() {

byte[] data = this.prepareData(this.getBlock().getNonce());

return new BigInteger(DigestUtils.sha256Hex(data), 16).compareTo(this.target) == -1;

}

}

创建TXInput.java(交易中的输入)

package com.example.blockchain;

import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

@AllArgsConstructor

@NoArgsConstructor

@Data

public class TXInput {

/**

• txId是前一次交易的ID

*/

private byte[] txId;

/**

• 交易输出索引

*/

private int txOutputIndex;

/**

• 解锁脚本

*/

private String scriptSig;

/**

• 判断解锁数据是否能够解锁交易输出

• @param unlockingData

• @return

*/

public boolean canUnlockOutputWith(String unlockingData) {

return this.getScriptSig().endsWith(unlockingData);

}

}

创建TXOutput.java（交易中的输出）

package com.example.blockchain;

import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

/**

• @author hanru

*/

@Data

@AllArgsConstructor

@NoArgsConstructor

public class TXOutput {

/**

• 数值金额

*/

private int value;

/**

• 锁定脚本

*/

private String scriptPubKey;

/**

• 判断解锁数据是否能够解锁交易输出

• @param unlockingData

• @return

*/

public boolean canBeUnlockedWith(String unlockingData) {

return this.getScriptPubKey().endsWith(unlockingData);

}

}

创建 Transaction.java

package com.example.blockchain;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.codec.digest.DigestUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import java.util.Iterator;

import java.util.Map;

import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

@Data

@AllArgsConstructor

@NoArgsConstructor

public class Transaction {

private static final int SUBSIDY = 10;

/**

• 交易的Hash

*/

private byte[] txId;

/**

• 交易输入

*/

private TXInput[] inputs;

/**

• 交易输出

*/

private TXOutput[] outputs;

/**

• 设置交易ID

*/

private void setTxId() {

this.setTxId(DigestUtils.sha256(SerializeUtils.serialize(this)));

}

/**

• 创建CoinBase交易

• @param to 收账的钱包地址

• @param data 解锁脚本数据

• @return

*/

public static Transaction newCoinbaseTX(String to, String data) {

if (StringUtils.isBlank(data)) {

data = String.format(“Reward to ‘%s’”, to);

}

// 创建交易输入

TXInput txInput = new TXInput(new byte[]{}, -1, data);

// 创建交易输出

TXOutput txOutput = new TXOutput(SUBSIDY, to);

// 创建交易

Transaction tx = new Transaction(null, new TXInput[]{txInput}, new TXOutput[]{txOutput});

// 设置交易ID

tx.setTxId();

return tx;

}

/**

• 从 from 向 to 支付一定的 amount 的金额

• @param from 支付钱包地址

• @param to 收款钱包地址

• @param amount 交易金额

• @param blockchain 区块链

• @return

*/

public static Transaction newUTXOTransaction(String from, String to, int amount, Blockchain blockchain) throws Exception {

SpendableOutputResult result = blockchain.findSpendableOutputs(from, amount);

int accumulated = result.getAccumulated();

Map<String, int[]> unspentOuts = result.getUnspentOuts();

if (accumulated < amount) {

throw new Exception(“ERROR: Not enough funds”);

}

Iterator<Map.Entry<String, int[]>> iterator = unspentOuts.entrySet().iterator();

TXInput[] txInputs = {};

while (iterator.hasNext()) {

Map.Entry<String, int[]> entry = iterator.next();

String txIdStr = entry.getKey();

int[] outIdxs = entry.getValue();

byte[] txId = Hex.decodeHex(txIdStr.toCharArray());

for (int outIndex : outIdxs) {

txInputs = ArrayUtils.add(txInputs, new TXInput(txId, outIndex, from));

}

}

TXOutput[] txOutput = {};

txOutput = ArrayUtils.add(txOutput, new TXOutput(amount, to));

if (accumulated > amount) {

txOutput = ArrayUtils.add(txOutput, new TXOutput((accumulated - amount), from));

}

Transaction newTx = new Transaction(null, txInputs, txOutput);

newTx.setTxId();

return newTx;

}

/**

• 是否为 Coinbase 交易

• @return

*/

public boolean isCoinbase() {

return this.getInputs().length == 1

&& this.getInputs()[0].getTxId().length == 0

&& this.getInputs()[0].getTxOutputIndex() == -1;

}

}

区块持久化存储

创建SerializeUtils.java

该类将原来的类型转换成byte[]类型，这样可以将其存入数据库中，当我们需要从数据库读取数据，再将其反序列化获得指定object

package com.example.blockchain;

import com.esotericsoftware.kryo.Kryo;

import com.esotericsoftware.kryo.io.Input;

import com.esotericsoftware.kryo.io.Output;

/**

• 序列化工具类

*/

public class SerializeUtils {

/**

• 序列化

• @param object 需要序列化的对象

• @return

*/

public static byte[] serialize(Object object) {

Output output = new Output(4096, -1);

new Kryo().writeClassAndObject(output, object);

byte[] bytes = output.toBytes();

output.close();

return bytes;

}

/**

• 反序列化

• @param bytes 对象对应的字节数组

• @return

*/

public static Object deserialize(byte[] bytes) {

Input input = new Input(bytes);

Object obj = new Kryo().readClassAndObject(input);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在IT学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多程序员朋友无法获得正确的资料得到学习提升，故此将并将重要的Android进阶资料包括自定义view、性能优化、MVC与MVP与MVVM三大框架的区别、NDK技术、阿里面试题精编汇总、常见源码分析等学习资料。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

【Android进阶学习视频】、【全套Android面试秘籍】

希望我能够用我的力量帮助更多迷茫、困惑的朋友们，帮助大家在IT道路上学习和发展

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

ssAndObject(output, object);

byte[] bytes = output.toBytes();

output.close();

return bytes;

}

/**

• 反序列化

• @param bytes 对象对应的字节数组

• @return

*/

public static Object deserialize(byte[] bytes) {

Input input = new Input(bytes);

Object obj = new Kryo().readClassAndObject(input);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-4axLd6kd-1713596469658)]

[外链图片转存中…(img-gx4wqJ3f-1713596469660)]

[外链图片转存中…(img-IX19dO3r-1713596469662)]

[外链图片转存中…(img-vzeQ3KXT-1713596469663)]

[外链图片转存中…(img-O9sQvNz1-1713596469664)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在IT学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多程序员朋友无法获得正确的资料得到学习提升，故此将并将重要的Android进阶资料包括自定义view、性能优化、MVC与MVP与MVVM三大框架的区别、NDK技术、阿里面试题精编汇总、常见源码分析等学习资料。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

[外链图片转存中…(img-WvP1BhUG-1713596469665)]

【Android进阶学习视频】、【全套Android面试秘籍】

希望我能够用我的力量帮助更多迷茫、困惑的朋友们，帮助大家在IT道路上学习和发展

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！