Java Chaincode學習交易系統中Hyperledger Fabric賬戶錢包模型

時間  2019-11-15
標籤 java chaincode 學習 交易 系統 hyperledger fabric 賬戶 錢包 模型 欄目 Java 简体版
原文   原文鏈接

這是Hyperledger Fabric Java Chaincode的教程。還有Go和NodeJS Chaincodes，咱們未來可能會討論它們。此外，我採用基於賬戶的錢包模型做爲示例，咱們將使用Hyperledger Fabric構建你的第一個網絡（BYFN，build your first network），做爲咱們的測試環境（v1.4網絡）。php

若是你不知道如何啓動BYFN網絡，我也會提供步驟，不用擔憂。可是若是你想了解BYFN是如何工做的，你能夠參考：html

基於賬戶的錢包模型

基於賬戶的錢包模型是交易系統的實現之一，通常而言系統中存在一些錢包，而且每一個錢包包含可用於轉帳的一些值或代幣。固然，實現的細節有不少變化，例如代幣交換和多代幣功能。java

特徵

在Java Chaincode中，咱們將實現：node

  • 1.用戶錢包建立。
  • 2.用戶錢包查詢。
  • 3.錢包代幣轉帳（即從一個錢包發送錢或代幣到另外一個錢包）。
  • [可選] Hyperledger Fabric中有兩個數據庫選項用於保存超級帳本的world state：LevelDB和CouchDB，在本教程中，爲了簡單起見，我將使用LevelDB。
  • [可選]在上面，world state（或全局狀態）不是超級帳本自己，而是與超級帳本分開，雖然它是派生的，能夠隨時從超級帳本中恢復。此外，世界狀態存儲在數據庫中以表示超級帳本，使得這些節點不須要老是搜索超級帳本以進行數據檢索，而且能夠更快地從數據庫中檢索數據（狀態）。
  • [可選]在個人負載測試和一些關於Hyperledger Fabric性能的論文中，LevelDB的性能優於CouchDB。但與LevelDB中的簡單鍵值查詢相比，CouchDB能夠支持可用於構建更復雜查詢的豐富查詢。

IDE——Java Chaincode開發工具

咱們使用IntelliJ IDEA。此外，你須要JDK。請安裝它們。python

固然，若是你有本身的Java IDE，也可使用它。但在本教程中，咱們使用IntelliJ。android

第1步，準備開發

讓咱們打開IntelliJ。git

在IntelliJ中建立新項目Create New Project：程序員

選擇左邊的Gradle，而後:github

輸入你的GroupId和ArtifactId。就我而言，我使用java_account_model_cc。接下來：web

而後如今，你應該配置本身的項目位置。就我而言，我使用/Desktop/java_account_model_cc。單擊完成Finish。

1.1 settings.gradle

在左側的項目文件中，你應該看到settings.gradle。讓咱們雙擊打開它：

輸入如下內容：

rootProject.name = 'fabric-chaincode-gradle'
1.2 build.gradle

在左側的項目文件面板中，能夠看到build.gradle。讓咱們雙擊打開它：

而後，輸入如下內容：

plugins {
    id 'com.github.johnrengelman.shadow' version '2.0.3'
    id 'java'
}

group 'org.hyperledger.fabric-chaincode-java'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile group: 'org.hyperledger.fabric-chaincode-java', name: 'fabric-chaincode-shim', version: '1.+'
    compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.6'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

shadowJar {
    baseName = 'chaincode'
    version = null
    classifier = null

    manifest {
        attributes 'Main-Class': 'org.hyperledger.fabric.chaincode.AccountBasedChaincode'
    }
}

若是IntelliJ右下角有一個須要導入的Gradle項目Gradle project needs to be imported的彈出窗口，請選擇導入更改Import Changes。

1.3 Chaincode文件

在左側的項目文件面板中，在src>main>java下，右鍵單擊它並選擇New>Java Class：

在Name字段中輸入org.hyperledger.fabric.chaincode.AccountBasedChaincode：

而後，應該看到如下內容：

上面的AccountBasedChaincode(.java)是咱們在Java中編寫Chaincode的地方。

