Java sdk使用加载账户私钥调用合约

水深无声 2024-03-24 13:18 12阅读 0赞

## Java sdk使用加载账户私钥调用合约 ##

### 1.智能合约案例 ###

#### 1.2 智能合约的流程 ####

![image-20230304233838681][]

#### 1.2 智能合约详细代码 ####

实现了一个简单的商店功能。它定义了三个结构体：用户、商家和商品，以及对应的映射关系。它提供了一些方法用于注册用户和商家，创建商品，更新用户余额，购买商品等等。它还包括一些修饰符，用于限制只有用户或商家可以调用特定的方法。用户购买商品主要涉及到的是，检测当前用户是否有用户的权限，商家生产出售商品检测当前的用户是否有商家的权限。

主要的三个结构体

*  `User`
 *  `Merchant`
 *  `Commodity`

三个结构体分别是用户、商家、商品。

具体业务关系如下：

1.  **用户注册和商家注册** 该合约允许用户和商家进行注册，分别在 `userMap` 和 `merchantMap` 中将对应的用户地址和信息映射起来。
2.  **创建商品** 商家可以调用 `createCommodity` 方法创建一种新的商品，包括商品名称、价格和数量，并将此商品信息存储在 `commodityMap` 和 `commoditys` 数组中，同时将商品数量映射到相应的商家地址（即 `commodityToMerchantMap`）上。
3.  **更新用户余额** 用户可以通过 `updateBalance` 方法更新其账户余额。
4.  **购买商品** 用户可以通过 `buyCommodity` 方法购买已有的商品，其中需要传入商品ID和购买数量。如果用户余额足够且商品库存充足，则会购买成功，同时商家收到相应的款项。
5.  **分页查询商品** 用户可通过 `queryAllCommoditys` 方法查看所有商品并按照分页方式展示。
6.  **查询用户信息和商家信息** 用户和商家都可以通过 `queryUserInfo` 和 `queryMerchantInfo` 方法查询自己的信息。

pragma solidity ^0.4.25;
    pragma experimental ABIEncoderV2;
    
    
    contract Shop {
        // 用户的结构体
        struct User {
            address userAddress;
            string  userName;
            uint256 userBalance;
            Role    role;
        }
        
        // 商家的结构体
        struct Merchant {
            address merchantAddress;
            uint256 merchantBalance;
            Role    role;
        }
        
        // 商品的结构体
        struct Commodity {
            uint256 commodityId;
            string  commodityName;
            uint256 commodityPrice;
            uint256 commodityQuantity;
        }
        
        // 资产ID
        uint256 public commodityCount;
        // 角色枚举
        enum Role { UserType,MerchantType }
        
        // 地址映射用户信息
        mapping(address => User) userMap;
        // 地址映射商家信息
        mapping(address => Merchant) merchantMap;
        // 商品ID映射商品信息
        mapping(uint256 => Commodity) commodityMap;
        // 商品ID映射售卖的商家
        mapping(uint256 => address) commodityToMerchantMap;
        
        // 存储所有商品
        Commodity[] commoditys;
        
        
        // 判断当前是不是用户
        modifier AuthUser(address _userAddress) {
            require(userMap[_userAddress].role == Role.UserType,"当前不是用户");
            _;
        }
        
        // 判断当前是不是商家
        modifier AuthMerchant(address _merchantAddress) {
            require(merchantMap[_merchantAddress].role == Role.MerchantType,"当前不是商家");
            _;
        }
        // 注册事件 
        event Registered(address indexed _Address);
    	// 商家添加商品事件
    	event CreateCommodity(address indexed _Address,string _name);
    	// 用户更新余额事件
        event UpdateBalance(address indexed _Address,uint256 indexed _amount);
        // 用户购买商品事件
        event BuyCommodity(address indexed _Address,uint256 indexed _commodityId);
        
        // 企业注册
        function registerUser(
       		address _userAddress,
       		string _userName
       	) public {
            User memory user = User({
                userAddress: _userAddress,
                userName: _userName,
                userBalance: 0,
                role: Role.UserType
            });
            userMap[_userAddress] = user;
            emit Registered(_userAddress);
        }
        
        // 商家注册
        function registerMerchant(
       		address _merchantAddress,
       		uint256 _merchantBalance
       	) public {
            Merchant memory merchant = Merchant({
                merchantAddress: _merchantAddress,
                merchantBalance: _merchantBalance,
                role: Role.MerchantType
            }); 
            merchantMap[_merchantAddress] = merchant;
            emit Registered(_merchantAddress);
        }
        
        
        // 创建资产 
        function createCommodity(
        	string memory _name,
        	uint256 _price,
        	uint256 _quantity
        ) public AuthMerchant(msg.sender) {
            Commodity memory commodity = Commodity({
                commodityId: commodityCount,
                commodityName: _name,
                commodityPrice: _price,
                commodityQuantity: _quantity
            });
            commodityMap[commodityCount] = commodity;
            commoditys.push(commodity);
            commodityToMerchantMap[commodityCount] = msg.sender;
            commodityCount++;
            emit CreateCommodity(msg.sender,_name);
        }
        
        // 更新余额
        function updateBalance(
        	address _userAddress,
        	uint256 _amount
        ) public AuthUser(msg.sender) {
            userMap[_userAddress].userBalance += _amount;
            emit UpdateBalance(msg.sender,_amount);
        }
        
        // 用户购买一个物品
        function buyCommodity(
        	uint256 _commodityId,
        	uint256 _amount
        ) public AuthUser(msg.sender) {
            require(userMap[msg.sender].userBalance >= _amount,"当前余额不足");
            require(commodityMap[_commodityId].commodityQuantity != 0,"当前的物品没有库存");
            userMap[msg.sender].userBalance -= _amount;
            commodityMap[_commodityId].commodityQuantity--;
            merchantMap[commodityToMerchantMap[_commodityId]].merchantBalance += _amount;
            for (uint i = 0; i < commoditys.length; i++){
                if (commoditys[i].commodityId == _commodityId){
                    commoditys[i].commodityQuantity--;
                }
            }
            emit BuyCommodity(msg.sender,_commodityId);
        }
        
        
        // 分页查询商品
        function queryAllCommoditys(
        	uint256 page,
        	uint256 pageSize
        ) public returns(Commodity[] memory) {
            require(page > 0, "页数不能为0");
            uint256 startIndex = (page - 1) * pageSize; // 计算起始索引
            uint256 endIndex = startIndex + pageSize > commoditys.length ? commoditys.length : startIndex + pageSize; // 计算结束索引
            Commodity[] memory CommodityArr = new Commodity[](endIndex - startIndex); // 创建每页大小的 Enterprise 数组
            for (uint i = startIndex; i < endIndex; i++){
                CommodityArr[i - startIndex] = commoditys[i];
            }
            return CommodityArr;
        }
        
        // 查询用户信息
        function queryUserInfo() public returns(
        	address,
        	string memory,
        	uint256,
        	Role
        ) {
            User memory user = userMap[msg.sender];
            return (user.userAddress,user.userName,user.userBalance,user.role);
        }
        
        // 查询商家信息
        function queryMerchantInfo() public AuthMerchant(msg.sender) returns(
        	address,
        	uint256,
        	Role
        )  {
            Merchant memory merchant = merchantMap[msg.sender];
            return (merchant.merchantAddress,merchant.merchantBalance,merchant.role);
        }
        
    }

