个人随笔
目录
三、Java实现一个简单的区块链源码
2021-06-29 23:35:26

下面开始根据上一篇文章说的区块链的属性来用Java实现一个简单版的区块链比特币逻辑，逻辑大概要实现如下功能。

1、生成账户
2、挖矿获得比特币
3、查询所有区块链
4、转账交易

我们知道，转账后交易还未记账的，需要先进行记账才能生效，而记账是通过挖矿来记账的。

下面简单介绍一下项目的组成。

1、SpringBoot

这里是简单的SpringBoot项目Contrller层暴露上面1、生成账户；2、挖矿获得比特币；3、查询所有区块链；4、转账交易这些接口。

2、WebSocket

这里是通过WebSocket来实现节点之间的通信，区块链的最大的优势就是去中心化。

3、关键源码如下

钱包
  1. public class Wallet {
  2.     //公钥
  3.     private String publicKey;
  4.     //私钥
  5.     private String privateKey;
  6.     public String getPublicKey() {
  7.         return publicKey;
  8.     }
  9.     public void setPublicKey(String publicKey) {
  10.         this.publicKey = publicKey;
  11.     }
  12.     public String getPrivateKey() {
  13.         return privateKey;
  14.     }
  15.     public void setPrivateKey(String privateKey) {
  16.         this.privateKey = privateKey;
  17.     }
  18.     public Wallet() {
  19.         //构造参数会生成一个公钥，一个私钥，这里用RSA算法
  20.         //1、生成一队公钥私钥
  21.          Map<String,String> keyMap = RSA.getKeyMap();
  22.          //获得公钥
  23.         this.publicKey=keyMap.get(RSA.PUBLIC_KEY);
  24.         this.privateKey= keyMap.get(RSA.PRIVATE_KEY);
  25.     }
  26.     //交易的输入需要公钥的hash，所以这里需要获取公钥的hash
  27.     public static String getPublicKeyHash(String publicKey) {
  28.         //这里用SHA256
  29.         return SHA256.encrypt(publicKey);
  30.     }
  31.     //当然上面那个方法是用来验证交易输出是否是这个用户的，这里还有一个自己的方法
  32.     public String getPublicKeyHash() {
  33.         return Wallet.getPublicKeyHash(publicKey);
  34.     }
  35.     //下面这里还需要获取地址，根据这个地址可以找到这个钱包，这里用MD5不用那么长
  36.     public String getAdress() {
  37.         return MD5.encrypt(getPublicKeyHash());
  38.     }
  40.     @Override
  41.     public String toString() {
  42.         return "Wallet [publicKey=" + publicKey + ", privateKey=" + privateKey + ", getPublicKeyHash()="
  43.                 + getPublicKeyHash() + ", getAdress()=" + getAdress() + "]";
  44.     }
  45.     public static void main(String[] args) {
  46.         //生成一个钱包
  47.         Wallet wallet = new Wallet();
  48.         System.out.println(wallet);
  49.     }
  51. }

钱包有私钥和公钥属性以及生成公钥Hash和钱包地址的方法。

区块
  1. public class Block {
  2.     //区块索引号
  3.     private String index;
  4.     //当前区块的唯一标识
  5.     private String hash;
  6.     //前一区块的唯一标识
  7.     private String preHash;
  8.     //生成区块的时间戳
  9.     private String timestamp;
  10.     //交易集合
  11.     private List<Transaction> transactions;
  12.     //计算次数
  13.     private String num;
  14.     //辅助计算值:目的是增加随机性
  15.     private String uuid;
  17.     public String getNum() {
  18.         return num;
  19.     }
  21.     public void setNum(String num) {
  22.         this.num = num;
  23.     }
  25.     public String getUuid() {
  26.         return uuid;
  27.     }
  29.     public void setUuid(String uuid) {
  30.         this.uuid = uuid;
  31.     }
  33.     public String getIndex() {
  34.         return index;
  35.     }
  37.     public void setIndex(String index) {
  38.         this.index = index;
  39.     }
  41.     public String getHash() {
  42.         return hash;
  43.     }
  45.     public void setHash(String hash) {
  46.         this.hash = hash;
  47.     }
  49.     public String getPreHash() {
  50.         return preHash;
  51.     }
  53.     public void setPreHash(String preHash) {
  54.         this.preHash = preHash;
  55.     }
  57.     public String getTimestamp() {
  58.         return timestamp;
  59.     }
  61.     public void setTimestamp(String timestamp) {
  62.         this.timestamp = timestamp;
  63.     }
  65.     public List<Transaction> getTransactions() {
  66.         return transactions;
  67.     }
  69.     public void setTransactions(List<Transaction> transactions) {
  70.         this.transactions = transactions;
  71.     }
  73.     public static void main(String[] args) {
  74.         // TODO Auto-generated method stub
  76.     }
  78. }

