快捷搜索:

(七)HyperledgerFarbic1.4- Fabric的SDK使用

一、SDK提供的功能

在之前的操作中 无论是创建channel还是 链码 安装实例化 合约的查询 调用 在CA中注册用户,都是通过命令行的形式去操作的。 sdk提供了一系列的功能,可以通过sdk去实现之前使用命令行操作的效果。 现阶段fabric提供的比较稳定的sdk有:Node、java、go 如果是创建一个区块链管理平台。就更需要SDK来获取到区块链中的信息。

总之,业务系统想要与fabric工程交互就应该使用sdk。

二、使用java-fabric-sdk

创建一个springboot项目pom中引用对应版本的sdk

<!--fabric java sdk -->
<dependency>
   <groupId>org.hyperledger.fabric-sdk-java</groupId>
   <artifactId>fabric-sdk-java</artifactId>
   <version>1.4.6</version>
</dependency>

三、使用sdk创建channel 并将peer加入到channel中

创建channel 需要使用channel配置文件中指定在Channel中的org的Admin用户。 创建channel需要生成创世区块,这一步需要有orderer 的配置信息

所以 使用sdk创建channel要准备一下的配置信息

    channel中任意一个org的 admin用户信息 orderer节点的信息

3.1 启动first-network

使用fabric-samples 提供的byfn.sh脚本启动first-network

./byfn.sh uo -s couchdb

启动完成后会在first-network目录下生成两个目录

crypto-config : 存放了orderer的证书和peer的证书
channel-artifacts:存放了channel的配置和peer锚节点的配置以及channel的创世区块

3.2 生成channel的配置文件

使用first-network中提供的configtx.yaml配置文件,配置文件中有关于channel的一个配置。

TwoOrgsChannel:
        Consortium: SampleConsortium
        <<: *ChannelDefaults
        Application:
            <<: *ApplicationDefaults
            Organizations:
                - *Org1
                - *Org2
            Capabilities:
                <<: *ApplicationCapabilities

按照这个配置文件的描述,将会生成一个SampleConsortium联盟,联盟中包含Org1和Org2两个组织 使用configtxgen工具 生成channel的配置文件

configtxgen -profile TwoOrgsChannel -outputCreateChannelTx channel-artifacts/mychannel1.tx -channelID mychannel1

以上命令中的几个参数

-profile 使用配置文件中Profiles下的那个配置项,这里用到的Profiles.TwoOrgsChannel
  -outputCreateChannelTx 执行最终生成的channel的tx配置文件的位置
  -channelID 使用这个configtx的channel的channelId
  -configPath 指定包含configtx.yaml配置文件的目录(如果命令执行的目录就包含configtx.yaml则不需要使用该参数)

执行完命令后在指定的目录下会出现mychannel1.tx配置文件。

3.3 创建一个springboot项目

通过maven引入fabric-sdk-java

<!--fabric java sdk -->
<dependency>
    <groupId>org.hyperledger.fabric-sdk-java</groupId>
    <artifactId>fabric-sdk-java</artifactId>
    <version>1.4.6</version>
</dependency>

将上一步生成的channel1.tx和联盟中的证书都复制到springboot的resources目录下 为了方便从resources目录下读取文件编写一个utils类

import org.springframework.core.io.ClassPathResource;

import java.io.File;

public class ClasspathFileUtils {
    /**
     * 在springboot的resources目录下 获取文件
     *
     * @param resPath
     * @return
     * @throws Exception
     */
    public static File getFileFromSpringBootClassPath(String resPath) throws Exception {
        ClassPathResource classPathResource = new ClassPathResource(resPath);
        return classPathResource.getFile();
    }
}

3.4 修改application.properties文件

# 配置用户信息
fabric.user.name=admin
fabric.user.account=LH
fabric.user.affiliation=Org1
fabric.user.msp-id=Org1MSP

# 配置orderer信息
fabric.orderer.name=orderer.example.com
fabric.orderer.grpcs-addr=grpcs://orderer.example.com:7050
fabric.orderer.tlsca-cert=crypto-config/ordererOrganizations/example.com/tlsca/tlsca.example.com-cert.pem
fabric.orderer.ca-cert=crypto-config/ordererOrganizations/example.com/ca/ca.example.com-cert.pem