#### 1.3 使用WeBASE-Front导出 ####

使用基于FISCO BCOS区块链平台，以及WeBASE-Front部署智能合约，导出Java项目。

![image-20230304234059356][]

使用IDEA查看当前的项目。

![image-20230304234346997][]

### 2.Java SDK加载私钥调用合约 ###

**使用场景**

Webase-front部署智能合约时，私钥的切换通常用于以下场景：

1.  **部署智能合约**：在部署智能合约时，需要使用部署账户的私钥对合约进行签名，确保合约被正确地部署到区块链网络中。
2.  **调用智能合约**：在调用智能合约时，需要使用调用账户的私钥对调用进行签名，确保调用请求的安全性和可信度。
3.  **管理智能合约**：在管理智能合约时，可能需要使用不同的账户私钥进行操作，例如更新合约、授权其他账户对合约进行操作等。

在这些场景下，私钥的切换可以确保智能合约的安全性和可信度，同时也可以保护账户的私密信息不被泄露。

**私钥存储的方式**

*  Java SDK支持通过私钥字符串或者文件加载，所以账户的私钥可以存储在`数据库`中或者`本地文件`。
 *  本地文件支持两种存储格式，其中`PKCS12`加密存储，而`PEM`格式明文存储。
 *  开发业务时可以根据实际业务场景选择私钥的存储管理方式。

这里我选择将私钥加密存储到数据库中，通过用户的地址去查询该地址的私钥或者公钥的方式，用户需要权限的时候，通过用户的地址获取私钥，通过加载用户的私钥传入调用合约的方法中。脱离默认的合约调用者。

针对Java SDK调用合约，有基于ABI和基于BIN的方式调用合约。

*  官网链接-基于ABI和BIN的方式： https://fisco-bcos-documentation.readthedocs.io/zh\_CN/v2.8.0/docs/sdk/java\_sdk/assemble\_transaction.html
 *  官网链接-账户管理: https://fisco-bcos-documentation.readthedocs.io/zh\_CN/v2.8.0/docs/sdk/java\_sdk/key\_tool.html

如下是完整的项目结构图。

![image-20230305153951516][]

#### 2.1 创建数据库表存储公私钥 ####

虽然把私钥和公钥存储在Mysql中，但是还是不算很安全，所以存储的时候需要加盐加密。

create database shop default character set utf8mb4;
    
    create table shop_userKey(
        user_address varchar(60) comment '用户地址',
        user_privateKey text comment '用户私钥',
        user_publicKey text comment '用户公钥'
    ) comment '用户的公私钥表';

#### 2.2 Gradlew添加依赖 ####

在dependencies中添加相对应的依赖。

*  mybatis-plus
 *  mysql-connector-java
 *  fastjson

compile group: 'com.baomidou', name: 'mybatis-plus-boot-starter', version: '3.5.0'
        implementation 'mysql:mysql-connector-java:8.0.27'
        implementation group: 'com.alibaba', name: 'fastjson', version: '2.0.24'
        implementation group: 'org.apache.directory.studio', name: 'org.apache.commons.codec', version: '1.8'

#### 2.3 连接数据库 ####

spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/shop?serverTimezone=UTC&useSSL=false
    
    mybatis.configuration.cache-enabled=true
    mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
    mybatis-plus.mapper-locations=classpath:/mapper/*.xml
    mybatis-plus.global-config.id-type=auto
    mybatis-plus.global-config.db-config.table-prefix=shop_

#### 2.3 创建实体类对象 ####

创建`UserKey`对象，主要是用来操作数据库。在用户注册的时候，需要给用户返回地址和公私钥，私钥仅提供一次下载。

import com.baomidou.mybatisplus.annotation.TableField;
    import com.baomidou.mybatisplus.annotation.TableName;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    @TableName(value = "shop_userKey")
    public class UserKey {
        
    
        @TableField(value = "user_address")
        private String userAddress;
        @TableField(value = "user_privateKey")
        private String userPrivateKey;
        @TableField(value = "user_publicKey")
        private String userPublicKey;
    }

创建User对象，用于返回前端页面用户的数据。

import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public class User {
        
        // 用户地址
        private String  userAddress;
        // 用户名称
        private String  userName;
        // 用户余额
        private int     userBalance;
        // 用户角色
        private int     role;
    }

创建Merchant对象，用于返回前端页面商家的信息。

import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    import java.math.BigInteger;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public class Merchant {
        
        
        // 商家地址
        private String  merchantAddress;
    	// 商家余额
        private int 	merchantBalance;
    	// 用户角色
        private int 	role;
    }

创建Commodity的对象，用于返回前端页面的商品信息或者商品集合

import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.ToString;
    import java.math.BigInteger;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public class Commodity {
        
        // 商品ID
        private  int commodityId;
        // 商品名称
        private  String  commodityName;
        // 商品价格
        private  int commodityPrice;
        // 商品数量
        private  int  commodityQuantity;
    }

#### 2.4 数据持久层 ####

创建UserKeyMapper的接口，继承Mybatis-plus的接口，实现对数据库的CRUD操作。

这里主要是查询和删除两个操作，后续测试暂时需要用到这两个操作，如果有具体的场景还需要详细的操作。

@Mapper
    public interface UserKeyMapper extends BaseMapper<UserKey> {
        
    }
    
    
    public interface UserKeyService extends IService<UserKey> {
        
        public UserKey selectByUserAddress(String address);
    
        public boolean deleteByUserAddress(String address);
    }
    
    
    @Service
    public class UserKeyServiceImpl extends ServiceImpl<UserKeyMapper, UserKey> implements UserKeyService {
        
    
        @Autowired
        private UserKeyMapper userKeyMapper;
        @Override
        public UserKey selectByUserAddress(String address) {
        
            if (address.isEmpty()){
        
                return null;
            }
            LambdaQueryWrapper<UserKey> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(UserKey::getUserAddress, address);
            return userKeyMapper.selectOne(queryWrapper);
        }
    
        @Override
        public boolean deleteByUserAddress(String address) {
        
            if (address.isEmpty()){
        
                return false;
            }
            LambdaQueryWrapper<UserKey> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(UserKey::getUserAddress, address);
            userKeyMapper.delete(queryWrapper);
            return true;
        }
    }

#### 2.5 使用AES算法加密工具类 ####

AES算法是一种对称密钥加密算法，用于保护数据的机密性。它使用相同的密钥进行加密和解密操作。在AES算法中，数据被分成固定长度的块，并通过多轮的密钥混合和替换运算来加密。解密则通过逆向的操作将密文转换为明文。AES算法以其高安全性、高效性和广泛应用而受到广泛认可。

package org.example.Shop.utils;
    
    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;
    import java.nio.charset.StandardCharsets;
    import java.security.Key;
    import java.util.Base64;
    
    public class EncryptionUtils {
        
    
        private static final String ALGORITHM = "AES"; // 加密算法
        private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding"; // 加密模式
    
        private static final String KEY = "MySecretKey12345";
        /**
         * 加密数据
         *
         * @param data 待加密的数据
         * @param KEY 密钥
         * @return 加密后的数据
         */
        public static String encrypt(String data) throws Exception {
        
            Key secretKey = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encryptedBytes);
        }
    
        /**
         * 解密数据
         *
         * @param encryptedData 加密后的数据
         * @param KEY 密钥
         * @return 解密后的数据
         */
        public static String decrypt(String encryptedData) throws Exception {
        
            Key secretKey = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] decodedBytes = Base64.getDecoder().decode(encryptedData);
            byte[] decryptedBytes = cipher.doFinal(decodedBytes);
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        }
    }

#### 2.6 业务层实现 ####

导出Java项目之后，在service层中，有写好的业务方法，可以直接调用，但是有一些方法和业务并不满足需求，比如需要切换账户调用合约，需要加载用户的私钥再调用合约进行交易。

*  用户注册的业务默认
 *  商家注册的业务默认

Java SDK的`org.fisco.bcos.sdk.crypto.CryptoSuite`提供了账户生成功能。

// 创建非国密类型的CryptoSuite
    CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
    // 随机生成非国密公私钥对
    CryptoKeyPair cryptoKeyPair = cryptoSuite.createKeyPair();
    // 获取账户地址
    String accountAddress = cryptoKeyPair.getAddress();
    // 获取账户私钥
    String hexPrivateKey = cryptoKeyPair.getHexPrivateKey();
    // 获取账户公钥
    String hexPublicKey = cryptoKeyPair.getHexPublicKey();

加载用户的私钥：

CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
    // 加载用户私钥        
    CryptoKeyPair cryptoKeyPair = cryptoSuite.getKeyPairFactory().createKeyPair(EncryptionUtils.decrypt(userKey.getUserPrivateKey()));

由于我这里是随机生产的地址，所以没用`pem`和`p12`的方式保存和获取。

**如下图：**

商家需要创建一个苹果，但是创建苹果的用户和地址必须是商家的，不能是其他未注册或者是购买商品的用户去创建的。

![image-20230305162713999][]

##### 2.6.1 添加用户注册获取公私钥 #####

在`UserKeyServiceImpl`的实现类中，添加一个方法`makeNewUserKey()`,用于生成用户新注册时候随机生成的地址和公私钥，以及加密公私钥返回给数据库。

@Service
    public class UserKeyServiceImpl extends ServiceImpl<UserKeyMapper, UserKey> implements UserKeyService {
        
    
        @Autowired
        private UserKeyMapper userKeyMapper;
    
        @SneakyThrows
        @Override
        public UserKey makeNewUserKey() {
        
            // 创建非国密类型的CryptoSuite
            CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
            // 随机生成非国密公私钥对
            CryptoKeyPair cryptoKeyPair = cryptoSuite.createKeyPair();
            // 获取账户地址
            String keyPairAddress = cryptoKeyPair.getAddress();
            // 获取账户私钥
            String hexPrivateKey = cryptoKeyPair.getHexPrivateKey();
            // 获取账户公钥
            String hexPublicKey = cryptoKeyPair.getHexPublicKey();
    
            UserKey userKey = new UserKey();
            userKey.setUserAddress(keyPairAddress);
            // 对数据进行AES算法加密
            userKey.setUserPrivateKey(EncryptionUtils.encrypt(hexPrivateKey));
            userKey.setUserPublicKey(EncryptionUtils.encrypt(hexPublicKey));
            // 加密后存储数据库
            userKeyMapper.insert(userKey);
            return userKey;
        }
        // 其他业务代码
    	......
    }

