通過Java Chaincode例項學習交易系統中基於Hyperledger Fabric帳戶的錢包模型

Java Hyperledger · 發表 2019-02-19 10:53:30

摘要：這是Hyperledger Fabric Java Chaincode的教程。還有Go和NodeJS Chaincodes，我們將來可能會討論它們。此外，我採用基於帳戶的錢包模型作為示例，我們將使用Hyperledger Fabric構建你的第一個網路（BYFN，build your firs...

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

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

基於帳戶的錢包模型

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

特徵

在Java Chaincode中，我們將實現：

world state
world state

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實戰，適合進階。
C#以太坊，主要講解如何使用C#開發基於.Net的以太坊應用，包括帳戶管理、狀態與交易、智慧合約開發與互動、過濾器和交易等。
java比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈儲存、去中心化共識機制、金鑰與指令碼、交易與UTXO等，同時也詳細講解如何在Java程式碼中整合比特幣支援功能，例如建立地址、管理錢包、構造裸交易等，是Java工程師不可多得的比特幣開發學習課程。
php比特幣開發教程，本課程面向初學者，內容即涵蓋比特幣的核心概念，例如區塊鏈儲存、去中心化共識機制、金鑰與指令碼、交易與UTXO等，同時也詳細講解如何在Php程式碼中整合比特幣支援功能，例如建立地址、管理錢包、構造裸交易等，是Php工程師不可多得的比特幣開發學習課程。
tendermint區塊鏈開發詳解，本課程適合希望使用tendermint進行區塊鏈開發的工程師，課程內容即包括tendermint應用開發模型中的核心概念，例如ABCI介面、默克爾樹、多版本狀態庫等，也包括代幣發行等豐富的實操程式碼，是go語言工程師快速入門區塊鏈開發的最佳選擇。

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