本文最后更新于1 年前，文中所描述的信息可能已发生改变。
概述
区块链（Blockchain）技术，自从在比特币（Bitcoin）白皮书《比特币：一种点对点电子货币系统（Bitcoin: A Peerto-Peer Electronic Cash System）》 一文中被化名为中本聪的作者提出以来就受到许多关注，并且在后续的发展中备受争议。有些人认为区块链是继蒸汽机、电力、互联网之后的颠覆性技术发明， 将彻底改变整个人类社会价值传递的方式，甚至带来新一轮的科技革命；而有些反对者则认为比特币乃至区块链是一个骗局，或是对其未来充满担忧。 近年来，随着比特币、以太坊（Ethereum）等加密货币的火热，区块链技术在全球范围内得到越来越多的关注。 2019年10月24日，中共中央政治局就区块链技术发展现状和趋势进行第十八次集体学习，此后，区块链技术更是吸引了举国上下的目光。区块链技术目前已经应用于多个领域，如金融、物流、食品安全等。 尽管不少人对比特币的未来发展仍然充满疑虑，但大多数技术专家非常认可区块链技术的未来，认为其理念的推广与应用最终会超越加密货币，成为时代的热点和前沿技术。 但是，与其火热的应用、受到广泛的关注度和蓬勃的发展相比，普通大众对于区块链的认知尚停留在很简单的层面。 人们对于区块链的认识往往是局限于加密数字货币，或者是一项敬而远之、远离日常生活的高新技术。
总的来说，区块链技术建立了新的信任机制，允许各网络节点之间在没有权威节点的去中心化情况下达成可信共识，是一项从思想到技术的重大飞跃。
概念
中本聪在《比特币：一种点对点电子货币系统》一文中，并未给出“区块链”的具体定义，只是提出了一种基于哈希证明的链式区块结构，即称为区块链的数据结构。 “区块链”一词也是来源于此，其中“区块”（Block）一词指代一个包含了数据的基本结构单元（块），而链（Chain）则代表了由区块产生的哈希链表。
从狭义上来说，根据工业和信息化部2016年发布的《中国区块链技术和应用发展白皮书》所述，区块链技术是一种按照时间顺序将数据区块以顺序相连的方式组合成链式数据结构， 并以密码学方式保证不可篡改和不可伪造的分布式账本技术。 从广义来说，区块链技术是利用块链式数据结构来验证与存储数据、利用分布式节点共识算法来生成和更新数据、利用密码学方式保证数据传输和访问的安全、 利用由自动化脚本代码组成的智能合约来编程和操作数据的一种全新的分布式基础架构与计算范式。 一般认为，区块链技术是伴随着以“比特币”为首的数字货币而出现的一项新兴技术，是一种以密码学算法为基础的点对点分布式账本技术，是分布式存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式。
区块链包括三个基本要素，即交易（Transaction，一次操作，导致账本状态的一次改变）、区块（Block，记录一段时间内发生的交易和状态结果，是对当前账本状态的一次共识）和链（Chain，由一个个区块按照发生顺序串联而成，是整个状态变化的日志记录）。 区块链中每个区块保存规定时间段内的数据记录（即交易），并通过密码学的方式构建一条安全可信的链条，形成一个不可篡改、全员共有的分布式账本。
通俗地说，区块链是一个收录所有历史交易的账本，不同节点之间各持一份，节点间通过共识算法确保所有人的账本最终趋于一致。区块链中的每一个区块就是账本的每一页，记录了一个批次记录下来的交易条目。 这样一来，所有交易的细节都被记录在一个任何节点都可以看得到的公开账本上，如果想要修改一个已经记录的交易，需要所有持有账本的节点同时修改。
同时，由于区块链账本里面的每一页都记录了上一页的一个摘要信息，如果修改了某一页的账本（也就是篡改了某一个区块），其摘要就会跟下一页上记录的摘要不匹配，这时候就要连带修改下一页的内容，这就进一步导致了下一页的摘要与下下页的记录不匹配。 如此循环，一个交易的篡改会导致后续所有区块摘要的修改，考虑到还要让所有人承认这些改变，这将是一个工作量巨大到近乎不可能完成的工作。正是从这个角度看，区块链具有不可篡改的特性。
关于区块链
区块链自诞生以来，就备受争议。由于本身属于web3领域新秀，民众对区块链的了解仅仅停留于区块链货币，且区块链货币近些年来总被冠以“击鼓传花”和“庞氏骗局”的称号，再加之 大众对区块链本身认识就不够，自然也导致了区块链本身风评比较差。
什么是区块链
区块链是一种分布式的共享账本或数据库，且被称为世界上最慢的数据库，它允许用户存储数据，并让数据在网络中传播。存储于其中的数据或信息，具有去中心化、不可篡改等特点。
- 什么是分布式：多台计算机或服务器进行
分配处理的过程就叫分布式。 - 什么是账本：账本，顾名思义就是存储所有交易记录的媒介或者载体。
- 什么是数据库：数据库是存储和检索数据的载体。
- 什么是去中心化：去中心化，是指在互联网上，数据存储在各个节点上，而不是在某一台服务器上，每个节点都有完整的数据，并且可以独立运行。
区块链的分类
区块链分为如下三种：
1.公有链
公有区块链是任何人都可以加入和参与的区块链，例如比特币。 缺点可能包括：绝大部分公链系统需要较高的硬件资源来保障安全性，交易的隐私性极低或根本没有隐私性可言。而这些又是区块链企业用例的重要考虑因素。
2.私有链
私有区块链网络类似于公有区块链网络，是一个去中心化的点对点网络，其显著差异是，私有区块链的整个网络由一个组织管理。该组织有完全的权限来控制允许谁参与、维护区块链网络。 根据使用情况，可以显著提高参与者之间的信任和信心。私有区块链可以在企业防火墙后面运行，甚至可以在企业内部托管。
3.联盟链
多个组织可以分担维护区块链的责任。这些预先选定的组织将决定谁可以提交交易或访问数据。 在所有参与者都需要获得许可且对区块链负有共同责任时，财团区块链是业务理想的理想之选。
区块链的优缺点
区块链的优点：
- 难以篡改，更加安全。
在传统信息系统的安全方案中，安全依赖于层层设防的访问控制。通过区块链技术，记录交易的数据库任何人都可以访问，但由于巧妙的设计并辅以密码学和共识机制，区块链的数据记录方式使得修改某一数据需要变更所有的后续数据记录，难度极大。实践证明，这样一个数据库可以确保市值达千亿美金的比特币，在全球黑客的攻击下，运转稳定。
- 异构多活，可靠性强。
区块链每个系统参与方都是一个异地多活节点，是天生的多活系统。如果某个节点遇到网络问题、硬件故障、软件错误或者被黑客控制，均不会影响系统以及其他参与节点。区块链中的节点通过点对点的通信协议进行交互，在保证通信协议一致的情况下不同节点可由不同开发者使用不同的编程语言、不同版本的全节点来处理交易。由此构成的软件异构环境确保了即便某个版本的软件出现问题，区块链的整体网络不会受到影响，这也是其高可用的基石所在。
- 具备智能合约，自动执行。
智能合约具有透明可信、自动执行、强制履约的优点。尽管如此，自尼克·萨博 1993 年提出以来，智能合约始终停留在理念层面。重要原因在于，长久以来没有支持可信代码运行的环境，无法实现自动强制执行。而区块链第一次让智能合约的构想成为现实。
- 网状直接协作机制，更加透明。
区块链提供了不同于传统的方法，以对等的方式把参与方连接起来，由参与方共同维护一个系统，参与方职责明确，无需向第三方机构让渡权利，有利于各方更好地开展协作。作为信任机器，区块链有望成为低成本、高效率的一种全新的协作模式，形成更大范围、更低成本的新协同机制。
区块链早期缺点：
性能和扩展性不能满足要求，从目前的情况来看，区块链的性能问题主要表现为吞吐量及存储带宽远不能满足整个社会的支付需求。
数据隐私和访问控制有待改进。
治理机制有待完善。公有链社区摸索出了“硬分叉”和“软分叉” 等升级机制，但遗留问题有待观察。由于公有链不能“关停”，其错误修复也异常棘手，一旦出现问题，尤其是安全漏洞，将非常致命。
区块链技术改进方向：
主要集中在共识机制，性能，隐私和安全，治理机制，跨链技术等方面。
前置知识
在正式开始进行区块链学习前，你需要了解一些最基本的前置知识，才能正式进行区块链的学习。
- 密码学（特别是非对称加密知识）
- 哈希原理
- 分布式系统（特别是CAP理论）
区块链的架构
区块链的层级架构图如下：
六层架构
数据层：处于区块链技术的最底层，包含了数据区块、哈希函数、Merkel树、非对称公私钥数据加密技术、时间戳技术，主要有两大功能：数据存储、账户和交易的实现与安全。
网络层：这层主要包含了传输和验证机制，目的是实现区块链网络节点之间的信息交互。从本质上看，区块链是一个P2P网络。在区块链网络中，节点可以接受信息也可以产生信息，一个节点创造出新区块之后便会以广播形式通知其他节点，其他节点接收到信息后对该节点进行验证。
共识层：包含共识算法和共识机制，即让高度分散的节点在区块链网络中达成共识，决定由谁来进行记账，主要指解决账本“一致性”的问题。例如POW、POS、DPOS共识机制等。
激励层：主要出现在公有链中，包含经济激励的发行机制和分配机制，其目的就是提供一定的激励措施节点参与区块链的安全验证工作。 激励层也称为挖矿机制：为了维护挖矿活动以及账本更新持续进行，它将经济因素集成到区块链技术体系中来并设计出一套经济激励模型，奖惩分明。 通过奖励部分数字资产激励矿工验证交易信息，激励验证节点，惩罚恶意节点。
合约层：主要包括脚本、代码、算法和智能合约，可编程。将代码嵌入区块链中，通过数字代码实现自定义的智能合约，在达到预设规则和条件时自动触发执或自动解约，无需经由第三方就能够自动执行。例如生活中的无人售卖机、自动续费功能等。
应用层：是区块链的展示层，封装了其各种应用场景和案例，包含未来区块链应用落地的各个方面。类似于我们日常使用的应用程序、门户网站、搜索引擎等，有社交娱乐、电商购物等各种不同的应用场景展现在我们面前。
代码演示
本文中代码以Java为主要语言，开发框架为spring boot，开发工具为IntelliJ IDEA，进行示例程序开发。
数据层主要是存储数据、形成默克尔树等，那么我们在spring程序中只需要一个单例的本地cache（也可以暂存到Redis，但是这样不够典型）。类似的代码如下：
java
@ConfigurationProperties(prefix = "block")
@Component
public class BlockCache implements CommandLineRunner {
@Autowired
private RedisUtil redisUtil;
private static final String BLOCKCHAIN_KEY = "blockchain:dataList";
/**
* 当前节点的区块链结构
*/
private List<Block> blockChain = new CopyOnWriteArrayList<Block>();
/**
* 已打包保存的业务数据集合
*/
private List<Transaction> packedTransactions = new CopyOnWriteArrayList<Transaction>();
/**
* 当前节点的socket对象
*/
private List<WebSocket> socketsList = new CopyOnWriteArrayList<WebSocket>();
/**
* 挖矿的难度系数
*/
@Value("${block.difficulty}")
private int difficulty;
/**
* 当前节点p2pserver端口号
*/
@Value("${block.p2pport}")
private int p2pport;
/**
* 要连接的节点地址
*/
@Value("${block.address}")
private String address;
private static String difficultyString;
/**
* 获取最新的区块，即当前链上最后一个区块
*
* @return
*/
public Block getLatestBlock() {
return blockChain.size() > 0 ? blockChain.get(blockChain.size() - 1) : null;
}
public List<Block> getBlockChain() {
return blockChain;
}
public void setBlockChain(List<Block> blockChain) {
this.blockChain = blockChain;
}
public List<Transaction> getPackedTransactions() {
return packedTransactions;
}
public void setPackedTransactions(List<Transaction> packedTransactions) {
this.packedTransactions = packedTransactions;
}
public int getDifficulty() {
return difficulty;
}
public String difficultyString() {
if (difficultyString == null) {
difficultyString = "0".repeat(Math.max(0, difficulty));
}
return difficultyString;
}
public void setDifficulty(int difficulty) {
this.difficulty = difficulty;
}
public List<WebSocket> getSocketsList() {
return socketsList;
}
public void setSocketsList(List<WebSocket> socketsList) {
this.socketsList = socketsList;
}
public int getP2pport() {
return p2pport;
}
public void setP2pport(int p2pport) {
this.p2pport = p2pport;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public void flushBlockToRedis(Block block) {
try {
redisUtil.lRightPush(BLOCKCHAIN_KEY, block);
}
// 防止出现Redis连接问题
catch (Exception e) {
Thread thread = new Thread(() -> {
try {
sleep(1000);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}finally {
redisUtil.lRightPush(BLOCKCHAIN_KEY, block);
}
});
thread.start();
}
}
/**
* 初始化，从redis中获取数据加入到缓存
* @param args
*/
@Override
public void run(String... args) {
if (redisUtil.containsKey(BLOCKCHAIN_KEY)){
List<Object> cacheList = redisUtil.getCacheList(BLOCKCHAIN_KEY);
String jsonString = JSONArray.toJSONString(cacheList);
blockChain = JSONArray.parseArray(jsonString, Block.class);
}
}
}@ConfigurationProperties(prefix = "block")
@Component
public class BlockCache implements CommandLineRunner {
@Autowired
private RedisUtil redisUtil;
private static final String BLOCKCHAIN_KEY = "blockchain:dataList";
/**
* 当前节点的区块链结构
*/
private List<Block> blockChain = new CopyOnWriteArrayList<Block>();
/**
* 已打包保存的业务数据集合
*/
private List<Transaction> packedTransactions = new CopyOnWriteArrayList<Transaction>();
/**
* 当前节点的socket对象
*/
private List<WebSocket> socketsList = new CopyOnWriteArrayList<WebSocket>();
/**
* 挖矿的难度系数
*/
@Value("${block.difficulty}")
private int difficulty;
/**
* 当前节点p2pserver端口号
*/
@Value("${block.p2pport}")
private int p2pport;
/**
* 要连接的节点地址
*/
@Value("${block.address}")
private String address;
private static String difficultyString;
/**
* 获取最新的区块，即当前链上最后一个区块
*
* @return
*/
public Block getLatestBlock() {
return blockChain.size() > 0 ? blockChain.get(blockChain.size() - 1) : null;
}
public List<Block> getBlockChain() {
return blockChain;
}
public void setBlockChain(List<Block> blockChain) {
this.blockChain = blockChain;
}
public List<Transaction> getPackedTransactions() {
return packedTransactions;
}
public void setPackedTransactions(List<Transaction> packedTransactions) {
this.packedTransactions = packedTransactions;
}
public int getDifficulty() {
return difficulty;
}
public String difficultyString() {
if (difficultyString == null) {
difficultyString = "0".repeat(Math.max(0, difficulty));
}
return difficultyString;
}
public void setDifficulty(int difficulty) {
this.difficulty = difficulty;
}
public List<WebSocket> getSocketsList() {
return socketsList;
}
public void setSocketsList(List<WebSocket> socketsList) {
this.socketsList = socketsList;
}
public int getP2pport() {
return p2pport;
}
public void setP2pport(int p2pport) {
this.p2pport = p2pport;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public void flushBlockToRedis(Block block) {
try {
redisUtil.lRightPush(BLOCKCHAIN_KEY, block);
}
// 防止出现Redis连接问题
catch (Exception e) {
Thread thread = new Thread(() -> {
try {
sleep(1000);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}finally {
redisUtil.lRightPush(BLOCKCHAIN_KEY, block);
}
});
thread.start();
}
}
/**
* 初始化，从redis中获取数据加入到缓存
* @param args
*/
@Override
public void run(String... args) {
if (redisUtil.containsKey(BLOCKCHAIN_KEY)){
List<Object> cacheList = redisUtil.getCacheList(BLOCKCHAIN_KEY);
String jsonString = JSONArray.toJSONString(cacheList);
blockChain = JSONArray.parseArray(jsonString, Block.class);
}
}
}网络层主要是P2P交互，包括广播等。具体的示例代码如下：
java
@Service
public class P2PService implements ApplicationRunner {
@Autowired
BlockService blockService;
@Autowired
BlockCache blockCache;
@Autowired
P2PServer p2PServer;
@Autowired
P2PClient p2PClient;
/**
* 客户端和服务端共用的消息处理方法
* @param webSocket
* @param msg
* @param sockets
*/
public void handleMessage(
WebSocket webSocket, String msg, List<WebSocket> sockets) {
try {
Message message = JSON.parseObject(msg, Message.class);
System.out.println("接收到IP地址为：" +
webSocket.getRemoteSocketAddress().getAddress().toString()
+"，端口号为："+ webSocket.getRemoteSocketAddress().getPort()
+ "的p2p消息："
+ JSON.toJSONString(message));
switch (message.getType()) {
//客户端请求查询最新的区块:1
case BlockConstant.QUERY_LATEST_BLOCK:
write(webSocket, responseLatestBlockMsg());//服务端调用方法返回最新区块:2
break;
//接收到服务端返回的最新区块:2
case BlockConstant.RESPONSE_LATEST_BLOCK:
handleBlockResponse(message.getData(), sockets);
break;
//客户端请求查询整个区块链:3
case BlockConstant.QUERY_BLOCKCHAIN:
write(webSocket, responseBlockChainMsg());//服务端调用方法返回最新区块:4
break;
//直接接收到其他节点发送的整条区块链信息:4
case BlockConstant.RESPONSE_BLOCKCHAIN:
handleBlockChainResponse(message.getData(), sockets);
break;
}
} catch (Exception e) {
System.out.println("处理IP地址为：" +
webSocket.getRemoteSocketAddress().getAddress().toString()
+"，端口号为："+ webSocket.getRemoteSocketAddress().getPort()
+ "的p2p消息错误:"
+ e.getMessage());
}
}
/**
* 处理其它节点发送过来的区块信息
* @param blockData
* @param sockets
*/
public synchronized void handleBlockResponse(
String blockData, List<WebSocket> sockets) {
//反序列化得到其它节点的最新区块信息
Block latestBlockReceived = JSON.parseObject(blockData, Block.class);
//当前节点的最新区块
Block latestBlock = blockCache.getLatestBlock();
if (latestBlockReceived != null) {
if(latestBlock != null) {
//如果接收到的区块高度比本地区块高度大的多
if(latestBlockReceived.getIndex() > latestBlock.getIndex() + 1) {
broatcast(queryBlockChainMsg());
System.out.println("重新查询所有节点上的整条区块链");
}else if (latestBlockReceived.getIndex() > latestBlock.getIndex() &&
latestBlock.getHash().equals(
latestBlockReceived.getPreviousHash())) {
if (blockService.addBlock(latestBlockReceived)) {
broatcast(responseLatestBlockMsg());
}
System.out.println("将新接收到的区块加入到本地的区块链");
}
}else if(latestBlock == null) {
broatcast(queryBlockChainMsg());
System.out.println("重新查询所有节点上的整条区块链");
}
}
}
/**
* 处理其它节点发送过来的区块链信息
* @param blockData
* @param sockets
*/
public synchronized void handleBlockChainResponse(
String blockData, List<WebSocket> sockets) {
//反序列化得到其它节点的整条区块链信息
List<Block> receiveBlockchain = JSON.parseArray(blockData, Block.class);
if(!CollectionUtils.isEmpty(receiveBlockchain)
&& blockService.isValidChain(receiveBlockchain)) {
//根据区块索引先对区块进行排序
Collections.sort(receiveBlockchain, new Comparator<Block>() {
public int compare(Block block1, Block block2) {
return block1.getIndex() - block2.getIndex();
}
});
//其它节点的最新区块
Block latestBlockReceived = receiveBlockchain
.get(receiveBlockchain.size() - 1);
//当前节点的最新区块
Block latestBlock = blockCache.getLatestBlock();
if(latestBlock == null) {
//替换本地的区块链
blockService.replaceChain(receiveBlockchain);
}else {
//其它节点区块链如果比当前节点的长，则处理当前节点的区块链
if (latestBlockReceived.getIndex() > latestBlock.getIndex()) {
if (latestBlock.getHash().equals(
latestBlockReceived.getPreviousHash())) {
if (blockService.addBlock(latestBlockReceived)) {
broatcast(responseLatestBlockMsg());
}
System.out.println("将新接收到的区块加入到本地的区块链");
} else {
// 用长链替换本地的短链
blockService.replaceChain(receiveBlockchain);
}
}
}
}
}
/**
* 全网广播消息
* @param message
*/
public void broatcast(String message) {
List<WebSocket> socketsList = this.getSockets();
if (CollectionUtils.isEmpty(socketsList)) {
return;
}
System.out.println("======全网广播消息开始：");
for (WebSocket socket : socketsList) {
this.write(socket, message);
}
System.out.println("======全网广播消息结束");
}
/**
* 向其它节点发送消息
* @param ws
* @param message
*/
public void write(WebSocket ws, String message) {
System.out.println("发送给IP地址为：" +ws.getRemoteSocketAddress()
.getAddress().toString()
+ "，端口号为："+ws.getRemoteSocketAddress().getPort() +
" 的p2p消息:" + message);
ws.send(message);
}
/**
* 查询整条区块链
* @return
*/
public String queryBlockChainMsg() {
return JSON.toJSONString(new Message(BlockConstant.QUERY_BLOCKCHAIN));
}
/**
* 返回整条区块链数据
* @return
*/
public String responseBlockChainMsg() {
Message msg = new Message();
msg.setType(BlockConstant.RESPONSE_BLOCKCHAIN);
msg.setData(JSON.toJSONString(blockCache.getBlockChain()));
return JSON.toJSONString(msg);
}
/**
* 查询最新的区块
* @return
*/
public String queryLatestBlockMsg() {
return JSON.toJSONString(new Message(BlockConstant.QUERY_LATEST_BLOCK));
}
/**
* 返回最新的区块
* @return
*/
public String responseLatestBlockMsg() {
Message msg = new Message();
msg.setType(BlockConstant.RESPONSE_LATEST_BLOCK);
Block b = blockCache.getLatestBlock();
msg.setData(JSON.toJSONString(b));
return JSON.toJSONString(msg);
}
public List<WebSocket> getSockets(){
return blockCache.getSocketsList();
}
@Override
public void run(ApplicationArguments args) throws Exception {
p2PServer.initP2PServer(blockCache.getP2pport());
p2PClient.connectToPeer(blockCache.getAddress());
System.out.println("*****难度系数******"+blockCache.getDifficulty());
System.out.println("*****端口号******"+blockCache.getP2pport());
System.out.println("*****节点地址******"+blockCache.getAddress());
}
}@Service
public class P2PService implements ApplicationRunner {
@Autowired
BlockService blockService;
@Autowired
BlockCache blockCache;
@Autowired
P2PServer p2PServer;
@Autowired
P2PClient p2PClient;
/**
* 客户端和服务端共用的消息处理方法
* @param webSocket
* @param msg
* @param sockets
*/
public void handleMessage(
WebSocket webSocket, String msg, List<WebSocket> sockets) {
try {
Message message = JSON.parseObject(msg, Message.class);
System.out.println("接收到IP地址为：" +
webSocket.getRemoteSocketAddress().getAddress().toString()
+"，端口号为："+ webSocket.getRemoteSocketAddress().getPort()
+ "的p2p消息："
+ JSON.toJSONString(message));
switch (message.getType()) {
//客户端请求查询最新的区块:1
case BlockConstant.QUERY_LATEST_BLOCK:
write(webSocket, responseLatestBlockMsg());//服务端调用方法返回最新区块:2
break;
//接收到服务端返回的最新区块:2
case BlockConstant.RESPONSE_LATEST_BLOCK:
handleBlockResponse(message.getData(), sockets);
break;
//客户端请求查询整个区块链:3
case BlockConstant.QUERY_BLOCKCHAIN:
write(webSocket, responseBlockChainMsg());//服务端调用方法返回最新区块:4
break;
//直接接收到其他节点发送的整条区块链信息:4
case BlockConstant.RESPONSE_BLOCKCHAIN:
handleBlockChainResponse(message.getData(), sockets);
break;
}
} catch (Exception e) {
System.out.println("处理IP地址为：" +
webSocket.getRemoteSocketAddress().getAddress().toString()
+"，端口号为："+ webSocket.getRemoteSocketAddress().getPort()
+ "的p2p消息错误:"
+ e.getMessage());
}
}
/**
* 处理其它节点发送过来的区块信息
* @param blockData
* @param sockets
*/
public synchronized void handleBlockResponse(
String blockData, List<WebSocket> sockets) {
//反序列化得到其它节点的最新区块信息
Block latestBlockReceived = JSON.parseObject(blockData, Block.class);
//当前节点的最新区块
Block latestBlock = blockCache.getLatestBlock();
if (latestBlockReceived != null) {
if(latestBlock != null) {
//如果接收到的区块高度比本地区块高度大的多
if(latestBlockReceived.getIndex() > latestBlock.getIndex() + 1) {
broatcast(queryBlockChainMsg());
System.out.println("重新查询所有节点上的整条区块链");
}else if (latestBlockReceived.getIndex() > latestBlock.getIndex() &&
latestBlock.getHash().equals(
latestBlockReceived.getPreviousHash())) {
if (blockService.addBlock(latestBlockReceived)) {
broatcast(responseLatestBlockMsg());
}
System.out.println("将新接收到的区块加入到本地的区块链");
}
}else if(latestBlock == null) {
broatcast(queryBlockChainMsg());
System.out.println("重新查询所有节点上的整条区块链");
}
}
}
/**
* 处理其它节点发送过来的区块链信息
* @param blockData
* @param sockets
*/
public synchronized void handleBlockChainResponse(
String blockData, List<WebSocket> sockets) {
//反序列化得到其它节点的整条区块链信息
List<Block> receiveBlockchain = JSON.parseArray(blockData, Block.class);
if(!CollectionUtils.isEmpty(receiveBlockchain)
&& blockService.isValidChain(receiveBlockchain)) {
//根据区块索引先对区块进行排序
Collections.sort(receiveBlockchain, new Comparator<Block>() {
public int compare(Block block1, Block block2) {
return block1.getIndex() - block2.getIndex();
}
});
//其它节点的最新区块
Block latestBlockReceived = receiveBlockchain
.get(receiveBlockchain.size() - 1);
//当前节点的最新区块
Block latestBlock = blockCache.getLatestBlock();
if(latestBlock == null) {
//替换本地的区块链
blockService.replaceChain(receiveBlockchain);
}else {
//其它节点区块链如果比当前节点的长，则处理当前节点的区块链
if (latestBlockReceived.getIndex() > latestBlock.getIndex()) {
if (latestBlock.getHash().equals(
latestBlockReceived.getPreviousHash())) {
if (blockService.addBlock(latestBlockReceived)) {
broatcast(responseLatestBlockMsg());
}
System.out.println("将新接收到的区块加入到本地的区块链");
} else {
// 用长链替换本地的短链
blockService.replaceChain(receiveBlockchain);
}
}
}
}
}
/**
* 全网广播消息
* @param message
*/
public void broatcast(String message) {
List<WebSocket> socketsList = this.getSockets();
if (CollectionUtils.isEmpty(socketsList)) {
return;
}
System.out.println("======全网广播消息开始：");
for (WebSocket socket : socketsList) {
this.write(socket, message);
}
System.out.println("======全网广播消息结束");
}
/**
* 向其它节点发送消息
* @param ws
* @param message
*/
public void write(WebSocket ws, String message) {
System.out.println("发送给IP地址为：" +ws.getRemoteSocketAddress()
.getAddress().toString()
+ "，端口号为："+ws.getRemoteSocketAddress().getPort() +
" 的p2p消息:" + message);
ws.send(message);
}
/**
* 查询整条区块链
* @return
*/
public String queryBlockChainMsg() {
return JSON.toJSONString(new Message(BlockConstant.QUERY_BLOCKCHAIN));
}
/**
* 返回整条区块链数据
* @return
*/
public String responseBlockChainMsg() {
Message msg = new Message();
msg.setType(BlockConstant.RESPONSE_BLOCKCHAIN);
msg.setData(JSON.toJSONString(blockCache.getBlockChain()));
return JSON.toJSONString(msg);
}
/**
* 查询最新的区块
* @return
*/
public String queryLatestBlockMsg() {
return JSON.toJSONString(new Message(BlockConstant.QUERY_LATEST_BLOCK));
}
/**
* 返回最新的区块
* @return
*/
public String responseLatestBlockMsg() {
Message msg = new Message();
msg.setType(BlockConstant.RESPONSE_LATEST_BLOCK);
Block b = blockCache.getLatestBlock();
msg.setData(JSON.toJSONString(b));
return JSON.toJSONString(msg);
}
public List<WebSocket> getSockets(){
return blockCache.getSocketsList();
}
@Override
public void run(ApplicationArguments args) throws Exception {
p2PServer.initP2PServer(blockCache.getP2pport());
p2PClient.connectToPeer(blockCache.getAddress());
System.out.println("*****难度系数******"+blockCache.getDifficulty());
System.out.println("*****端口号******"+blockCache.getP2pport());
System.out.println("*****节点地址******"+blockCache.getAddress());
}
}示例系统在共识层的权益机制方面使用的是工作量证明。工作量证明俗称
挖矿。本质上是一个伯努利实验。具体代码如下：
java
/**
* 共识机制
* 采用POW即工作量证明实现共识
* @author Administrator
*
*/
@Service
public class PowService {
@Autowired
BlockCache blockCache;
@Autowired
BlockService blockService;
@Autowired
P2PService p2PService;
/**
* 通过“挖矿”进行工作量证明，实现节点间的共识
*
* @return
* @throws
*/
public Block mine(Object businessData){
// 封装业务数据集合，记录区块产生的节点信息，临时硬编码实现
List<Transaction> tsaList = new ArrayList<Transaction>();
Transaction tsa1 = new Transaction();
if (blockCache.getBlockChain().size()==0) blockService.createGenesisBlock();
// 写入业务数据
Transaction data=new Transaction();
data.setId("0");
data.setBusinessInfo(JSON.toJSONString(businessData));
tsaList.add(data);
// 通报挖矿节点
tsa1.setId("1");
tsaList.add(tsa1);
// 通报区块链高度，以预见软硬分叉问题
Transaction tsa2 = new Transaction();
tsa2.setId("2");
tsa2.setBusinessInfo("区块链高度为："+(blockCache.getLatestBlock().getIndex()+1));
tsaList.add(tsa2);
// 定义每次哈希函数的结果
String newBlockHash = "";
int nonce = 0;
long start = System.currentTimeMillis();
System.out.println("开始挖矿");
while (true) {
// 计算新区块hash值
newBlockHash = blockService.calculateHash
(blockCache.getLatestBlock().getHash(), tsaList, nonce);
// 校验hash值
if (blockService.isValidHash(newBlockHash)) {
System.out.println("挖矿完成，正确的hash值：" + newBlockHash);
break;
}
System.out.println("第"+(nonce+1)+"次尝试计算的hash值：" + newBlockHash);
nonce++;
}
// 创建新的区块
Block block = blockService.createNewBlock(
nonce, blockCache.getLatestBlock().getHash(), newBlockHash, tsaList);
//创建成功后，全网广播出去
Message msg = new Message();
msg.setType(BlockConstant.RESPONSE_LATEST_BLOCK);
msg.setData(JSON.toJSONString(block));
p2PService.broatcast(JSON.toJSONString(msg));
return block;
}
}/**
* 共识机制
* 采用POW即工作量证明实现共识
* @author Administrator
*
*/
@Service
public class PowService {
@Autowired
BlockCache blockCache;
@Autowired
BlockService blockService;
@Autowired
P2PService p2PService;
/**
* 通过“挖矿”进行工作量证明，实现节点间的共识
*
* @return
* @throws
*/
public Block mine(Object businessData){
// 封装业务数据集合，记录区块产生的节点信息，临时硬编码实现
List<Transaction> tsaList = new ArrayList<Transaction>();
Transaction tsa1 = new Transaction();
if (blockCache.getBlockChain().size()==0) blockService.createGenesisBlock();
// 写入业务数据
Transaction data=new Transaction();
data.setId("0");
data.setBusinessInfo(JSON.toJSONString(businessData));
tsaList.add(data);
// 通报挖矿节点
tsa1.setId("1");
tsaList.add(tsa1);
// 通报区块链高度，以预见软硬分叉问题
Transaction tsa2 = new Transaction();
tsa2.setId("2");
tsa2.setBusinessInfo("区块链高度为："+(blockCache.getLatestBlock().getIndex()+1));
tsaList.add(tsa2);
// 定义每次哈希函数的结果
String newBlockHash = "";
int nonce = 0;
long start = System.currentTimeMillis();
System.out.println("开始挖矿");
while (true) {
// 计算新区块hash值
newBlockHash = blockService.calculateHash
(blockCache.getLatestBlock().getHash(), tsaList, nonce);
// 校验hash值
if (blockService.isValidHash(newBlockHash)) {
System.out.println("挖矿完成，正确的hash值：" + newBlockHash);
break;
}
System.out.println("第"+(nonce+1)+"次尝试计算的hash值：" + newBlockHash);
nonce++;
}
// 创建新的区块
Block block = blockService.createNewBlock(
nonce, blockCache.getLatestBlock().getHash(), newBlockHash, tsaList);
//创建成功后，全网广播出去
Message msg = new Message();
msg.setType(BlockConstant.RESPONSE_LATEST_BLOCK);
msg.setData(JSON.toJSONString(block));
p2PService.broatcast(JSON.toJSONString(msg));
return block;
}
}通过以上代码，实现了区块链架构的下三层。实际上整个区块链系统重要的部分就已经实现了。
应用领域
区块链前后分为了三个时代：
货币时代、合约时代和治理时代。同时，在区块链趋于商业化的道路上，是一个实现
完全去中心化到有效去中心化的过程。完全去中心化只是一种理想的状态，实际上，区块链的去中心化，并不是指没有中心，而是指没有中心化的中心。这一点可以参考了解比特币挖矿过程中，矿池（一种算力集群，类似矿场之于矿工的关系）的产生。故此，区块链的有机效用停留在三个方面：有效降低商业摩擦、为非标产品定价、大规模分布式协同。
而这些概念，具体可以应用到如下领域：
物联网
区块链可通过物联网设施，实现与物理实体的自动化联接，从而实现区块链信任与物理世界信任的有机融合与自动统一。
人工智能
区块链技术简而言之就是信任的技术，最典型的区块链就是加密货币。人工智能是计算机科学的一个分支，它企图了解智能的实质，并生产出一种与人类智能相似的智能机器。该领域的研究包括机器人、自动驾驶、语言识别、图像识别、自然语言处理等。 人工智能的关键，是一种模仿人类思考和执行的能力，这种能力依赖于数据构造出来的模型。如果数据越多越全面，那么模型可能越优越。 而区块链就可以为人工智能提供一份优良的数据，数据可在共识机制下写入、可追溯、无法篡改，另外，区块链的分布式记账法，保证了数据的备份 也有利于跨区域共享数据，建立一个超级数据账本，在区块链技术下，这种超级数据账本的建立成本很小，而且不用担心数据的安全性。
金融
- 数字货币 ：
比特币是目前区块链技术最广泛、最成功的运用，在比特币基础上，又衍生出了大量其他种类的去中心化数字货币（ ETH,狗狗币,莱特币等种类 2000 余种）。国家发行数字货币将成趋势。 - 支付清算 ：传统支清算系统的处理流程于过繁琐，成本较高；区块链支付可以为交易双方直接进行端到端支付，不涉及中间机构，在提高速度和降低成本方面能得到大幅的改善。
- 数字票据 ：一是可实现票据价值传递的去中心化；二是能够有效防范票据市场风险.
- 银行征信管理 ：在征信领域，区块链的优势在于可依靠程序算法自动记录信用相关信息，并存储在区块链网络的每一台计算机上，信息透明、不可篡改、使用成本低。
- 权益证明和交易所证券交易 ：在区块链系统中，交易信息具有不可篡改性和不可抵赖性。该属性可充分应用于对权益的所有者进行确权。
- 保险管理 ：随着区块链技术的发展，未来关于个人的健康状况、发生事故记录等信息可能会上传至区块链中，使保险公司在客户投保时可以更加及时、准确地获得风险信息，从而降低核保成本、提升效率。
- 金融审计 ：由于区块链技术能够保证所有数据的完整性、永久性和不可更改性，因而可有效解决审计行业在交易取证、追踪、关联、回溯等方面的难点和痛点。
- 客户征信与反欺诈 ：银行的客户征信及法律合规的成本不断增加。记载于区块链中的客户信息与交易纪录有助于银行识别异常交易并有效防止欺诈。
- 跨境支付与结算 ：当前的跨境支付结算时间长、费用高、又必须通过多重中间环节。区块链将可摒弃中转银行的角色，实现点到点快速且成本低廉的跨境支付
- 票据与供应链金融业务 :票据及供应链金融业务因人为介入多，导致许多违规事件及操作风险。实现票据价值传递的去中介化。供应链金融也能通过区块链减少人工成本、提高安全度及实现端到端透明化。
- 证券发行与交易 ：证券的发行与交易的流程手续繁杂且效率低下。区块链技术使得金融交易市场的参与者享用平等的数据来源，让交易流程更加公开、透明、有效率。区块链技术可准实时地记录交易者的身份、交易量等关键信息，有利于证券发行者更快速清晰地了解股权结构，提升商业决策效率；
供应链
- 物源追踪 ：大的公司和企业在供应链都有很多的因素。因为这样，甚至对于跨国企业，追踪每个记录都是几乎不可能的。缺少透明度就导致了成本和客户关系问题，这会使得企业的名气被毁。在基于区块链的供应链管理体系中，记录存储和溯源都是很容易的，因为企业的信息可以通过内置感应器和RFID标签来获得产品信息。产品从起源地到终点所在的过程都可以通过区块链来追踪。而且，这类准确的溯源方式，可以用来检测供应链中的缺陷。
- 降低成本 ：通过区块链，产品在供应链中的实时追踪会降低整体转移的成本。当区块链被用来加速供应链的管理流程，就会自动减少系统中多余的成本，同时还能保证交易的安全性。客户和供应商可以使用数字货币在供应链中进行支付，而不是依赖于EDI。而且，效率可以提高，产品丢失的风险也会因为准确的记录而降低。
- 建立信任 ：在复杂的区块链中，多方间的信任很有必要。例如，当生产商和供应商分享产品，它可能会依赖于跟随工厂安全的标准。同时，当讨论到监管条例，例如海关条例，信任就会显得很重要。区块链的不可更改性可以防止造假，并且建立信任。
保险
- 有助于提升保险业务的安全性 ：区块链技术通过加密算法实现了对客户信息的保护。
- 有助于缓解保险业务的信息不对称 ：区块链技术通过数字化合同将信誉变成一个具有可管理的属性。保险公司可以轻而易举地发现赔付过程中是否存在重复交易或者是否存在可疑交易当事人的交易。
- 基于智能合约有助于提升保险行业的效率 ：智能合约可以支持自动化索赔，它是一种透明且可靠的支付机制，并且可以用来执行特定于合同的规则。
教育
- 学历证书区块链 ：通过在区块链上创建类似学术成绩单和资格证书这样的记录，利用 Blockcerts 可以审查文件是否可信并发现伪造的信息。
- 资格证书区块链 ：利用区块链、智能合约以及机器学习技术来验证学生和教授的学术资格证书
- 知识分享区块链 ：知识分享平台，学生或作者其上面分享和探讨小说、文学作品或者其他相关信息，可以用虚拟币（虚拟物品）奖励用户，以鼓励用户参与内容的分享、讨论和创作。这些代币可以用来购买平台上的数字化的学术书籍。
- 去中心化的教育产品集 ： 利用区块链将教育者、学生和专业人士连接到相关的课程和资源。
- 竞赛成绩区块链 ：支持教育机构在该平台账本上记录学生的学术成就及其他适当的信息，从而创建不可否认的学习记录。区块链帮助教育机构记录学生的数字化成绩单以及学生的支付记录。
- 区块链教育网络 ：世界各地对区块链和数字加密货币感兴趣的学生和毕业生组成，他们分享区块链方面的思路、构建原型并上线其产品。
- 产学合作区块链 ：教育机构与用人企业之间多赢的机制，现在教育存在的问题之一就是封闭办学、即学生的技能信息、知识体系未与用人企业的技能需求、市场趋势保持信息对称。通过引入区块链技术，实现学生技能与社会用人需求无缝衔接，可精确评估人才录用、岗位安排的科学性和合理性，能有效促进学校和企业之间的合作。
其他领域
区块链还可以用于**信息公开、文件防篡改、电子合同（蚂蚁的授权合同就是一个典型例子）**等应用场景。