区块链源码研究


目前看了一哈一个简易区块链的源码，下面贴贴自己的研究结果：


-------------------------------------------------------------------------------------------
-----------------------------------Block.java---------------------------------------------
-------------------------------------------------------------------------------------------
package com.fpfpp.server.blockchain;


public class Block {
	
    //索引值
	private int    index;
    //上一条记录的hash值
    private String previousHash;
    //插入block时的时间戳
    private long   timestamp;
    //插入的数据
    private String data;
    //计算得出的当前的hash值
    private String hash;


    public Block() {
    }


    public Block(int index, String previousHash, long timestamp, String data, String hash) {
        this.index = index;
        this.previousHash = previousHash;
        this.timestamp = timestamp;
        this.data = data;
        this.hash = hash;
    }


    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 getData() {
        return data;
    }


    public void setData(String data) {
        this.data = data;
    }


    public String getHash() {
        return hash;
    }


    public void setHash(String hash) {
        this.hash = hash;
    }
}




-------------------------------------------------------------------------------------------
-----------------------------------BlockService.java-------------------------------------
-------------------------------------------------------------------------------------------


package com.fpfpp.server.blockchain;


import java.util.ArrayList;
import java.util.List;


public class BlockService {
	
	//用来保存所有数据的区块链表
    private List<Block> blockChain;


    public BlockService() {
        this.blockChain = new ArrayList<Block>();
        blockChain.add(this.getFristBlock());
    }


    //非常原始的。就时把previousHash加上时间戳，加上数据。然后算出hash值。
    private String calculateHash(int index, String previousHash, long timestamp, String data) {
        StringBuilder builder = new StringBuilder(index);
        builder.append(previousHash).append(timestamp).append(data);
        return CryptoUtil.getSHA256(builder.toString());
    }


    //获取插入的最后一个区块
    public Block getLatestBlock() {
        return blockChain.get(blockChain.size() - 1);
    }


    //获取第一个区块
    private Block getFristBlock() {
        return new Block(1, "0", System.currentTimeMillis(), "Hello Block", "aa212344fc10ea0a2cb885078fa9bc2354e55efc81be8f56b66e4a837157662e");
    }


    //产生下一个区块
    public Block generateNextBlock(String blockData) {
        Block previousBlock = this.getLatestBlock();
        int nextIndex = previousBlock.getIndex() + 1;
        long nextTimestamp = System.currentTimeMillis();
        String nextHash = calculateHash(nextIndex, previousBlock.getHash(), nextTimestamp, blockData);
        return new Block(nextIndex, previousBlock.getHash(), nextTimestamp, blockData, nextHash);
    }


    public void addBlock(Block newBlock) {
        if (isValidNewBlock(newBlock, getLatestBlock())) {
            blockChain.add(newBlock);
        }
    }


    //比较新区块是否有效区块。
    private boolean isValidNewBlock(Block newBlock, Block previousBlock) {
        if (previousBlock.getIndex() + 1 != newBlock.getIndex()) {
            System.out.println("invalid index");
            return false;
        } else if (!previousBlock.getHash().equals(newBlock.getPreviousHash())) {
            System.out.println("invalid previoushash");
            return false;
        } else {
            String hash = calculateHash(newBlock.getIndex(), newBlock.getPreviousHash(), newBlock.getTimestamp(),
                    newBlock.getData());
            if (!hash.equals(newBlock.getHash())) {
                System.out.println("invalid hash: " + hash + " " + newBlock.getHash());
                return false;
            }
        }
        return true;
    }


    public void replaceChain(List<Block> newBlocks) {
        if (isValidBlocks(newBlocks) && newBlocks.size() > blockChain.size()) {
            blockChain = newBlocks;
        } else {
            System.out.println("Received blockchain invalid");
        }
    }


    private boolean isValidBlocks(List<Block> newBlocks) {
    	//校验第一个区块是否一致.
    	Block fristBlock = newBlocks.get(0);
        if (fristBlock.equals(getFristBlock())) {
            return false;
        }
        //再依次校验所有的区块是否一致。
        for (int i = 1; i < newBlocks.size(); i++) {
            if (isValidNewBlock(newBlocks.get(i), fristBlock)) {
                fristBlock = newBlocks.get(i);
            } else {
                return false;
            }
        }
        return true;
    }


    public List<Block> getBlockChain() {
        return blockChain;
    }


}


-------------------------------------------------------------------------------------------

