weixin_39942451
weixin_39942451

挖矿区块链_使用Java语言从零开始创建区块链

目前网络上关于区块链入门、科普的文章不少，本文就不再赘述区块链的基本概念了，如果对区块链不是很了解的话，可以看一下我之前收集的一些入门学习资源：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文件内容如下：

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

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(" ------------------------- ");

// 检查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张图片

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

你可能感兴趣的:(挖矿区块链)

  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • 炒币好还是挖矿好？ 区块链大社会
    炒币好还是挖矿好？相信这个问题对于很多初入行的朋友来说是个不小的问题，小编也经常会被问到类似问题。为此，本文专门针对这个问题做一下分析，供各位朋友们参考。在比特币世界里，有些非常有意思的比喻，像挖金子一样“挖”比特币叫做“挖矿”，挖比特币的人被称为“矿工”，而用于“挖”比特币的电脑被称为“矿机”。而“炒币”就像炒股，直接在交易平台购买数字货币进行交易，不需要“挖”，只要将法币兑换成某种数字货币，再
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • 区块链～我的念 夜未央0075460
    世界上最快的速度不是光，不是电，而是我们的「念」。一念起，万水千山；一念灭，沧海桑田。念起念灭当随缘，切莫执迷。执念区块链
  • 以太坊DApp开发指南 Kirn
    DApp架构设计DApp架构.png如上图，DApp的架构我们可以简单分为以上三种类型：轻钱包模式、重钱包模式和兼容模式。轻钱包模式轻钱包模式下我们需要有一个开放HttpRPC协议的节点与钱包通信，这个节点可以是任意链上的节点。轻钱包通常会作为一个浏览器插件存在，插件在运行时会自动注入Web3框架，DApp可以通过Web3与区块链节点通信。当DApp只是单纯的获取数据时是不需要钱包介入的，但是当D
  • 【数字化供应链】数字化供应链架构、全景管理、全流程贯通方案 数字化建设方案 数字化转型数据治理主数据数据仓库供应链数字仓储智慧物流智慧仓储物流园区架构微服务数据挖掘大数据人工智能
    原文《数字化供应链架构、全景管理、全流程贯通方案》PPT格式。主要从供应链管理全景、智慧供应链建设总体目标、供应链总体业务流程、供应链总体功能架构、供应链总体技术架构、供应链全流程贯通、供应链全领域管理、供应链数据数据分析、供应链决策中台等进行建设。本文仅对主要内容进行介绍。来源网络公开渠道，旨在交流学习，如有侵权联系速删，更多参考公众号：优享智库基于先进IT技术、大数据能力、物联网应用、区块链平
  • 区块链私有链new qis_qis 区块链区块链以太坊数字货币
    {“config”:{“chainld”:666,“homesteadBlock”:0,“eip150Block”:0,“eip150Hash”:“0x0000000000000000000000000000000000000000000000000000000000000000”,“eip155Block”:0,“eip158Block”:0,“byzantiumBlock”:0,“consta
  • 区块链私有链 qis_qis 区块链区块链以太坊数字货币
    {"config":{"chainld":666,"homesteadBlock":0,"eip150Block":0,"eip150Hash":"0x0000000000000000000000000000000000000000000000000000000000000000","eip155Block":0,"eip158Block":0,"byzantiumBlock":0,"consta
  • 数字化（电子化）招标采购平台系统核心功能详细介绍 xinyuan_123456 oracle
    数智化招标采购平台覆盖全业务类型、全采购流程、全采购方式，是郑州信源公司运用“互联网+”、大数据、人工智能、区块链、物联网等新兴技术，结合供应链管理理念，以招标采购为核心，提供交易、管理、数据、服务、监管为一体的高标准采购管理平台，赋能政企用户实现采购业务全流程的电子化、数字化、智慧化。根据产品功能及应用领域，产品包括：企业数智化招采供应链平台、金融数智化招采平台、政府数智化采购平台、公共资源数智
  • 【老韭菜区块链日记】第32篇 定投是牛市最佳投机方式 铁予
    2021年2月19日星期五定投是牛市最佳投机方式牛市里，怎样才能轻松赚到钱？追涨杀跌？高抛低吸？想法很美满，现实很骨感。技术不够硬，行情不配合的情况下，追涨杀跌，高抛低吸只会让账户分分钟缩水归零。牛市里，其实不管买神马币，拿住了，都会等来自己的春天。关键在于，拿住！这个拿住，并不是说起来那么简单，当看到其他币种一天拉几十个点，自己的币不涨就算了，还在阴跌，这样的情况若是一天两天还好，若是持续了三四
  • 万字长文聊聊Web3的组成架构 Keegan小钢 web3架构区块链
    本文首发于公众号：Keegan小钢Web3发展至今，生态已然初具雏形，如果将当前阶段的Web3生态组成架构抽象出一个鸟瞰图，由下而上可划分为四个层级：区块链网络层、中间件层、应用层、访问层。下面我们来具体看看每一层级都有什么。另外，此章节会涉及到很多项目的名称，因为篇幅原因不会一一进行介绍，有兴趣的可以另外去查阅相关资料进行深入了解。区块链网络层最底层是「区块链网络层」，也是Web3的基石层，主要
  • Web3入门指南：从基础概念到实际应用 dingzd95 去中心化web3区块链人工智能智能合约
    Web3，即“去中心化的第三代互联网”，正在逐步改变我们对互联网的传统认知。从最初的静态网页（Web1.0）到互动平台和社交媒体为主的互联网（Web2.0），Web3的目标是让用户重新掌握对数据和数字资产的控制权。什么是Web3？Web3被视为互联网的下一代发展阶段，其核心是去中心化。与以往依赖中心化服务器和大公司控制的数据模式不同，Web3通过区块链技术实现了数据的分布式存储和处理。这一去中心化
  • 智能合约系统DAPP开发 I592O929783 智能合约区块链
    智能合约系统DAPP（去中心化应用）的开发是一个复杂且综合性的过程，它结合了区块链技术、智能合约编程、前端开发以及安全性等多方面的知识和技能。以下是对智能合约系统DAPP开发过程的详细概述：一、需求分析明确应用场景：首先，需要明确DAPP的应用场景，如金融、游戏、社交等。功能需求：确定DAPP需要实现的具体功能，包括数据处理、用户交互等。用户群体：了解目标用户群体的需求和习惯，以便更好地设计DAP
  • 一切皆是映射：AI的去中心化：区块链技术的融合 AI大模型应用之禅 计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    一切皆是映射：AI的去中心化：区块链技术的融合作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming关键词：AI，区块链，去中心化，智能合约，共识机制，数据安全，隐私保护，分布式账本技术，机器学习，数据隐私1.背景介绍1.1问题的由来随着人工智能（AI）技术的快速发展，其在各个领域的应用越来越广泛，从自动驾驶、智能医疗到金融服务，AI正在改变着我们的生活。
  • 比特币，跨时代的产物 宇智波士郎
    图片发自App2017，随着比特币价格大爆发，创造出了一大批财富神话。吸引无数人前往币圈，无数数字货币诞生，价格疯狂到让人失了智。区块链，比特币运行的底层机制。有人认为，区块链对人类的发展比比特币自身更为重要。有些政府甚至只要区块链，而不要比特币。但是，区块链最为重要的特性便是去中心化，比特币的奖励机制完美的解决了去中心化这个问题。所以比特币比区块链更为重要，比特币就是中本聪先生，为了反抗现代金融
  • 专访徐小平：AI已进入日常生活 没有泡沫只有彩虹 网易智能
    ▼点击上方蓝字关注网易智能为你解读AI领域大公司大事件，新观点新应用从共享单车到新零售，从人工智能到区块链，从直播答题到内容创业，移动互联网时代，每一次商业机遇的新风口周期在变得越来越短，无论对于创业者还是投资人，一上场就出现“留给选手的时间不多了”已成了常态。2018年春，网易科技联合起风了推出“Top中国投资人”深度访谈节目，将分别就当下热点方向，邀请国内顶级机构若干位资深合伙人共同探索未来一
  • LSP协议：技术创新背后的团队与愿景 BTColdman1 区块链
    随着去中心化金融（DeFi）和区块链技术的迅猛发展，创新性的项目层出不穷，LSP协议（LiquiditySlicingProtocolforNodeStaking）以其独特的技术优势和市场定位迅速成为行业焦点。在这背后，项目的成功离不开核心团队的领导与执行力，特别是CEOMichaelRey的卓越贡献。突破质押流动性瓶颈LSP协议作为全球首个专注于节点质押流动性的切片协议，其独特卖点在于实现了DP
  • 有舍社区-我有一个梦想 有舍社区
    刚才有个电商项目在某群热议，无数人帮助分析，在这个时候我把有舍社区的白皮书发出来，没有人看，真的很难受。电商项目以发币为目的，还谈梦想。有舍社区是有梦想的，如果把项目方，交易所，媒体，比作富人，普通投资者比做穷人，那么有舍社区是一个穷人的队伍。有舍社区能做什么呢？精选优质平台，为投资者提供便捷的服务。为用户提供有价值的项目，媒体，钱包等服务平台追踪行业趋势，引导区块链最前沿趋势解决用户在投资中遇到
  • 区块链之变：揭秘Web3对互联网的改变 清 晨 web3web3去中心化区块链人工智能
    传统游戏中，玩家的虚拟资产（如角色、装备）通常由游戏公司控制，玩家无法真正拥有这些资产或进行交易。而在区块链游戏中，虚拟资产通过去中心化技术记录在区块链上，玩家对其拥有完全的所有权，并能够自由交易或转移。Web3的去中心化特点为区块链游戏带来了更高的透明性和公平性。智能合约自动执行游戏规则，确保所有玩家在相同条件下进行游戏，并消除了作弊和规则篡改的风险。这种透明性不仅增强了玩家的信任，也为开发者提
  • 【加密社】深入理解TON智能合约 (FunC语法) 加密社 闲侃Nethereum教程区块链智能合约
    king:摘要：在TON（TheOpenNetwork）区块链平台中，智能合约扮演着举足轻重的角色。本文将通过分析一段TON智能合约代码带领读者学习dict（字典）和list（列表）在FunC语言中的用法，以及如何在实际场景中实现高效的验证者选举。一、引言TON区块链平台的智能合约采用FunC语法一、引言TON区块链平台的智能合约采用FunC语言编写，该语言提供了丰富的数据结构，如dict和lis
  • 区块链如何大规模落地？ 西门锤靴
    区块链要实现大规模的落地应用，有三个前提，一是技术本身的进步，二是要有保护商业安全和利益的机制，三是要能够服务于实体经济。以下针对这三点分别来阐述。技术本身，区块链在过去几年的发展很迅速，但从技术革命的角度来看，现在还是处于很早期的阶段：1）首当其冲的是性能问题，即使是EOS，号称能做到百万TPS，但还是有待时间验证。区块链作为一个去中心化技术，自然也受到类似于分布式系统的CAP定律的制约。CAP
  • 《图说区块链》（一） 馨思遇
    未来五年最有前景的行业之一。掌掌握它你讲无往而不胜失去它，你将错失金融业的未来。取区块链如瑞士仪表般精密，如互联网般，惊世骇俗，他在以神一般的节奏颠覆社会，当新兴技术来临时。作作者徐明星okcoian必行okimk。创始人兼ceo。全球区块链商业理事会中国分中心副主席，中国区块链应用研究中心创始理事兼理事长，曾担任豆丁网，CTO和雅虎开发工程师。七区块链能实现价值转移，是超越信息的第二代互联网区块
  • Golang学习路线图及go-starter.md knight11112 golang开发语言后端
    Golang学习路线图及go-starter.md背景为什么要学习golang最早接触golang是因为对区块链感兴趣，因为golang的并发和内置的网络库还有大公司的支持，先天比较适合区块链，很多著名的框架都是golang写，比如geth再后来，到新加坡Shopee工作，技术栈从Java切换成了golang，更要好好学习golang的语言特性了如下是之前列的一个学习路线图1.数据类型（含stru
  • Meta Force原力元宇宙区块链驱动的财富新引擎 口碑信息传播者
    在数字化浪潮席卷全球的今天，区块链技术以其去中心化、透明性和不可篡改的特性，正逐渐改变着传统行业的运营模式。其中，MetaForce2.0原力元宇宙作为区块链技术应用的佼佼者，以其独特的矩阵玩法和智能合约机制，成为了市场竞争的新宠。本文将详细解析MetaForce2.0原力元宇宙的运作机制，以及它如何为参与者带来丰厚的收益。13分钟视频内容讲明白原力元宇宙创富项目，中国区运营服务对接微信：Forc
  • 跨界创新，走向财富成功：原力元宇宙项目助你实现 口碑信息传播者
    在这个数字化时代，随着技术的不断进步和创新，我们正处于一个前所未有的机遇时刻。原力元宇宙项目，作为一项跨界创新的先驱，为您提供了实现财富成功的独特机会。本文将为您详细介绍原力元宇宙项目的特点和优势，以及如何利用它来实现财富增长和个人成功。13分钟视频内容讲明白原力元宇宙创富项目，中国区运营服务对接微信：ForceZen背景介绍原力元宇宙项目是一项基于区块链和虚拟现实技术的创新项目。它将现实世界与虚
  • 有三套房还要挖矿,男子称手痒停不下来 IPFS资讯俱乐部
    我们经常说挖矿赚钱，想必大家都想知道这些币价值几何，这里提供部分币种今日的情况供大家参考。看完这些是不是激发了大家伙学习的欲望，下面开始步入正题啦！当你有IPFS时，你可以开始以一种特定的方式查看其他所有东西，并且你会意识到其它方式都是多余的。市面上关于IPFS的资料较少，本节将尝试性的提出个人的见解。IPFS开始作为胡安贝内努力建立一个系统，可以快速的移动版本化的科学数据。版本控制使您能够跟踪随
  • 016 币币置换思考 叶雷雷
    这周数字货币GBI从20900多高点一路下跌到16800，btc下跌最剧烈。前期用部分eos置换了一点btc，这段时间没有法币，用btc又置换了一些big和dew。big和dew没有白名单，现在买入的成本是白名单的近十倍价格。我为什么用这么高的成本买入呢，这两个代币是币币交易所的代币，数量会随着时间递减，且它的价值应该符合指数曲线递增型。有人分析了数字货币领域最赚钱的三个方向，分叉，开交易所，挖矿
  • 区块链的可伸缩性以及面临的挑战 Mindfulness code 区块链开发区块链
    1.可伸缩性在过去的几年中，可伸缩性（Scalability,也称为可扩展性)问题一直是激烈辩论、严格研究和媒体关注的焦点。这是一个至关重要的问题，因为它可能意味着区块链不适于广泛应用，而仅限于联盟许可的私有网络。在经过对该领域的大量研究之后，人们提出了许多解决方案，下面将详细介绍这些解决方案。从理论上讲，解决可伸缩性问题的一般方法通常围绕协议级别的强化。例如，通常提到的比特比可伸缩性解决方案是增
  • 区块链当前发展和未来展望 Mindfulness code 区块链开发区块链
    1.区块链技术发展的新兴趋势由于学术界和商业界对区块链技术的浓厚兴趣，该技术正处于快速变化和蓬勃发展状态中。随着区块链技术的日益成熟，出现了一些新兴趋势。例如，在金融领域出现了区块链的特定用例，引起了人们的较大关注。此外，企业区块链也演变成一个新趋势，旨在开发满足企业级效率、安全性和集成要求的区块链解决方案。1.1专用区块链目前出现了一种专用区块链（Application-SpecificBloc
  • 解读Servlet原理篇二---GenericServlet与HttpServlet 周凡杨 javaHttpServlet源理GenericService源码
    在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
  • MySQL性能优化 bijian1013 数据库mysql
            性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有：         a.优化查询         b.优化数据库结构  
  • ThreadPool定时重试 dai_lm javaThreadPoolthreadtimertimertask
    项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 为了解决不定间隔的重试，选择Timer和TimerTask来完成 package threadpool; public class ThreadPoolTest {
  • Oracle 查看数据库的连接情况 周凡杨 sqloracle 连接
    首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 select * from dict where table_name like '%SESSION%'; 就可以查出一些表，然后根据这些表就可以获得会话信息 select sid,serial#,status,username,schemaname,osuser,terminal,ma
  • 类的继承 朱辉辉33 java
    类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 格式:public class 类名（子类）extends 类名（父类）{ } 子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 protected属性，但要使用private属性仍需通过调用。 子类的方法可以重写，但必须和父类的返回值类
  • android 悬浮窗特效 肆无忌惮_ android
    最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下：   一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。   后来想利用Dialog的dismiss动画来完成。   自定义一个Dialog后，在styl
  • hadoop伪分布式搭建 林鹤霄 hadoop
    要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
  • gdb调试命令 aigo gdb
    原文：http://blog.csdn.net/hanchaoman/article/details/5517362   一、GDB常用命令简介   r run 运行.程序还没有运行前使用 c             cuntinue 
  • Socket编程的HelloWorld实例 alleni123 socket
    public class Client { public static void main(String[] args) { Client c=new Client(); c.receiveMessage(); } public void receiveMessage(){ Socket s=null; BufferedRea
  • 线程同步和异步 百合不是茶 线程同步异步
    多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法   多线程和异步:多线程可以做不同的事情,涉及到线程通知     &
  • JSP中文乱码分析 bijian1013 javajsp中文乱码
            在JSP的开发过程中，经常出现中文乱码的问题。         首先了解一下Java中文问题的由来：         Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
  • js实现页面跳转重定向的几种方式 bijian1013 JavaScript重定向
            js实现页面跳转重定向有如下几种方式： 一.window.location.href <script language="javascript"type="text/javascript"> window.location.href="http://www.baidu.c
  • 【Struts2三】Struts2 Action转发类型 bit1129 struts2
     在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下   <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configurat
  • 【HBase十一】Java API操作HBase bit1129 hbase
    Admin类的主要方法注释：   1. 创建表 /** * Creates a new table. Synchronous operation. * * @param desc table descriptor for table * @throws IllegalArgumentException if the table name is res
  • nginx gzip ronin47 nginx gzip
    Nginx GZip 压缩 Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 常用配置片段如下： gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
  • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交 bylijinnan java
    public class LinkListTest { /** * we deal with two main missions: * * A. * 1.we create two joined-List(both have no loop) * 2.whether list1 and list2 join * 3.print the join
  • Spring源码学习-JdbcTemplate batchUpdate批量操作 bylijinnan javaspring
    Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 JDBC的batch操作： String sql = "INSERT INTO CUSTOMER " + "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
  • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展 comsci 工作流
        生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出.........     竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
  • base64编码和url编码 cuityang base64url
    import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.StringWriter; import java.io.UnsupportedEncodingException;
  • web应用集群Session保持 dalan_123 session
    关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
  • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式'] dcj3sjt126com 数据库
        public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
  • solr StatsComponent（聚合统计） eksliang solr聚合查询solr stats
    StatsComponent 转载请出自出处：http://eksliang.iteye.com/blog/2169134 http://eksliang.iteye.com/ 一、概述        Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能   二、参数
  • 百度一道面试题 greemranqq 位运算百度面试寻找奇数算法bitmap 算法
    那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字.   我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。   还有人觉得应该用算法xxx,我是没想到用啥算法好...！   还有觉得应该先排序...   还有觉
  • Spring之在开发中使用SpringJDBC ihuning spring
      在实际开发中使用SpringJDBC有两种方式：   1. 在Dao中添加属性JdbcTemplate并用Spring注入；     JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
  • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节 justjavac json
    2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
  • 网站项目建设流程概述 macroli 工作
    一.概念 网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 二.需求分析 项目立项 　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 客户的需求说明书 　　第一步是需
  • AngularJs 三目运算 表达式判断 qiaolevip 每天进步一点点学习永无止境众观千象AngularJS
    事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 var b = "{{", a = "}}"; this.startSymbol = function(a) {
  • Spark算子：统计RDD分区中的元素及数量 superlxw1234 sparkspark算子Spark RDD分区元素
    关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量     Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。   可以利用RDD的mapPartitionsWithInd
  • Spring 3.2.x将于2016年12月31日停止支持 wiselyman Spring 3
                  Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。          请大家及时准备及时升级到Spring
  • fis纯前端解决方案fis-pure zccst JavaScript
    作者：zccst FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 1，fis-pure的安装 $ fis install -g fis-pure $ pure -v 0.1.4 2，下载demo到本地 git clone https://github.com/hefangshi/f