区块链的定义和概念

@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);
		}
	}
}

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

	}

}

/**
 * 共识机制
 * 采用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;
	}

}