转载

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

这是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中，我们将实现：

world state
world state

IDE——Java Chaincode开发工具

我们使用IntelliJ IDEA。此外，你需要JDK。请安装它们。

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

第1步，准备开发

让我们打开IntelliJ。

在IntelliJ中创建新项目 Create New Project ：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

选择左边的 Gradle ，然后:

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

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

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

然后现在，你应该配置自己的项目位置。就我而言，我使用 /Desktop/java_account_model_cc 。单击完成 Finish 。

1.1 settings.gradle

在左侧的项目文件中，你应该看到 settings.gradle 。让我们双击打开它：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

输入以下内容：

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 ：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

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

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

然后，应该看到以下内容：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

上面的 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 下创建一个新包：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

调用模型包 Models ，然后确定：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

应该可以看到：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

在 Models 包下，创建一个新的Java类并将其命名为 Wallet 。（这次我没有详细说明，让大家自己尝试）

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

现在我们为 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/ ：

通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

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实战，适合进阶。
  • C#以太坊，主要讲解如何使用C#开发基于.Net的以太坊应用，包括帐户管理、状态与交易、智能合约开发与交互、过滤器和交易等。
  • java比特币开发教程，本课程面向初学者，内容即涵盖比特币的核心概念，例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等，同时也详细讲解如何在Java代码中集成比特币支持功能，例如创建地址、管理钱包、构造裸交易等，是Java工程师不可多得的比特币开发学习课程。
  • php比特币开发教程，本课程面向初学者，内容即涵盖比特币的核心概念，例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等，同时也详细讲解如何在Php代码中集成比特币支持功能，例如创建地址、管理钱包、构造裸交易等，是Php工程师不可多得的比特币开发学习课程。
  • tendermint区块链开发详解 ，本课程适合希望使用tendermint进行区块链开发的工程师，课程内容即包括tendermint应用开发模型中的核心概念，例如ABCI接口、默克尔树、多版本状态库等，也包括代币发行等丰富的实操代码，是go语言工程师快速入门区块链开发的最佳选择。

汇智网原创翻译，转载请标明出处。这里是原文 通过Java Chaincode实例学习交易系统中基于Hyperledger Fabric帐户的钱包模型

原文  http://blog.hubwiz.com/2019/02/19/hyperledger-fabric-wallet-java/
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：657 人
  • 运行天数：4,409天
  • 最后更新：2024年11月22日01点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG