springboot 测试链码（二）

最新推荐文章于 2024-10-10 11:51:08 发布
最新推荐文章于 2024-10-10 11:51:08 发布
阅读量204 收藏 1
点赞数
文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45485924/article/details/130344732
版权

四、进阶开发

采用springboot方式构建app测试

4.1、阶段一

最简单的目录结构如下，其中配置文件的组织来源fabric的test-network

在这里插入图片描述
resource目录下的配置文件如下：

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>app-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>app-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.hyperledger.fabric-sdk-java/fabric-sdk-java -->
        <dependency>
            <groupId>org.hyperledger.fabric-sdk-java</groupId>
            <artifactId>fabric-sdk-java</artifactId>
            <version>2.2.12</version>
        </dependency>

<!--         https://mvnrepository.com/artifact/org.hyperledger.fabric/fabric-gateway-java-->
                <dependency>
                    <groupId>org.hyperledger.fabric</groupId>
                    <artifactId>fabric-gateway-java</artifactId>
                    <version>2.2.3</version>
                </dependency>

        <dependency>
            <groupId>org.hyperledger.fabric</groupId>
            <artifactId>fabric-gateway</artifactId>
            <version>1.0.1</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/io.grpc/grpc-netty-shaded -->
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>1.42.0</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.79</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.15</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>org.example.appdemo.Application
                    </mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

network.json

{
  "name": "test-network",
  "version": "1.0.0",
  "client": {
    "organization": "Org1",
    "connection": {
      "timeout": {
        "peer": {
          "endorser": "300"
        },
        "orderer": "300"
      }
    }
  },
  "channels": {
    "mychannel": {
      "orderers": [
        "orderer.example.com"
      ],
      "peers": {
        "peer0.org1.example.com": {
          "endorsingPeer": true,
          "chaincodeQuery": true,
          "ledgerQuery": true,
          "eventSource": true
        },
        "peer0.org2.example.com": {
          "endorsingPeer": true,
          "chaincodeQuery": true,
          "ledgerQuery": true,
          "eventSource": true
        }
      }
    }
  },
  "organizations": {
    "Org1": {
      "mspid": "Org1MSP",
      "peers": [
        "peer0.org1.example.com"
      ],
      "certificateAuthorities": [
        "ca-org1"
      ],
      "adminPrivateKeyPEM": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/keystore/priv_sk"
      },
      "signedCertPEM": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/signcerts/Admin@org1.example.com-cert.pem"
      }
    },
    "Org2": {
      "mspid": "Org2MSP",
      "peers": [
        "peer0.org2.example.com"
      ],
      "certificateAuthorities": [
        "ca-org2"
      ],
      "adminPrivateKeyPEM": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp/keystore/priv_sk"
      },
      "signedCertPEM": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp/signcerts/Admin@org2.example.com-cert.pem"
      }
    }
  },
  "orderers": {
    "orderer.example.com": {
      "url": "grpcs://192.168.20.11:7050",
      "mspid": "OrdererMSP",
      "grpcOptions": {
        "ssl-target-name-override": "orderer.example.com",
        "hostnameOverride": "orderer.example.com"
      },
      "tlsCACerts": {
        "path": "src/main/resources/crypto-config/test-network/ordererOrganizations/example.com/orderers/orderer.example.com/tls/ca.crt"
      },
      "adminPrivateKeyPEM": {
        "path": "src/main/resources/crypto-config/test-network/ordererOrganizations/example.com/users/Admin@example.com/msp/keystore/priv_sk"
      },
      "signedCertPEM": {
        "path": "src/main/resources/crypto-config/test-network/ordererOrganizations/example.com/users/Admin@example.com/msp/signcerts/Admin@example.com-cert.pem"
      }
    }
  },
  "peers": {
    "peer0.org1.example.com": {
      "url": "grpcs://192.168.20.11:7051",
      "grpcOptions": {
        "ssl-target-name-override": "peer0.org1.example.com",
        "hostnameOverride": "peer0.org1.example.com",
        "request-timeout": 120001
      },
      "tlsCACerts": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt"
      }
    },
    "peer0.org2.example.com": {
      "url": "grpcs://192.168.20.11:9051",
      "grpcOptions": {
        "ssl-target-name-override": "peer0.org2.example.com",
        "hostnameOverride": "peer0.org2.example.com",
        "request-timeout": 120001
      },
      "tlsCACerts": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt"
      }
    }
  },
  "certificateAuthorities": {
    "ca-org1": {
      "url": "https://192.168.20.11:7054",
      "grpcOptions": {
        "verify": true
      },
      "tlsCACerts": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org1.example.com/ca/ca.org1.example.com-cert.pem"
      },
      "registrar": [
        {
          "enrollId": "admin",
          "enrollSecret": "adminpw"
        }
      ]
    },
    "ca-org2": {
      "url": "https://192.168.20.11:8054",
      "grpcOptions": {
        "verify": true
      },
      "tlsCACerts": {
        "path": "src/main/resources/crypto-config/test-network/peerOrganizations/org2.example.com/ca/ca.org2.example.com-cert.pem"
      },
      "registrar": [
        {
          "enrollId": "admin",
          "enrollSecret": "adminpw"
        }
      ]
    }
  }
}