##### 2.6.2 添加加载账户私钥 #####

如下的操作是在`service`层的默认导出的`ShopService`类中修改。

![image-20230305163216365][]

这是一个公共的方法，可以复用，用户和商家传递私钥对合约的调用。

/**
       * 加载用户账户切换业务
       * @param cryptoKeyPair
       * @param params
       * @return
       * @throws Exception
       */
      private TransactionResponse getTransactionResponse(CryptoKeyPair cryptoKeyPair,String funcName,List<Object> params) throws Exception {
        
          // 过创建和使用AssembleTransactionProcessor对象来调用和查询等操作。不部署合约，那么就不需要复制binary文件
        AssembleTransactionProcessor transactionProcessor = TransactionProcessorFactory
                .createAssembleTransactionProcessor(client, cryptoKeyPair,"src/main/resources/abi/","");
          // 使用同步方式发送交易
        TransactionResponse transactionResponse = transactionProcessor
                .sendTransactionAndGetResponseByContractLoader("Shop",this.address,funcName, params);
        return transactionResponse;
      }

##### 2.6.3 添加商家加载私钥 #####

商家注册之后需要保存地址信息，调用合约的时候携带了商家的地址，通过商家的地址查询获取数据库中加密的私钥，然后该方法主要是商家传入私钥和合约方法，通过加载商家的私钥，即可调用创建商品的方法。

/**
       * 商家添加商品信息
       * @param input
       * @param cryptoKeyPair
       * @param params
       * @return
       * @throws Exception
       */
      public boolean createCommodity(CryptoKeyPair cryptoKeyPair,ShopCreateCommodityInputBO input) throws Exception {
        
        TransactionResponse transactionResponse = getTransactionResponse(cryptoKeyPair,"createCommodity", input.toArgs());
        return transactionResponse.getReceiptMessages().equals("Success");
      }
    
      /**
       * 查询商家的信息
       * @param cryptoKeyPair
       * @param params
       * @return
       * @throws Exception
       */
      public Merchant queryMerchantInfo(CryptoKeyPair cryptoKeyPair, List<Object> params) throws Exception {
        
        TransactionResponse transactionResponse = getTransactionResponse(cryptoKeyPair,"queryMerchantInfo", params);
        return Optional.of(transactionResponse)
                .filter(response -> "Success".equals(response.getReceiptMessages()))
                .map(response -> JSON.parseArray(response.getValues()))
                .filter(objects -> objects.size() >= 3)
                .map(objects -> {
        
                  Merchant merchant = new Merchant();
                  merchant.setMerchantAddress(objects.getString(0));
                  merchant.setMerchantBalance(objects.getInteger(1));
                  merchant.setRole(objects.getInteger(2));
                  return merchant;
                })
                .orElse(null);
      }

##### 2.6.4 添加用户加载私钥 #####

需要用户加载私钥进行的操作的是：

*  更新用户的余额
 *  用户购买商品

这里的操作和上面是一样的，都是需要验证用户加载私钥后，是否为当前私钥的用户地址。

/**
       * 用户更新账户余额
       * @param cryptoKeyPair
       * @param input
       * @return
       * @throws Exception
       */
      public TransactionResponse updateBalance(CryptoKeyPair cryptoKeyPair,ShopUpdateBalanceInputBO input) throws Exception {
        
        return getTransactionResponse(cryptoKeyPair,"updateBalance", input.toArgs());
      }
    
      /**
       * 用户购买商品
       * @param cryptoKeyPair
       * @param input
       * @return
       * @throws Exception
       */
      public TransactionResponse buyCommodity(CryptoKeyPair cryptoKeyPair,ShopBuyCommodityInputBO input) throws Exception {
        
        return getTransactionResponse(cryptoKeyPair,"buyCommodity", input.toArgs());
      }

##### 2.6.5 完整的业务代码 #####