-----------------------------------CryptoUtil.java----------------------------------------

-------------------------------------------------------------------------------------------



package com.fpfpp.server.blockchain;


import java.security.MessageDigest;


public class CryptoUtil {
    private CryptoUtil() {
    }
    
    //加密字符串成hash值。
    public static String getSHA256(String str) {
        MessageDigest messageDigest;
        String encodeStr = "";
        try {
            messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.update(str.getBytes("UTF-8"));
            encodeStr = byte2Hex(messageDigest.digest());
        } catch (Exception e) {
            System.out.println("getSHA256 is error" + e.getMessage());
        }
        return encodeStr;
    }


    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        String temp;
        for (int i = 0; i < bytes.length; i++) {
            temp = Integer.toHexString(bytes[i] & 0xFF);
            if (temp.length() == 1) {
                builder.append("0");
            }
            builder.append(temp);
        }
        return builder.toString();
    }
}



-------------------------------------------------------------------------------------------
-----------------------------------HTTPService.java-------------------------------------
-------------------------------------------------------------------------------------------




package com.fpfpp.server.blockchain;


import com.alibaba.fastjson.JSON;
import org.java_websocket.WebSocket;


import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.InetSocketAddress;


public class HTTPService {
    private BlockService blockService;
    private P2PService   p2pService;


    public HTTPService(BlockService blockService, P2PService p2pService) {
        this.blockService = blockService;
        this.p2pService = p2pService;
    }


    public void initHTTPServer(int port) {
        try {
//            Server server = new Server(port);
//            System.out.println("listening http port on: " + port);
//            ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
//            context.setContextPath("/");
//            server.setHandler(context);
//            context.addServlet(new ServletHolder(new BlocksServlet()), "/blocks");
//            context.addServlet(new ServletHolder(new MineBlockServlet()), "/mineBlock");
//            context.addServlet(new ServletHolder(new PeersServlet()), "/peers");
//            context.addServlet(new ServletHolder(new AddPeerServlet()), "/addPeer");
//            server.start();
//            server.join();
        } catch (Exception e) {
            System.out.println("init http server is error:" + e.getMessage());
        }
    }


    private class BlocksServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setCharacterEncoding("UTF-8");
            resp.getWriter().println(JSON.toJSONString(blockService.getBlockChain()));
        }
    }




    private class AddPeerServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            this.doPost(req, resp);
        }


        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setCharacterEncoding("UTF-8");
            String peer = req.getParameter("peer");
            p2pService.connectToPeer(peer);
            resp.getWriter().print("ok");
        }
    }




    private class PeersServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setCharacterEncoding("UTF-8");
            for (WebSocket socket : p2pService.getSockets()) {
                InetSocketAddress remoteSocketAddress = socket.getRemoteSocketAddress();
                resp.getWriter().print(remoteSocketAddress.getHostName() + ":" + remoteSocketAddress.getPort());
            }
        }
    }




    private class MineBlockServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            this.doPost(req, resp);
        }


        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setCharacterEncoding("UTF-8");
            String data = req.getParameter("data");
            Block newBlock = blockService.generateNextBlock(data);
            blockService.addBlock(newBlock);
            p2pService.broatcast(p2pService.responseLatestMsg());
            String s = JSON.toJSONString(newBlock);
            System.out.println("block added: " + s);
            resp.getWriter().print(s);
        }
    }
}



-------------------------------------------------------------------------------------------
-----------------------------------Message.java-----------------------------------------
-------------------------------------------------------------------------------------------



package com.fpfpp.server.blockchain;


import java.io.Serializable;


public class Message implements Serializable{
    private int    type;
    private String data;


    public Message() {
    }


    public Message(int type) {
        this.type = type;
    }


    public Message(int type, String data) {
        this.type = type;
        this.data = data;
    }


    public int getType() {
        return type;
    }


    public void setType(int type) {
        this.type = type;
    }


    public String getData() {
        return data;
    }


    public void setData(String data) {
        this.data = data;
    }
}



-------------------------------------------------------------------------------------------
-----------------------------------P2PService.java----------------------------------------
-------------------------------------------------------------------------------------------

package com.fpfpp.server.blockchain;


import com.alibaba.fastjson.JSON;
import org.java_websocket.WebSocket;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ClientHandshake;
import org.java_websocket.handshake.ServerHandshake;
import org.java_websocket.server.WebSocketServer;


import java.net.InetSocketAddress;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;