application.properties

spring.application.name=fabric-java-demo

server.port=8888

fabric.networkConnectionConfigPath=src/main/resources/network.json
#fabric.mspId=Org1MSP
fabric.certificatePath=src/main/resources/crypto-config/test-network/peerOrganizations/org1.example.com/users/User1@org1.example.com/msp/signcerts/User1@org1.example.com-cert.pem
fabric.privateKeyPath=src/main/resources/crypto-config/test-network/peerOrganizations/org1.example.com/users/User1@org1.example.com/msp/keystore/priv_sk
#fabric.tlsCertPath=src/main/resources/crypto-config/prod-network/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
#fabric.channel=mychannel
logging.level.org.hyperledger=trace

java各个类

Application.java主程序入口

package org.example.appdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

/**
 * @Author: kingtao
 * @Date: 2023-04-22-10:52
 * @Description:
 */
@SpringBootApplication
@EnableConfigurationProperties
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

CatContractController.java

controller提供的各个maping与fabric交互

package org.example.appdemo;

import com.google.common.collect.Maps;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.codec.binary.StringUtils;
import org.hyperledger.fabric.gateway.Contract;
import org.hyperledger.fabric.gateway.ContractException;
import org.hyperledger.fabric.gateway.Gateway;
import org.hyperledger.fabric.gateway.Network;
import org.hyperledger.fabric.sdk.Peer;
import org.springframework.web.bind.annotation.*;

import java.util.EnumSet;
import java.util.Map;
import java.util.concurrent.TimeoutException;

/**
 * @Author: kingtao
 * @Date: 2023-04-22-10:52
 * @Description:
 */
@RestController
@RequestMapping("/cat")
@Slf4j
@AllArgsConstructor
public class CatContractController {
    final Gateway gateway;

    @GetMapping("/{key}")
    public Map<String, Object> queryCatByKey(@PathVariable String key) throws ContractException {
        Map<String, Object> res = Maps.newConcurrentMap();
        Contract contract = getContract();
        byte[] cat = contract.evaluateTransaction("queryCat", key);

        res.put("payload", StringUtils.newStringUtf8(cat));
        res.put("status", "ok");
        return res;
    }

    @PutMapping("/")
    public Map<String, Object> createCat(@RequestBody CatDTO cat) throws InterruptedException, TimeoutException, ContractException {
        Map<String, Object> res = Maps.newConcurrentMap();
        Contract contract = getContract();
        byte[] bytes = contract.submitTransaction("createCat", cat.getKey(), cat.getName(), String.valueOf(cat.getAge()), cat.getColor(), cat.getBreed());

        res.put("payload", StringUtils.newStringUtf8(bytes));
        res.put("status", "ok");

        return res;
    }

    @DeleteMapping("/{key}")
    public Map<String, Object> deleteCatByKey(@PathVariable String key) throws InterruptedException, TimeoutException, ContractException {
        Map<String, Object> res = Maps.newConcurrentMap();
        Contract contract = getContract();

        // 合约生效规则
        byte[] cat = contract.createTransaction("deleteCat")
                .setEndorsingPeers(getNetwork().getChannel().getPeers(EnumSet.of(Peer.PeerRole.ENDORSING_PEER)))
                .submit(key);

        res.put("payload", StringUtils.newStringUtf8(cat));
        res.put("status", "ok");

        return res;
    }

    private Network getNetwork() {
        // 获取通道
        return gateway.getNetwork("mychannel");
    }

    private Contract getContract() {
        // 获取合约
        return getNetwork().getContract("demo");
    }

    @GetMapping("/test")
    public String test() {
        return "test success";
    }
}

CatDTO.java 实体

package org.example.appdemo;

import lombok.Data;
import lombok.experimental.Accessors;

/**
 * @Author: kingtao
 * @Date: 2023-04-22-10:51
 * @Description:
 */
@Data
@Accessors(chain = true)
public class CatDTO {

    private String key;

    private String name;

    private Integer age;

    private String color;

    private String breed;
}

fabricConfig.java 相关fabric的配置

package org.example.appdemo;

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
//import org.hyperledger.fabric.client.Gateway;
//import org.hyperledger.fabric.client.identity.Identities;
import org.hyperledger.fabric.gateway.Gateway;
import org.hyperledger.fabric.gateway.Identities;
import org.hyperledger.fabric.gateway.Wallet;
import org.hyperledger.fabric.gateway.Wallets;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.BufferedReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.PrivateKey;
import java.security.cert.X509Certificate;

