区块链的产生基础
区块链：是一种分布式数据库，是一串使用密码学方法相关联产生的数据块链表，每个数据块都包含了一次网络交易信息，用于验证其信息的有效性和生成下一个区块。
其特点：
1.去中心化：实现点对点直接交互，既节约资源，使交易自主化、简易化，又排除被中心化代理控制的风险
2.开放性：区块链可以理解为一种公共记账的技术方案，系统是完全开放透明的，账簿对所有人公开，实现数据共享，任何人都可以查账。
3.不可撤销、不可篡改和加密安全性： 区块链采取单向哈希算法，每个新产生的区块严格按照时间线形顺序推进，时间的不可逆性、不可撤销导致任何试图入侵篡改区块链内数据信息的行为易被追溯，导致被其他节点的排斥，造假成本极高，从而可以限制相关不法行为。
4.自治性：区块链采用基于协商一致的规范和协议（比如一套公开透明的算法），然后各个节点就按照这个规范来操作，这样就是所有的东西都有机器完成，就没有人情成分。 使得对"人"的信任改成了对机器的信任，任何人为的干预不起作用
5.匿名性：区块链上面没有个人的信息，因为这些都是加密的，是一堆数字字母组成的字符串，这样就不会出现你的各种身份证信息、电话号码被倒卖的现象。
区块链表现的数据形式：
区块链就是一串或者是一系列区块的集合，类似于链表的概念，每个区块都指向于后面一个区块，然后顺序的连接在一起。主要包括三个部分：自己的数字签名，上一个区块的数字签名，还有一切需要加密的数据（这些数据在比特币中就相当于是交易的信息，它是加密货币的本质）。每个数字签名不但证明了自己是特有的一个区块，而且指向了前一个区块的来源，让所有的区块在链条中可以串起来，而数据就是一些特定的信息，你可以按照业务逻辑来保存业务数据。
区块链分哪几种？
区块链包括公有连、联盟链、私有链三种。
公有链：无官方发行机构，由参与者自行组成，任何节点都可以随时加入随时退出。
联盟链：节点加入需要申请和身份验证并签订协议，采用基于协议的共识机制，由预设的某些节点进行记。账、建立区块，实现分布式账本，全网所有几点都可以参与交易，并查看所有账本。
私有链：建立在某个机构内部，具体规则由机构自己来设定。
JAVA 抒写简单的区块
写一个区块object对象
package block;
import java.security.MessageDigest;
/**
* 区块
* @author luzhongliang
*
*/
public class Block {
/**
* 索引
*/
private int index;
/**
* 前一个区块的hashValue
*/
private String previousHash;
/**
* 时间梭
*/
private long timeStamp;
/**
* date
*/
private String date;
/**
* hash
*/
private String hash;
/**
* nonce 难度系数调节值（用于计算符合难度系数的变化量）
*/
private long nonce;
public Block(int index, String previousHash, long timeStamp, String date, String hash, long nonce) {
super();
this.index = index;
this.previousHash = previousHash;
this.timeStamp = timeStamp;
this.date = date;
this.hash = hash;
this.nonce = nonce;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getPreviousHash() {
return previousHash;
}
public void setPreviousHash(String previousHash) {
this.previousHash = previousHash;
}
public long getTimeStamp() {
return timeStamp;
}
public void setTimeStamp(long timeStamp) {
this.timeStamp = timeStamp;
}
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
public String getHash() {
return hash;
}
public void setHash(String hash) {
this.hash = hash;
}
public long getNonce() {
return nonce;
}
public void setNonce(long nonce) {
this.nonce = nonce;
}
}
BLOCK的处理
package block;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.NumberFormat;
import java.util.ArrayList;
import com.alibaba.fastjson.JSON;
public class BlockManger {
/**
* 区块链:逻辑上链表形式，
* 存储根据具体运用设计
*/
private ArrayList<Block> blocKChain = new ArrayList<>();
/**
* 难度系 越高 计算出下一个区块时间越长
*/
private static final int DIFFICULTY_NUM = 4;
/**
* 根据难度系数生成的hash前缀
*/
private String DIFFICULTY_Str = "";
public BlockManger() {
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < DIFFICULTY_NUM; i++) {
buffer.append(0);
}
DIFFICULTY_Str = buffer.toString();
}
/**
*
* @param objectDate 数据交易的记录 为NUll创建起始区块
* @return
*/
public Block creatBlock(Object objectDate) {
int index = 0;
String previousHash = "0";
String date = "Genesis：起始块";
long timeStamp = System.currentTimeMillis();
String hash;
long nonce = 0;
if (blocKChain.size() > 0) {
/**
* 前一个区块
*/
Block previousBlcok = blocKChain.get(blocKChain.size() - 1);
index = previousBlcok.getIndex() + 1;
previousHash = previousBlcok.getHash();
/**
* JSON 把交易数据专实体 转化为字符串
*/
date = JSON.toJSONString(objectDate);
}else {
if(objectDate!=null) {
return null;
}
}
try {
/**
* 生成hash值 它的耗时即为挖矿时间
*/
while (nonce < Long.MAX_VALUE) {
StringBuffer buffer = new StringBuffer();
/**
* 需要加密的对象转化为字符串对象
*/
buffer.append(index).append(timeStamp).append(previousHash).append(date).append(nonce);
timeStamp = System.currentTimeMillis();
/**
* 这里使用SHA-256加密算法对其加密，生成的哈希值大小为 256 位
*/
MessageDigest digest = MessageDigest.getInstance("SHA-256");
/**
* 放入block 对象中需要加密的对象
*/
digest.update(buffer.toString().getBytes());
/**
* 生成报文
*/
byte[] bytes = digest.digest();
/**
* 转化为16进制最为Hash值
*/
hash = bytesToHexString(bytes);
/**
* 判断是否符合难度设计
*/
if (hash.startsWith(DIFFICULTY_Str)) {
return new Block(index, previousHash, timeStamp, date, hash, nonce);
} else {
/**
* 变量，用来找出符合难度的设计的Hash
*/
nonce++;
}
}
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* byte转化为16进制的方法
* @param src
* @return
*/
private String bytesToHexString(byte[] src) {
StringBuilder stringBuilder = new StringBuilder("");
if (src == null || src.length <= 0) {
return null;
}
for (int i = 0; i < src.length; i++) {
int v = src[i] & 0xFF;
String hv = Integer.toHexString(v);
if (hv.length() < 2) {
stringBuilder.append(0);
}
stringBuilder.append(hv);
}
return stringBuilder.toString();
}
/**
* 检验区块链 合法性
* @return
*/
public boolean cheakBolckChain() {
if (blocKChain.size() < 2) {
/**
*i=0为起始区块
* 从 i=1 加入的记录区块开始核验
*/
for (int i = 1; i < blocKChain.size(); i++) {
//前一个区块
Block previousBlcok = blocKChain.get(i - 1);
//核验区块
Block blcok = blocKChain.get(i);
//hash 前后关联是否相等
if (!previousBlcok.getHash().equals(blcok.getPreviousHash())) {
return false;
}
//hash 是否符合难度设计
if (!blcok.getPreviousHash().startsWith(DIFFICULTY_Str)) {
return false;
}
//更具需要加密的内容重新加密生成新的hash 若不相等则内容被修改
StringBuffer buffer = new StringBuffer();
MessageDigest digest;
try {
digest = MessageDigest.getInstance("SHA-256");
buffer.append(blcok.getIndex()).append(blcok.getTimeStamp()).append(blcok.getTimeStamp()).append(blcok.getDate()).append(blcok.getNonce());
digest.update(buffer.toString().getBytes());
byte[] bytes = digest.digest();
String hash = bytesToHexString(bytes);
if(!hash.equals(blcok.getHash())) {
return false;
}
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return true;
}
return true;
}
public void add(Block block) {
blocKChain.add(block);
}
public static void main(String[] args) {
BlockManger blockManger=new BlockManger();
blockManger.add(blockManger.creatBlock(null));
blockManger.add(blockManger.creatBlock("1"));
blockManger.add(blockManger.creatBlock("2"));
blockManger.add(blockManger.creatBlock("3"));
System.out.println(JSON.toJSON(blockManger.blocKChain));
}
}
以上Java代码即为 简单的区块链表现表现形式。