区块有区块索引号、当前区块的唯一标识hash、生产区块的时间戳、前一区块的唯一标识、交易集合。

交易输入
  1. public class TransactionInput {
  2.     //前一个交易的ID
  3.     private String preId;
  4.     //比特币数量
  5.     private String value;
  6.     //发送方的公钥
  7.     private String senderPublicKey;
  8.     //交易签名
  9.     //对发送者和接收者的公钥哈希以及整个交易签名
  10.     private String sign;
  11.     public String getPreId() {
  12.         return preId;
  13.     }
  14.     public void setPreId(String preId) {
  15.         this.preId = preId;
  16.     }
  17.     public String getValue() {
  18.         return value;
  19.     }
  20.     public void setValue(String value) {
  21.         this.value = value;
  22.     }
  23.     public String getSenderPublicKey() {
  24.         return senderPublicKey;
  25.     }
  26.     public void setSenderPublicKey(String senderPublicKey) {
  27.         this.senderPublicKey = senderPublicKey;
  28.     }
  29.     public String getSign() {
  30.         return sign;
  31.     }
  32.     public void setSign(String sign) {
  33.         this.sign = sign;
  34.     }
  36. }

交易输入有前一个交易的ID、比特币数量、发送方的公钥、交易签名（对发送者和接收者的公钥哈希以及整个交易签名）

交易输出
  1. public class TransactionOutput {
  2.     //比特币数量
  3.     private String value;
  4.     //接收者的公钥hash
  5.     private String publicKeyHash;
  6.     public String getValue() {
  7.         return value;
  8.     }
  9.     public void setValue(String value) {
  10.         this.value = value;
  11.     }
  12.     public String getPublicKeyHash() {
  13.         return publicKeyHash;
  14.     }
  15.     public void setPublicKeyHash(String publicKeyHash) {
  16.         this.publicKeyHash = publicKeyHash;
  17.     }
  18.     public TransactionOutput(String value, String publicKeyHash) {
  19.         super();
  20.         this.value = value;
  21.         this.publicKeyHash = publicKeyHash;
  22.     }
  24. }

只有比特币数量和接收者的公钥Hash

交易
  1. public class Transaction {
  2.     //唯一ID
  3.     private String id;
  4.     private TransactionInput transactionInput;
  5.     private TransactionOutput transactionOutput;
  6.     public String getId() {
  7.         return id;
  8.     }
  9.     public void setId(String id) {
  10.         this.id = id;
  11.     }
  12.     public TransactionInput getTransactionInput() {
  13.         return transactionInput;
  14.     }
  15.     public void setTransactionInput(TransactionInput transactionInput) {
  16.         this.transactionInput = transactionInput;
  17.     }
  18.     public TransactionOutput getTransactionOutput() {
  19.         return transactionOutput;
  20.     }
  21.     public void setTransactionOutput(TransactionOutput transactionOutput) {
  22.         this.transactionOutput = transactionOutput;
  23.     }
  24.     //对交易进行签名:对发送者和接收者的公钥hash以及整个交易签名
  25.     public void sign(String senderPrivateKey,String senderPublicKeyHash) {
  26.         //这里签名用的发送者的私钥，在签名之前，
  27.         //签名字段为空，所以生成签名之前，可以把签名设置成发送者公钥hash，这样子就全了
  28.         this.getTransactionInput().setSign(senderPublicKeyHash);
  29.         //获取签名,签名是对摘要进行签名的
  30.         String hash = SHA256.encrypt(new Gson().toJson(this));
  31.         System.out.println("hash:"+hash);
  32.         String sign = RSA.rsaEncrypt(senderPrivateKey, hash);
  33.         this.getTransactionInput().setSign(sign);
  34.         System.out.println(sign);
  35.     }
  36.     //验证签名
  37.     //对交易进行签名:对发送者和接收者的公钥hash以及整个交易签名
  38.     public boolean verify(Transaction preTransaction) {
  39.         if(!this.getTransactionInput().getPreId().equals("0")) {
  40.             //这里表明该交易不是系统给的，有上一个交易
  41.             if(!this.getTransactionInput().getPreId().equals(preTransaction.getId())) {
  42.                 //上一个交易的id和本交易的上一个交易的id不同
  43.                 return false;
  44.             }
  45.         }else {
  46.             //该交易是系统给的
  47.             return true;
  48.         }
  50.         //1、先获取发送者的公钥Hash
  51.         String senderPublicKey = this.getTransactionInput().getSenderPublicKey();
  52.         String senderPublicKeyHash = Wallet.getPublicKeyHash(senderPublicKey);
  53.         //判断引用的输出是不是发送者的
  54.         if(!preTransaction.getTransactionOutput().getPublicKeyHash().equals(senderPublicKeyHash)) {
  55.             //上一个交易的输出不是发送者的
  56.             return false;
  57.         }
  60.         //判断是否是发送者发送的
  62.         //2、暂存签名
  63.         String oldSign = this.getTransactionInput().getSign();
  64.         System.out.println("oldSign:"+oldSign);
  65.         //设置公钥Hash
  66.         this.getTransactionInput().setSign(senderPublicKeyHash);
  67.         //获取签名,签名是对摘要进行签名的
  68.         String hash = SHA256.encrypt(new Gson().toJson(this));
  69.         System.out.println("hash:"+hash);
  70.         //用发送者的公钥解密
  71.         String newHash = RSA.rsaDecode(senderPublicKey, oldSign);
  72.         System.out.println("newHash:"+newHash);
  73.         //将签名设置回去
  74.         this.getTransactionInput().setSign(oldSign);
  75.         if(hash.equals(newHash)) {
  76.             System.out.println("是发送者发送的");
  77.             return true;
  78.         }else {
  79.             System.out.println("不是发送者发送的");
  80.             return false;
  81.         }
  82.     }
  84.     @Override
  85.     public String toString() {
  86.         return "Transaction [id=" + id + ", transactionInput=" + transactionInput + ", transactionOutput="
  87.                 + transactionOutput + "]";
  88.     }
  89. }

交易包括交易ID和交易输入以及输出，因为交易输入的签名包括整个交易，所以交易的验证就放到交易对象本身

挖矿
  1. public Block mine() {
  2.         //生成一个区块
  3.         Block block = new Block();
  4.         //1、获取当前区块链的最后一个区块
  5.         if(blockChain.size()==0) {
  6.             block.setIndex("0");//创世区块
  7.             block.setPreHash("0");
  8.         }else {
  9.             Block lastBlock = blockChain.get(blockChain.size()-1);
  10.             block.setIndex((Integer.parseInt(lastBlock.getIndex())+1)+"");
  11.             block.setPreHash(lastBlock.getHash());
  12.         }
  14.         List<Transaction> transactions = new ArrayList<Transaction>();
  15.         //生成一个交易，这个交易是区块链这个系统给的
  16.         //交易输入
  17.         TransactionInput transactionInput = new TransactionInput();
  18.         //上一个交易的ID。系统发的，所以为0
  19.         transactionInput.setPreId("0");
  20.         //这个系统发的。所以发送方的公钥为空
  21.         transactionInput.setSenderPublicKey("");
  22.         transactionInput.setValue("10");
  24.         //交易输出:发给自己
  25.         TransactionOutput transactionOutput = new TransactionOutput("10", myWallet.getPublicKeyHash());
  27.         //构建交易
  28.         Transaction transaction = new Transaction();
  29.         //唯一ID
  30.         transaction.setId(MD5.encrypt(UUID.randomUUID().toString()));
  31.         //交易输入
  32.         transaction.setTransactionInput(transactionInput);
  33.         //交易输出
  34.         transaction.setTransactionOutput(transactionOutput);
  35.         //签名
  36.         transaction.sign(myWallet.getPrivateKey(), myWallet.getPublicKeyHash());
  37.         transactions.add(transaction);
  39.         //获得所有未花费的交易
  40.         for (Transaction notPackedTransaction : notPackedTransactions) {
  41.             Transaction preTransaction = preTransaction(notPackedTransaction);
  42.             if(preTransaction!=null) {
  43.                 if(notPackedTransaction.verify(preTransaction)) {
  44.                     //加入挖矿中
  45.                     transactions.add(notPackedTransaction);
  46.                 }
  47.             }
  49.         }
  50.         block.setTransactions(transactions);
  51.         int num = 0;
  52.         //挖矿
  53.         while(true) {
  54.             //时间搓
  55.             String timestamp = System.currentTimeMillis()+"";
  56.             //num
  57.             num++;
  58.             //UUID
  59.             String uuid = UUID.randomUUID().toString();
  60.             block.setNum(num+"");
  61.             block.setTimestamp(timestamp);
  62.             block.setUuid(uuid);
  63.             block.setHash("");
  64.             //用SHA256计算目标值
  65.             String value = SHA256.encrypt(gson.toJson(block));
  66.             log.info("挖矿中："+value);
  67.             if("0000".equals(value.substring(0, 4))) {
  68.                 log.info("挖矿成功："+value+"block="+gson.toJson(block));
  69.                 block.setHash(value);
  70.                 break;
  71.             }
  72.         }
  73.         //挖矿成功
  74.         blockChain.add(block);
  75.         //从已打包交易中移除
  76.         for(Transaction t : block.getTransactions()) {
  77.             notPackedTransactions.remove(t);
  78.         }
  79.         //这里需要将该区块广播出去:
  80.         Message message = new Message(Const.BROATCAST_BLOCK);
  81.         message.setBody(block);
  82.         //不管是客户端还是服务器，全部广播
  83.         p2pService.broatcast(gson.toJson(message));
  85.         //把剩下的交易也广播出去
  87.         Message message2 = new Message(Const.RESPONSE_NOT_PACKET_TRANSACTIONS);
  88.         message2.setBody(notPackedTransactions);
  89.         //不管是客户端还是服务器，全部广播
  90.         p2pService.broatcast(gson.toJson(message2));
  91.         return block;
  92.     }

