基於Hyperledger Fabric交易系統帳戶的錢包模型的java Chaincode實例

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

如果你不知道如何啓動BYFN網絡，我也會提供步驟，不用擔心。但是如果你想了解BYFN是如何工作的，你可以參考：

基於帳戶的錢包模型

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

特徵

在Java Chaincode中，我們將實現：

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

IDE——Java Chaincode開發工具

我們使用IntelliJ IDEA。此外，你需要JDK。請安裝它們。

當然，如果你有自己的Java IDE，也可以使用它。但在本教程中，我們使用IntelliJ。

第1步，準備開發

讓我們打開IntelliJ。

在IntelliJ中創建新項目Create New Project：

選擇左邊的Gradle，然後:

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

然後現在，你應該配置自己的項目位置。就我而言，我使用/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/[email protected]/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帳戶的錢包模型

基於Hyperledger Fabric交易系統帳戶的錢包模型的java Chaincode實例

基於帳戶的錢包模型

特徵

IDE——Java Chaincode開發工具

第1步，準備開發

1.1 settings.gradle

1.2 build.gradle

1.3 Chaincode文件

第2步——需求分析

第3步——錢包類

第4步——Chaincode類

第5步——在BYFN中運行Chaincode

5.1 安裝相關項目

5.2 Chaincode準備

5.3 建立網絡

5.4 訪問Cli

第6步——清理

DAPPER 事務 TRANSACTION

Solidity 0.5.7簡明教程

Fabric Kafka入門

如何編寫一個企業級區塊鏈Hyperledger Fabric開源框架

configtx.yaml中文詳解

Hyperledger Fabric Node.js如何使用基於通道的事件服務

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結