/**
 * @Author: kingtao
 * @Date: 2023-04-22-10:50
 * @Description:
 */
@Configuration
@AllArgsConstructor
@Slf4j
public class FabricConfig {

    final FabricProperties fabricProperties;

    @Bean
    public Gateway gateway() throws Exception {

        BufferedReader certificateReader = Files.newBufferedReader(Paths.get(fabricProperties.getCertificatePath()), StandardCharsets.UTF_8);

        X509Certificate certificate = Identities.readX509Certificate(certificateReader);

        BufferedReader privateKeyReader =  Files.newBufferedReader(Paths.get(fabricProperties.getPrivateKeyPath()), StandardCharsets.UTF_8);

        PrivateKey privateKey = Identities.readPrivateKey(privateKeyReader);

        Wallet wallet = Wallets.newInMemoryWallet();
        wallet.put("user1", Identities.newX509Identity("Org1MSP", certificate, privateKey));

        Gateway.Builder builder = org.hyperledger.fabric.gateway.Gateway.createBuilder()
                .identity(wallet, "user1")
                .networkConfig(Paths.get("src/main/resources/network.json"));

        Gateway gateway = builder.connect();

        log.info("=================connected fabric gateway {}", gateway );

        return gateway;
    }
}

FabricProperties.java fabric的相关配置类

package org.example.appdemo;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: kingtao
 * @Date: 2023-04-22-10:52
 * @Description:
 */

@Configuration
@ConfigurationProperties(prefix = "fabric")
@Data
public class FabricProperties {

    private String networkConnectionConfigPath;

    private String certificatePath;

    private String privateKeyPath;

}

然后通过postman测试接口,注意参数的位置与链码的相对应

例如：创建方法
在这里插入图片描述

哎，啥也不会
关注
编写你的第一个hyperledger fabric network程序
ShareBoy
10-27 4374
Writing Your First Application 编写你的第一个程序。 本文档的目标是使阅读本文档的人能基于HyperLedger Fabric Network编写自己的第一个程序。 在这个程序里，我们提供最基本的功能： 用户能在账本中查询一条数据或者用户更新账本中的一条数据。 我们的程序是使用JAVASCRIPT编写，运行在NODEJS平台上。 此文档将会指导你通过三步去
3.测试链码1
08-03
测试链码1"的详细知识点： 1. **链码安装**： - 在部署链码前，首先需要将其安装到网络中的特定节点。使用`peer chaincode install`命令，指定链码名称（-n），版本（-v）以及链码所在的路径（-p）。例如： ```...
fabric2.X以上系统用test-network环境测试自己的链码
lakersssss24的博客
06-14 1172
首先，我们需要安装好fabric2.X的环境，具体参考我之前的文章：这里默认已经有了fabric2.X的环境，进入test-network文件夹：在开始测试之前：先把gopath项目路径全部解锁：sudo chmod -R 777 $GOPATH打开测试网络：sudo ./network.sh up如果想要同时启动CA服务器和couchdb，执行这条指令：./network.sh up createChannel -ca -s couchdb可以看到启动了fabric2.3的测试网络，包含了一个cli，两个
(Fabric 学习四)Fabric Java SDK 连接fabcar网络
Wannabe_hacker的博客
04-19 4223
一、打开fabcar网络 在/你自己的路径/github.com/hyperledger/fabric/scripts/fabric-samples/fabcar中启动网络 ./networkDown.sh 启动成功后查看启动情况： docker ps -a 如果容器成功打开，则可以进行下一步操作！ 二、创建一个springboot项目 创建一个springboot项目 其中选项建议： 2.0 项目结构目录 这是我们最终要生成的项目结构目录，接下来我们将一个一个创建器中的文
4.4 开发模式下的测试：简化我们对链码的测试过程
hanxiaodong
02-26 1045
目标 熟练掌握链码的 dev 开发测试模式 任务实现 从之前对链码操作来看，我们需要在相关操作（安装、实例化、升级、调用、查询）命令中加入大量的参数，尤其是开启 TLS 验证之后指定 TLS 证书时的那一长串路径会让人不厌其烦。如果每次都需要输入那么内容，我想大部分人都会崩溃掉的。那么我们现在就来掌握一种能够快速对链码进行测试而不需要输入那些烦琐的内容，从而简化我们对链码的测试。 正常情况...
区块链测试网服务开发
雨云21的博客
12-26 2364
1、准备一个空白的springboot项目 pom.xml依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://
fabric-gateway-java 调用虚拟机上的fabric链码，以fabcar为例
zxingyu的博客
03-30 9494
作为学习的记录。我是在虚拟机上搭建了fabric网络和通道，并部署了官方示例fabcar链码，现在想在windows上通过fabric-gateway-java 实现对fabric上链码的调用。 fabric的版本是2.4.0，编译器是IDEA，代码基于springboot框架。 fanric环境的搭建、test-network及通道的创建、链码的部署这里不再赘述。 首先导入如下依赖： <dependency> <groupId>or
fabric + java 链码测试（一）
weixin_45485924的博客
04-24 5980
所有节点既是客户端，又是客户端（节点对等）
hyperledger fabric 实战开发——水产品溯源交易平台(二）
专攻毕设大企鹅的博客
07-09 6422
大黄鱼追溯平台开发
Fabric-Java-SDK调用（二）——调试跑通
热门推荐
qq_44887604的博客
01-30 1万+
运行测试Demo——End2endIT.java 运行结果分析 1. 先构建通道foo，把org1加入该通道，运行该通道 run-channel.png 2. 初始化a为100，b为200，并把此交易送至orderer中 set-a-b.png 3. a转账100给b，背书后，把交易送至orderer a-100to-b.png 4. 查询b的值 query-b.png 5. 后面就是创建调用另一个通道bar，进行相同的操作，这里也不详细罗列了 End2endI
fabcar-caliper测试链码及配置.zip
01-21
`fabcar-caliper测试链码及配置.zip` 文件包含了用于测试 Fabric 链码（智能合约）的 Caliper 负载配置和网络配置文件，这些文件是用 Golang 语言编写的。下面将详细解释这两个组件以及它们在区块链应用中的作用。 ...
Fabric开发进阶篇二 使用IBP调试链码.docx
05-24
本文将深入探讨如何利用IBP进行链码的开发和调试，帮助开发者更有效地优化代码和测试功能。 首先，确保你的开发环境符合先决条件。你需要安装以下工具： 1. Visual Studio Code (VSCode) 1.32 或更高版本 2. Node....
一种改进的二值图像边界跟踪与边界链码获取算法
01-27
为了克服传统二值图像边界跟踪速度慢和边界漏跟踪等问题, 基于Freeman 链码提出一种通用性强的多起点分段二值图像边界跟踪与边界链码获取算法。在借鉴前人对传统Freeman 链码搜索算法的改进, 将平均搜索方向减少为...
基于matlab实现链码提取内含测试图片及所用的算法
04-18
本资源提供了基于MATLAB实现链码提取的实例，包括测试图片和相关算法。 链码是一种表示图像边界像素顺序的方法，它通过将像素连接成序列，并用数字编码来表示像素之间的相对位置。常见的链码有八方向链码和四方向...
洗衣店订单管理：Spring Boot技术实现
2401_85763803的博客
10-10 1134
所以产品在上线前必须反复测试，经过反复测试，修改，再测试，再修改，产品才能够不断完善。在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
洗衣店订单处理：Spring Boot系统的优势
最新发布
2402_85761468的博客
10-10 863
概念模式的设计方法是在需求分析的基础上，用概念数据模型（例如E-R模型）表示数据及数据之间的相互联系，设计出反映用户信息需求和处理需求的数据库系统概念模式。概念设计的目标是准确描述应用领域的信息模式，支持用户的各种应用，这样既容易转换为数据库系统逻辑模式，又容易为用户理解。在概念模式的设计中，E-R模型法是最常见的设计方法。概念设计的目标是设计出反映某个组织部门信息需求的数据库系统概念模式，数据库系统的概念模式独立于数据库系统的逻辑结构、独立于数据库管理系统（DBMS）、独立于计算机系统。
Spring Boot项目使用多线程执行定时任务
左直拳的马桶_日用桶
10-10 232
我在一个Spring Boot项目中，采用定时器执行一些操作，比如10秒就发送一次数据。这些操作有2个，如下所示。我就想，虽然这两个操作各自指定了时间频率，但如果其中一个操作非常耗时，会不会影响其他操作呢？答案是会。怎么办呢？AI告诉我，引入多线程。
Spring Boot项目中使用MyBatis
weixin_73060959的博客
10-02 875
在Spring Boot项目中使用MyBatis可以极大地简化配置过程，并且Spring Boot提供了很好的集成支持。你只需要添加必要的依赖，配置数据源，然后创建Mapper接口、XML映射文件和实体类，就可以轻松地进行数据库操作了。
实验步骤：Hyperledger链码测试
06-08
Hyperledger链码测试的实验步骤如下： 1. 安装Hyperledger Fabric 2. 编写链码 3. 打包链码 4. 部署链码 5. 调用链码 具体步骤如下： 1. 安装Hyperledger Fabric 首先需要安装Hyperledger Fabric，可以参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值