挖矿需要打包所有未打包的交易，然后做工作了证明，这里是计算一个固定的hash值规律，真正的比特币实现这个难度是可以动态变化的。

获得账户比特币数目

比特币是所有未花费的交易输出，计算方式如下

  1. public String balance() {
  2.     int value = 0;
  3.     //获取该账户所有未花费的交易输出
  4.     List<Transaction> unspentTransactions = this.getUnspentTransactions();
  5.     for (Transaction transaction : unspentTransactions) {
  6.         //获得交易输出
  7.         TransactionOutput transactionOutput = transaction.getTransactionOutput();
  8.         value=value+Integer.parseInt(transactionOutput.getValue());
  9.     }
  10.     return value+"";
  11. }
  12. //这里的实现效率是比较慢的，真正的比特币是借助一种merkle树的结构来提高效率
  13. private List<Transaction> getUnspentTransactions(){
  14.         //获取未打包的交易中属于自己的交易输入的ID
  15.                 List<String> ids =new ArrayList<String>();
  16.                 for (Transaction transaction : notPackedTransactions) {
  17.                     //该交易的输入是否是自己
  18.                     TransactionInput transactionInput = transaction.getTransactionInput();
  19.                     String senderPublicKey =  transactionInput.getSenderPublicKey();
  20.                     if(senderPublicKey.equals(myWallet.getPublicKey())) {
  21.                         //该交易的是自己产生的，用的是自己的交易输出所在的交易
  22.                         ids.add(transactionInput.getPreId());
  23.                     }
  24.                 }
  26.                 //获取所有已打包的交易中数以自己的交易输入的ID
  27.                 for (Block block : blockChain) {
  28.                     //获取交易
  29.                     List<Transaction> transactions = block.getTransactions();
  30.                     //获取属于自己的交易输入
  31.                     for (Transaction transaction : transactions) {
  32.                         //该交易的输入是否是自己
  33.                         TransactionInput transactionInput = transaction.getTransactionInput();
  34.                         String senderPublicKey =  transactionInput.getSenderPublicKey();
  35.                         if(senderPublicKey.equals(myWallet.getPublicKey())) {
  36.                             //该交易的是自己产生的，用的是自己的交易输出所在的交易
  37.                             ids.add(transactionInput.getPreId());
  38.                         }
  39.                     }
  40.                 }
  41.                 //获取为话费的交易输出，也就是这个交易的输出是自己，但是交易未花费
  42.                 List<Transaction> unspentTransactions = new ArrayList<Transaction>();
  43.                 for (Block block : blockChain) {
  44.                     //获取交易
  45.                     List<Transaction> transactions = block.getTransactions();
  46.                     //获取属于自己的交易输入
  47.                     for (Transaction transaction : transactions) {
  48.                         //获得交易输出
  49.                         TransactionOutput transactionOutput = transaction.getTransactionOutput();
  50.                         //判断是否是自己的
  51.                         if(transactionOutput.getPublicKeyHash().equals(myWallet.getPublicKeyHash())) {
  52.                             //检查这个交易有没有花费
  53.                             if(!ids.contains(transaction.getId())) {
  54.                                 unspentTransactions.add(transaction);
  55.                             }
  56.                         }
  57.                     }
  58.                 }
  59.         return unspentTransactions;
  60.     }
