心神沫沫
心神沫沫

使用Java语言从零开始创建区块链 侵立删

转自：https://mp.weixin.qq.com/s/oBc5P3_ZywmCv4wGmiY12w

 

目前网络上关于区块链入门、科普的文章不少，本文就不再赘述区块链的基本概念了，如果对区块链不是很了解的话，可以看一下我之前收集的一些入门学习资源：http://blog.51cto.com/zero01/2066321

 

对区块链技术感到新奇的我们，都想知道区块链在代码上是怎么实现的，所以本文是实战向的，毕竟理论我们都看了不少，但是对于区块链具体的实现还不是很清楚，本文就使用Java语言来实现一个简单的区块链。

 

但是要完全搞懂区块链并非易事，对于一门较为陌生的技术，我们需要在理论+实践中学习，通过写代码来学习技术会掌握得更牢固，构建一个区块链可以加深对区块链的理解。

 

准备工作

 

掌握基本的JavaSE以及JavaWeb开发，能够使用Java开发简单的项目，并且需要了解HTTP协议。

 

我们知道区块链是由区块的记录构成的不可变、有序的链结构，记录可以是交易、文件或任何你想要的数据，重要的是它们是通过哈希值（hashes）链接起来的。

 

如果你还不是很了解哈希是什么，可以查看这篇文章：https://learncryptography.com/hash-functions/what-are-hash-functions

 

环境描述

 

  • JDK1.8

  • Tomcat 9.0

  • Maven 3.5

  • JSON 20160810

  • javaee-api 7.0

 

pom.xml文件配置内容：

 


       
           javax
           javaee-api
           7.0
           provided
       
       
           org.json
           json
           20160810
       
   

 

然后还需要一个HTTP客户端，比如Postman，Linux命令行下的curl或其它客户端，我这里使用的是Postman。

 

Blockchain类


首先创建一个Blockchain类，在构造器中创建了两个主要的集合，一个用于储存区块链，一个用于储存交易列表，本文中所有核心的主要代码都写在这个类里，方便随时查看，在实际开发则不宜这么做，应该把代码拆分仔细降低耦合度。

 

以下是Blockchain类的框架代码：

 

package org.zero01.core;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class BlockChain {

   // 存储区块链
   private List chain;
   // 该实例变量用于当前的交易信息列表
   private List currentTransactions;

   public BlockChain() {
       // 初始化区块链以及当前的交易信息列表
       this.chain = new ArrayList();
       this.currentTransactions= new ArrayList();
   }

   public List getChain() {
       return chain;
   }

   public void setChain(List chain) {
       this.chain = chain;
   }

   public List getCurrentTransactions() {
       return currentTransactions;
   }

   public void setCurrentTransactions(List currentTransactions) {
       this.currentTransactions = currentTransactions;
   }

   public Object lastBlock() {
       return null;
   }

   public HashMap newBlock() {
       return null;
   }

   public int newTransactions() {
       return 0;
   }

   public static Object hash(HashMap block) {
       return null;
   }
} 
  
 
 
  
Blockchain类用来管理区块链，它能存储交易，加入新块等，下面我们来进一步完善这些方法。
 
  
 
 
  
区块的结构
 
  
 
 
  
首先需要说明一下区块的结构，每个区块包含属性：索引（index），时间戳（timestamp），交易列表（transactions），工作量证明（稍后解释）以及前一个区块的Hash值。
 
  
 
 
  
以下是一个区块的结构：
 
  
 
 
  