public class P2PService {
    private List<WebSocket> sockets;
    private BlockService    blockService;
    private final static int QUERY_LATEST        = 0;
    private final static int QUERY_ALL           = 1;
    private final static int RESPONSE_BLOCKCHAIN = 2;


    public P2PService(BlockService blockService) {
        this.blockService = blockService;
        this.sockets = new ArrayList<WebSocket>();
    }


    //初始化一个P2P的server，用传入的port做端口进行服务
    public void initP2PServer(int port) {
        final WebSocketServer socket = new WebSocketServer(new InetSocketAddress(port)) {
        	

        	//打开端口时触发
        	public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {
                write(webSocket, queryChainLengthMsg());
                sockets.add(webSocket);
            }


        	//关闭端口时触发
            public void onClose(WebSocket webSocket, int i, String s, boolean b) {
                System.out.println("connection failed to peer:" + webSocket.getRemoteSocketAddress());
                sockets.remove(webSocket);
            }


            //接受消息时触发
            public void onMessage(WebSocket webSocket, String s) {
                handleMessage(webSocket, s);
            }


            //消息出错时触发
            public void onError(WebSocket webSocket, Exception e) {
                System.out.println("connection failed to peer:" + webSocket.getRemoteSocketAddress());
                sockets.remove(webSocket);
            }


            //服务开始时触发
            public void onStart() {


            }
        };
        socket.start();
        System.out.println("listening websocket p2p port on: " + port);
    }


    //
    private void handleMessage(WebSocket webSocket, String s) {
        try {
            Message message = JSON.parseObject(s, Message.class);
            System.out.println("Received message" + JSON.toJSONString(message));
            switch (message.getType()) {
                case QUERY_LATEST:
                    write(webSocket, responseLatestMsg());
                    break;
                case QUERY_ALL:
                    write(webSocket, responseChainMsg());
                    break;
                case RESPONSE_BLOCKCHAIN:
                    handleBlockChainResponse(message.getData());
                    break;
            }
        } catch (Exception e) {
            System.out.println("hanle message is error:" + e.getMessage());
        }
    }


    private void handleBlockChainResponse(String message) {
        List<Block> receiveBlocks = JSON.parseArray(message, Block.class);
        Collections.sort(receiveBlocks, new Comparator<Block>() {
            public int compare(Block o1, Block o2) {
                return o1.getIndex() - o1.getIndex();
            }
        });


        Block latestBlockReceived = receiveBlocks.get(receiveBlocks.size() - 1);
        Block latestBlock = blockService.getLatestBlock();
        if (latestBlockReceived.getIndex() > latestBlock.getIndex()) {
            if (latestBlock.getHash().equals(latestBlockReceived.getPreviousHash())) {
                System.out.println("We can append the received block to our chain");
                blockService.addBlock(latestBlockReceived);
                broatcast(responseLatestMsg());
            } else if (receiveBlocks.size() == 1) {
                System.out.println("We have to query the chain from our peer");
                broatcast(queryAllMsg());
            } else {
                blockService.replaceChain(receiveBlocks);
            }
        } else {
            System.out.println("received blockchain is not longer than received blockchain. Do nothing");
        }
    }


    public void connectToPeer(String peer) {
        try {
            final WebSocketClient socket = new WebSocketClient(new URI(peer)) {
                @Override
                public void onOpen(ServerHandshake serverHandshake) {
                    write(this, queryChainLengthMsg());
                    sockets.add(this);
                }


                @Override
                public void onMessage(String s) {
                    handleMessage(this, s);
                }


                @Override
                public void onClose(int i, String s, boolean b) {
                    System.out.println("connection failed");
                    sockets.remove(this);
                }


                @Override
                public void onError(Exception e) {
                    System.out.println("connection failed");
                    sockets.remove(this);
                }
            };
            socket.connect();
        } catch (URISyntaxException e) {
            System.out.println("p2p connect is error:" + e.getMessage());
        }
    }


    private void write(WebSocket ws, String message) {
        ws.send(message);
    }


    public void broatcast(String message) {
        for (WebSocket socket : sockets) {
            this.write(socket, message);
        }
    }


    private String queryAllMsg() {
        return JSON.toJSONString(new Message(QUERY_ALL));
    }


    private String queryChainLengthMsg() {
        return JSON.toJSONString(new Message(QUERY_LATEST));
    }


    private String responseChainMsg() {
        return JSON.toJSONString(new Message(RESPONSE_BLOCKCHAIN, JSON.toJSONString(blockService.getBlockChain())));
    }