转账
  1. public Map<String, Object> transaction(String value, String address) {
  3.         Map<String, Object> result= new HashMap<String, Object>();
  5.         if(address.equals(myWallet.getAdress())) {
  6.             result.put("status", "不能给自己转账");
  7.             return result;
  8.         }
  9.         //获取当前用户的价值数目
  10.         List<Transaction> unspentTransactions = this.getUnspentTransactions();
  11.         for (Transaction transaction : unspentTransactions) {
  12.             //获得交易输出
  13.             TransactionOutput transactionOutput = transaction.getTransactionOutput();
  14.             //先实现整个转
  15.             if(transactionOutput.getValue().equals(value)) {
  17.                 //生成一个交易
  18.                 //交易输入
  19.                 TransactionInput transactionInput = new TransactionInput();
  20.                 //上一个交易的ID
  21.                 transactionInput.setPreId(transaction.getId());
  22.                 //这个系统发的。所以发送方的公钥为空
  23.                 transactionInput.setSenderPublicKey(myWallet.getPublicKey());
  24.                 transactionInput.setValue(value);
  26.                 String receivePublicHashKey = "";//接受者公钥Hash
  27.                 //获取接受者的钱包
  28.                 for (Wallet wallet : wallets) {
  29.                     if(address.equals(wallet.getAdress())) {
  30.                         receivePublicHashKey = wallet.getPublicKeyHash();
  31.                         break;
  32.                     }
  33.                 }
  35.                 if(StringUtils.isBlank(receivePublicHashKey)) {
  36.                     result.put("status", "接受者不存在");
  37.                     return result;
  38.                 }
  40.                 //交易输出:发给自己
  41.                 TransactionOutput transactionOutput2 = new TransactionOutput(value, receivePublicHashKey);
  43.                 //构建交易
  44.                 Transaction transaction2 = new Transaction();
  45.                 //唯一ID
  46.                 transaction2.setId(MD5.encrypt(UUID.randomUUID().toString()));
  47.                 //交易输入
  48.                 transaction2.setTransactionInput(transactionInput);
  49.                 //交易输出
  50.                 transaction2.setTransactionOutput(transactionOutput2);
  51.                 //签名
  52.                 transaction2.sign(myWallet.getPrivateKey(), myWallet.getPublicKeyHash());
  54.                 log.info("交易生成成功："+gson.toJson(transaction2));
  55.                 //加入到未打包交易中
  56.                 notPackedTransactions.add(transaction2);
  57.                 result.put("status", "success");
  59.                 //把交易广播出去
  60.                 //这里需要将该区块广播出去:
  61.                 Message message = new Message(Const.BROATCAST_TRANSACTION);
  62.                 message.setBody(transaction2);
  63.                 //不管是客户端还是服务器，全部广播
  64.                 p2pService.broatcast(gson.toJson(message));
  65.                 return result; 
  66.             }
  67.         }
  68.         result.put("status", "不够钱");
  69.         return result;
  70.     }

转账得先判断有没有足够的比特币，有才能够转账，这里实现的是刚好10个比特币，没有说扣不完的情况，如果要实现用户有10个比特币，但是只转账5个，那么要实现
找零的逻辑，其实也很简单，比特币是没有说只用5个的，每个交易输出一定是全部用完，比如我有一个未花费的交易输出为10，也就是10个未花费的比特币，如果我要转账给张三5个，那么这个交易输出将会全部用完，会生成两个交易输出，一个是给张三的5，另一个是给自己的5.

P2P的实现

这个其实比较简单，这里借助WebSocket来实现即可
客户端

  1. @Component("p2pClient")
  2. public class P2PClient {
  3.     private static Gson gson = new Gson();
  4.     //ws服务 ws://127.0.0.1:port
  5.     @Value("${P2P_CLIENT_PEER}")
  6.     private String P2P_SERVER_PORT;
  8.     @Autowired
  9.     private P2PService p2pService;
  11.     public void connectToPeer() { 
  12.         if("".equals(P2P_SERVER_PORT)) {
  13.             return;
  14.         }
  15.         try {
  16.             final WebSocketClient socketClient = new WebSocketClient(new URI(P2P_SERVER_PORT)) {
  17.                 @Override
  18.                 public void onOpen(ServerHandshake serverHandshake) {
  19.                     //向服务器发送获取区块链，未打包交易，钱包集合
  20.                     Message QUERY_BLOCKCHAIN = new Message(Const.QUERY_BLOCKCHAIN);
  21.                     Message QUERY_NOT_PACKET_TRANSACTIONS = new Message(Const.QUERY_NOT_PACKET_TRANSACTIONS);
  22.                     Message QUERY_WALLETS = new Message(Const.QUERY_WALLETS);
  23.                     p2pService.sockets.add(this);
  24.                     p2pService.write(this, gson.toJson(QUERY_BLOCKCHAIN));
  25.                     p2pService.write(this, gson.toJson(QUERY_NOT_PACKET_TRANSACTIONS));
  26.                     p2pService.write(this, gson.toJson(QUERY_WALLETS));
  27.                 }
  29.                 @Override
  30.                 public void onMessage(String msg) {
  31.                     System.out.println("收到服务端发送的消息:" + msg);
  32.                     p2pService.handleMessage(this, msg);
  33.                 }
  35.                 @Override
  36.                 public void onClose(int i, String msg, boolean b) {
  37.                     System.out.println("connection failed");
  38.                     p2pService.sockets.remove(this);
  39.                 }
  41.                 @Override
  42.                 public void onError(Exception e) {
  43.                     System.out.println("connection failed");
  44.                     p2pService.sockets.remove(this);
  45.                 }
  46.             };
  47.             socketClient.connect();
  48.         } catch (URISyntaxException e) {
  49.             System.out.println("p2p connect is error:" + e.getMessage());
  50.         }
  51.     }
  55. }