block = {
   'index': 1,
   'timestamp': 1506057125.900785,
   'transactions': [
       {
           'sender': "8527147fe1f5426f9dd545de4b27ee00",
           'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
           'amount': 5,
       }
   ],
   'proof': 324984774000,
   'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}
 
  
 
 
  
到这里，区块链的概念就清楚了，每个新的区块都包含上一个区块的Hash，这是关键的一点，它保障了区块链不可变性。如果***者破坏了前面的某个区块，那么后面所有区块的Hash都会变得不正确。不理解的话，慢慢消化，可以参考区块链记账原理（https://learnblockchain.cn/2017/10/25/whatbc/）。
 
  
 
 
  
由于需要计算区块的hash，所以我们得先编写一个用于计算hash值的工具类：
 
  
 
 
  
package org.zero01.util;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Encrypt {

   /**
    * 传入字符串，返回 SHA-256 加密字符串
    * 
    * @param strText
    * @return
    */
   public String getSHA256(final String strText) {
       return SHA(strText, "SHA-256");
   }

   /**
    * 传入字符串，返回 SHA-512 加密字符串
    * 
    * @param strText
    * @return
    */
   public String getSHA512(final String strText) {
       return SHA(strText, "SHA-512");
   }

   /**
    * 传入字符串，返回 MD5 加密字符串
    * 
    * @param strText
    * @return
    */
   public String getMD5(final String strText) {
       return SHA(strText, "SHA-512");
   }

   /**
    * 字符串 SHA 加密
    * 
    * @param strSourceText
    * @return
    */
   private String SHA(final String strText, final String strType) {
       // 返回值
       String strResult = null;

       // 是否是有效字符串
       if (strText != null && strText.length() > 0) {
           try {
               // SHA 加密开始
               // 创建加密对象，传入加密类型
               MessageDigest messageDigest = MessageDigest.getInstance(strType);
               // 传入要加密的字符串
               messageDigest.update(strText.getBytes());
               // 得到 byte 数组
               byte byteBuffer[] = messageDigest.digest();

               // 將 byte 数组转换 string 类型
               StringBuffer strHexString = new StringBuffer();
               // 遍历 byte 数组
               for (int i = 0; i < byteBuffer.length; i++) {
                   // 转换成16进制并存储在字符串中
                   String hex = Integer.toHexString(0xff & byteBuffer[i]);
                   if (hex.length() == 1) {
                       strHexString.append('0');
                   }
                   strHexString.append(hex);
               }
               // 得到返回結果
               strResult = strHexString.toString();
           } catch (NoSuchAlgorithmException e) {
               e.printStackTrace();
           }
       }

       return strResult;
   }
}
 
  
 
 
  
加入交易功能
 
  
 
 
  
接下来我们需要实现一个交易\记账功能，所以来完善newTransactions以及lastBlock方法：
 
  
 
 
  
/**
    * @return 得到区块链中的最后一个区块
    */
   public HashMap lastBlock() {
       return getChain().get(getChain().size() - 1);
   }

   /**
    * 生成新交易信息，信息将加入到下一个待挖的区块中
    * 
    * @param sender
    *            发送方的地址
    * @param recipient
    *            接收方的地址
    * @param amount
    *            交易数量
    * @return 返回存储该交易事务的块的索引
    */
   public int newTransactions(String sender, String recipient, long amount) {

       Map transaction = new HashMap();
       transaction.put("sender", sender);
       transaction.put("recipient", recipient);
       transaction.put("amount", amount);

       getCurrentTransactions().add(transaction);

       return (Integer) lastBlock().get("index") + 1;
   }
 
  
 
 
  
newTransactions方法向列表中添加一个交易记录，并返回该记录将被添加到的区块 (下一个待挖掘的区块)的索引，等下在用户提交交易时会有用。
 
  
 
 
  
创建新块
 
  
 
 
  
当Blockchain实例化后，我们需要构造一个创世区块（没有前区块的第一个区块），并且给它加上一个工作量证明。
  
 
  
每个区块都需要经过工作量证明，俗称挖矿，稍后会继续讲解。
 
  
 
 
  
为了构造创世块，我们还需要完善剩下的几个方法，并且把该类设计为单例：
 
  
 
 
  
package org.zero01.dao;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.json.JSONObject;
import org.zero01.util.Encrypt;

public class BlockChain {

   // 存储区块链
   private List> chain;
   // 该实例变量用于当前的交易信息列表
   private List> currentTransactions;
   private static BlockChain blockChain = null;

   private BlockChain() {
       // 初始化区块链以及当前的交易信息列表
       chain = new ArrayList>();
       currentTransactions = new ArrayList>();

       // 创建创世区块
       newBlock(100, "0");
   }

   // 创建单例对象
   public static BlockChain getInstance() {
       if (blockChain == null) {
           synchronized (BlockChain.class) {
               if (blockChain == null) {
                   blockChain = new BlockChain();
               }
           }
       }
       return blockChain;
   }

   public List> getChain() {
       return chain;
   }

   public void setChain(List> chain) {
       this.chain = chain;
   }

   public List> getCurrentTransactions() {
       return currentTransactions;
   }

   public void setCurrentTransactions(List> currentTransactions) {
       this.currentTransactions = currentTransactions;
   }

   /**
    * @return 得到区块链中的最后一个区块
    */
   public Map lastBlock() {
       return getChain().get(getChain().size() - 1);
   }

   /**
    * 在区块链上新建一个区块
    * 
    * @param proof
    *            新区块的工作量证明
    * @param previous_hash
    *            上一个区块的hash值
    * @return 返回新建的区块
    */
   public Map newBlock(long proof, String previous_hash) {

       Map block = new HashMap();
       block.put("index", getChain().size() + 1);
       block.put("timestamp", System.currentTimeMillis());
       block.put("transactions", getCurrentTransactions());
       block.put("proof", proof);
       // 如果没有传递上一个区块的hash就计算出区块链中最后一个区块的hash
       block.put("previous_hash", previous_hash != null ? previous_hash : hash(getChain().get(getChain().size() - 1)));

       // 重置当前的交易信息列表
       setCurrentTransactions(new ArrayList>());

       getChain().add(block);

       return block;
   }

   /**
    * 生成新交易信息，信息将加入到下一个待挖的区块中
    * 
    * @param sender
    *            发送方的地址
    * @param recipient
    *            接收方的地址
    * @param amount
    *            交易数量
    * @return 返回该交易事务的块的索引
    */
   public int newTransactions(String sender, String recipient, long amount) {

       Map transaction = new HashMap();
       transaction.put("sender", sender);
       transaction.put("recipient", recipient);
       transaction.put("amount", amount);

       getCurrentTransactions().add(transaction);

       return (Integer) lastBlock().get("index") + 1;
   }

   /**
    * 生成区块的 SHA-256格式的 hash值
    * 
    * @param block
    *            区块
    * @return 返回该区块的hash
    */
   public static Object hash(Map block) {
       return new Encrypt().getSHA256(new JSONObject(block).toString());
   }
}
 
  
 
 
  
通过上面的代码和注释可以对区块链有直观的了解，接下来我们来编写一些简单的测试代码来测试一下这些代码能否正常工作：
 
  
 
 
  
package org.zero01.test;

import java.util.HashMap;
import java.util.Map;

import org.json.JSONObject;
import org.zero01.dao.BlockChain;

public class Test {

   public static void main(String[] args) throws Exception {

       BlockChain blockChain = BlockChain.getInstance();

       // 一个区块中可以不包含任何交易记录
       Map block = blockChain.newBlock(300, null);
       System.out.println(new JSONObject(block));

       // 一个区块中可以包含一笔交易记录
       blockChain.newTransactions("123", "222", 33);
       Map block1 = blockChain.newBlock(500, null);
       System.out.println(new JSONObject(block1));

       // 一个区块中可以包含多笔交易记录
       blockChain.newTransactions("321", "555", 133);
       blockChain.newTransactions("000", "111", 10);
       blockChain.newTransactions("789", "369", 65);
       Map block2 = blockChain.newBlock(600, null);
       System.out.println(new JSONObject(block2));

       // 查看整个区块链
       Map chain = new HashMap();
       chain.put("chain", blockChain.getChain());
       chain.put("length", blockChain.getChain().size());
       System.out.println(new JSONObject(chain));
   }
}
 
  
 
 
  
运行结果：
 
  
 
 
  
// 挖出来的新区块
{
   "index": 2,
   "transactions": [],
   "proof": 300,
   "timestamp": 1519478559703,
   "previous_hash": "185b62ca1fc31285bce8878acfc970983cb561f19c63b65120d2c95148cf151f"
}

// 包含一笔交易的区块
{
   "index": 3,
   "transactions": [
       {
           "amount": 33,
           "sender": "123",
           "recipient": "222"
       }
   ],
   "proof": 500,
   "timestamp": 1519478559728,
   "previous_hash": "bce15693c0a028b1fc6d7d1c1d30494f97ef37b8b3384865559ceed9b5ff798b"
}

// 包含多笔交易的区块
{
   "index": 4,
   "transactions": [
       {
           "amount": 133,
           "sender": "321",
           "recipient": "555"
       },
       {
           "amount": 10,
           "sender": "000",
           "recipient": "111"
       },
       {
           "amount": 65,
           "sender": "789",
           "recipient": "369"
       }
   ],
   "proof": 600,
   "timestamp": 1519478656178,
   "previous_hash": "b0edde645f76fc3a6cb45b7c91b07b686e8e214cfc1dea4823bf38bda37c909c"
}

// 整个区块链，第一个是创始区块
{
   "chain": [
       {
           "index": 1,
           "transactions": [],
           "proof": 100,
           "timestamp": 1519478656153,
           "previous_hash": "0"
       },
       {
           "index": 2,
           "transactions": [],
           "proof": 300,
           "timestamp": 1519478656154,
           "previous_hash": "7925a01fa8cb67b51ea89b9cfcfa16c5febee008bb559f94c5758418e7acc670"
       },
       {
           "index": 3,
           "transactions": [
               {
                   "amount": 33,
                   "sender": "123",
                   "recipient": "222"
               }
           ],
           "proof": 500,
           "timestamp": 1519478656178,
           "previous_hash": "40ccc2f4ad97f75cb611ed69a4ecc7438eefd31afca17ca00c2ed7b5163d0831"
       },
       {
           "index": 4,
           "transactions": [
               {
                   "amount": 133,
                   "sender": "321",
                   "recipient": "555"
               },
               {
                   "amount": 10,
                   "sender": "000",
                   "recipient": "111"
               },
               {
                   "amount": 65,
                   "sender": "789",
                   "recipient": "369"
               }
           ],
           "proof": 600,
           "timestamp": 1519478656178,
           "previous_hash": "b0edde645f76fc3a6cb45b7c91b07b686e8e214cfc1dea4823bf38bda37c909c"
       }
   ],
   "length": 4
}
 
  
 
 
  
通过以上的测试，可以很直观的看到区块链的数据，但是现在只是完成了初步的代码编写，还有几件事情还没做，接下来我们看看区块是怎么挖出来的。
 
  
 
 
  
理解工作量证明
 
  

 新的区块依赖工作量证明算法（PoW）来构造。PoW的目标是找出一个符合特定条件的数字，这个数字很难计算出来，但容易验证。这就是工作量证明的核心思想。
 
  
 
 
  
为了方便理解，举个例子：
 
  
 
 
  
假设一个整数 x 乘以另一个整数 y 的积的 Hash 值必须以 0 结尾，即 hash(x * y) = ac23dc…0。设变量 x = 5，求 y 的值？
 
  
 
 
  
用Java实现如下：
 
  
 
 
  
package org.zero01.test;

import org.zero01.util.Encrypt;

public class TestProof {

   public static void main(String[] args) {

       int x = 5;
       int y = 0;

       while (!new Encrypt().getSHA256((x * y) + "").endsWith("0")) {
           y++;
       }

       System.out.println("y=" + y);
   }
}
 
  
 
 
  
结果是 y=21 ，因为：
 
  
 
 
  
hash(5 * 21) = 1253e9373e...5e3600155e860
 
  
 
 
  
在比特币中，使用称为Hashcash的工作量证明算法，它和上面的问题很类似。矿工们为了争夺创建区块的权利而争相计算结果。通常，计算难度与目标字符串需要满足的特定字符的数量成正比，矿工算出结果后，会获得比特币奖励。
 
  

 当然，在网络上非常容易验证这个结果。
 
  
 
 
  
实现工作量证明
 
  

 让我们来实现一个相似PoW算法，规则是：寻找一个数 p，使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头：
 
  
 
 
  
...
   /**
    * 简单的工作量证明: 
    *   - 查找一个 p' 使得 hash(pp') 以4个0开头 
    *   - p 是上一个块的证明, p' 是当前的证明
    *   
    * @param last_proof
    *               上一个块的证明
    * @return
    */
   public long proofOfWork(long last_proof) {
       long proof = 0;
       while (!validProof(last_proof, proof)) {
           proof += 1;
       }
       return proof;
   }

   /**
    * 验证证明: 是否hash(last_proof, proof)以4个0开头?
    * 
    * @param last_proof
    *            上一个块的证明
    * @param proof
    *            当前的证明
    * @return 以4个0开头返回true，否则返回false
    */
   public boolean validProof(long last_proof, long proof) {
       String guess = last_proof + "" + proof;
       String guess_hash = new Encrypt().getSHA256(guess);
       return guess_hash.startsWith("0000");
   }
 
  
 
 
  
衡量算法复杂度的办法是修改零开头的个数。使用4个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。
 
  
 
 
  
现在Blockchain类基本已经完成了，接下来使用Servlet接收HTTP请求来进行交互。
 
  
 
 
  
Blockchain作为API接口
 
  

 我们将使用Java Web中的Servlet来接收用户的HTTP请求，通过Servlet我们可以方便的将网络请求的数据映射到相应的方法上进行处理，现在我们来让Blockchain运行在基于Java Web上。
 
  
 
 
  
我们将创建三个接口：
 
  
 
 
  
     
   
  •  
    /transactions/new 创建一个交易并添加到区块
     
    •  
   
  •  
    /mine 告诉服务器去挖掘新的区块
     
    •  
   
  •  
    /chain 返回整个区块链
     
    •  
  
 
  
 
 
  
注册节点ID
 
  

 我们的“Tomcat服务器”将扮演区块链网络中的一个节点，而每个节点都需要有一个唯一的标识符，也就是id。在这里我们使用UUID来作为节点ID，我们需要在服务器启动时，将UUID设置到ServletContext属性中，这样我们的服务器就拥有了唯一标识，这一步我们可以配置监听类来完成，首先配置web.xml文件内容如下：
 
  
 
 
  



   
       org.zero01.servlet.InitialID
   


 
  
 
 
  
然后编写一个类实现ServletContextListener接口，在初始化方法中把uuid设置到ServletContext的属性中：
 
  
 
 
  
package org.zero01.servlet;

import java.util.UUID;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class InitialID implements ServletContextListener {

   public void contextInitialized(ServletContextEvent sce) {
       ServletContext servletContext = sce.getServletContext();
       String uuid = UUID.randomUUID().toString().replace("-", "");
       servletContext.setAttribute("uuid", uuid);
   }

   public void contextDestroyed(ServletContextEvent sce) {
   }
}
 
  
 
 
  
创建Servlet类
 
  

 我们这里没有使用任何框架，所以我们需要通过最基本的Servlet来接收并处理用户的HTTP请求：
 
  
 
 
  
package org.zero01.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 该Servlet用于运行工作算法的证明来获得下一个证明，也就是所谓的挖矿
@WebServlet("/mine")
public class Mine extends HttpServlet{

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   }
}