# 配置channel信息
fabric.channel.channel-name=mychannel1
fabric.channel.channel-config-tx-path=channel-artifacts/mychannel1.tx

# 配置org1-peer0的信息
fabric.org1-peer0.name=peer0.org1.example.com
fabric.org1-peer0.grpcs-addr=grpcs://peer0.org1.example.com:7051
fabric.org1-peer0.tlsca-cert=crypto-config/peerOrganizations/org1.example.com/msp/tlscacerts/tlsca.org1.example.com-cert.pem
fabric.org1-peer0.users-admin-private-key=crypto-config/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/keystore/2b33de36c48cc20ff8056c525db5ddfc3b3cbfe337984e867294de19fc3a770b_sk
fabric.org1-peer0.users-admin-cert=crypto-config/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/admincerts/Admin@org1.example.com-cert.pem

编写配置文件对应的配置类

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.Set;
@Getter
@Setter
@ConfigurationProperties(prefix = "fabric.user")
public class FabricUserProperties {
    private String name;
    private String account;
    private String affiliation;
    private String mspId;
    private Set<String> roles;
}
@Getter
@Setter
@ConfigurationProperties(prefix = "fabric.channel")
public class FabricChannelProperties {
    private String channelName;
    private String channelConfigTxPath;
}
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
@Getter
@Setter
@ConfigurationProperties(prefix = "fabric.orderer")
public class FabricOrdererProperties {
    private String name;
    private String grpcsAddr;
    private String tlscaCert;
    private String caCert;
}
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
@Getter
@Setter
@ConfigurationProperties(prefix = "fabric.org1-peer0")
public class FabricOrg1Peer0Properties {
    private String name;
    private String grpcsAddr;
    private String tlscaCert;
    private String usersAdminPrivateKey;
    private String usersAdminCert;
}

在启动类上声明使用的配置类

@EnableConfigurationProperties({
        FabricUserProperties.class,
        FabricOrdererProperties.class,
        FabricChannelProperties.class,
        FabricOrg1Peer0Properties.class
})
@SpringBootApplication
public class JavaFabricSdkApplication {
    public static void main(String[] args) {
        SpringApplication.run(JavaFabricSdkApplication.class, args);
    }
}

3.5 编写Fabric用户信息实现Fabric User接口

import com.lhit.fabric.javafabricsdk.fabric.properties.FabricOrg1Peer0Properties;
import com.lhit.fabric.javafabricsdk.fabric.properties.FabricUserProperties;
import com.lhit.fabric.javafabricsdk.fabric.util.UserUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.hyperledger.fabric.sdk.Enrollment;
import org.hyperledger.fabric.sdk.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.security.Security;
import java.util.Set;

/**
 * 在联盟网络中的用户信息
 */
@Slf4j
@Getter
@Setter
@Component
public class FabricUserContext implements User {

    @Autowired
    private FabricUserProperties userProperties;

    @Autowired
    private FabricOrg1Peer0Properties org1Peer0Properties;

    @PostConstruct
    private void init() {
        log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>加载FabricUserContext");
        // 指定下加密算法 否则节点通讯过程会报错
        Security.addProvider(new BouncyCastleProvider());
    }

    @Override
    public String getName() {
        return userProperties.getName();
    }

    @Override
    public Set<String> getRoles() {
        return userProperties.getRoles();
    }

    @Override
    public String getAccount() {
        return userProperties.getAccount();
    }

    @Override
    public String getAffiliation() {
        return userProperties.getAffiliation();
    }