    public String responseLatestMsg() {
        Block[] blocks = {blockService.getLatestBlock()};
        return JSON.toJSONString(new Message(RESPONSE_BLOCKCHAIN, JSON.toJSONString(blocks)));
    }


    public List<WebSocket> getSockets() {
        return sockets;
    }
}



---------------------------------------------------------------------------------------
简单来说，区块链，就是一种对一个block的加密
不过是因为消耗了计算能力来获取特定的加密字符串，也就是要求sha码前16位全是0, 

当矿工挖到矿以后，调用addPeers接口，发布自己挖到的矿，然后再通过peers2peers的方式广播出去。
技术本身没啥奇怪的。

结果又被疯狂炒作。

这个疯狂的结果是啥？想割中国的羊毛想疯了？这种算术的加密字符串应该不算是啥有效货币哈。



        
        
                
    

能源区块链的优点：

促进多方间安全、去中心化的交易；增强安全性与互信，减少欺诈；促进多方交易中的透明度和效率——都适用于能源领域。相比于金融等其他领域，能源领域不仅涉及到价值的转移，物理产品本身（例如电力）也必须考虑在内。

区块链源码在能源领域的应用主要有以下分类：

分布式能源交易与供应系统：

分布式能源交易与供应系统/P2P能源交易是目前区块链源码在能源领域的最主要的应用场景，目前已经有多个在试验阶段的项目在推进，最典型的应用，一个基于区块链技术的P2P能源销售网络，安装了屋顶太阳能的家庭可以向同一条街上没有安装屋顶太阳能的邻居出售他们生产的电力。

交易、结算、资源整合：

区块链源码可以通过智能合约来控制能源网络，所有能源的消耗与存储都由智能合约自动控制，结合其他的技术手段来保持供需平衡，同时分布式存储确保了交易过程安全透明。

YuBao将可再生能源整合到现有能源市场中，作为能源市场和当地企业之间的中介，为管理所有类型的能源资产提供平台。

YuBao是一个能源的跟踪和交易平台，它由以太坊区块链上的智能合约驱动，比现有系统更安全，透明和高效。

电动汽车充电和共享

此外，区块链能源项目还有其它应用。以下是小编整理的24个典型区块链能源项目。

小编观点

目前，能源区块链源码应用还在初级阶段，面临的问题包括技术成熟度、计算能力与处理速度以及政策监管风险，但是随着越来越多机构的加入，区块链源码对能源行业的影响将愈发深刻。

YuBao数据是一级市场量化投资数据平台——YuBao数据推出的全球首家区块链行业数据库，致力于通过整合区块链行业的创业项目、投资机构、新闻资讯、投融资事件，以及虚拟货币的行情、快讯、公告等讯息，为全球关注区块链产业投资人与投资机构、媒体、金融与法律专业人士、咨询机构、研究学者，以及关注虚拟货币的投资者们等提供一站式实时资讯服务。

 

 

 

 

引子



 

区块链作为「新基建」的重要组成部分，越来越受技术爱好者关注。区块链极客信奉“code is law”，相信通过代码可以构筑一个可信的世界。

而作为一门综合学科技术，区块链建立在数学、密码学、计算机原理、分布式网络和博弈论等众多基础学科之上，底层代码动辄数十万行，如果没有摸清门道，要完全掌握这些代码是极具挑战的。

本文希望给读者一个走读区块链源码的方法，让读者面对区块链底层项目时可以从容地说出“show me the code”。

 

基础知识储备



 

区块链是一门综合学科，涉及多个专业领域，涵括多方面的基础知识，在深度研究区块链之前需要做一定广度的知识储备。注意，这里说的是广度，并非深度，也就是说你只需要大概知道这些基础知识的基本原理与作用即可。



 

密码学相关：理解哈希、对称加密、非对称加密以及数字签名的基本原理和作用；
	
计算机操作系统相关：理解多进程、多线程、互斥、并行等相关概念和作用；
	
数据结构相关：理解队列、堆栈、树等基本数据结构和使用场景；
	
计算机网络相关：理解TCP/IP、心跳包、消息流等基本概念；
	
数据库相关：理解数据库基本概念，了解KV数据库的基本原理；
	
计算机原理相关：理解程序编译、解析、执行和字节码、虚拟机等概念；
	
分布式系统相关：理解点对点网络、分布式一致性、CAP等相关概念和基本原理；
	