服务端

  1. @Component("p2pServer")
  2. public class P2PServer {
  4.     //端口
  5.     @Value("${P2P_SERVER_PORT}")
  6.     private String P2P_SERVER_PORT;
  8.     @Autowired
  9.     private P2PService p2pService;
  11.     public void initP2PServer() {
  12.         int port = Integer.parseInt(P2P_SERVER_PORT);
  13.         System.out.println("PORT:"+port);
  14.         final WebSocketServer socketServer = new WebSocketServer(new InetSocketAddress(port)) {
  15.             public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {
  16.                 //write(webSocket, "服务端连接成功");
  17.                 p2pService.sockets.add(webSocket);
  18.             }
  20.             public void onClose(WebSocket webSocket, int i, String s, boolean b) {
  21.                 System.out.println("connection failed to peer:" + webSocket.getRemoteSocketAddress());
  22.                 p2pService.sockets.remove(webSocket);
  23.             }
  25.             public void onMessage(WebSocket webSocket, String msg) {
  26.                 System.out.println("接收到客户端消息：" + msg);
  27.                 p2pService.handleMessage(webSocket,msg);
  28.             }
  30.             public void onError(WebSocket webSocket, Exception e) {
  31.                 System.out.println("connection failed to peer:" + webSocket.getRemoteSocketAddress());
  32.                 p2pService.sockets.remove(webSocket);
  33.             }
  35.             public void onStart() {
  37.             }
  38.         };
  39.         socketServer.start();
  40.         System.out.println("listening websocket p2p port on: " + port);
  41.     }
  42. }