@Service
    @NoArgsConstructor
    @Data
    public class ShopService {
        
      public static final String ABI = org.example.Shop.utils.IOUtil.readResourceAsString("abi/Shop.abi");
    
      public static final String BINARY = org.example.Shop.utils.IOUtil.readResourceAsString("bin/ecc/Shop.bin");
    
      public static final String SM_BINARY = org.example.Shop.utils.IOUtil.readResourceAsString("bin/sm/Shop.bin");
    
      @Value("${system.contract.shopAddress}")
      private String address;
    
      @Autowired
      private Client client;
    
      AssembleTransactionProcessor txProcessor;
    
      @PostConstruct
      public void init() throws Exception {
        
        this.txProcessor = TransactionProcessorFactory.createAssembleTransactionProcessor(this.client, this.client.getCryptoSuite().getCryptoKeyPair());
      }
    
      /**
       * 用户更新账户余额
       * @param cryptoKeyPair
       * @param input
       * @return
       * @throws Exception
       */
      public TransactionResponse updateBalance(CryptoKeyPair cryptoKeyPair,ShopUpdateBalanceInputBO input) throws Exception {
        
        return getTransactionResponse(cryptoKeyPair,"updateBalance", input.toArgs());
      }
    
      /**
       * 用户购买商品
       * @param cryptoKeyPair
       * @param input
       * @return
       * @throws Exception
       */
      public TransactionResponse buyCommodity(CryptoKeyPair cryptoKeyPair,ShopBuyCommodityInputBO input) throws Exception {
        
        return getTransactionResponse(cryptoKeyPair,"buyCommodity", input.toArgs());
      }
    
      public TransactionResponse registerUser(ShopRegisterUserInputBO input) throws Exception {
        
        return this.txProcessor.sendTransactionAndGetResponse(this.address, ABI, "registerUser", input.toArgs());
      }
    
      /**
       * 查询商家的信息
       * @param cryptoKeyPair
       * @param params
       * @return
       * @throws Exception
       */
      public Merchant queryMerchantInfo(CryptoKeyPair cryptoKeyPair, List<Object> params) throws Exception {
        
        TransactionResponse transactionResponse = getTransactionResponse(cryptoKeyPair,"queryMerchantInfo", params);
        return Optional.of(transactionResponse)
                .filter(response -> "Success".equals(response.getReceiptMessages()))
                .map(response -> JSON.parseArray(response.getValues()))
                .filter(objects -> objects.size() >= 3)
                .map(objects -> {
        
                  Merchant merchant = new Merchant();
                  merchant.setMerchantAddress(objects.getString(0));
                  merchant.setMerchantBalance(objects.getInteger(1));
                  merchant.setRole(objects.getInteger(2));
                  return merchant;
                })
                .orElse(null);
      }
    
      /**
       * 加载用户账户切换业务
       * @param cryptoKeyPair
       * @param params
       * @return
       * @throws Exception
       */
      private TransactionResponse getTransactionResponse(CryptoKeyPair cryptoKeyPair,String funcName,List<Object> params) throws Exception {
        
        AssembleTransactionProcessor transactionProcessor = TransactionProcessorFactory
                .createAssembleTransactionProcessor(client, cryptoKeyPair,"src/main/resources/abi/","");
    
        TransactionResponse transactionResponse = transactionProcessor
                .sendTransactionAndGetResponseByContractLoader("Shop",this.address,funcName, params);
        return transactionResponse;
      }
    
      /**
       * 商家添加商品信息
       * @param input
       * @param cryptoKeyPair
       * @param params
       * @return
       * @throws Exception
       */
      public boolean createCommodity(CryptoKeyPair cryptoKeyPair,ShopCreateCommodityInputBO input) throws Exception {
        
        TransactionResponse transactionResponse = getTransactionResponse(cryptoKeyPair,"createCommodity", input.toArgs());
        return transactionResponse.getReceiptMessages().equals("Success");
      }
    
      public TransactionResponse queryAllCommoditys(ShopQueryAllCommoditysInputBO input) throws Exception {
        
        return this.txProcessor.sendTransactionAndGetResponse(this.address, ABI, "queryAllCommoditys", input.toArgs());
      }
    
      public TransactionResponse queryUserInfo() throws Exception {
        
        return this.txProcessor.sendTransactionAndGetResponse(this.address, ABI, "queryUserInfo", Arrays.asList());
      }
    
      public TransactionResponse registerMerchant(ShopRegisterMerchantInputBO input) throws Exception {
        
        return this.txProcessor.sendTransactionAndGetResponse(this.address, ABI, "registerMerchant", input.toArgs());
      }
    
      public CallResponse commodityCount() throws Exception {
        
        return this.txProcessor.sendCall(this.client.getCryptoSuite().getCryptoKeyPair().getAddress(), this.address, ABI, "commodityCount", Arrays.asList());
      }
    }

#### 2.7 控制层实现 ####

这里主要是做测试，为了更加的安全隐患，实际开发模式中需要使用POST请求，不能暴露出来。

##### 2.7.1 RegisterController #####

主要实现的是：

1.  用户的注册接口
2.  商家的注册接口
3.  用户和商家创建新的地址和随机公私钥接口

<table> 
 <thead> 
  <tr> 
   <th>API接口</th> 
   <th>请求类型</th> 
   <th>请求参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/register</td> 
   <td>GET</td> 
   <td>无</td> 
  </tr> 
  <tr> 
   <td>/register/user</td> 
   <td>POST</td> 
   <td>ShopRegisterUserInputBO</td> 
  </tr> 
  <tr> 
   <td>/register/merchant</td> 
   <td>POST</td> 
   <td>ShopRegisterMerchantInputBO</td> 
  </tr> 
 </tbody> 
</table>

用户的请求接口示例：

http://localhost:8088/register/user
    
    {
        
        "_userAddress": "0xaf9f11d639600dffa32ce7f1c3474d1e280cf791",
        "_userName": "张三"
    }

商家的请求接口示例：

http://localhost:8088/register/merchant
    
    {
        
        "_merchantAddress": "0xaf9f11d639600dffa32ce7f1c3474d1e280cf791",
        "_merchantBalance": 1000
    }

@RestController
    @RequestMapping("register")
    public class RegisterController {
        
    
        @Autowired
        private UserKeyService userKeyService;
    
        @Autowired
        private ShopService shopService;
    
        /**
         * 用户注册创建新的随机地址和公私钥
         * @return
         */
        @SneakyThrows
        @GetMapping
        public CommonResponse getAddressAndPrivateKey(){
        
            return CommonResponse.ok("Success",userKeyService.makeNewUserKey());
        }
    
        /**
         * 用户注册
         * @param registerUserInputBO
         * @return
         */
        @SneakyThrows
        @PostMapping("user")
        public CommonResponse registerUser(@RequestBody ShopRegisterUserInputBO registerUserInputBO){
        
            if (StringUtils.isBlank(registerUserInputBO.get_userAddress()) || StringUtils.isBlank(registerUserInputBO.get_userName())){
        
                return CommonResponse.fail("400",new RuntimeException("参数为空"));
            }
            TransactionResponse transactionResponse = shopService.registerUser(registerUserInputBO);
            return CommonResponse.ok("注册成功",transactionResponse.getReceiptMessages());
        }
    
        /**
         * 商家注册
         * @param registerMerchantInputBO
         * @return
         */
        @SneakyThrows
        @PostMapping("merchant")
        public CommonResponse registerMerchant(@RequestBody ShopRegisterMerchantInputBO registerMerchantInputBO){
        
            if (StringUtils.isBlank(registerMerchantInputBO.get_merchantAddress())){
        
                return CommonResponse.fail("400",new RuntimeException("参数为空"));
            }
            TransactionResponse transactionResponse = shopService.registerMerchant(registerMerchantInputBO);
            return CommonResponse.ok("注册成功",transactionResponse.getReceiptMessages());
        }
    }

##### 2.7.2 UserController #####

主要实现的是：

