共计 13851 个字符，预计需要花费 35 分钟才能阅读完成。
这是 Hyperledger Fabric Java Chaincode 的教程。还有 Go 和 NodeJS Chaincodes，我们将来可能会讨论它们。此外，我采用基于帐户的钱包模型作为示例，我们将使用 Hyperledger Fabric 构建你的第一个网络（BYFN，build your first network），作为我们的测试环境（v1.4 网络）。
如果你不知道如何启动 BYFN 网络，我也会提供步骤，不用担心。但是如果你想了解 BYFN 是如何工作的，你可以参考：
1.Hyperledger Fabric 官方 BYFN 教程
2. 我之前关于 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。
首先，你可以按照官方说明安装相关项目：
1. 安装依赖项目
2. 从 Hyperledger Fabric 安装示例，程序和 docker 镜像
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 帐户的钱包模型
