Demo：第一章：Java实现比特币系统

柔光的暖阳◎ 2022-09-11 08:15 129阅读 0赞

创建一个maven项目  
pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.blockchain.block</groupId>
        <artifactId>blockchain</artifactId>
        <version>1.0-SNAPSHOT</version>
        <properties>
            <java-version>1.8</java-version>
        </properties>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>${
        java-version}</source>
                        <target>${
        java-version}</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                    <configuration>
                        <archive>
                            <addMavenDescriptor>false</addMavenDescriptor>
                            <manifest>
                                <addClasspath>true</addClasspath>
                                <classpathPrefix>lib/</classpathPrefix>
                                <mainClass>com.blockchain.Main</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>2.1</version>
                    <executions>
                        <execution>
                            <id>copy-dependencies</id>
                            <phase>package</phase>
                            <goals>
                                <goal>copy-dependencies</goal>
                            </goals>
                            <configuration>
                                <outputDirectory>${
        project.build.directory}/lib</outputDirectory>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
            <finalName>blockchain</finalName>
            <defaultGoal>compile</defaultGoal>
        </build>
        <dependencies>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.7</version>
            </dependency>
        </dependencies>
    </project>

创建二个实体类：  
Block

package com.blockchain.model;
    
    import java.util.List;
    
    import com.alibaba.fastjson.JSON;
    import com.blockchain.security.CryptoUtil;
    
    /**
     * 区块结构
     * @author zhiwei liao
     *
     */
    public class Block {
        
    
    	/**
    	 * 区块索引号
    	 */
    	private int index;
    	/**
    	 * 当前区块的hash值,区块唯一标识
    	 */
    	private String hash;
    	/**
    	 * 生成区块的时间戳
    	 */
    	private long timestamp;
    	/**
    	 * 当前区块的交易集合
    	 */
    	private List<Transaction> transactions;
    	/**
    	 * 工作量证明，计算正确hash值的次数
    	 */
    	private int nonce;
    	/**
    	 * 前一个区块的hash值
    	 */
    	private String previousHash;
    
    	public Block() {
        
    		super();
    	}
    
    	public Block(int index, long timestamp, List<Transaction> transactions, int nonce, String previousHash, String hash) {
        
    		super();
    		this.index = index;
    		this.timestamp = timestamp;
    		this.transactions = transactions;
    		this.nonce = nonce;
    		this.previousHash = previousHash;
    		this.hash = hash;
    	}
    
    	public int getIndex() {
        
    		return index;
    	}
    
    	public void setIndex(int index) {
        
    		this.index = index;
    	}
    
    	public long getTimestamp() {
        
    		return timestamp;
    	}
    
    	public void setTimestamp(long timestamp) {
        
    		this.timestamp = timestamp;
    	}
    
    	public List<Transaction> getTransactions() {
        
    		return transactions;
    	}
    
    	public void setTransactions(List<Transaction> transactions) {
        
    		this.transactions = transactions;
    	}
    
    	public int getNonce() {
        
    		return nonce;
    	}
    
    	public void setNonce(int nonce) {
        
    		this.nonce = nonce;
    	}
    
    	public String getPreviousHash() {
        
    		return previousHash;
    	}
    
    	public void setPreviousHash(String previousHash) {
        
    		this.previousHash = previousHash;
    	}
    
    	public String getHash() {
        
    		return hash;
    	}
    
    	public void setHash(String hash) {
        
    		this.hash = hash;
    	}
    	
    	/**
    	 * 挖矿
    	 * @param blockchain 整个区块链
    	 * @param txs 需记账交易记录
    	 * @param address 矿工钱包地址
    	 * @return
    	 */
    	public static void mineBlock(List<Block> blockchain, List<Transaction> txs, String address) {
        
    		//加入系统奖励的交易
    		Transaction sysTx = new Transaction(CryptoUtil.UUID(), "", address, 10);
    		txs.add(sysTx);
    		//获取当前区块链里的最后一个区块
    	    Block latestBlock = blockchain.get(blockchain.size() - 1);
    		//随机数
    		int nonce = 1;
    		String hash = "";
    		while(true){
        
    			hash = CryptoUtil.SHA256(latestBlock.getHash() + JSON.toJSONString(txs) + nonce);
    			if (hash.startsWith("0000")) {
        
    		        System.out.println("=====计算结果正确，计算次数为：" +nonce+ ",hash:" + hash);
    		        break;
    	        }
    			nonce++;
    			System.out.println("计算错误，hash:" + hash); 
    		}
    		
    		//解出难题，可以构造新区块并加入进区块链里
    		Block newBlock = new Block(latestBlock.getIndex() + 1, System.currentTimeMillis(), txs, nonce, latestBlock.getHash(), hash);
    		blockchain.add(newBlock);
    		System.out.println("挖矿后的区块链：" + JSON.toJSONString(blockchain));
        }
    	
    }

Transaction