第2步——需求分析

在咱們開始編碼以前，讓咱們組織咱們須要編碼的內容。

如特性部分所述，在Java Chaincode中，咱們將實現：

  • 1.用戶錢包建立
  • 2.用戶錢包查詢
  • 3.錢包代幣轉帳（即從一個錢包向另外一個錢包匯款）

從上面這個簡單的要求，咱們須要有如下類：

  • 1.錢包類
  • 2.Chaincode類——擁有Chaincode

咱們的Chaincode應該提供如下功能：

  • 1.建立一個錢包。
  • 2.將代幣從一個錢包轉帳到另外一個錢包。
  • 3.獲取（查詢）錢包。
  • 4.Init函數，在實例化Chaincode時調用。
  • 5.Invoke函數，當用戶想要調用函數(1)(2)或(3)時調用。

Init函數必須在Chaincode中實現，而且每當咱們實例化或升級Chaincode時都會自動調用。一般，它用於初始化區塊鏈中的一些數據。 Invoke函數用於接收全部用戶函數調用，而後根據Invoke調用（調用）相應的函數(1)(2)或(3)。它就像一個路由器 ，將傳入的請求路由到不一樣的路徑。

第3步——錢包類

如今，咱們建立並編寫Wallet類。

在org.hyperledger.fabric.chaincode下建立一個新包：

調用模型包Models，而後肯定：

應該能夠看到：

在Models包下，建立一個新的Java類並將其命名爲Wallet。（此次我沒有詳細說明，讓你們本身嘗試）

如今咱們爲wallet類編碼：

package org.hyperledger.fabric.chaincode.Models;

public class Wallet {
    private String walletId;
    private Double tokenAmount;

    public Wallet(String walletId, Double tokenAmount) {
        this.walletId = walletId;
        this.tokenAmount = tokenAmount;
    }
    
    private Wallet() {}

    public String getWalletId() {
        return walletId;
    }

    public Double getTokenAmount() {
        return tokenAmount;
    }

    public void setWalletId(String walletId) {
        this.walletId = walletId;
    }

    public void setTokenAmount(Double tokenAmount) {
        this.tokenAmount = tokenAmount;
    }
}

錢包具備用於識別特定錢包的wallet id和用於指定錢包擁有多少代幣的數量。

請注意，在生產案例中，Wallet類應該更復雜。例如，你可能對tokenAmount使用BigDecimal數據類型而不是Double。此外，在咱們的例子中，咱們在整個交易系統中只支持一種代幣類型（即只有一種代幣）。

第4步——Chaincode類

package org.hyperledger.fabric.chaincode;
import java.util.List;
import org.hyperledger.fabric.chaincode.Models.Wallet;
import org.hyperledger.fabric.shim.ChaincodeBase;
import org.hyperledger.fabric.shim.ChaincodeStub;
import com.fasterxml.jackson.databind.ObjectMapper;

public class AccountBasedChaincode extends ChaincodeBase {
    private class ChaincodeResponse {
        public String message;
        public String code;
        public boolean OK;

        public ChaincodeResponse(String message, String code, boolean OK) {
            this.code = code;
            this.message = message;
            this.OK = OK;
        }
    }

    private String responseError(String errorMessage, String code) {
        try {
            return (new ObjectMapper()).writeValueAsString(new ChaincodeResponse(errorMessage, code, false));
        } catch (Throwable e) {
            return "{\"code\":'" + code + "', \"message\":'" + e.getMessage() + " AND " + errorMessage + "', \"OK\":" + false + "}";
        }
    }

    private String responseSuccess(String successMessage) {
        try {
            return (new ObjectMapper()).writeValueAsString(new ChaincodeResponse(successMessage, "", true));
        } catch (Throwable e) {
            return "{\"message\":'" + e.getMessage() + " BUT " + successMessage + " (NO COMMIT)', \"OK\":" + false + "}";
        }
    }

    private String responseSuccessObject(String object) {
        return "{\"message\":" + object + ", \"OK\":" + true + "}";
    }