因为是点对点通信，所以自己又是客户端，又是服务端，当然对应的比特币的就是部署在服务器上的能够通过公网IP向外提供服务的全节点啦。
主要的实现逻辑是通过P2PService

  1. @Component("p2pService")
  2. public class P2PService {
  3.     public List<WebSocket> sockets = new ArrayList<WebSocket>();
  4.     private static Gson gson = new Gson();
  5.     @Autowired
  6.     private CommonService commonService;
  9.     /**
  10.      * 获取区块链
  11.      * @return
  12.      */
  13.     private String getBlockChain() {
  14.         Message message = new Message(Const.RESPONSE_BLOCKCHAIN);
  15.         message.setBody(commonService.blockChain);
  16.         return gson.toJson(message);
  17.     }
  18.     /**
  19.      * 获取未打包交易
  20.      * @return
  21.      */
  22.     private String getNotPackedTransactions() {
  23.         Message message = new Message(Const.RESPONSE_NOT_PACKET_TRANSACTIONS);
  24.         message.setBody(commonService.notPackedTransactions);
  25.         return gson.toJson(message);
  26.     }
  27.     /**
  28.      * 查询钱包的信息
  29.      * @return
  30.      */
  31.     private String getWallets() {
  32.         Message message = new Message(Const.RESPONSE_WALLETS);
  33.         message.setBody(commonService.wallets);
  34.         return gson.toJson(message);
  35.     }
  37.     /**
  38.      * 消息处理
  39.      * @param webSocket
  40.      * @param msg
  41.      */
  42.     public void handleMessage(WebSocket webSocket, String msg) {
  43.         //将msg转变成Message
  44.         Message  message =gson.fromJson(msg, Message.class);
  45.         System.out.println("服务器或者客户端收到的消息："+message);
  46.         Object body = message.getBody();
  47.         String str = gson.toJson(body);
  48.         switch (message.getType()) {
  49.             case Const.QUERY_BLOCKCHAIN:
  50.                 //客户端发来查询区块链的信息
  51.                 this.write(webSocket, getBlockChain());
  52.                 break;
  53.             case Const.QUERY_NOT_PACKET_TRANSACTIONS:
  54.                 //客户端发来查询未打包交易的信息
  55.                 this.write(webSocket, getNotPackedTransactions());
  56.                 break;
  57.             case Const.QUERY_WALLETS:
  58.                 //客户端发来查询钱包的信息
  59.                 this.write(webSocket, getWallets());
  60.                 break;
  61.             case Const.RESPONSE_BLOCKCHAIN:
  62.                 Type type =  new TypeToken<List<Block>>(){}.getType() ;
  63.                 List<Block> bc =  gson.fromJson(str, type);
  64.                 if(bc.size()>commonService.blockChain.size()) {
  65.                     commonService.blockChain = bc;
  66.                     System.out.println(commonService.blockChain );
  67.                 }
  68.                 break;
  69.             case Const.RESPONSE_NOT_PACKET_TRANSACTIONS:
  70.                 Type type2 =  new TypeToken<List<Transaction>>(){}.getType() ;
  71.                 commonService.notPackedTransactions = gson.fromJson(str,type2);
  72.                 System.out.println(commonService.notPackedTransactions );
  73.                 break;
  74.             case Const.RESPONSE_WALLETS:
  75.                 Type type3 =  new TypeToken<List<Wallet>>(){}.getType() ;
  76.                 commonService.wallets =  gson.fromJson(str,type3);
  77.                 System.out.println(commonService.wallets );
  78.                 break;
  79.             case Const.BROATCAST_BLOCK:
  80.                 //区块也一样
  81.                 Block block = gson.fromJson(str, Block.class);
  82.                 //先校验区块，获取区块的hash值
  83.                 String hash = block.getHash();
  84.                 block.setHash("");
  85.                 //用SHA256计算目标值
  86.                 String value = SHA256.encrypt(gson.toJson(block));
  88.                 if("0000".equals(value.substring(0, 4))&&hash.equals(value)) {
  89.                     //挖矿成功，获取当前最长的链
  90.                     if(commonService.blockChain.size()==0) {
  91.                         commonService.blockChain.add(block);
  92.                     }else {
  93.                         //检查是否在区块中
  94.                         boolean flag1 = false;
  95.                         for(Block b:commonService.blockChain) {
  96.                             if(b.getHash().equals(block.getHash())) {
  97.                                 //在区块中
  98.                                 flag1=true;
  99.                             }
  100.                         }
  102.                         if(!flag1) {
  104.                             //获取最后一个区块
  105.                             Block lastBlock = commonService.blockChain.get(commonService.blockChain.size()-1);
  106.                             if(Integer.parseInt(lastBlock.getIndex())+1==Integer.parseInt(block.getIndex())) {
  107.                                 //加入新的区块中
  108.                                  commonService.blockChain.add(block);
  109.                                  //广播出去
  110.                                 //把交易广播出去
  111.                                 //这里需要将该区块广播出去:
  112.                                 Message m = new Message(Const.BROATCAST_TRANSACTION);
  113.                                 m.setBody(block);
  114.                                 //不管是客户端还是服务器，全部广播
  115.                                 broatcast(gson.toJson(m));
  116.                             }else {
  117.                                 //获取最新的链
  118.                                 Message QUERY_BLOCKCHAIN = new Message(Const.QUERY_BLOCKCHAIN);
  119.                                 //向所有节点
  120.                                 broatcast(gson.toJson(QUERY_BLOCKCHAIN));
  121.                             }
  122.                         }
  124.                     }
  127.                 }
  129.                 break;
  130.             case Const.BROATCAST_TRANSACTION:
  131.                 Transaction transaction = gson.fromJson(str, Transaction.class);
  132.                 //先验证交易,先获取上一个交易
  133.                 System.out.println("transaction:"+transaction);
  134.                 Transaction preTransaction = commonService.preTransaction(transaction);
  135.                 System.out.println("preTransaction:"+preTransaction);
  136.                 Boolean check = transaction.verify(preTransaction);
  137.                 //交易正确
  138.                 if(check) {
  139.                     boolean flag1 = false;
  140.                     for(Transaction t:commonService.notPackedTransactions) {
  141.                         if(transaction.getId().equals(t.getId())) {
  142.                             //在未打包的交易中
  143.                             flag1=true;
  144.                         }
  145.                     }
  146.                     if(!flag1) {
  147.                         commonService.notPackedTransactions.add(transaction);
  148.                         //把交易广播出去
  149.                         //这里需要将该区块广播出去:
  150.                         Message m = new Message(Const.BROATCAST_TRANSACTION);
  151.                         m.setBody(transaction);
  152.                         //不管是客户端还是服务器，全部广播
  153.                         broatcast(gson.toJson(m));
  154.                     }
  155.                 }
  157.                 break;
  158.             case Const.BROATCAST_WALLET:
  159.                 Wallet wallet = gson.fromJson(str, Wallet.class);
  160.                 //检查该钱包有没有加入，若已经加入则不处理，否则加入钱包集合中，广播出去
  161.                 boolean flag = false;
  162.                 for(Wallet w:commonService.wallets) {
  163.                     if(w.getAdress().equals(wallet.getAdress())) {
  164.                         //在钱包中
  165.                         flag=true;
  166.                     }
  167.                 }
  168.                 if(!flag) {
  169.                     //加入钱包
  170.                     commonService.wallets.add(wallet);
  171.                     //广播出去，这里要给把自己当作服务其的用户广播
  172.                     //这里需要将该钱包广播出去:
  173.                     Message m = new Message(Const.BROATCAST_WALLET);
  174.                     m.setBody(wallet);
  175.                     //这里不需要过滤掉客户端，因为都会做上面的逻辑判断，如果钱包已经在集合中了就
  176.                     //不会再加入，也不会再广播，当然为了提高效率也可以做个过滤
  177.                     broatcast(gson.toJson(message));
  178.                 }
  179.                 break;
  180.         }
  181.     }
  183.     public void write(WebSocket ws, String message) {
  184.         System.out.println("发送给" + ws.getRemoteSocketAddress().getPort() + "的p2p消息:" + message);
  185.         ws.send(message);
  186.     }
  187.     public void broatcast(String message) {
  188.         if (sockets.size() == 0) {
  189.             return;
  190.         }
  191.         System.out.println("======广播消息开始：");
  192.         for (WebSocket socket : sockets) {
  193.             this.write(socket, message);
  194.         }
  195.         System.out.println("======广播消息结束");
  196.     }
  197. }