1.  用户获取商品的列表接口
2.  用户购买商品的接口
3.  用户更新账户余额的接口

<table> 
 <thead> 
  <tr> 
   <th>API接口</th> 
   <th>请求类型</th> 
   <th>请求参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/users/{address}</td> 
   <td>POST</td> 
   <td>ShopQueryAllCommoditysInputBO</td> 
  </tr> 
  <tr> 
   <td>/users/{address}</td> 
   <td>POST</td> 
   <td>ShopBuyCommodityInputBO</td> 
  </tr> 
  <tr> 
   <td>/users/{address}</td> 
   <td>PUT</td> 
   <td>BigInteger</td> 
  </tr> 
 </tbody> 
</table>

用户的接口示例：

// 查询商品的列表
    POST http://localhost:8088/users/{
        address}
    
    {
        
        "page": 1,
        "pageSize": 4
    }
    
    // 用户购买商品
    POST http://localhost:8088/users/{
        address}
    {
        
        "_commodityId": 1,
        "_amount": 100
    }
    
    // 更新用户的余额
    PUT http://localhost:8088/users/{
        address}?balance=1000

@RestController
    @RequestMapping("users")
    public class UserController {
        
    
        @Autowired
        private Client client;
        @Autowired
        private ShopService shopService;
        @Autowired
        private UserKeyService userKeyService;
    
        @SneakyThrows
        @GetMapping("{address}")
        public CommonResponse getCommodityList(@PathVariable String address,@RequestBody ShopQueryAllCommoditysInputBO commoditysInputBO){
        
            if (address.isEmpty() || commoditysInputBO.toArgs().isEmpty()){
        
                return CommonResponse.fail("400",new RuntimeException("查询异常"));
            }
            TransactionResponse transactionResponse = shopService.queryAllCommoditys(commoditysInputBO);
            if (transactionResponse.getReceiptMessages().equals("Success")){
        
                String responseValues = transactionResponse.getValues();
                int pageSize = commoditysInputBO.getPageSize();
                // 使用 intStream.range() 方法生成 [0, pageSize-1] 的整数流
                List<Commodity> commodities = IntStream.range(0, pageSize)
                        // 把每一个整数映射成一个 JSONArray 对象
                        .mapToObj(i -> JSON.parseArray(responseValues).getJSONArray(0).getJSONArray(i))
                        // 把每个 JSONArray 转换成 Commodity 对象
                        .map(jsonArray -> {
        
                            // 根据 jsonArray 创建一个 Commodity 对象
                            Commodity commodity = new Commodity();
                            commodity.setCommodityId((Integer) jsonArray.get(0));
                            commodity.setCommodityName((String) jsonArray.get(1));
                            commodity.setCommodityPrice((Integer) jsonArray.get(2));
                            commodity.setCommodityQuantity((Integer) jsonArray.get(3));
                            return commodity;
                        })
                        // 把所有 Commodity 对象收集到一个 List 中
                        .collect(Collectors.toList());
                return CommonResponse.ok("查询成功",commodities);
            }
            return CommonResponse.fail("400",new RuntimeException("查询异常"));
        }
    
        @SneakyThrows
        @PostMapping("{address}")
        public CommonResponse buyCommodity(@PathVariable String address, @RequestBody ShopBuyCommodityInputBO commodityInputBO){
        
            if (StringUtils.isBlank(address)){
        
                return CommonResponse.fail("400", new RuntimeException("当前用户无效"));
            }
            // 获取当前用户的私钥，并使用其创建加密套件及密钥对
            UserKey userKey = userKeyService.selectByUserAddress(address);
            CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
            CryptoKeyPair cryptoKeyPair = cryptoSuite.getKeyPairFactory().createKeyPair(EncryptionUtils.decrypt(userKey.getUserPrivateKey()));
            // 购买商品操作
            TransactionResponse transactionResponse = shopService.buyCommodity(cryptoKeyPair, commodityInputBO);
            if (transactionResponse.getReceiptMessages().equals("Success")){
        
                return CommonResponse.ok("购买成功",address);
            }
            return CommonResponse.fail("400",new RuntimeException("购买失败"));
        }
    
        @SneakyThrows
        @PutMapping("{address}")
        public CommonResponse updateBalance(@PathVariable String address,@RequestParam BigInteger balance){
        
            if (StringUtils.isBlank(address)){
        
                return CommonResponse.fail("400", new RuntimeException("当前用户无效"));
            }
            // 获取当前用户的私钥，并使用其创建加密套件及密钥对
            UserKey userKey = userKeyService.selectByUserAddress(address);
            CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
            CryptoKeyPair cryptoKeyPair = cryptoSuite
                    .getKeyPairFactory()
                    .createKeyPair(EncryptionUtils.decrypt(userKey.getUserPrivateKey()));
    
            ShopUpdateBalanceInputBO balanceInputBO = new ShopUpdateBalanceInputBO(address, balance);
            // 更新账户余额操作
            TransactionResponse transactionResponse = shopService.updateBalance(cryptoKeyPair,balanceInputBO);
            if (transactionResponse.getReceiptMessages().equals("Success")){
        
                return CommonResponse.ok("更新成功",balance);
            }
            return CommonResponse.fail("400",new RuntimeException("更新失败"));
        }
    }

##### 2.7.3 MerchantController #####

主要实现的是：

1.  查看商家内部信息的接口
2.  商家创建商品的接口

<table> 
 <thead> 
  <tr> 
   <th>API接口</th> 
   <th>请求类型</th> 
   <th>请求参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/merchants?address={address}</td> 
   <td>GET</td> 
   <td>address</td> 
  </tr> 
  <tr> 
   <td>/merchants/address</td> 
   <td>POST</td> 
   <td>ShopCreateCommodityInputBO</td> 
  </tr> 
 </tbody> 
</table>

商家的接口请求示例：

GET http://localhost:8088/merchants/?address={
        address}
    
    POST http://localhost:8088/merchants/address
    {
        
        "_name": "苹果",
        "_price": 100,
        "_quantity": 20
    }