package org.zero01.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 该Servlet用于接收并处理新的交易信息
@WebServlet("/transactions/new")
public class NewTransaction extends HttpServlet{

   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   }
}

package org.zero01.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 该Servlet用于输出整个区块链的数据
@WebServlet("/chain")
public class FullChain extends HttpServlet{

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   }
}
 
  
 
 
  
我们先来完成最简单的FullChain的代码，这个Servlet用于向客户端输出整个区块链的数据（JSON格式）：
 
  
 
 
  
package org.zero01.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.json.JSONObject;
import org.zero01.core.BlockChain;

// 该Servlet用于输出整个区块链的数据
@WebServlet("/chain")
public class FullChain extends HttpServlet {

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       BlockChain blockChain = BlockChain.getInstance();
       Map response = new HashMap();
       response.put("chain", blockChain.getChain());
       response.put("length", blockChain.getChain().size());

       JSONObject jsonResponse = new JSONObject(response);
       resp.setContentType("application/json");
       PrintWriter printWriter = resp.getWriter();
       printWriter.println(jsonResponse);
       printWriter.close();
   }
}
 
  
 
 
  
发送交易
 
  

 然后是记录交易数据的功能，每一个区块都可以记录交易数据，发送到节点的交易数据结构如下：
 
  
 
 
  