package com.blockchain.model;
    
    
    /**
     * 交易
     * @author zhiwei liao
     */
    public class Transaction {
        
    	/**
    	 * 交易唯一标识
    	 */
    	private String id;
    	/**
    	 * 交易发送方
    	 */
    	private String sender;
    	/**
    	 * 交易接收方
    	 */
    	private String recipient;
    	/**
    	 * 交易金额
    	 */
    	private int amount;
    
    	public Transaction() {
        
    		super();
    	}
    
    	public Transaction(String id, String sender, String recipient, int amount) {
        
    		super();
    		this.id = id;
    		this.sender = sender;
    		this.recipient = recipient;
    		this.amount = amount;
    	}
    
    	public String getId() {
        
    		return id;
    	}
    
    	public void setId(String id) {
        
    		this.id = id;
    	}
    	
    	public String getSender() {
        
    		return sender;
    	}
    
    	public void setSender(String sender) {
        
    		this.sender = sender;
    	}
    
    	public String getRecipient() {
        
    		return recipient;
    	}
    
    	public void setRecipient(String recipient) {
        
    		this.recipient = recipient;
    	}
    	
    	public int getAmount() {
        
    		return amount;
    	}
    
    	public void setAmount(int amount) {
        
    		this.amount = amount;
    	}
    
    
    	@Override
    	public int hashCode() {
        
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((id == null) ? 0 : id.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) {
        
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Transaction other = (Transaction) obj;
    		if (id == null) {
        
    			if (other.id != null)
    				return false;
    		} else if (!id.equals(other.id))
    			return false;
    		return true;
    	}
    	
    }

加密工具类

package com.blockchain.security;
    
    import java.security.MessageDigest;
    import java.util.UUID;
    
    
    /**
     * 加密工具类
     * 
     * @author zhiwei liao
     *
     */
    public class CryptoUtil {
        
    	private CryptoUtil() {
        
    	}
    
    	public static String SHA256(String str) {
        
    		MessageDigest messageDigest;
    		String encodeStr = "";
    		try {
        
    			messageDigest = MessageDigest.getInstance("SHA-256");
    			messageDigest.update(str.getBytes("UTF-8"));
    			encodeStr = byte2Hex(messageDigest.digest());
    		} catch (Exception e) {
        
    			System.out.println("getSHA256 is error" + e.getMessage());
    		}
    		return encodeStr;
    	}
    
    	public static String UUID() {
        
    		return UUID.randomUUID().toString().replaceAll("\\-", "");
    	}
    
    	private static String byte2Hex(byte[] bytes) {
        
    		StringBuilder builder = new StringBuilder();
    		String temp;
    		for (int i = 0; i < bytes.length; i++) {
        
    			temp = Integer.toHexString(bytes[i] & 0xFF);
    			if (temp.length() == 1) {
        
    				builder.append("0");
    			}
    			builder.append(temp);
    		}
    		return builder.toString();
    	}
    
    }

Main方法执行：

package com.blockchain;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import com.alibaba.fastjson.JSON;
    import com.blockchain.model.Block;
    import com.blockchain.model.Transaction;
    import com.blockchain.security.CryptoUtil;
    /**
     * 交易
     * @author zhiwei liao
     */
    public class Main {
        
    	
    	public static void main(String[] args) {
        
    		//创建一个空的区块链
    		List<Block> blockchain = new ArrayList<>();
    		//生成创世区块
    		Block block = new Block(1, System.currentTimeMillis(), new ArrayList<Transaction>(), 1, "1", "1");
    		//加入创世区块到区块链里
    		blockchain.add(block);
    		System.out.println(JSON.toJSONString(blockchain));
    		
    		// 发送方钱包地址
    		String sender = "sender_wallet";
    		//接收方钱包地址
    		String recipient = "recipient_wallet";
    		
    		//创建一个空的交易集合
    		List<Transaction> txs = new ArrayList<>();
    		//挖矿
    		Block.mineBlock(blockchain, txs, sender);
    		System.out.println(sender + "钱包的余额为：" + getWalletBalance(blockchain, sender));
    		
    		//创建一个空的交易集合
    		List<Transaction> txs1 = new ArrayList<>();
    		//已发生但未记账的交易记录，发送者给接收者转账3个比特币
    		Transaction tx1 = new Transaction(CryptoUtil.UUID(), sender, recipient, 3);
    		//已发生但未记账的交易记录，发送者给接收者转账1个比特币
    		Transaction tx2 = new Transaction(CryptoUtil.UUID(), sender, recipient, 1);
    		txs1.add(tx1);
    		txs1.add(tx2);
    		//挖矿
    		Block.mineBlock(blockchain, txs1, sender);
    		System.out.println(sender + "钱包的余额为：" + getWalletBalance(blockchain, sender));
    		System.out.println(recipient + "钱包的余额为：" + getWalletBalance(blockchain, recipient));
        }
    	
    	/**
    	 * 查询余额
    	 * @param blockchain
    	 * @param address
    	 * @return
    	 */
    	public static int getWalletBalance(List<Block> blockchain, String address) {
        
    		int balance = 0;
    		for (Block block : blockchain) {
        
    	        List<Transaction> transactions = block.getTransactions();
    	        for (Transaction transaction : transactions) {
        
    	            if (address.equals(transaction.getRecipient())) {
        
    	            	balance += transaction.getAmount();
                    }
    	            if (address.equals(transaction.getSender())) {
        
    	            	balance -= transaction.getAmount();
                    }
                }
            }
    		return balance;
    	}
    }

这样一个简单的比特币系统就做好啦