@RestController
    @RequestMapping("merchants")
    public class MerchantController {
        
        @Autowired
        private UserKeyService userKeyService;
    
        @Autowired
        private ShopService shopService;
    
        /**
         * 查询商家信息接口
         *
         * @param address   用户地址（商家地址）
         * @return          响应结果对象
         */
        @SneakyThrows
        @GetMapping
        public CommonResponse queryMerchant(@RequestParam String address)  {
        
            if (StringUtils.isEmpty(address)){
        
                return CommonResponse.fail("400",new RuntimeException("查询失败"));
            }
            // 获取商家用户的私钥，并使用其创建加密套件及密钥对
            UserKey userKey = userKeyService.selectByUserAddress(address);
            CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
            CryptoKeyPair cryptoKeyPair = null;
            cryptoKeyPair = cryptoSuite.getKeyPairFactory().createKeyPair(EncryptionUtils.decrypt(userKey.getUserPrivateKey()));
            List<Object> params = new ArrayList<>();
    
            // 调用查询商家信息 假设这是商家的内部信息 普通用户不可查询
            Merchant merchant = shopService.queryMerchantInfo(cryptoKeyPair, params);
            if (Objects.isNull(merchant)){
        
                return CommonResponse.fail("400",new RuntimeException("当前角色不是商家"));
            }
            return CommonResponse.ok("查询成功",merchant);
        }
    
        /**
         * 创建商品接口
         *
         * @param address                   用户地址（商家地址）
         * @param createCommodityInputBO     商品信息参数对象
         * @return                          响应结果对象
         */
        @SneakyThrows
        @PostMapping("{address}")
        public CommonResponse createCommodity(@PathVariable String address,@RequestBody ShopCreateCommodityInputBO createCommodityInputBO){
        
            if (StringUtils.isEmpty(createCommodityInputBO.get_name())){
        
                return CommonResponse.fail("400",new RuntimeException("商品的名称不能为空"));
            }
            // 获取商家用户的私钥，并使用其创建加密套件及密钥对
            UserKey userKey = userKeyService.selectByUserAddress(address);
            System.out.println(userKey.getUserPrivateKey());
            CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
            CryptoKeyPair cryptoKeyPair = cryptoSuite.getKeyPairFactory().createKeyPair(EncryptionUtils.decrypt(userKey.getUserPrivateKey()));
            // 商家调用创建商品
            boolean commodity = shopService.createCommodity(cryptoKeyPair, createCommodityInputBO);
            return CommonResponse.ok("创建成功",commodity);
        }
    }

#### 2.8 API测试 ####

##### 2.8.1 测试注册用户 #####

GET http://localhost:8088/register
    
    POST http://localhost:8088/register/user

1.发送GET请求获取如下的信息：

*  用户的地址： `0x17b1730bb77db57313ac59c20c0aaae2efbaeab6`
 *  用户加密的私钥： `dzuF553WpMInWPeLqjP/dyZ4s381sEPeQni4+mY/L7Y50P46JZkLXiV7RaMYXjMxz1AD+cq9ktjWH4ZCX2jOXAbb0lJO2pSgRxctIDarhYM=`

![image-20230305221854226][]

2.使用上面的用户地址，去注册一个叫”张三“的用户。如下图是注册成功。

![image-20230305222248111][]

3.这里显示注册成功，然后我们通过AES算法的加密工具类解密如下：

得到解密后的私钥： `c8c25e5a9bc3485e90a2cab239861eae9e51a2d57bbb60ea7eda9a4c83267eac`

![image-20230305222758718][]

4.在WeBASE-Front中导入私钥，并且创建`zhangsan`的测试用户。

![image-20230305222932099][]

成功导入之后，直接使用这个账号调用`queryUserInfo`的合约。因为我写查看用户合约的时候我加了检测当前地址是否有权限。

![image-20230305223114434][]

可以发现如下是直接交易成功，并且我是能查看到`张三`的信息的。

*  zhangsan的用户地址：`0x17B1730bb77db57313aC59C20C0AAAe2EFBAeAB6`

对比一下上面接口的测试获取的用户地址，用户地址一模一样。

![image-20230305223623743][]

##### 2.8.2 测试注册商家 #####

GET http://localhost:8088/register
    
    POST http://localhost:8088/register/merchant

1.发送GET请求获取如下的信息：

*  商家的地址： `0x4ab865d51fbf01e2a102a86e56fe9e7358382dce`
 *  商家加密的私钥：`SxWg6lFxmvmp/uyIA0GBmkE1iaCh6jioFigyk+VSbTP4OuyK4HGSbinGKFTzDmwft7dz5hOsiJyUgQ0lQXeuqwbb0lJO2pSgRxctIDarhYM=`

![image-20230305224313691][]

2.使用新的用户地址注册商家，注册资金为1000元。

![image-20230305224500695][]

3.通过解密后得到商家的私钥

*  商家的私钥： `f143333a17243b5d804c4162adbb68bf28fc75dfb7e3db680d48a1f1e2dfcb48`

在WeBASE-Front导入私钥商家的名称为`merchant`，调用查询商家的方法。

![image-20230305224817909][]

调用当前的`queryMerchantInfo`的函数，查看交易如下：

*  merchant的用户地址： `0x4aB865D51fbf01E2A102A86e56Fe9E7358382DcE`

![image-20230305224954366][]

当我使用`zhangsan`的用户去查看企业的内部信息的时候，会交易失败。显示当前不是商家。

![image-20230305225216954][]

4.使用接口测试查询商家的信息，结果和上面一样。

![image-20230305225905882][]

##### 2.8.3 测试商家的添加商品 #####

POST http://localhost:8088/merchants/0x4ab865d51fbf01e2a102a86e56fe9e7358382dce

1.使用商家的地址`0x4ab865d51fbf01e2a102a86e56fe9e7358382dce`，添加两个商品，一个是苹果，一个是香蕉。如下添加成功。