程序开发相关：掌握相关的编程语言、构建工具等，理解项目构建基本流程。
 

多维走读



 

在储备了相关的基础知识之后，你就可以打开一份真正的区块链底层代码了，一般通过git clone可以快速下载到项目代码。

但是，面对数十万行的代码，该从何看起呢？


庖丁为文惠君解牛，手之所触，肩之所倚，足之所履，膝之所踦，砉然向然，奏刀𬴃然，莫不中音：合于《桑林》之舞，乃中《经首》之会。

出自《庄子·养生主》


一个优秀的区块链底层项目，必然有一份优秀的工程代码，这份代码有其合理的组织结构与纹理逻辑。走读代码应效仿庖丁解牛，先摸清区块链的基本结构和逻辑，再开始走读，可以达到事半功倍的效果。

本文推荐要从四个不同视角进行走读，站在自己的需求角度出发去看代码，而不要被巨量的代码所左右。这四个角度为功能视角、系统视角、用户视角和开发视角，分别从逻辑层面、运行层面、使用层面和开发层面厘清代码架构和关键算法。



 

功能视角

 

在深入一份区块链底层代码之前，首先要通过其官网、技术文档、github wiki等渠道获取项目设计文档，了解其基本功能设计。

一般每个项目都会提供核心功能列表、总体架构图、功能模块图等介绍文档，通过这些介绍可以掌握项目基本功能。即使你真的找不到也不打紧，大部分区块链底层项目在功能设计层面的差异较小，核心功能模块也大致相同。



以FISCO BCOS为例，基础层代码如下：



 核心层核心代码如下：



接口层核心代码如下：



从功能视角出发，先定位核心功能模块的代码位置，再仔细深入各个功能代码，从单个功能模块内，也可继续递归采用功能视角拆分法，广度遍历直至了解全貌。

 

系统视角

 

系统视角从整个区块链网络运行角度，关注区块链节点全生命周期所参与的系统行为。

关注点包括从敲下启动节点的命令开始，节点经历了哪些初始化环节，之后又是如何与其他节点建立点对点网络，以及完成分布式协作的。

由于不同区块链在部署架构上略有差异，系统运行方式也有所不同，但万变不离其宗，系统视角来看，每个区块链系统都要经历节点初始化、建立点对点网络、完成分布式交互的过程。

 

从系统视角看区块链，首先要关注初始化工作。以FISCO BCOS为例，区块链节点启动从main函数入口进入，通过libinitializer模块初始化并启动各模块，启动顺序如下：



通过启动顺序可以知道FISCO BCOS的一个重要特性——支持多群组账本，每个群组是一个独立的Ledger模块，每个Ledger具有独立的存储、同步、共识处理功能。

完成初始化工作同时，系统将会启动若干线程（或者进程、协程，原理类似），这些线程包括网络监听、共识、消息同步等，可以结合代码分析与系统命令查看运行节点配合确定有哪些关键线程，搞清楚关键线程的工作机制就可以基本掌握区块链系统运行机制。

以FISCO BCOS为例，节点启动之后的关键线程以及他们之间的关系如下：

 



初始化完成之后，网络模块的Host线程将根据配置列表，主动与其他节点建立连接，并且持续监听来自其他节点的连接；Sync线程开始相互发送区块高度，发现高度低于其他节点则开启下载逻辑；RPC与Channel线程等待客户端发送请求，将收到的交易塞入txpool；Sealer线程从txpool获取交易，Consensus线程则开始处理共识消息包。

如此，整个区块链系统有条不紊地运转，完成客户端请求与分布式协作。

 

用户视角

 

用户视角关注操作接口和交易生命周期，关注访问区块链的接口和协议设计、编解码方式、核心数据结构、错误码规范等，还会关注如何发送一笔交易到链上，交易在链上又经历了哪些处理流程，直到达成全网共识。

一般区块链底层项目都会给出交互协议的说明文档，通常实现包括JsonRPC、gRPC、Restful等不同类型的交互协议。

不同项目的交互接口会有所不同，但大都会包含发送交易、部署合约、调用合约、查看区块、查看交易以及回执、查看区块链状态等接口。不同项目的数据编码也会有所不同，有些采用Json，有些采用protobuf等。

当从技术文档中了解清楚交互协议、接口、编解码和错误码等设计细节之后，接下来最重要的是通过发送交易、部署合约、调用合约这些关键接口，对代码进行抽丝剥茧，贯穿交易整个生命周期，从而搞清楚区块链底层最核心的逻辑。