    private boolean checkString(String str) {
        if (str.trim().length() <= 0 || str == null)
            return false;
        return true;
    }

    @Override
    public Response init(ChaincodeStub stub) {
        return newSuccessResponse(responseSuccess("Init"));
    }

    @Override
    public Response invoke(ChaincodeStub stub) {
        String func = stub.getFunction();
        List<String> params = stub.getParameters();
        if (func.equals("createWallet"))
            return createWallet(stub, params);
        else if (func.equals("getWallet"))
            return getWallet(stub, params);
        else if (func.equals("transfer"))
            return transfer(stub, params);
        return newErrorResponse(responseError("Unsupported method", ""));
    }

    private Response createWallet(ChaincodeStub stub, List<String> args) {
        if (args.size() != 2)
            return newErrorResponse(responseError("Incorrect number of arguments, expecting 2", ""));
        String walletId = args.get(0);
        String tokenAmount = args.get(1);
        if (!checkString(walletId) || !checkString(tokenAmount))
            return newErrorResponse(responseError("Invalid argument(s)", ""));

        double tokenAmountDouble = 0.0;
        try {
            tokenAmountDouble = Double.parseDouble(tokenAmount);
            if(tokenAmountDouble < 0.0)
                return newErrorResponse(responseError("Invalid token amount", ""));
        } catch (NumberFormatException e) {
            return newErrorResponse(responseError("parseInt error", ""));
        }

        Wallet wallet = new Wallet(walletId, tokenAmountDouble);
        try {
            if(checkString(stub.getStringState(walletId)))
                return newErrorResponse(responseError("Existent wallet", ""));
            stub.putState(walletId, (new ObjectMapper()).writeValueAsBytes(wallet));
            return newSuccessResponse(responseSuccess("Wallet created"));
        } catch (Throwable e) {
            return newErrorResponse(responseError(e.getMessage(), ""));
        }
    }

    private Response getWallet(ChaincodeStub stub, List<String> args) {
        if (args.size() != 1)
            return newErrorResponse(responseError("Incorrect number of arguments, expecting 1", ""));
        String walletId = args.get(0);
        if (!checkString(walletId))
            return newErrorResponse(responseError("Invalid argument", ""));
        try {
            String walletString = stub.getStringState(walletId);
            if(!checkString(walletString))
                return newErrorResponse(responseError("Nonexistent wallet", ""));
            return newSuccessResponse((new ObjectMapper()).writeValueAsBytes(responseSuccessObject(walletString)));
        } catch(Throwable e){
            return newErrorResponse(responseError(e.getMessage(), ""));
        }
    }

    private Response transfer(ChaincodeStub stub, List<String> args) {
        if (args.size() != 3)
            return newErrorResponse(responseError("Incorrect number of arguments, expecting 3", ""));
        String fromWalletId = args.get(0);
        String toWalletId = args.get(1);
        String tokenAmount = args.get(2);
        if (!checkString(fromWalletId) || !checkString(toWalletId) || !checkString(tokenAmount))
            return newErrorResponse(responseError("Invalid argument(s)", ""));
        if(fromWalletId.equals(toWalletId))
            return newErrorResponse(responseError("From-wallet is same as to-wallet", ""));

        double tokenAmountDouble = 0.0;
        try {
            tokenAmountDouble = Double.parseDouble(tokenAmount);
            if(tokenAmountDouble < 0.0)
                return newErrorResponse(responseError("Invalid token amount", ""));
        } catch (NumberFormatException e) {
            return newErrorResponse(responseError("parseDouble error", ""));
        }

        try {
            String fromWalletString = stub.getStringState(fromWalletId);
            if(!checkString(fromWalletString))
                return newErrorResponse(responseError("Nonexistent from-wallet", ""));
            String toWalletString = stub.getStringState(toWalletId);
            if(!checkString(toWalletString))
                return newErrorResponse(responseError("Nonexistent to-wallet", ""));

            ObjectMapper objectMapper = new ObjectMapper();
            Wallet fromWallet = objectMapper.readValue(fromWalletString, Wallet.class);
            Wallet toWallet = objectMapper.readValue(toWalletString, Wallet.class);

            if(fromWallet.getTokenAmount() < tokenAmountDouble)
                return newErrorResponse(responseError("Token amount not enough", ""));

            fromWallet.setTokenAmount(fromWallet.getTokenAmount() - tokenAmountDouble);
            toWallet.setTokenAmount(toWallet.getTokenAmount() + tokenAmountDouble);
            stub.putState(fromWalletId, objectMapper.writeValueAsBytes(fromWallet));
            stub.putState(toWalletId, objectMapper.writeValueAsBytes(toWallet));

            return newSuccessResponse(responseSuccess("Transferred"));
        } catch(Throwable e){
            return newErrorResponse(responseError(e.getMessage(), ""));
        }
    }