然后我们看下springboot引用的相关包

  1. <parent>
  2.       <groupId>org.springframework.boot</groupId>
  3.       <artifactId>spring-boot-starter-parent</artifactId>
  4.       <version>2.0.5.RELEASE</version>
  5.   </parent>
  6.   <dependencies>
  7.       <dependency>
  8.           <groupId>org.springframework.boot</groupId>
  9.           <artifactId>spring-boot-starter-web</artifactId>
  10.       </dependency>
  11.       <dependency>
  12.         <groupId>org.springframework.boot</groupId>  
  13.         <artifactId>spring-boot-starter-freemarker</artifactId>  
  14.       </dependency>
  17.      <!-- AOP依赖 -->
  18.     <dependency>
  19.             <groupId>org.springframework.boot</groupId>
  20.             <artifactId>spring-boot-starter-aop</artifactId>
  21.     </dependency>
  23.       <dependency>
  24.           <groupId>com.google.code.gson</groupId>
  25.           <artifactId>gson</artifactId>
  26.       </dependency>
  27.       <dependency>
  28.         <groupId>commons-lang</groupId>
  29.         <artifactId>commons-lang</artifactId>
  30.         <version>2.6</version>
  31.     </dependency>
  33.       <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
  34. <dependency>
  35.     <groupId>org.apache.httpcomponents</groupId>
  36.     <artifactId>httpclient</artifactId>
  37.     <version>4.5.5</version>
  38. </dependency>
  40.       <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
  41. <dependency>
  42.     <groupId>org.apache.httpcomponents</groupId>
  43.     <artifactId>httpcore</artifactId>
  44.     <version>4.4.9</version>
  45. </dependency>
  46.       <!-- email -->
  47.     <dependency>
  48.         <groupId>org.apache.commons</groupId>
  49.         <artifactId>commons-email</artifactId>
  50.         <version>1.4</version>
  51.     </dependency>
  53.           <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
  54.     <dependency>
  55.         <groupId>dom4j</groupId>
  56.         <artifactId>dom4j</artifactId>
  57.         <version>1.6.1</version>
  58.     </dependency>
  59.     <!-- https://mvnrepository.com/artifact/org.java-websocket/Java-WebSocket -->
  60. <dependency>
  61.     <groupId>org.java-websocket</groupId>
  62.     <artifactId>Java-WebSocket</artifactId>
  63.     <version>1.5.2</version>
  64. </dependency>

以及配置文件

  1. ###服务启动端口号
  2. server:
  3.   ###节点1 
  4.   #port: 8001
  5.   ###节点2
  6.   port: 8002
  7.   servlet:
  8.     session:
  9.       timeout: 7200
  10.   max-http-header-size: 10000000
  11.   tomcat: 
  12.     basedir: temp
  13. spring:
  14.   servlet:
  15.     multipart: 
  16.       max-file-size: 10MB 
  17.       max-request-size: 100MB
  18.   application:
  19.     name: miniblog
  21. ###当前p2p服务端口号：节点1
  22. #P2P_SERVER_PORT: 7001
  23. ###p2p服务
  24. #P2P_CLIENT_PEER: 
  27. ###当前p2p服务端口号：节点2
  28. P2P_SERVER_PORT: 7002
  29. ###p2p服务
  30. P2P_CLIENT_PEER: ws://127.0.0.1:7001

3、启动测试的方式为

修改配置文件，将节点1的端口以及websocket的端口放开，启动完后切换到节点2的端口，然后访问如下api即可。

  1. #节点1
  2. http://localhost:8001/getWallet 获得钱包
  3. http://localhost:8001/mine 挖矿
  4. http://localhost:8001/balance 查询余额
  5. http://localhost:8001/getBlockChain 获得区块链
  6. http://localhost:8001/transaction?value=10&address=751f520e1a3c3de161003a32b616d03d 交易
  8. #节点2
  9. http://localhost:8002/getWallet 获得钱包
  10. http://localhost:8002/mine 挖矿
  11. http://localhost:8002/balance 查询余额
  12. http://localhost:8002/getBlockChain 获得区块链

转账后必须通过挖矿才能生效。

好了一个特别简陋，没有完善的区块链原型就实现了，当然应该还有无数的漏洞。
有兴趣可以参考下：https://www.suibibk.com/fileupload/files/minichain.zip

 807

啊！这个可能是世界上最丑的留言输入框功能~


当然，也是最丑的留言列表

有疑问发邮件到 : suibibk@qq.com 侵权立删
Copyright : 个人随笔   备案号 : 粤ICP备18099399号-2