    @Override
    public Enrollment getEnrollment() {
        try {
        	// 这里用到了org1 peer0节点的 私钥和证书。用于用户enroll到节点中
            Enrollment enrollment = UserUtils.getEnrollment(org1Peer0Properties.getUsersAdminPrivateKey(), org1Peer0Properties.getUsersAdminCert());
            return enrollment;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String getMspId() {
        return userProperties.getMspId();
    }
}

为了方便读取证书信息封装的工具类

import org.bouncycastle.crypto.CryptoException;
import org.hyperledger.fabric.sdk.Enrollment;
import javax.xml.bind.DatatypeConverter;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;

/**
 * 用户工具类用于读取证书和私钥信息到java对象中
 */
public class UserUtils {

    private static class CAEnrollment implements Enrollment {

        private PrivateKey key;
        private String ecert;

        public CAEnrollment(PrivateKey key, String ecert) {
            this.key = key;
            this.ecert = ecert;
        }

        @Override
        public PrivateKey getKey() {
            return key;
        }

        @Override
        public String getCert() {
            return ecert;
        }
    }

    /**
     * @param keyPath  私钥的地址 crypto-config/ordererOrganizations/example.com/ca/ca.example.com-cert.pem
     * @param certPath 证书的地址 crypto-config/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp/admincerts/Admin@org1.example.com-cert.pem
     * @return enrollment 带有用户信息的对象
     * @throws IOException
     * @throws NoSuchAlgorithmException
     * @throws CryptoException
     * @throws InvalidKeySpecException
     * @description 根据证书目录和私钥目录读取到enrollment里面。
     */
    public static Enrollment getEnrollment(String keyPath, String certPath) throws Exception {
        PrivateKey key = null;
        String certificate = null;
        InputStream isKey = null;
        BufferedReader brKey = null;
        try {
            isKey = new FileInputStream(ClasspathFileUtils.getFileFromSpringBootClassPath(keyPath));
            brKey = new BufferedReader(new InputStreamReader(isKey));
            StringBuilder keyBuilder = new StringBuilder();
            for (String line = brKey.readLine(); line != null; line = brKey.readLine()) {
                if (line.indexOf("PRIVATE") == -1) {
                    keyBuilder.append(line);
                }
            }
            certificate = new String(Files.readAllBytes(Paths.get(ClasspathFileUtils.getFileFromSpringBootClassPath(certPath).getPath())));
            byte[] encoded = DatatypeConverter.parseBase64Binary(keyBuilder.toString());
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
            KeyFactory kf = KeyFactory.getInstance("ECDSA");
            key = kf.generatePrivate(keySpec);
        } finally {
            isKey.close();
            brKey.close();
        }
        return new CAEnrollment(key, certificate);
    }
}

3.6 编写FabricClient用于与网络的交互

import com.lhit.fabric.javafabricsdk.fabric.properties.FabricChannelProperties;
import com.lhit.fabric.javafabricsdk.fabric.properties.FabricOrdererProperties;
import com.lhit.fabric.javafabricsdk.fabric.properties.FabricOrg1Peer0Properties;
import com.lhit.fabric.javafabricsdk.fabric.user.FabricUserContext;
import com.lhit.fabric.javafabricsdk.fabric.util.ClasspathFileUtils;
import lombok.extern.slf4j.Slf4j;
import org.hyperledger.fabric.sdk.*;
import org.hyperledger.fabric.sdk.security.CryptoSuite;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Properties;

/**
 * 创建Channel使用到的client
 */
@Slf4j
@Component
public class FabricClient {

    @Autowired
    private FabricUserContext userContext;

    // Hyperledger Fabric Client 用于创建Channel
    private HFClient hfClient;

    @Autowired
    private FabricChannelProperties channelProperties;

    @Autowired
    private FabricOrdererProperties ordererProperties;

    @Autowired
    private FabricOrg1Peer0Properties org1Peer0Properties;

    private Orderer orderer;

    private Peer org1Peer0;

    @PostConstruct
    private void init() throws Exception {
        log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>加载FabricClient");
        // 创建客户端
        hfClient = HFClient.createNewInstance();
        // 指定加密算法
        CryptoSuite cryptoSuite = CryptoSuite.Factory.getCryptoSuite();
        hfClient.setCryptoSuite(cryptoSuite);
        // 指定用户身份
        hfClient.setUserContext(userContext);
    }

    /**
     * 创建channel
     *
     */
    public Channel createChannel() throws Exception {

        // channel的配置信息
        ChannelConfiguration channelConfiguration = new ChannelConfiguration(ClasspathFileUtils.getFileFromSpringBootClassPath(channelProperties.getChannelConfigTxPath()));
        // 创建channel 需要的参数
        // channelName channel的名称
        // orderer orderer节点对象
        // channelConfiguration channel的配置信息
        // channelConfigurationSignature 用户签名信息
        Channel channel = hfClient.newChannel(channelProperties.getChannelName(), getOrderer(), channelConfiguration, hfClient.getChannelConfigurationSignature(channelConfiguration, hfClient.getUserContext()));
        channel.initialize();
        return channel;
    }

    /**
     * 获取orderer对象
     *
     * @return
     * @throws Exception
     */
    public Orderer getOrderer() throws Exception {
        if (orderer == null) {
            String path = ClasspathFileUtils.getFileFromSpringBootClassPath(ordererProperties.getTlscaCert()).getPath();
            Properties properties = new Properties();
            properties.setProperty("pemFile", path);
            Orderer orderer = hfClient.newOrderer(ordererProperties.getName(), ordererProperties.getGrpcsAddr(), properties);
            return orderer;
        }
        return orderer;
    }
    
    /**
     * 获取peer对象
     *
     * @return
     * @throws Exception
     */
    public Peer getOrg1Peer0() throws Exception {
        if (org1Peer0 == null) {
            String path = ClasspathFileUtils.getFileFromSpringBootClassPath(org1Peer0Properties.getTlscaCert()).getPath();
            Properties properties = new Properties();
            properties.setProperty("pemFile", path);
            Peer peer = hfClient.newPeer(org1Peer0Properties.getName(), org1Peer0Properties.getGrpcsAddr(), properties);
            return peer;
        }
        return org1Peer0;
    }

    /**
     * 根据channel名称获取channel
     *
     * @param channelName
     * @return
     * @throws Exception
     */
    public Channel getChannel(String channelName) throws Exception {
        Channel channel = hfClient.getChannel(channelName);
        if (channel == null) {
            channel = hfClient.newChannel(channelName);
        }
        channel.addOrderer(getOrderer());
        return channel;
    }
}

3.7 编写Service来提供与Fabric网络交互的能力

import com.lhit.fabric.javafabricsdk.fabric.client.FabricClient;
import org.hyperledger.fabric.sdk.Channel;
import org.hyperledger.fabric.sdk.Peer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class FabricChannelService {

    @Autowired
    private FabricClient fabricClient;


    /**
     * 创建通道
     *
     * @throws Exception
     */
    public Channel createChannel() throws Exception {
        return fabricClient.createChannel();
    }

    /**
     * 加入通道
     *
     * @throws Exception
     */
    public void joinChannel(Channel channel,Peer peer) throws Exception {
        channel.joinPeer(peer);
        channel.initialize();
    }

    public Channel getChannel(String channelName) throws Exception {
        return fabricClient.getChannel(channelName);
    }
}

3.8 完整的目录结构

3.9 编写测试类 测试是否可以成功创建channel并将节点org1Peer0加入到channel中

@Slf4j
@SpringBootTest
class JavaFabricSdkApplicationTests {


    @Autowired
    private FabricChannelService channelService;

    @Autowired
    private FabricClient fabricClient;

    @Test
    void contextLoads() throws Exception {

        log.info("开始创建channel");
        Channel channel = channelService.createChannel();

        log.info("org1peer0节点 加入channel");
        channelService.joinChannel(channel,fabricClient.getOrg1Peer0());

        log.info("完成创建channel并将org1peer0加入到channel中");
    }

}

成功执行完毕后 ,如果没有报错 到docker容器中验证org1 peer0 节点是否加入到了channel中

# 进入到cli容器中
docker exec -it cli bash
# cli默认的用户身份就是 org1 peer0 admin用户所以可以直接查看当前节点加入的channel
peer channel list
# 输出 说明 成功的通过java sdk向fabric网络中添加了channel和并将peer加入到了channel中
root@dbe359f6631b:/opt/gopath/src/github.com/hyperledger/fabric/peer# peer channel list
2020-04-01 07:28:46.769 UTC [channelCmd] InitCmdFactory -> INFO 001 Endorser and orderer connections initialized
Channels peers has joined: 
mychannel
mychannel1

四、使用java sdk 安装链码到peer节点中

4.1 在FabricChannelService中添加安装链码的方法

/**
     * 安装链码
     *
     * 注意:目录 {chaincodeLoaction}/src/{chaincodePath}/
     *
     * 在当前项目中 就是
     * chaincodeLoaction = chaincode
     * chaincodePath = basic_info
     *
     * @param type          链码语言GO JAVA NODE
     * @param chaincodeName 链码名称
     * @param version       链码版本
     * @param chaincodeLoaction 链码路径
     * @param chaincodePath 链码路径
     * @param peers         要安装到哪些节点上(这些节点必须在同一个org内)
     * @throws Exception
     */
    public Collection<ProposalResponse> installChaincode(TransactionRequest.Type type, String chaincodeName, String version,String chaincodeLoaction ,String chaincodePath, List<Peer> peers) throws Exception {
        // 初始化Install对象
        InstallProposalRequest installProposalRequest = fabricClient.getHfClient().newInstallProposalRequest();
        // 生成chaincodeId
        ChaincodeID chaincodeID = ChaincodeID.newBuilder().setName(chaincodeName).setVersion(version).build();
        // 设置链码语言类型
        installProposalRequest.setChaincodeLanguage(type);
        // 设置chaincodeId
        installProposalRequest.setChaincodeID(chaincodeID);
        // 指定链码源文件
        installProposalRequest.setChaincodeSourceLocation(ClasspathFileUtils.getFileFromSpringBootClassPath(chaincodeLoaction));
        // 设置chanincodePata
        installProposalRequest.setChaincodePath(chaincodePath);
        return fabricClient.getHfClient().sendInstallProposal(installProposalRequest, peers);
    }

编写测试用例

@Test
    void testInstallChaincodeToPeer() throws Exception {
        Collection<ProposalResponse> basicinfo = channelService.installChaincode(TransactionRequest.Type.GO_LANG,
                "basicinfo",
                "1.0",
                "chaincode",
                "basic_info",
                Lists.newArrayList(fabricClient.getOrg1Peer0()));
    }

测试完成后在容器中查看Org1Peer0是否已经安装了链码

# 进入容器
docker exec -it cli bash

# 执行查看链码安装列表命令
peer chaincode list --installed

# 输出
Get installed chaincodes on peer:
Name: basicinfo, Version: 1.0, Path: basic_info, Id: 124f873c5b5ffa6b57fa2dbb55c463bff7cae916ef297d2d78c6f345126714a2
Name: mycc, Version: 1.0, Path: github.com/chaincode/chaincode_example02/go/, Id: 333a19b11063d0ade7be691f9f22c04ad369baba15660f7ae9511fd1a6488209

五、使用java sdk实例化链码

在service中添加实例化链码的方法,在实例化链码时需要制定背书策略。背书策略一般使用yaml文件来描述

# 背书策略描述文件
identities: # 指定参与背书的角色身份 因为代码中只是将链码安装实例化到了org1的peer0节点,所以先只写user1
  user1: {"role":{"name":"member","mspId":"Org1MSP"}}
#  user2: {"role":{"name":"member","mspId":"Org2MSP"}}
policy: # 具体策略
  1-of: # 以下声明中的一个 就是 user1 背书即可
    - signed-by: "user1"
#    - signed-by: "user2"
#  2-of: # 以下声明中的两个 就是 user1 user2 都需要背书即可
#    - signed-by: "user1"
#    - signed-by: "user2"
#  1-of: # 以下声明中的任意一个 就是 user1 user2 其中一个背书即可
#    - signed-by: "user1"
#    - signed-by: "user2"

把文件复制到resources目录下

/**
     * 实例化链码
     *
     * @param type          链码语言类型
     * @param channelName   channel名称
     * @param chaincodeName 链码名称
     * @param version       版本
     * @param orderer       orderer节点信息
     * @param peer          要安装到那个peer
     * @param funcName      初始化方法名 如果没有可以填写任意字符串
     * @param args          初始化方法传参 如果没有 也要传个 String[] args = {""}
     * @throws Exception
     */
    public void instantiateChaincode(TransactionRequest.Type type, String channelName, String chaincodeName, String version, Orderer orderer, Peer peer, String funcName, String[] args) throws Exception {

        // 获取到channel
        Channel channel = getChannel(channelName);
        // 指定channel中的 orderer和peer
        channel.addPeer(peer);
        channel.addOrderer(orderer);
        // 初始化channel
        channel.initialize();

        //构造提案
        InstantiateProposalRequest instantiateProposalRequest = fabricClient.getHfClient().newInstantiationProposalRequest();
        // 设置语言
        instantiateProposalRequest.setChaincodeLanguage(type);

        // 生成chaincodeId
        ChaincodeID chaincodeID = ChaincodeID.newBuilder().setName(chaincodeName).setVersion(version).build();
        instantiateProposalRequest.setChaincodeID(chaincodeID);
        // 设置初始化方法和参数
        instantiateProposalRequest.setFcn(funcName);
        instantiateProposalRequest.setArgs(args);

        // 设置背书策略
        ChaincodeEndorsementPolicy chaincodeEndorsementPolicy = new ChaincodeEndorsementPolicy();
        chaincodeEndorsementPolicy.fromYamlFile(ClasspathFileUtils.getFileFromSpringBootClassPath("endorsement_policy/my_endorsement_policy.yaml"));
        // 背书策略设置到提案中
        instantiateProposalRequest.setChaincodeEndorsementPolicy(chaincodeEndorsementPolicy);

        // 合约实例化 用channel 提交提案
        Collection<ProposalResponse> proposalResponses = channel.sendInstantiationProposal(instantiateProposalRequest);
        for (ProposalResponse proposalRespons : proposalResponses) {
            if (proposalRespons.getStatus().getStatus() != 200) {
                throw new Exception("提案返回报错");
            }
        }

        // 提交 数据到链上
        channel.sendTransaction(proposalResponses);

    }

添加测试方法

@Test
    void testInstantiateChaincode() throws Exception {
        log.info("开始实例化链码");
        String[] args = {""};
        channelService.instantiateChaincode(TransactionRequest.Type.GO_LANG,
                channelProperties.getChannelName(),
                "basicinfo",
                "1.0",
                fabricClient.getOrderer(),
                fabricClient.getOrg1Peer0(),
                "",
                args
        );
        log.info("完成实例化链码");
    }

测试通过后检查对应节点上已经实例化的链码

# 进入cli容器
docker exec -it cli bash
# 查看当前节点已经实例化的链码
peer chaincode list --instantiated -C mychannel1
# 输出channel中已经实例化的链码
Get instantiated chaincodes on channel mychannel1:
Name: basicinfo, Version: 1.0, Path: basic_info, Escc: escc, Vscc: vscc

六、更新链码

在service中增加更新链码的方法

/**
     * 更新升级链码
     *
     * @param type          链码语言类型
     * @param channelName   channel名称
     * @param chaincodeName 链码名称
     * @param version       版本
     * @param orderer       orderer节点信息
     * @param peer          要安装到那个peer
     * @param funcName      初始化方法名 如果没有可以填写任意字符串
     * @param args          初始化方法传参 如果没有 也要传个 String[] args = {""}
     * @throws Exception
     */
    public void upgradeChaincode(TransactionRequest.Type type, String channelName, String chaincodeName, String version, Orderer orderer, Peer peer, String funcName, String[] args) throws Exception {

        // 获取到channel
        Channel channel = getChannel(channelName);
        // 指定channel中的 orderer和peer
        channel.addPeer(peer);
        channel.addOrderer(orderer);
        // 初始化channel
        channel.initialize();

        //构造提案
        UpgradeProposalRequest upgradeProposalRequest = fabricClient.getHfClient().newUpgradeProposalRequest();
        // 设置语言
        upgradeProposalRequest.setChaincodeLanguage(type);

        // 生成chaincodeId
        ChaincodeID chaincodeID = ChaincodeID.newBuilder().setName(chaincodeName).setVersion(version).build();
        upgradeProposalRequest.setChaincodeID(chaincodeID);
        // 设置初始化方法和参数
        upgradeProposalRequest.setFcn(funcName);
        upgradeProposalRequest.setArgs(args);

        // 修改背书策略
        ChaincodeEndorsementPolicy chaincodeEndorsementPolicy = new ChaincodeEndorsementPolicy();
        chaincodeEndorsementPolicy.fromYamlFile(ClasspathFileUtils.getFileFromSpringBootClassPath("endorsement_policy/my_endorsement_policy.yaml"));
        // 背书策略设置到提案中
        upgradeProposalRequest.setChaincodeEndorsementPolicy(chaincodeEndorsementPolicy);


        // 合约实例化 用channel 提交提案
        Collection<ProposalResponse> proposalResponses = channel.sendUpgradeProposal(upgradeProposalRequest);
        for (ProposalResponse proposalRespons : proposalResponses) {
            if (proposalRespons.getStatus().getStatus() != 200) {
                throw new Exception("提案返回报错");
            }
        }

        // 提交 数据到链上
        channel.sendTransaction(proposalResponses);
    }

编写测试方法 要想更新链码到2.0版本 就需要先将2.0版的链码安装到peer上。

@Test
    void testUpgradeChaincode() throws Exception {
        log.info("开始更新链码");

        // 先安装2.0合约
        Collection<ProposalResponse> basicinfo = channelService.installChaincode(TransactionRequest.Type.GO_LANG,
                "basicinfo",
                "2.0",
                "chaincode",
                "basic_info",
                Lists.newArrayList(fabricClient.getOrg1Peer0()));

        System.out.println("end");

        // 更新链码到2.0
        String[] args = {""};
        channelService.upgradeChaincode(TransactionRequest.Type.GO_LANG,
                channelProperties.getChannelName(),
                "basicinfo",
                "2.0",
                fabricClient.getOrderer(),
                fabricClient.getOrg1Peer0(),
                "",
                args
        );
        log.info("完成更新链码");
    }

执行完成后 查看channel中peer已经实例化的链码

# 进入cli容器
docker exec -it cli bash
# 查看已经实例化的链码
peer chaincode list --instantiated -C mychannel1
# 输出
Get instantiated chaincodes on channel mychannel1:
Name: basicinfo, Version: 2.0, Path: basic_info, Escc: escc, Vscc: vscc

可以看到basicinfo链码的version已经是2.0了

七、 调用链码-invoke

在service中增加调用链码的方法

/**
     * 调用链码invoke链码
     *
     * @param type          链码语言类型
     * @param channelName   channel名称
     * @param chaincodeName 链码名称
     * @param version       版本
     * @param orderer       orderer节点信息
     * @param peers          需要哪些peer背书
     * @param funcName      调用方法名
     * @param args          方法传参
     * @throws Exception
     */
    public CompletableFuture<BlockEvent.TransactionEvent> invokeChaincode(TransactionRequest.Type type, String channelName, String chaincodeName, String version, Orderer orderer,List<Peer>  peers, String funcName, String[] args) throws Exception {

        // 获取到channel
        Channel channel = getChannel(channelName);
        for (Peer peer : peers) {
            channel.addPeer(peer);
        }
        channel.addOrderer(orderer);
        // 初始化channel
        channel.initialize();

        // 构建交易提案
        TransactionProposalRequest proposalRequest = fabricClient.getHfClient().newTransactionProposalRequest();
        // 指定语言
        proposalRequest.setChaincodeLanguage(TransactionRequest.Type.GO_LANG);
        // 生成chaincodeId
        ChaincodeID chaincodeID = ChaincodeID.newBuilder().setName(chaincodeName).setVersion(version).build();
        proposalRequest.setChaincodeID(chaincodeID);
        // 设置初始化方法和参数
        proposalRequest.setFcn(funcName);
        proposalRequest.setArgs(args);

        // 发送提案 peers要与背书规则相匹配,需要哪个peer背书 就将那个peer添加进去
        Collection<ProposalResponse> proposalResponses = channel.sendTransactionProposal(proposalRequest);
        // 合约实例化 用channel 提交提案
        for (ProposalResponse proposalRespons : proposalResponses) {
            if (proposalRespons.getStatus().getStatus() != 200) {
                throw new Exception("提案返回报错:" + proposalRespons.getMessage());
            } else {
                log.info("调用:{} 链码方法成功",funcName);
            }
        }

        // 发送数据到链上
        return channel.sendTransaction(proposalResponses);

    }

编写测试方法

@Test
    void testInvokeChaincode() throws Exception {
        log.info("开始调用链码方法");
//        {"identity":"110115","mobile":"18910012222","name":"zhangsan"}
        String[] args = {"110115", "{"name":"zhangsan-5.0","identity":"110115","mobile":"18910012222"}"};
        CompletableFuture<BlockEvent.TransactionEvent> completableFuture = channelService.invokeChaincode(TransactionRequest.Type.GO_LANG,
                channelProperties.getChannelName(),
                "basicinfo",
                "2.0",
                fabricClient.getOrderer(),
                Lists.newArrayList(fabricClient.getOrg1Peer0()),
                "save",
                args
        );
        log.info("完成链码");
    }

完成测试后 到cli容器中验证下

# 进入cli容器
docker exec -it cli bash

# 查询保存的数据
peer chaincode query -C mychannel4 -n basicinfo  -c {"Args":["query","110115"]}
# 输出
{"identity":"110115","mobile":"18910012222","name":"zhangsan-5.0"}

八 、使用sdk提供的查询功能

在service中添加查询方法

/**
     * 调用链码query链码
     *
     * @param channelName   channel名称
     * @param chaincodeName 链码名称
     * @param funcName      调用方法名
     * @param args          方法传参
     * @throws Exception
     */
    public ProposalResponse queryChaincode(TransactionRequest.Type type,String channelName, String chaincodeName, List<Peer> peers, String funcName, String[] args) throws Exception {
        // 获取到channel
        Channel channel = getChannel(channelName);
        // 多个peer 可以防止单点故障
        for (Peer peer : peers) {
            channel.addPeer(peer);
        }
        // 初始化channel
        channel.initialize();


        // 构建交易提案
        QueryByChaincodeRequest queryByChaincodeRequest = fabricClient.getHfClient().newQueryProposalRequest();
        // 指定语言
        queryByChaincodeRequest.setChaincodeLanguage(type);
        // 生成chaincodeId
        ChaincodeID chaincodeID = ChaincodeID.newBuilder().setName(chaincodeName).build();
        queryByChaincodeRequest.setChaincodeID(chaincodeID);

        // 设置初始化方法和参数
        queryByChaincodeRequest.setFcn(funcName);
        queryByChaincodeRequest.setArgs(args);

        // 调用查询方法
        Collection<ProposalResponse> proposalResponses = channel.queryByChaincode(queryByChaincodeRequest);


        // 合约实例化 用channel 提交提案
        for (ProposalResponse proposalRespons : proposalResponses) {
            if (proposalRespons.getStatus().getStatus() != 200) {
                log.info("提案返回报错:" + proposalRespons.getMessage());
            } else {
                log.info("调用:{} 链码方法成功返回数据:{}", funcName,proposalRespons.getProposalResponse().getPayload());
                return proposalRespons;
            }
        }

        // 如果没有成功提案
        return null;
    }

编写测试方法

@Test
    void testQueryChaincode() throws Exception {
        log.info("开始调用查询链码方法");
//        {"identity":"110115","mobile":"18910012222","name":"zhangsan"}
        String[] args = {"110115"};
        ProposalResponse proposalResponse = channelService.queryChaincode(TransactionRequest.Type.GO_LANG,
                channelProperties.getChannelName(),
                "basicinfo",
                Lists.newArrayList(fabricClient.getOrg1Peer0()),
                "query",
                args
        );

        byte[] chaincodeActionResponsePayload = proposalResponse.getChaincodeActionResponsePayload();
        log.info("完成查询链码:"+ new String(chaincodeActionResponsePayload,"UTF-8") );
    }

测试执行输出

完成查询链码:{"identity":"110115","mobile":"18910012222","name":"zhangsan-5.0"}

说明已经成功从peer上查询到了数据

经验分享 程序员 微信小程序 职场和发展