为了更好的理解区块链的底层实现原理，决定自己动手模拟实现一条区块链。
通过之前的学习，从文本知识的角度，我们知道，创世区块、记账原理、挖矿原理、工作量证明、共识机制等等区块链的相关知识。
创建一条区块链，首先默认构造创世区块。在此基础上，我们可以发布交易，并进行挖矿，计算出工作量证明，将交易记录到区块中，每成功的挖一次矿，块高就+1。当然在此过程中，可能会出现“造假”的问题。也就是说，每一个新注册的节点，都可以有自己的链。这些链长短不一，为了保证账本的一致性，需要通过一种一致性共识算法来找到最长的链，作为样本，同步数据，保证每个节点上的账本信息都是一致的。
我们将通过Postman来模拟请求。请求API如下：
/nodes/register 注册网络节点
/nodes/resolve 一致性共识算法
/transactions/new 新建交易
/mine 挖矿
/chain 输出整条链的数据
Gradle Web 项目
dependencies {
compile('javax:javaee-api:7.0')
compile('org.json:json:20160810')
testCompile('junit:junit:4.12')
}
注释写的很详细，如果遇到不懂的地方，欢迎大家一同讨论。
// 存储区块链
private List<Map<String, Object>> chain;
// 该实例变量用于当前的交易信息列表
private List<Map<String, Object>> currentTransactions;
// 网络中所有节点的集合
private Set<String> nodes;
private static BlockChain blockChain = null;
private BlockChain() {
// 初始化区块链以及当前的交易信息列表
chain = new ArrayList<Map<String, Object>>();
currentTransactions = new ArrayList<Map<String, Object>>();
// 初始化存储网络中其他节点的集合
nodes = new HashSet<String>();
// 创建创世区块
newBlock(100, "0");
}
/**
* 在区块链上新建一个区块
* @param proof 新区块的工作量证明
* @param previous_hash 上一个区块的hash值
* @return 返回新建的区块
*/
public Map<String, Object> newBlock(long proof, String previous_hash) {
Map<String, Object> block = new HashMap<String, Object>();
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<Map<String, Object>>());
getChain().add(block);
return block;
}
// 创建单例对象
public static BlockChain getInstance() {
if (blockChain == null) {
synchronized (BlockChain.class) {
if (blockChain == null) {
blockChain = new BlockChain();
}
}
}
return blockChain;
}
/**
* @return 得到区块链中的最后一个区块
*/
public Map<String, Object> lastBlock() {
return getChain().get(getChain().size() - 1);
}
/**
* 生成新交易信息，信息将加入到下一个待挖的区块中
* @param sender 发送方的地址
* @param recipient 接收方的地址
* @param amount 交易数量
* @return 返回该交易事务的块的索引
*/
public int newTransactions(String sender, String recipient, long amount) {
Map<String, Object> transaction = new HashMap<String, Object>();
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<String, Object> block) {
return new Encrypt().Hash(new JSONObject(block).toString());
}
/**
* 注册节点
* @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);
}
/**
* 验证是否为有效链,遍历每个区块验证hash和proof，来确定一个给定的区块链是否有效
* @param chain
* @return
*/
public boolean vaildChain(List<Map<String,Object>> chain) {
Map<String,Object> lastBlock = chain.get(0);
int currentBlockIndex = 1;
while (currentBlockIndex < lastBlock.size()) {
Map<String,Object> currentBlock = chain.get(currentBlockIndex);
//检查区块的hash是否正确
if (!currentBlock.get("previous_hash").equals(hash(lastBlock))) {
return false;
}
lastBlock = currentBlock;
currentBlockIndex ++;
}
return true;
}
/**
* 使用网络中最长的链. 遍历所有的邻居节点，并用上一个方法检查链的有效性，
* 如果发现有效更长链，就替换掉自己的链
* @return 如果链被取代返回true, 否则返回false
* @throws IOException
*/
public boolean resolveConflicts() throws IOException {
//获得当前网络上所有的邻居节点
Set<String> neighbours = this.nodes;
List<Map<String, Object>> newChain = null;
// 寻找最长的区块链0
long maxLength = this.chain.size();
// 获取并验证网络中的所有节点的区块链
for (String node : neighbours) {
URL url = new URL("http://" + node + "/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(responseData.toString());
long length = jsonData.getLong("blockLength");
List<Map<String, Object>> chain = (List) jsonData.getJSONArray("chain").toList();
// 检查长度是否长，链是否有效
if (length > maxLength && vaildChain(chain)) {
maxLength = length;
newChain = chain;
}
}
}
// 如果发现一个新的有效链比我们的长，就替换当前的链
if (newChain != null) {
this.chain = newChain;
return true;
}
return false;
}/**
* 计算当前区块的工作量证明
* @param last_proof 上一个区块的工作量证明
* @return
*/
public long ProofOfWork(long last_proof){
long proof = 0;
while (!(vaildProof(last_proof,proof))) {
proof ++;
}
return proof;
}
/**
* 验证证明，是否拼接后的Hash值以4个0开头
* @param last_proof 上一个区块工作量证明
* @param proof 当前区块的工作量证明
* @return
*/
public boolean vaildProof(long last_proof, long proof) {
String guess = last_proof + "" + proof;
String guess_hash = new Encrypt().Hash(guess);
boolean flag = guess_hash.startsWith("0000");
return flag;
}public class Encrypt {
/**
* 传入字符串，返回 SHA-256 加密字符串
* @param strText
* @return
*/
public String Hash(final String strText) {
// 返回值
String strResult = null;
// 是否是有效字符串
if (strText != null && strText.length() > 0) {
try {
// 创建加密对象，传入要加密类型
MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
// 传入要加密的字符串
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;
}
}/**
* @Author: cfx
* @Description: 该Servlet用于输出整个区块链的数据(Json)
* @Date: Created in 2018/5/9 17:24
*/
@WebServlet("/chain")
public class FullChain extends HttpServlet{
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
BlockChain blockChain = BlockChain.getInstance();
Map<String,Object> response = new HashMap<String, Object>();
response.put("chain",blockChain.getChain());
response.put("blockLength",blockChain.getChain().size());
JSONObject jsonObject = new JSONObject(response);
resp.setContentType("application/json");
PrintWriter printWriter = resp.getWriter();
printWriter.println(jsonObject);
printWriter.close();
}
}/**
* @Author: cfx
* @Description: 初始化时，使用UUID来作为节点ID
* @Date: Created in 2018/5/9 17:17
*/
@WebListener
public class InitialID implements ServletContextListener {
public void contextInitialized(ServletContextEvent sce) {
ServletContext servletContext = sce.getServletContext();
String uuid = UUID.randomUUID().toString().replace("-", "");
servletContext.setAttribute("uuid", uuid);
System.out.println("uuid is : "+servletContext.getAttribute("uuid"));
}
public void contextDestroyed(ServletContextEvent sce) {
}
}/**
* @Author: cfx
* @Description: 注册网络节点
* @Date: Created in 2018/5/10 11:26
*/
@WebServlet("/nodes/register")
public class Register extends HttpServlet {
@Override
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 jsonValue = new JSONObject(requestBody.toString());
BlockChain blockChain = BlockChain.getInstance();
blockChain.registerNode(jsonValue.getString("nodes"));
PrintWriter printWriter = resp.getWriter();
printWriter.println(new JSONObject().append("message","The Nodes is : " + blockChain.getNodes()));
printWriter.close();
}
}/**
* @Author: cfx
* @Description: 该Servlet用于接收并处理新的交易信息
* @Date: Created in 2018/5/9 17:22
*/
@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();
}
}/**
* @Author: cfx
* @Description: 该Servlet用于运行工作算法的证明来获得下一个证明，也就是所谓的挖矿
* @Date: Created in 2018/5/9 17:21
*/
@WebServlet("/mine")
public class Mine extends HttpServlet{
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
BlockChain blockChain = BlockChain.getInstance();
//计算出工作量证明
Map<String,Object> lastBlock = blockChain.lastBlock();
Long last_proof = Long.parseLong(lastBlock.get("proof") + "");
Long proof = new Proof().ProofOfWork(last_proof);
//奖励计算出工作量证明的矿工1个币的奖励，发送者为"0"表明这是新挖出的矿。
String uuid = (String) this.getServletContext().getAttribute("uuid");
blockChain.newTransactions("0",uuid,1);
//构建新的区块
Map<String,Object> newBlock = blockChain.newBlock(proof,null);
Map<String, Object> response = new HashMap<String, Object>();
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();
}
}
/**
* @Author: cfx
* @Description: 一致性共识算法，解决共识冲突，保证所有的节点都在同一条链上(最长链)
* @Date: Created in 2018/5/10 11:38
*/
@WebServlet("/nodes/resolve")
public class Consensus extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
BlockChain blockChain = BlockChain.getInstance();
boolean flag = blockChain.resolveConflicts();
System.out.println("是否解决一致性共识冲突：" + flag);
}
}
以下是本人之前的测试记录：
首次请求/chain:
初始化Blockchain
{
"chain": [
{
"index": 1,
"proof": 100,
"transactions": [],
"timestamp": 1526284543591,
"previous_hash": "0"
}
],
"chainLenth": 1
}
请求/nodes/register，进行网络节点的注册。
request:
{
"nodes": "http://lcoalhost:8080"
}
response:
{"message":["All Nodes are:[lcoalhost:8080]"]}
请求/mine,进行挖矿。
{
"index": 2,
"proof": 35293,
"message": "New Block Forged",
"transactions": [
{
"amount": 1,
"sender": "0",
"recipient": "e91467fe51bd43b8ad7892b3bc09bd4e"
}
],
"previous_hash": "c4b2bb2f6e042680aed249309791cac96da6c1f65b811c306088723ae3c73f66"
}
请求/chain,查看链上所有区块的数据
{
"chain": [
{
"index": 1,
"proof": 100,
"transactions": [],
"timestamp": 1526284543591,
"previous_hash": "0"
},
{
"index": 2,
"proof": 35293,
"transactions": [
{
"amount": 1,
"sender": "0",
"recipient": "e91467fe51bd43b8ad7892b3bc09bd4e"
}
],
"timestamp": 1526284661678,
"previous_hash": "c4b2bb2f6e042680aed249309791cac96da6c1f65b811c306088723ae3c73f66"
}
],
"chainLenth": 2
}
请求/transactions/new,新建交易。
request:
{
"sender": "d4ee26eee15148ee92c6cd394edd974e",
"recipient": "someone-other-address",
"amount": 6
}
response:
{
"message": [
"Transaction will be added to Block 3"
]
}
请求/mine，计算出工作量证明。将上面的交易记录到账本之中。
{
"index": 3,
"proof": 35089,
"message": "New Block Forged",
"transactions": [
{
"amount": 6,
"sender": "d4ee26eee15148ee92c6cd394edd974e",
"recipient": "someone-other-address"
},
{
"amount": 1,
"sender": "0",
"recipient": "e91467fe51bd43b8ad7892b3bc09bd4e"
}
],
"previous_hash": "a12748a35d57a4a371cefc4a8c294236d69c762d28b889abb2ae34a31d2b7597"
}
请求/chain,查看链上所有区块的数据
{
"chain": [
{
"index": 1,
"proof": 100,
"transactions": [],
"timestamp": 1526284543591,
"previous_hash": "0"
},
{
"index": 2,
"proof": 35293,
"transactions": [
{
"amount": 1,
"sender": "0",
"recipient": "e91467fe51bd43b8ad7892b3bc09bd4e"
}
],
"timestamp": 1526284661678,
"previous_hash": "c4b2bb2f6e042680aed249309791cac96da6c1f65b811c306088723ae3c73f66"
},
{
"index": 3,
"proof": 35089,
"transactions": [
{
"amount": 6,
"sender": "d4ee26eee15148ee92c6cd394edd974e",
"recipient": "someone-other-address"
},
{
"amount": 1,
"sender": "0",
"recipient": "e91467fe51bd43b8ad7892b3bc09bd4e"
}
],
"timestamp": 1526284774452,
"previous_hash": "a12748a35d57a4a371cefc4a8c294236d69c762d28b889abb2ae34a31d2b7597"
}
],
"chainLenth": 3
}有一个问题没有解决，就是我们启动多实例来模拟不同的网络节点时，并不能解决节点加入同一个Set的问题，也就是说根本无法通过节点本身来获得其他网络节点，进而判断最长链。所以/nodes/resolve请求暂时时无用的。期间也有想方法解决，比如通过所谓的“第三方”–数据库，当一个节点注册时，保存到数据库中；当第二个节点加入时，也加入到数据库中…当需要请求解决一致性算法时，去数据库中读取节点信息遍历即可。但是，自己没有去实现。这是我的想法，毕竟是两个不相干的实例。如果有朋友有其他的解决方案，请一定要告诉我！谢谢。
通过简单的Demo实现区块链，当然其中简化了大量的实现细节，所以说其实并没有多少实际参考价值。但是意义在于，能帮助我们更容易的理解区块链，为之后的学习打下夯实的基础。
https://learnblockchain.cn/2017/11/04/bitcoin-pow/
http://blog.51cto.com/zero01/2086195等。