【jv实现区块链交易存证记录】

用Java实现区块链交易存证
该文章仅供自己后期项目参考

1、如何在Java中构建区块链的基本结构，包括区块的创建、交易的处理和验证等。
我先从最基础的区块结构开始思考。一个区块应该包含交易数据、时间戳、前一个区块的哈希值以及自身的哈希值。哈希值的计算需要使用加密算法，我决定采用SHA-256算法，因为它是区块链中常用的加密算法，能够保证数据的完整性和安全性。
2、接下来，我思考如何处理交易。交易应该包含交易ID、发送方地址、接收方地址、交易金额和交易时间戳等信息。为了确保交易的安全性，还需要对交易进行数字签名。数字签名可以使用Java的内置安全库来实现，这样可以保证只有交易的发送方能够生成有效的签名。
3、我还需要考虑如何验证交易的合法性。这包括验证交易的输入是否未被花费过，以及交易的输入和输出是否匹配。此外，还需要验证交易的数字签名是否有效，以确保交易是由合法的发送方发起的。
4、在思考过程中，我意识到需要一个区块链类来管理整个区块链。这个类应该能够添加新的区块，并且能够验证整个区块链的完整性。为了实现这一点，我需要一个方法来验证每个区块的哈希值是否正确，以及每个区块的前一个哈希值是否与前一个区块的哈希值匹配。虑如何处理交易的输入和输出。每个交易的输入应该指向一个未被花费的输出，而输出则表示交易的接收方和金额。为了实现这一点，我需要创建交易输入和输出的类，并在交易类中引用它们。
以下是一个简单的Java区块链交易存证实现：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

public class Blockchain {
    private List<Block> chain = new ArrayList<>();
    private List<Transaction> pendingTransactions = new ArrayList<>();
    private int difficulty = 2;

    public Blockchain() {
        // 创建创世区块
        Block genesisBlock = new Block("Genesis Block", "0");
        genesisBlock.mineBlock(difficulty);
        chain.add(genesisBlock);
    }

    public void addTransaction(Transaction transaction) {
        pendingTransactions.add(transaction);
    }

    public void minePendingTransactions() {
        Block block = new Block(pendingTransactions, getLatestBlock().getHash());
        block.mineBlock(difficulty);
        chain.add(block);
        pendingTransactions = new ArrayList<>();
    }

    public Block getLatestBlock() {
        return chain.get(chain.size() - 1);
    }

    public boolean isChainValid() {
        for (int i = 1; i < chain.size(); i++) {
            Block currentBlock = chain.get(i);
            Block previousBlock = chain.get(i - 1);

            if (!currentBlock.getHash().equals(currentBlock.calculateHash())) {
                return false;
            }

            if (!previousBlock.getHash().equals(currentBlock.getPreviousHash())) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Blockchain blockchain = new Blockchain();

        // 创建交易
        Transaction transaction1 = new Transaction("Alice", "Bob", 100);
        Transaction transaction2 = new Transaction("Bob", "Charlie", 50);

        // 添加交易到区块链
        blockchain.addTransaction(transaction1);
        blockchain.addTransaction(transaction2);

        // 挖矿
        blockchain.minePendingTransactions();

        // 打印区块链
        for (Block block : blockchain.chain) {
            System.out.println("Block Hash: " + block.getHash());
            System.out.println("Previous Hash: " + block.getPreviousHash());
            System.out.println("Transactions: " + block.getTransactions());
            System.out.println();
        }

        // 验证区块链
        System.out.println("Is blockchain valid? " + blockchain.isChainValid());
    }
}

class Block {
    private String hash;
    private String previousHash;
    private List<Transaction> transactions;
    private long timestamp;
    private int nonce;

    public Block(List<Transaction> transactions, String previousHash) {
        this.transactions = transactions;
        this.previousHash = previousHash;
        this.timestamp = System.currentTimeMillis();
        this.hash = calculateHash();
    }

    public String calculateHash() {
        return StringUtil.applySha256(
                previousHash +
                        Long.toString(timestamp) +
                        Integer.toString(nonce) +
                        transactions.toString()
        );
    }

    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);
    }

    public String getHash() {
        return hash;
    }

    public String getPreviousHash() {
        return previousHash;
    }

    public List<Transaction> getTransactions() {
        return transactions;
    }
}

class Transaction {
    private String id;
    private String sender;
    private String receiver;
    private double amount;
    private String transactionTime;

    public Transaction(String sender, String receiver, double amount) {
        this.sender = sender;
        this.receiver = receiver;
        this.amount = amount;
        this.transactionTime = Long.toString(System.currentTimeMillis());
        this.id = StringUtil.applySha256(sender + receiver + amount + transactionTime);
    }

    @Override
    public String toString() {
        return "Transaction{" +
                "id='" + id + '\'' +
                ", sender='" + sender + '\'' +
                ", receiver='" + receiver + '\'' +
                ", amount=" + amount +
                ", transactionTime='" + transactionTime + '\'' +
                '}';
    }
}

class StringUtil {
    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);
        }
    }
}

这个实现包括了以下功能：
1、区块链的基本结构，包括区块和交易。
2、交易的创建和添加到区块链。
3、区块的挖矿过程，包括工作量证明（Proof of Work）。
4、区块链的验证，确保区块链的完整性和安全性。