    public static void main(String[] args) {
        new AccountBasedChaincode().start(args);
    }
}

請注意，在生產案例中，代碼應與個人不一樣。這些代碼主要用於演示或教程目的。

第5步——在BYFN中運行Chaincode

5.1 安裝相關項目

咱們在本教程中使用Hyperledger Fabric v1.4。

首先，你能夠按照官方說明安裝相關項目：

5.2 Chaincode準備

而後，讓咱們切換到這個目錄（假設你完成了上面安裝相關項目部分，你應該擁有全部須要的文件和目錄）：

cd fabric-samples/chaincode/chaincode_example02/
mv java java_01
mkdir java

如今，將項目目錄中的如下突出顯示的文件複製到fabric-samples/chaincode/chaincode_example02/java/：

5.3 創建網絡
cd ../../first-network
./byfn.sh up -l java

運行此腳本後，可能須要等待片刻......

若是你看到如下錯誤（而不是其餘錯誤），那就OKAY，繼續執行下一步驟

!!!!!!!!!!!!!!! Query result on peer0.org1 is INVALID !!!!!!!!!!!!!!!!
================== ERROR !!! FAILED to execute End-2-End Scenario ==================

另外，在運行上面的命令以前，請記住啓動Docker。若是你作錯了什麼，能夠運行如下命令關閉網絡，而後從新啓動：

./byfn.sh down
./byfn.sh up -l java

如今，咱們測試咱們的Chaincode是否有效。

5.4 訪問Cli

有一個自動建立的cli Docker容器，它是一個控制節點的命令行界面。

讓咱們訪問cli：

docker exec -it cli bash

而後，設置某些程序使用的環境變量：

export CHANNEL_NAME=mychannel
export CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
export CORE_PEER_ADDRESS=peer0.org1.example.com:7051
export CORE_PEER_LOCALMSPID="Org1MSP"
export CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt

你能夠複製全部這些，而後粘貼到你的終端並按enter。這些環境變量用於讓一些Hyperledger Fabric程序知道咱們須要使用peer0.org1.example.com:7051來調用Chaincode函數。如今，咱們建立了兩個帶有錢包ID的錢包，tom和sam：

peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n mycc --peerAddresses peer0.org1.example.com:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses peer0.org2.example.com:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c '{"Args":["createWallet","tom","100"]}'
peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n mycc --peerAddresses peer0.org1.example.com:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses peer0.org2.example.com:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c '{"Args":["createWallet","sam","100"]}'

運行上面的每一個命令後，你應該在終端中看到相似的內容：

2019-02-09 16:56:55.617 UTC [chaincodeCmd] chaincodeInvokeOrQuery -> INFO 001 Chaincode invoke successful. result: status:200 message:"{\"message\":\"Wallet created\",\"code\":\"\",\"OK\":true}"

如今，咱們得到上面建立的兩個錢包來驗證它們是否存在於區塊鏈中：

peer chaincode query -C $CHANNEL_NAME -n mycc -c '{"Args":["getWallet","tom"]}'
peer chaincode query -C $CHANNEL_NAME -n mycc -c '{"Args":["getWallet","sam"]}'

運行上面的每一個命令後，您應該在終端中看到相似的內容：

"{\"message\":{\"walletId\":\"tom\",\"tokenAmount\":100.0}, \"OK\":true}"
"{\"message\":{\"walletId\":\"sam\",\"tokenAmount\":100.0}, \"OK\":true}"