![image-20230305230204202][]

![image-20230305230228403][]

2.使用用户分页查询当前的所有数据。

![image-20230305235634870][]

##### 2.8.4 测试用户购买商品 #####

PUT http://localhost:8088/users/{address}?balance=1000
    
    POST http://localhost:8088/users/{address}

1.给用户的账户更新余额100元。然后查询当前用户的余额。

![image-20230306012030231][]

如下是使用WeBASE-Front查看的余额。

![image-20230306013545696][]

2.用户购买商品，确定只有注册的用户是可以购买成功的。

![image-20230306012341889][]

通过WeBASE-Front调用zhangsan的账户查看个人信息，成功扣款和购买商品。

![image-20230306012519581][]

查看当前的所有商品信息，香蕉已经扣款数量为1。

![image-20230306012718338][]

查看当前的商家余额，已经到账100元。

![image-20230306013035272][]

##### 2.8.5 测试是否加载了私钥 #####

1.我特意在合约中用户购买商品的业务写了触发事件，假设用户购买了该商品，会记录当前的地址是谁购买的，可以通过查看Event事件的`msg.sender`的地址是不是该用户的。

如下是合约的详细部分：

*  有AuthUser修饰符函数确定当前是否具备用户的权限
 *  有BuyCommodity的事件

![image-20230306014021787][]

2.在用户购买商品的部分，也就是用户购买商品时候访问的接口，添加获取当前的合约调用的用户地址。用log的方式查看。

如下是添加的测试代码，用于观察。

@SneakyThrows
        @PostMapping("{address}")
        public CommonResponse buyCommodity(@PathVariable String address, @RequestBody ShopBuyCommodityInputBO commodityInputBO){
        
            if (StringUtils.isBlank(address)){
        
                return CommonResponse.fail("400", new RuntimeException("当前用户无效"));
            }
            // 获取当前用户的私钥，并使用其创建加密套件及密钥对
            UserKey userKey = userKeyService.selectByUserAddress(address);
            CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
            CryptoKeyPair cryptoKeyPair = cryptoSuite.getKeyPairFactory().createKeyPair(EncryptionUtils.decrypt(userKey.getUserPrivateKey()));
            // 购买商品操作
            TransactionResponse transactionResponse = shopService.buyCommodity(cryptoKeyPair, commodityInputBO);
            if (transactionResponse.getReceiptMessages().equals("Success")){
        
                log.info("======================================================");
                log.info("++++++++++++当前的合约调用者:" + transactionResponse.getTransactionReceipt().getFrom());
                log.info("++++++++++++当前的合约调用者:" + transactionResponse.getTransactionReceipt().getLogs().get(0).getTopics().get(1));
                return CommonResponse.ok("购买成功",address);
            }
            return CommonResponse.fail("400",new RuntimeException("购买失败"));
        }

调用此接口继续测试。

![image-20230306023304521][]

3.查看当前的控制台输出情况。

![image-20230306023714077][]

4.使用WeBASE-Front的Event的事件查看。

从日志和Event事件查看，合约的调用者都是`0x17b1730bb77db57313ac59c20c0aaae2efbaeab6`地址。

![image-20230306023811570][]

根据以上的案例，可以理解私钥加载的使用场景。

[image-20230304233838681]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5e271f5e1aa6467e9560e252481ac799.png
[image-20230304234059356]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/50efcee6c25c49259bfbefd489e1ae18.png
[image-20230304234346997]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5d2f7fc34f4944a18b32e1f0c69ef71d.png
[image-20230305153951516]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c0041cf2540d49629e5ecfb939f5a620.png
[image-20230305162713999]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/74b9c26e88a744688ffa90da51bdb264.png
[image-20230305163216365]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0355ccce06fe4e1e8a9cd2868b6521e8.png
[image-20230305221854226]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/656efb41e57840919b70efd60dd1c403.png
[image-20230305222248111]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0c63bb5cfe1e4db7a4a35b987d0f256c.png
[image-20230305222758718]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4dff89850b6d4ccd96df4c7a4199bcdd.png
[image-20230305222932099]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/620ada635dc54d25abae9de7d470ba0e.png
[image-20230305223114434]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/295e0bf08fc7429f8f68103dbaadf706.png
[image-20230305223623743]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6f1a9a89773a455bb86615fa3b334a09.png
[image-20230305224313691]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/14128cd719bb4152ade99bb82a59bcb0.png
[image-20230305224500695]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8c7fa55b2249428ca31f891a9003d733.png
[image-20230305224817909]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c71b28bc075141948c1a128ec0f20832.png
[image-20230305224954366]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2b4fc7aee6614558b9efc9253ece24fb.png
[image-20230305225216954]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/1ab0f06d25a946eebb8eccce1bde2bd9.png
[image-20230305225905882]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c8345a51a28549d3a112dae40adc6e78.png
[image-20230305230204202]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/25e2a6832dcd4e8e83107edc4c01d330.png
[image-20230305230228403]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/72747468ef42429781324c4fd6dc5f1b.png
[image-20230305235634870]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/69fcf747277e4519b206e963dd1f06a4.png
[image-20230306012030231]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c8afc2e6c0244de9948af0621ee68d2e.png
[image-20230306013545696]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/409ae03e06294c32a7782ebd47744a2d.png
[image-20230306012341889]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3a0c180a80764b558661a0a681c63751.png
[image-20230306012519581]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/44831989e0184e758f6a703c08c52c6a.png
[image-20230306012718338]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/674e82da593340fd9d175ba4a09a93b9.png
[image-20230306013035272]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f2b3f531acc74776945f1f2147f5f20b.png
[image-20230306014021787]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f1de452a06504c319ffe433ace009722.png
[image-20230306023304521]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/30d3ed1c0b6a44dd9c0e9085b0fb6157.png
[image-20230306023714077]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/35672d8edd6d4fa196257091f09c8038.png
[image-20230306023811570]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c9db919a43d9431486c52d2f5805d496.png