{
"sender": "my address",
"recipient": "someone else's address",
"amount": 5
}
 
  
 
 
  
实现代码如下：
 
  
 
 
  
package org.zero01.servlet;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.json.JSONObject;
import org.zero01.core.BlockChain;

// 该Servlet用于接收并处理新的交易信息
@WebServlet("/transactions/new")
public class NewTransaction extends HttpServlet {

   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

       req.setCharacterEncoding("utf-8");
       // 读取客户端传递过来的数据并转换成JSON格式
       BufferedReader reader = req.getReader();
       String input = null;
       StringBuffer requestBody = new StringBuffer();
       while ((input = reader.readLine()) != null) {
           requestBody.append(input);
       }
       JSONObject jsonValues = new JSONObject(requestBody.toString());

       // 检查所需要的字段是否位于POST的data中
       String[] required = { "sender", "recipient", "amount" };
       for (String string : required) {
           if (!jsonValues.has(string)) {
               // 如果没有需要的字段就返回错误信息
               resp.sendError(400, "Missing values");
           }
       }

       // 新建交易信息
       BlockChain blockChain = BlockChain.getInstance();
       int index = blockChain.newTransactions(jsonValues.getString("sender"), jsonValues.getString("recipient"),
               jsonValues.getLong("amount"));

       // 返回json格式的数据给客户端
       resp.setContentType("application/json");
       PrintWriter printWriter = resp.getWriter();
       printWriter.println(new JSONObject().append("message", "Transaction will be added to Block " + index));
       printWriter.close();
   }
}
 
  
 
 
  
挖矿
 
  

 挖矿正是神奇所在，它很简单，只做了以下三件事：
 
  
 
 
  
     
   
  •  
    计算工作量证明PoW
     
    •  
   
  •  
    通过新增一个交易授予矿工（自己）一个币
     
    •  
   
  •  
    构造新区块并将其添加到链中
     
    •  
  
 
  
 
 
  
代码实现如下：
 
  
 
 
  
package org.zero01.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.json.JSONObject;
import org.zero01.core.BlockChain;

//该Servlet用于运行工作算法的证明来获得下一个证明，也就是所谓的挖矿
@WebServlet("/mine")
public class Mine extends HttpServlet {

   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       BlockChain blockChain = BlockChain.getInstance();
       Map lastBlock = blockChain.lastBlock();
       long lastProof = Long.parseLong(lastBlock.get("proof") + "");
       long proof = blockChain.proofOfWork(lastProof);

       // 给工作量证明的节点提供奖励，发送者为 "0" 表明是新挖出的币
       String uuid = (String) this.getServletContext().getAttribute("uuid");
       blockChain.newTransactions("0", uuid, 1);

