最近项目需要用到区块链来对某些信息进行快速校验，且由于每天的信息量都是很大的，因此直接使用区块链来保存信息是不可行的，故使用Merkle树的叶子节点先对传入的信息进行一次hash加密，紧接着利用结点两两hash构造Merkle树得到Merkle Root 最后与前区块hash，时间戳等信息一起再hash加密得到当前区块信息。

当数据被攻击篡改：

Merkle树构造算法：
设置Merkle树的基本架构，包括左右孩子，数据域，是否叶子几点和对应的信息主键

public class MerKleTreeNode {
    private MerKleTreeNode lChild;
    private MerKleTreeNode rChild;
    private String data;
    private Integer isLeaf;
    private Integer infoId;
}

先对叶子节点进行构造hash

for(Map<String,String> map : list){
            MerKleTreeNode node = new MerKleTreeNode(null,null,BlockHashAlgoUtils.encodeDataBySHA_256(map),1,-1);
            res.add(node);
}

由于Merkle二叉树的话可以利用他两两hash的缘故，构造一颗满二叉树，再利用满二叉树的特性（序号编排特点，树高公式，每层节点数公式）等等一切与满二叉树的特点，可以达到快速的存取MerkleTreeNode。既然要构造满二叉树，我们可以先利用叶子节点，通过求出一个数，设该数为 X，X必须大于叶子节点数，且是2的幂次数（1,2,4,8…），且X不能太大，不然造成空间浪费，必须越接近叶子节点总数越好。

        if((size & (size -1))!=0){
            int n = size;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            n = n >= MAXIMUM ? MAXIMUM : n + 1;
            //计算差距
            int distance = n - size;
            for(int i =size-distance;i < size; i++){
                //复制对称数据，凑齐merkle树所有节点
                data.add(data.get(i));
            }
            size = n;
        }

上图例子如下：
init: 0001101011011001
>>>1: 0001101010000100 | 0000110101000010 = 000111111000110
````````(无符号右移类推)
====>>> 0001111111111111
res = 0001111111111111 + 1 = 0010000000000000 = 2^14
利用高位右移的特性，其实就是把传入进来的数通过无符号右移把他所有的位都变为1，最后在通过一次+1 ，既可以在原数的下一个最高位上得到一个1，且其余的位置因为2进制的缘故变为了0，这下就可以得到一个准确地 X

接着就是计算一些高度啊，序号，以及每层拥有的节点树
获取size的二进制形式，它的长度就是merkle树的高度，也就是该二进制的长度

  int height = Integer.toBinaryString(size).length();
	int idxStart = (total +1) >> 1;
	int total = (int)(Math.pow(2,height)-1);

最后构造Merkle树
idxStart作为计算每一层节点（从左数起）第一个叶子节点的序号（根节点从1开始编排）

while(height-1>0){
                /**
                 * 总节点数 2^n-1
                 * 每一层的最左节点序号
                 */
                total = (int)(Math.pow(2,height-1)-1);
                idxStart = (total +1) >> 1;
                /**
                 * 逐层构建，new temp(list) 作为新一层的数据赋值到data（list）上，循环
                 */
                ArrayList<MerKleTreeNode> temp = new ArrayList<>();
                for(int j = 0; j < size ; j+=2){
                    MerKleTreeNode lChild = data.get(j);
                    MerKleTreeNode rChild = data.get(j+1);
                    String hash = BlockHashAlgoUtils.encodeDataBySHA_256(lChild.getData() + rChild.getData());
                    MerKleTreeNode node = new MerKleTreeNode(lChild, rChild, hash,0,-1);
                    temp.add(node);
                    //输出非叶节点的序号
                    System.out.println(idxStart++);
                }
            //temp 下个循环进行新建回收，赋值data
            data = temp;
            height--;
            //size长度每次减半
            size = size >> 1;
        }

接下来是SPV验证，由于数组存储不方便展示，顾我把数据先行存放在数据库中，利用index字段存储数组的下标。
进行SPV查询，最重要的就是需要先获取SPV验证路径（即需要对两两hash的另一半作为固定的因素，如下图黑圈所示），还是根据满二叉树的序号特点，通过计算下标
如图所示，很明显，左节点都是偶数，右节点是奇数，根结点是1，可以利用这个特性，根据传入消息所在的index快速得到所有的spv验证路径节点的index

 while(idx>1){
                /**
                 * if 是偶数左节点，取他的右兄弟节点
                 * else 取左节点
                 * 完成后向父节点移动
                 */
                if((idx&1) == 0){
                    list.add(idx+1);
                }else{
                    list.add(idx-1);
                }
                idx = idx >> 1;
            }
            /**
             * 1也要加入进去
             */
            list.add(idx);
            //根据集合在list集合中的数据去数据库中查询所有的节点
         		........(查库操作)
         }

接着就是再一次构造hash分支重新得到MerkleRoot了，与已经上传到区块链上的merkleROOT进行比对，既可以判断是否又被修改信息。

if(CollectionUtils.isEmpty(checkProofs)){
            return res;
        }
        /**
         * 从集合中取出一个，任意一个所属的区块和链都应相同
         */
        Integer blockIndex = checkProofs.get(0).getBlockIndex();
        MerkleNode merkleRoot = getMerkleRoot(blockIndex);
        if(Objects.isNull(merkleRoot)){
            return res;
        }
        /**
         * 与区块链上的block比对Merkle Root
         */
        Blockchain blockchain = blockchainMapper.selectByPrimaryKey(blockIndex);
        if(!blockchain.getBlockMerkle().equals(merkleRoot.getHash())){
            return res;
        }
        /**
         *  与merkle树上的验证路径比对
         *  mapper降序处理
         *  通过奇偶判断左右孩子
         *  跑到最后一层即可,不用继续计算
         */
        Info info = infoMapper.selectByPrimaryKey(infoId);
        String hash = BlockHashAlgoUtils.encodeDataBySHA_256(info.toString());
        for(int i = checkProofs.size()-1;i>0;i--){
            MerkleNode node2 = checkProofs.get(i);
            if((node2.getMerkleNodeIndex()&1)==0){
                hash = BlockHashAlgoUtils.encodeDataBySHA_256(node2.getHash()+hash);
            }else{
                hash = BlockHashAlgoUtils.encodeDataBySHA_256(hash + node2.getHash());
            }
        }
        /**
         * 新生成的与merkle root再次比对
         */
        if(!blockchain.getBlockMerkle().equals(hash)){
            return res;
        }

总的来说，采用Merkle + SPV的好处就是当需要验证海量信息中某个信息是否遭到修改，可以无需得知所有节点的信息，只需要验证某个小分支的节点即可，所需要的节点只需要log（n+1）个，当数量级很大的时候，节省的空间是很可观的，用户也无需承担那么大的代价，他们只需要保留区块链的头部数据即可。
余下就是区块链的特点了，由于MerkleRoot保存在区块链中，所以对应的信息可基本可以保障他的可靠性（仍有可能发生hash碰撞的因素，看利用的hash算法）