在上面，咱們能夠看到以前建立的兩個錢包能夠被查詢。他們都有100個代幣。

接下來，咱們進行轉帳交易，讓咱們將10個代幣從tom錢包轉移到sam錢包：

peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n mycc --peerAddresses peer0.org1.example.com:7051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt -c '{"Args":["transfer","tom","sam","10"]}'

最後，讓咱們再次驗證兩個錢包：

peer chaincode query -C $CHANNEL_NAME -n mycc -c '{"Args":["getWallet","tom"]}'
peer chaincode query -C $CHANNEL_NAME -n mycc -c '{"Args":["getWallet","sam"]}'

你能看到下面的結果：

"{\"message\":{\"walletId\":\"tom\",\"tokenAmount\":90.0}, \"OK\":true}"
"{\"message\":{\"walletId\":\"sam\",\"tokenAmount\":110.0}, \"OK\":true}"

請注意，如今Tom的錢包仍然是90個令牌，而Sam的錢包有110個令牌，交易已完成並寫入區塊鏈超級帳本中。

第6步——清理
exit
./byfn.sh down

而後，刪除目錄fabric-samples/chaincode/chaincode_example02/java並將目錄java_01重命名爲java。

謝謝！若是你喜歡個人內容，請關注我學習最新內容！

======================================================================

分享一些以太坊、EOS、比特幣等區塊鏈相關的交互式在線編程實戰教程：

  • EOS教程，本課程幫助你快速入門EOS區塊鏈去中心化應用的開發，內容涵蓋EOS工具鏈、賬戶與錢包、發行代幣、智能合約開發與部署、使用代碼與智能合約交互等核心知識點，最後綜合運用各知識點完成一個便籤DApp的開發。
  • java以太坊開發教程，主要是針對java和android程序員進行區塊鏈以太坊開發的web3j詳解。
  • python以太坊，主要是針對python工程師使用web3.py進行區塊鏈以太坊開發的詳解。
  • php以太坊，主要是介紹使用php進行智能合約開發交互，進行帳號建立、交易、轉帳、代幣開發以及過濾器和交易等內容。
  • 以太坊入門教程，主要介紹智能合約與dapp應用開發，適合入門。
  • 以太坊開發進階教程，主要是介紹使用node.js、mongodb、區塊鏈、ipfs實現去中心化電商DApp實戰，適合進階。
  • ERC721以太坊通證明戰，課程以一個數字藝術品創做與分享DApp的實戰開發爲主線，深刻講解以太坊非同質化通證的概念、標準與開發方案。內容包含ERC-721標準的自主實現，講解OpenZeppelin合約代碼庫二次開發，實戰項目採用Truffle，IPFS，實現了通證以及去中心化的通證交易所。
  • C#以太坊，主要講解如何使用C#開發基於.Net的以太坊應用，包括賬戶管理、狀態與交易、智能合約開發與交互、過濾器和交易等。
  • java比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈存儲、去中心化共識機制、密鑰與腳本、交易與UTXO等，同時也詳細講解如何在Java代碼中集成比特幣支持功能，例如建立地址、管理錢包、構造裸交易等，是Java工程師不可多得的比特幣開發學習課程。
  • php比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈存儲、去中心化共識機制、密鑰與腳本、交易與UTXO等，同時也詳細講解如何在Php代碼中集成比特幣支持功能，例如建立地址、管理錢包、構造裸交易等，是Php工程師不可多得的比特幣開發學習課程。
  • tendermint區塊鏈開發詳解，本課程適合但願使用tendermint進行區塊鏈開發的工程師，課程內容即包括tendermint應用開發模型中的核心概念，例如ABCI接口、默克爾樹、多版本狀態庫等，也包括代幣發行等豐富的實操代碼，是go語言工程師快速入門區塊鏈開發的最佳選擇。

匯智網原創翻譯，轉載請標明出處。這裏是原文經過Java Chaincode實例學習交易系統中基於Hyperledger Fabric賬戶的錢包模型

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程