       // 构建新的区块
       Map newBlock = blockChain.newBlock(proof, null);
       Map response = new HashMap();
       response.put("message", "New Block Forged");
       response.put("index", newBlock.get("index"));
       response.put("transactions", newBlock.get("transactions"));
       response.put("proof", newBlock.get("proof"));
       response.put("previous_hash", newBlock.get("previous_hash"));

       // 返回新区块的数据给客户端
       resp.setContentType("application/json");
       PrintWriter printWriter = resp.getWriter();
       printWriter.println(new JSONObject(response));
       printWriter.close();
   }
}
 
  
 
 
  
注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕Blockchain类的方法进行交互。到此，我们的区块链就算完成了，我们来实际运行下。
 
  
 
 
  
运行区块链
 
  

 由于我们这里也没有写前端的web页面，只写了后端的API，所以只能使用 Postman 之类的软件去和API进行交互。首先启动Tomcat服务器，然后通过post请求 http://localhost:8089/BlockChain_Java/transactions/new 来添加新的交易信息（注意我这里没有使用默认的8080端口，默认的情况下是8080端口）：
 
  

使用Java语言从零开始创建区块链 侵立删_第1张图片
 
  
但是这时候还没有新的区块可以写入这个交易信息，所以我们还需要请求 http://localhost:8089/BlockChain_Java/mine 来进行挖矿，挖出一个新的区块来存储这笔交易：
 
  

使用Java语言从零开始创建区块链 侵立删_第2张图片
 
  
在挖了两次矿之后，就有3个块了，通过请求 http://localhost:8089/BlockChain_Java/chain 可以得到所有的区块块的信息：
 
  
 
 
  
{
   "chain": [
       {
           "index": 1,
           "proof": 100,
           "transactions": [],
           "timestamp": 1520928588165,
           "previous_hash": "0"
       },
       {
           "index": 2,
           "proof": 35293,
           "transactions": [
               {
                   "amount": 6,
                   "sender": "d4ee26eee15148ee92c6cd394edd974e",
                   "recipient": "someone-other-address"
               },
               {
                   "amount": 1,
                   "sender": "0",
                   "recipient": "050bbfe4ad644d008545ff490387a889"
               }
           ],
           "timestamp": 1520928734580,
           "previous_hash": "e5cf7ba38f7f0c3a93fcca5d57b624c8fd255093af4abe3c6999be61bdb81040"
       },
       {
           "index": 3,
           "proof": 35089,
           "transactions": [
               {
                   "amount": 1,
                   "sender": "0",
                   "recipient": "050bbfe4ad644d008545ff490387a889"
               }
           ],
           "timestamp": 1520928870963,
           "previous_hash": "aa64ab003d15d50a43bd59deb88c939ea43349d00d0b653abd83b42e8fa4417c"
       }
   ],
   "length": 3
}
 
  
 
 
  
一致性（共识）
 
  

 我们已经有了一个基本的区块链可以接受交易和挖矿。但是区块链系统应该是分布式的。既然是分布式的，那么我们究竟拿什么保证所有节点有同样的链呢？这就是一致性问题，我们要想在网络上有多个节点，就必须实现一个一致性的算法。
 
  
 
 
  
注册节点
 
  

 在实现一致性算法之前，我们需要找到一种方式让一个节点知道它相邻的节点。每个节点都需要保存一份包含网络中其它节点的记录。因此让我们新增几个接口：
 
  
 
 
  
     
   
  •  
    /nodes/register 接收URL形式的新节点列表
     
    •  
   
  •  
    /nodes/resolve执行一致性算法，解决任何冲突，确保节点拥有正确的链
     
    •  
  
 
  
 
 
  
我们需要修改下BlockChain的构造函数并提供一个注册节点方法：
 
  
 
 
  
package org.zero01.core;
...
import java.net.URL;
...

   private Set nodes;
   private BlockChain() {
       ...
       // 用于存储网络中其他节点的集合
       nodes = new HashSet();
       ...
   }

   public Set getNodes() {
       return nodes;
   }

   /**
    * 注册节点
    * 
    * @param address
    *            节点地址
    * @throws MalformedURLException
    */
   public void registerNode(String address) throws MalformedURLException {
       URL url = new URL(address);
       String node = url.getHost() + ":" + (url.getPort() == -1 ? url.getDefaultPort() : url.getPort());
       nodes.add(node);
   }
   ...
 
  
 
 
  
我们用 HashSet 集合来储存节点，这是一种避免出现重复添加节点的简单方法。
 
  
 
 
  
实现共识算法
 
  

 前面提到，冲突是指不同的节点拥有不同的链，为了解决这个问题，规定最长的、有效的链才是最终的链，换句话说，网络中有效最长链才是实际的链。
 
  
 
 
  
我们使用以下算法，来达到网络中的共识：
 
  
 
 
  
...
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
...

public class BlockChain {
   ...
   /**
    * 检查是否是有效链，遍历每个区块验证hash和proof，来确定一个给定的区块链是否有效
    * 
    * @param chain
    * @return
    */
   public boolean validChain(List> chain) {
       Map lastBlock = chain.get(0);
       int currentIndex = 1;
       while (currentIndex < chain.size()) {
           Map block = chain.get(currentIndex);
           System.out.println(lastBlock.toString());
           System.out.println(block.toString());
           System.out.println("\n-------------------------\n");

           // 检查block的hash是否正确
           if (!block.get("previous_hash").equals(hash(lastBlock))) {
               return false;
           }

           lastBlock = block;
           currentIndex++;
       }
       return true;
   }