以FISCO BCOS为例，通过多个模块相互协作，完成交易整个生命周期的处理：

 



开发视角

 

开发视角关注的是整个代码工程，包括第三方依赖，源码模块之间的相互关系，单元测试框架和测试用例，编译和构建方式，持续集成和benchmark，以及如何参与社区源码贡献等等。

不同语言都有相应推荐的编译构建方式以及单测框架，通常在区块链项目源码目录可以快速定位到第三方依赖库，比如以cmake构建的C++项目有CmakeLists.txt文件，go项目有go.mod文件，rust项目有cargo.toml文件等。

 



以FISCO BCOS为例，从CmakeLists.txt可以看到依赖库包括：



项目核心源码包括fisco-bcos程序入口代码，以及libxxx的各模块代码，根据模块的名字可以快速识别其对应功能，这里也体现了一个项目源码质量的高低，高质量的代码应该是“代码即注释”。

单元测试代码在test目录，采用boost的单元测试框架，子目录unittests中单测代码与源码目录一一对应，非常容易找到源码对应的单元测试代码。

构建和持续集成工具代码在tools目录，子目录ci中维护了多个不同场景的持续集成用例，在github提交的每一个pr（pull request）都会触发这些持续集成用例，当且仅当每个用例成功通过方可允许合入pr。

关于FISCO BCOS的代码规范和贡献方式，在CODING_STYLE.md和CONTRIBUTING.md文件中有详细描述，鼓励社区用户积极参与贡献。

 

总结



 

区块链涉及领域和知识较多，需要深入源码细节，才能真正完全掌握区块链核心技术。所谓“重剑无锋，大巧不工”，掌握源码走读的基本方法论，才能在巨量代码前，面不改色心不跳。

本文提出从功能、系统、用户和开发四个不同视角进行区块链底层代码走读的方法，一般来说，依次选择不同视角进行走读是比较推荐的方式，也可以根据个人喜好和能力模型选择视角顺序。

最后，本文所举示例皆为FISCO BCOS，但这套走读方法可以适用于任何其他区块链底层项目，希望本文对你有所帮助。

 



我们鼓励机构成员、开发者等社区伙伴参与开源共建事业，有你在一起，会更了不起。多样参与方式：

1、进入微信社群，随时随地与圈内最活跃、最顶尖的团队畅聊技术话题（进群请添加小助手微信，

微信ID：FISCOBCOS010）；

2、订阅我们的公众号：“FISCO BCOS开源社区”，我们为你准备了开发资料库、最新FISCO BCOS动态、活动、大赛等信息；

3、来Meetup与开发团队面对面交流，FISCO BCOS正在全国举办巡回Meetup，深圳、北京、上海、成都……欢迎您公众号在菜单栏【找活动】中找到附近的Meetup，前往结识技术大咖，畅聊硬核技术；

4、参与代码贡献，您可以在Github提交Issue进行问题交流，欢迎向FISCO BCOS提交Pull Request，包括但不限于文档修改、修复发现的bug、提交新的功能特性。

代码贡献指引：

https://github.com/FISCO-BCOS/FISCO-BCOS/blob/master/docs/CONTRIBUTING_CN.md 

区块链项目源码大全

比特币BTC源码 ：https://github.com/bitcoin

以太坊ETH源码 ：https://github.com/ethereum

以太经典ETC源码 ：https://github.com/ethereumproject

小蚁NEO源码 ：https://github.com/neo-project

标准链CZR源码：https://github.com/canonchain

柚子EOS源码 ：https://github.com/eosio

量子链QTUM源码 ：https://github.com/qtumproject

比原链BTM源码 ：https://github.com/bytom

莱特币LTC源码 ：https://github.com/litecoin-project

公信宝GXS源码 ：https://github.com/ethereumproject

比特股BTS源码 ：https://github.com/bitshares

ADA源码 ：https://github.com/input-output-hk

AE源码 ：https://github.com/aeternity

ELF源码 ：https://github.com/aelfProject

OMG源码 ：https://github.com/omise

SNT源码 ：https://github.com/status-im

波场TRX源码 ：https://github.com/tronprotocol

更多项目源码 ：http://myhref.com/code.html

关于文章有好的意见或者对IT技术有所见解或疑惑都可以与我交流！！

当然得注明来意，不添加备注不会通过，谢谢（私人QQ  非诚勿扰）！！