   /**
    * 共识算法解决冲突，使用网络中最长的链. 遍历所有的邻居节点，并用上一个方法检查链的有效性， 如果发现有效更长链，就替换掉自己的链
    * 
    * @return 如果链被取代返回true, 否则返回false
    * @throws IOException
    */
   public boolean resolveConflicts() throws IOException {
       Set neighbours = this.nodes;
       List> newChain = null;

       // 寻找最长的区块链
       long maxLength = this.chain.size();

       // 获取并验证网络中的所有节点的区块链
       for (String node : neighbours) {

           URL url = new URL("http://" + node + "/BlockChain_Java/chain");
           HttpURLConnection connection = (HttpURLConnection) url.openConnection();
           connection.connect();

           if (connection.getResponseCode() == 200) {
               BufferedReader bufferedReader = new BufferedReader(
                       new InputStreamReader(connection.getInputStream(), "utf-8"));
               StringBuffer responseData = new StringBuffer();
               String response = null;
               while ((response = bufferedReader.readLine()) != null) {
                   responseData.append(response);
               }
               bufferedReader.close();

               JSONObject jsonData = new JSONObject(bufferedReader.toString());
               long length = jsonData.getLong("length");
               List> chain = (List) jsonData.getJSONArray("chain").toList();

               // 检查长度是否长，链是否有效
               if (length > maxLength && validChain(chain)) {
                   maxLength = length;
                   newChain = chain;
               }
           }

       }
       // 如果发现一个新的有效链比我们的长，就替换当前的链
       if (newChain != null) {
           this.chain = newChain;
           return true;
       }
       return false;
   }
   ...
 
  
 
 
  
第一个方法 validChain() 用来检查是否是有效链，遍历每个块验证hash和proof.
 
  
 
 
  
第2个方法 resolveConflicts() 用来解决冲突，遍历所有的邻居节点，并用上一个方法检查链的有效性， 如果发现有效更长链，就替换掉自己的链
 
  
 
 
  
让我们添加两个Servlet，一个用来注册节点，一个用来解决冲突：
 
  
 
 
  
我们可以在不同的机器运行节点，或在一台机机开启不同的网络端口来模拟多节点的网络，这里在同一台机器开启不同的端口演示，配置两个不同端口的服务器即可，我这里启动了两个节点：http://localhost:8089 和 http://localhost:8066。
 
  
 
 
  
两个节点互相进行注册：
 
  

使用Java语言从零开始创建区块链 侵立删_第3张图片
使用Java语言从零开始创建区块链 侵立删_第4张图片
 
  
然后在8066节点上挖两个块，确保是更长的链：
 
  

使用Java语言从零开始创建区块链 侵立删_第5张图片
 
  
接着在8089节点上访问接口/nodes/resolve ，这时8089节点的链会通过共识算法被8066节点的链取代：
 
  

使用Java语言从零开始创建区块链 侵立删_第6张图片
 
  
通过共识算法保持一致性后，两个节点的区块链数据就都是一致的了：
 
  

使用Java语言从零开始创建区块链 侵立删_第7张图片
使用Java语言从零开始创建区块链 侵立删_第8张图片
 
  
到此为止我们就完成了一个区块链的开发，虽然这只是一个最基本的区块链，而且在开发的过程中也没有考虑太多的程序设计方面的问题，而是以最基本、原始的方式进行开发的。但是我们不妨以这个简单的区块链为基础，发挥自己的能力动手去重构、扩展、完善这个区块链程序，直至成为自己的一个小项目。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(网文干货)

        

            

                
    
                    
  • 为什么你的小说总是会扑？很大可能是你不会写开头！
                        暴走网文圈

                        
    几年前，当很多写文新人找到我，并告诉我说，自己的小说扑街了。依稀记得，当时我是这么做的。我二话不说，直接问了句，“你是不是没按照我给你的方法写好开头？”当时，那个学生听我这么一问，顿时就茅塞顿开。然后，屁颠屁颠的回去改文去了。都说是个网文干货分享的最佳平台之一，关于“如何写好开头”的方法，我就不藏私了，直接就拿出来跟大家分享一下。老规矩，先收藏再看！1-改变情节顺序，将爆点提前-对于刚踏入写文大军
    
                    
    • 
                                
  • jQuery 跨域访问的三种方式 No 'Access-Control-Allow-Origin' header is present on the reque
                                    qiaolevip
每天进步一点点学习永无止境跨域众观千象
                                    
    XMLHttpRequest cannot load http://v.xxx.com. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:63342' is therefore not allowed access. test.html:1

    
                                
    • 
                                
  • mysql 分区查询优化
                                    annan211
java分区优化mysql
                                    
    


分区查询优化

  引入分区可以给查询带来一定的优势，但同时也会引入一些bug.
  
  分区最大的优点就是优化器可以根据分区函数来过滤掉一些分区，通过分区过滤可以让查询扫描更少的数据。
  所以，对于访问分区表来说，很重要的一点是要在where 条件中带入分区，让优化器过滤掉无需访问的分区。
  
  可以通过查看explain执行计划，是否携带 partitions
    
                                
    • 
                                
  • MYSQL存储过程中使用游标
                                    chicony
Mysql存储过程
                                    
    DELIMITER $$ 
DROP PROCEDURE IF EXISTS getUserInfo $$ 
CREATE PROCEDURE getUserInfo(in date_day datetime)-- -- 实例-- 存储过程名为：getUserInfo-- 参数为：date_day日期格式:2008-03-08--    BEGINdecla
    
                                
    • 
                                
  • mysql 和 sqlite 区别
                                    Array_06
sqlite
                                    
    转载： 
http://www.cnblogs.com/ygm900/p/3460663.html 
 
mysql 和 sqlite 区别 
 
SQLITE是单机数据库。功能简约，小型化，追求最大磁盘效率 
MYSQL是完善的服务器数据库。功能全面，综合化，追求最大并发效率 
 
MYSQL、Sybase、Oracle等这些都是试用于服务器数据量大功能多需要安装，例如网站访问量比较大的。而sq
    
                                
    • 
                                
  • pinyin4j使用
                                    oloz
pinyin4j
                                    
    首先需要pinyin4j的jar包支持；jar包已上传至附件内 
 
方法一:把汉字转换为拼音；例如：编程转换后则为biancheng 
     
 
/**
     * 将汉字转换为全拼
     * @param src 你的需要转换的汉字
     * @param isUPPERCASE 是否转换为大写的拼音； true:转换为大写；fal
    
                                
    • 
                                
  • 微博发送私信
                                    随意而生
微博
                                    
    在前面文章中说了如和获取登陆时候所需要的cookie，现在只要拿到最后登陆所需要的cookie，然后抓包分析一下微博私信发送界面 
http://weibo.com/message/history?uid=****&name=**** 
可以发现其发送提交的Post请求和其中的数据， 
让后用程序模拟发送POST请求中的数据，带着cookie发送到私信的接入口，就可以实现发私信的功能了。 
    
                                
    • 
                                
  • jsp
                                    香水浓
jsp
                                    
    JSP初始化 
    容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。如果您需要执行自定义的JSP初始化任务，复写jspInit()方法就行了 
 
 
JSP执行 
    这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。 
    当JSP网页完成初始化后
    
                                
    • 
                                
  • 在 Windows 上安装 SVN Subversion 服务端
                                    AdyZhang
SVN
                                    
    在 Windows 上安装 SVN Subversion 服务端2009-09-16高宏伟哈尔滨市道里区通达街291号 
  
最佳阅读效果请访问原地址：http://blog.donews.com/dukejoe/archive/2009/09/16/1560917.aspx 
  
现在的Subversion已经足够稳定，而且已经进入了它的黄金时段。我们看到大量的项目都在使
    
                                
    • 
                                
  • android开发中如何使用 alertDialog从listView中删除数据？
                                    aijuans
android
                                    
    我现在使用listView展示了很多的配置信息，我现在想在点击其中一条的时候填出 alertDialog,点击确认后就删除该条数据，（ ArrayAdapter ，ArrayList，listView 全部删除），我知道在 下面的onItemLongClick 方法中 参数 arg2  是选中的序号，但是我不知道如何继续处理下去        1   2   3   
    
                                
    • 
                                
  • jdk-6u26-linux-x64.bin 安装
                                    baalwolf
linux
                                    
    1.上传安装文件(jdk-6u26-linux-x64.bin) 
2.修改权限 
[root@localhost ~]# ls -l /usr/local/jdk-6u26-linux-x64.bin 
3.执行安装文件 
[root@localhost ~]# cd /usr/local 
[root@localhost local]# ./jdk-6u26-linux-x64.bin&nbs
    
                                
    • 
                                
  • MongoDB经典面试题集锦
                                    BigBird2012
mongodb
                                    
    1.什么是NoSQL数据库？NoSQL和RDBMS有什么区别？在哪些情况下使用和不使用NoSQL数据库？ 
NoSQL是非关系型数据库，NoSQL = Not Only SQL。 
关系型数据库采用的结构化的数据，NoSQL采用的是键值对的方式存储数据。 
在处理非结构化/半结构化的大数据时；在水平方向上进行扩展时；随时应对动态增加的数据项时可以优先考虑使用NoSQL数据库。 
在考虑数据库的成熟
    
                                
    • 
                                
  • JavaScript异步编程Promise模式的6个特性
                                    bijian1013
JavaScriptPromise
                                    
            Promise是一个非常有价值的构造器，能够帮助你避免使用镶套匿名方法，而使用更具有可读性的方式组装异步代码。这里我们将介绍6个最简单的特性。 
        在我们开始正式介绍之前，我们想看看Javascript Promise的样子： 
var p = new Promise(function(r
    
                                
    • 
                                
  • [Zookeeper学习笔记之八]Zookeeper源代码分析之Zookeeper.ZKWatchManager
                                    bit1129
zookeeper
                                    
    ClientWatchManager接口 
//接口的唯一方法materialize用于确定那些Watcher需要被通知
//确定Watcher需要三方面的因素1.事件状态 2.事件类型 3.znode的path
public interface ClientWatchManager {
    /**
     * Return a set of watchers that should
    
                                
    • 
                                
  • 【Scala十五】Scala核心九：隐式转换之二
                                    bit1129
scala
                                    
    隐式转换存在的必要性， 
  
在Java Swing中，按钮点击事件的处理，转换为Scala的的写法如下： 
  
val button = new JButton
button.addActionListener(
    new ActionListener {
        def actionPerformed(event: ActionEvent) {
 
    
                                
    • 
                                
  • Android JSON数据的解析与封装小Demo
                                    ronin47

                                    
    转自：http://www.open-open.com/lib/view/open1420529336406.html 
package com.example.jsondemo; 
import org.json.JSONArray; 
import org.json.JSONException; 
import org.json.JSONObject; 
   
impor
    
                                
    • 
                                
  • [设计]字体创意设计方法谈
                                    brotherlamp
UIui自学ui视频ui教程ui资料
                                    
      
从古至今，文字在我们的生活中是必不可少的事物，我们不能想象没有文字的世界将会是怎样。在平面设计中，UI设计师在文字上所花的心思和功夫最多，因为文字能直观地表达UI设计师所的意念。在文字上的创造设计，直接反映出平面作品的主题。 
如设计一幅戴尔笔记本电脑的广告海报，假设海报上没有出现“戴尔”两个文字，即使放上所有戴尔笔记本电脑的图片都不能让人们得知这些电脑是什么品牌。只要写上“戴尔笔
    
                                
    • 
                                
  • 单调队列-用一个长度为k的窗在整数数列上移动，求窗里面所包含的数的最大值
                                    bylijinnan
java算法面试题
                                    
    import java.util.LinkedList;

/*

单调队列 滑动窗口
单调队列是这样的一个队列：队列里面的元素是有序的，是递增或者递减

题目：给定一个长度为N的整数数列a(i),i=0,1,...,N-1和窗长度k.

要求：f(i) = max{a(i-k+1),a(i-k+2),..., a(i)},i = 0,1,...,N-1

问题的另一种描述就
    
                                
    • 
                                
  • struts2处理一个form多个submit
                                    chiangfai
struts2
                                    
    web应用中，为完成不同工作，一个jsp的form标签可能有多个submit。如下代码： 
<s:form action="submit" method="post" namespace="/my">
<s:textfield name="msg" label="叙述：">
    
                                
    • 
                                
  • shell查找上个月，陷阱及野路子
                                    chenchao051
shell
                                    
    date -d "-1 month" +%F 
    以上这段代码，假如在2012/10/31执行，结果并不会出现你预计的9月份，而是会出现八月份，原因是10月份有31天，9月份30天，所以-1 month在10月份看来要减去31天，所以直接到了8月31日这天，这不靠谱。 
    野路子解决：假设当天日期大于15号
    
                                
    • 
                                
  • mysql导出数据中文乱码问题
                                    daizj
mysql中文乱码导数据
                                    
    解决mysql导入导出数据乱码问题方法： 
 
１、进入mysql，通过如下命令查看数据库编码方式： 
 
mysql>  show variables like 'character_set_%'; 
+--------------------------+----------------------------------------+ 
| Variable_name&nbs
    
                                
    • 
                                
  • SAE部署Smarty出现：Uncaught exception 'SmartyException' with message 'unable to write
                                    dcj3sjt126com
PHPsmartysae
                                    
      
对于SAE出现的问题：Uncaught exception 'SmartyException' with message 'unable to write file...。 
官方给出了详细的FAQ：http://sae.sina.com.cn/?m=faqs&catId=11#show_213 
解决方案为： 
        
01  
$path 
    
                                
    • 
                                
  • 《教父》系列台词
                                    dcj3sjt126com

                                    
    Your love is also your weak point. 
你的所爱同时也是你的弱点。 
  
If anything in this life is certain, if history has taught us anything, it is 
that you can kill anyone. 
  
不顾家的人永远不可能成为一个真正的男人。 &
    
                                
    • 
                                
  • mongodb安装与使用
                                    dyy_gusi
mongo
                                    
    一.MongoDB安装和启动,widndows和linux基本相同 
1.下载数据库, 
    linux:mongodb-linux-x86_64-ubuntu1404-3.0.3.tgz 
2.解压文件,并且放置到合适的位置 
    tar -vxf mongodb-linux-x86_64-ubun
    
                                
    • 
                                
  • Git排除目录
                                    geeksun
git
                                    
    在Git的版本控制中，可能有些文件是不需要加入控制的，那我们在提交代码时就需要忽略这些文件，下面讲讲应该怎么给Git配置一些忽略规则。 
  
有三种方法可以忽略掉这些文件，这三种方法都能达到目的，只不过适用情景不一样。 
1.  针对单一工程排除文件 
这种方式会让这个工程的所有修改者在克隆代码的同时，也能克隆到过滤规则，而不用自己再写一份，这就能保证所有修改者应用的都是同一
    
                                
    • 
                                
  • Ubuntu 创建开机自启动脚本的方法
                                    hongtoushizi
ubuntu
                                    
    转载自： http://rongjih.blog.163.com/blog/static/33574461201111504843245/ 
Ubuntu 创建开机自启动脚本的步骤如下：  
1) 将你的启动脚本复制到 /etc/init.d目录下   以下假设你的脚本文件名为 test。       
2) 设置脚本文件的权限    $ sudo chmod 755
    
                                
    • 
                                
  • 第八章 流量复制/AB测试/协程
                                    jinnianshilongnian
nginxluacoroutine
                                    
    流量复制 
在实际开发中经常涉及到项目的升级，而该升级不能简单的上线就完事了，需要验证该升级是否兼容老的上线，因此可能需要并行运行两个项目一段时间进行数据比对和校验，待没问题后再进行上线。这其实就需要进行流量复制，把流量复制到其他服务器上，一种方式是使用如tcpcopy引流；另外我们还可以使用nginx的HttpLuaModule模块中的ngx.location.capture_multi进行并发
    
                                
    • 
                                
  • 电商系统商品表设计
                                    lkl

                                    
    DROP TABLE IF EXISTS `category`; -- 类目表
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `category` (
  `id` int(11) NOT NUL
    
                                
    • 
                                
  • 修改phpMyAdmin导入SQL文件的大小限制
                                    pda158
sqlmysql
                                    
    　用phpMyAdmin导入mysql数据库时，我的10M的 
数据库不能导入，提示mysql数据库最大只能导入2M。   　　 
phpMyAdmin数据库导入出错：   　　You probably tried to upload too large file. Please refer to documentation for ways to workaround this limit.  
    
                                
    • 
                                
  • Tomcat性能调优方案
                                    Sobfist
apachejvmtomcat应用服务器
                                    
    一、操作系统调优 
 对于操作系统优化来说，是尽可能的增大可使用的内存容量、提高CPU的频率，保证文件系统的读写速率等。经过压力测试验证，在并发连接很多的情况下，CPU的处理能力越强，系统运行速度越快。。 
 【适用场景】 任何项目。 
 二、Java虚拟机调优 
 应该选择SUN的JVM，在满足项目需要的前提下，尽量选用版本较高的JVM，一般来说高版本产品在速度和效率上比低版本会有改进。 
 J
    
                                
    • 
                                
  • SQLServer学习笔记
                                    vipbooks
数据结构xml
                                    
    1、create database school 创建数据库school 
 
2、drop database school 删除数据库school 
 
3、use school 连接到school数据库，使其成为当前数据库 
 
4、create table class(classID int primary key identity not null) 
 创建一个名为class的表，其有一
    
                                
    •