FISCO BCOS搭建

jdbc:mysql://127.0.0.1:3306/yxaqgl?verifyServerCertificate=true&useSSL=False&requireSSL=False

# 节点管理子系统mysql数据库配置
mysql.ip=127.0.0.1
mysql.port=3306
mysql.user=dbUsername
mysql.password=dbPassword
mysql.database=webasenodemanager

# 签名服务子系统mysql数据库配置
sign.mysql.ip=localhost
sign.mysql.port=3306
sign.mysql.user=dbUsername
sign.mysql.password=dbPassword
sign.mysql.database=webasesign

pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

import "./Table.sol";

contract Record {
    event InsertResult(int256 count);
    event UpdateResult(int256 count);
    event GetResult(string description,string remark);

    TableFactory tableFactory;
    string constant TABLE_NAME = "record";
    constructor() public {
        tableFactory = TableFactory(0x1001); //The fixed address is 0x1001 for TableFactory
        // the parameters of createTable are tableName,keyField,"vlaueFiled1,vlaueFiled2,vlaueFiled3,..."
        tableFactory.createTable(TABLE_NAME, "recordid", "description,remark");
    }

    //select records
    function getResult(string memory recordid)
    public
    view
    returns (string memory,string memory)
    {
        Table table = tableFactory.openTable(TABLE_NAME);

        Condition condition = table.newCondition();
        condition.EQ("recordid",recordid);

        Entries entries = table.select(recordid, condition);

        require(entries.size() > 0, "Record does not exist");

        Entry entry = entries.get(0);

        string memory description = entry.getString("description");

        string memory remark = entry.getString("remark");

        emit GetResult(description,remark);

        return (description,remark);
    }

    //insert records
    function insert(string memory recordid, string memory description, string memory remark)
    public
    returns (int256)
    {
        Table table = tableFactory.openTable(TABLE_NAME);

        Entry entry = table.newEntry();
        entry.set("recordid", recordid);
        entry.set("description",description);
        entry.set("remark", remark);

        int256 count = table.insert(recordid, entry);
        emit InsertResult(count);

        return count;
    }
    //update records
    function update(string memory recordid, string memory description, string memory remark)
    public
    returns (int256)
    {
        Table table = tableFactory.openTable(TABLE_NAME);

        Entry entry = table.newEntry();
        entry.set("description", description);
        entry.set("remark", remark);

        Condition condition = table.newCondition();
        condition.EQ("recordid", recordid);

        int256 count = table.update(recordid, entry, condition);
        emit UpdateResult(count);

        return count;
    }
}

pragma solidity ^0.4.24;

contract TableFactory {
    /**
     * 打开表，返回Table合约地址
     * @param tableName 表的名称
     * @return 返回Table的地址，当表不存在时，将会返回空地址即address(0x0)
     */
    function openTable(string tableName) public constant returns (Table);

    /**
     * 创建表，返回是否成功
     * @param tableName 表的名称
     * @param key 表的主键名
     * @param valueFields 表的字段名，多个字段名以英文逗号分隔
     * @return 返回错误码，成功为0，错误则为负数
     */
    function createTable(string tableName,string key,string valueFields) public returns(int);
}

// 查询条件
contract Condition {
    //等于
    function EQ(string, int) public;
    function EQ(string, string) public;

    //不等于
    function NE(string, int) public;
    function NE(string, string)  public;

    //大于
    function GT(string, int) public;
    //大于或等于
    function GE(string, int) public;

    //小于
    function LT(string, int) public;
    //小于或等于
    function LE(string, int) public;

    //限制返回记录条数
    function limit(int) public;
    function limit(int, int) public;
}

// 单条数据记录
contract Entry {
    function getInt(string) public constant returns(int);
    function getAddress(string) public constant returns(address);
    function getBytes64(string) public constant returns(byte[64]);
    function getBytes32(string) public constant returns(bytes32);
    function getString(string) public constant returns(string);

    function set(string, int) public;
    function set(string, string) public;
    function set(string, address) public;
}

// 数据记录集
contract Entries {
    function get(int) public constant returns(Entry);
    function size() public constant returns(int);
}

// Table主类
contract Table {
    /**
     *  查询接口
     * @param key 查询主键值
     * @param cond 查询条件
     * @return Entries合约地址，合约地址一定存在
     */
    function select(string key, Condition cond) public constant returns(Entries);
    /**
     *  插入接口
     * @param key 插入主键值
     * @param entry 插入字段值
     * @return 插入影响的行数
     */
    function insert(string key, Entry entry) public returns(int);
    /**
     *  更新接口
     * @param key 更新主键值
     * @param entry 更新字段值
     * @param cond 更新条件
     * @return 更新影响的行数
     */
    function update(string key, Entry entry, Condition cond) public returns(int);
    /**
     *  删除接口
     * @param key 删除的主键值
     * @param cond 删除条件
     * @return 删除影响的行数
     */
    function remove(string key, Condition cond) public returns(int);

    function newEntry() public constant returns(Entry);
    function newCondition() public constant returns(Condition);
}

[cryptoMaterial]
certPath = "conf"                           # The certification path

# The following configurations take the certPath by default if commented
# caCert = "conf/ca.crt"                    # CA cert file path
                                            # If connect to the GM node, default CA cert path is ${certPath}/gm/gmca.crt

# sslCert = "conf/sdk.crt"                  # SSL cert file path
                                            # If connect to the GM node, the default SDK cert path is ${certPath}/gm/gmsdk.crt

# sslKey = "conf/sdk.key"                   # SSL key file path
                                            # If connect to the GM node, the default SDK privateKey path is ${certPath}/gm/gmsdk.key

# enSslCert = "conf/gm/gmensdk.crt"         # GM encryption cert file path
                                            # default load the GM SSL encryption cert from ${certPath}/gm/gmensdk.crt

# enSslKey = "conf/gm/gmensdk.key"          # GM ssl cert file path
                                            # default load the GM SSL encryption privateKey from ${certPath}/gm/gmensdk.key

[network]
peers=["127.0.0.1:20200"]    # The peer list to connect


# AMOP configuration
# You can use following two methods to configure as a private topic message sender or subscriber.
# Usually, the public key and private key is generated by subscriber.
# Message sender receive public key from topic subscriber then make configuration.
# But, please do not config as both the message sender and the subscriber of one private topic, or you may send the message to yourself.

# Configure a private topic as a topic message sender.
# [[amop]]
# topicName = "PrivateTopic"
# publicKeys = [ "conf/amop/consumer_public_key_1.pem" ]    # Public keys of the nodes that you want to send AMOP message of this topic to.

# Configure a private topic as a topic subscriber.
# [[amop]]
# topicName = "PrivateTopic"
# privateKey = "conf/amop/consumer_private_key.p12"         # Your private key that used to subscriber verification.
# password = "123456"


[account]
keyStoreDir = "account"         # The directory to load/store the account file, default is "account"
# accountFilePath = ""          # The account file path (default load from the path specified by the keyStoreDir)
accountFileFormat = "pem"       # The storage format of account file (Default is "pem", "p12" as an option)

# accountAddress = ""           # The transactions sending account address
                                # Default is a randomly generated account
                                # The randomly generated account is stored in the path specified by the keyStoreDir

# password = ""                 # The password used to load the account file

[threadPool]
# channelProcessorThreadSize = "16"         # The size of the thread pool to process channel callback
                                            # Default is the number of cpu cores

# receiptProcessorThreadSize = "16"         # The size of the thread pool to process transaction receipt notification
                                            # Default is the number of cpu cores

maxBlockingQueueSize = "102400"             # The max blocking queue size of the thread pool

<!--FiSCO依赖-->
<dependency>
    <groupId>org.fisco-bcos.java-sdk</groupId>
    <artifactId>fisco-bcos-java-sdk</artifactId>
    <version>2.9.1</version>
</dependency>

package com.ruoyi.fisco;

import org.fisco.bcos.sdk.BcosSDK;
import org.fisco.bcos.sdk.client.Client;
import org.fisco.bcos.sdk.config.Config;
import org.fisco.bcos.sdk.config.ConfigOption;
import org.fisco.bcos.sdk.crypto.keypair.CryptoKeyPair;
import org.fisco.bcos.sdk.transaction.manager.AssembleTransactionProcessor;
import org.fisco.bcos.sdk.transaction.manager.TransactionProcessorFactory;
import org.fisco.bcos.sdk.transaction.model.dto.TransactionResponse;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: liuchang
 * @CreateTime: 2024-03-17  11:07
 * @Description: TODO
 * @Version: 1.0
 */
public class RecordTest {
    public final String configFile = "src/main/resources/config-example.toml";

    @Test
    public void testAddRecord() throws Exception {
        ConfigOption configOption = Config.load(configFile);
        // 初始化BcosSDK对象
        BcosSDK sdk = new BcosSDK(configOption);
        // 获取Client对象，此处传入的群组ID为1
        Client client = sdk.getClient(Integer.valueOf(1));
        // 构造AssembleTransactionProcessor对象，需要传入client对象，CryptoKeyPair对象和abi、binary文件存放的路径。abi和binary文件需要在上一步复制到定义的文件夹中。
        CryptoKeyPair keyPair = client.getCryptoSuite().createKeyPair();

        AssembleTransactionProcessor transactionProcessor = TransactionProcessorFactory.createAssembleTransactionProcessor(client, keyPair, "src/main/resources/abi/", "src/main/resources/bin");


        String recordid = "2";
        String description = "{\"name\": \"张三\", \"age\": 24, \"gender\": true}";
        String remark = "2024年3月17 11.22";

        // 创建调用交易函数的参数，此处为传入一个参数
        List<Object> params = new ArrayList<>();
        params.add(recordid);
        params.add(description);
        params.add(remark);
        // 调用HelloWorld合约，合约地址为helloWorldAddress， 调用函数名为『set』，函数参数类型为params
        TransactionResponse transactionResponse = transactionProcessor.sendTransactionAndGetResponseByContractLoader("Record", "0x34a9d8a36b69c3a7a9b0fd373385b26886dc8c22", "insert", params);
        List<Object> returnValues = transactionResponse.getReturnObject();
        if (returnValues != null) {
            for (Object value : returnValues) {
                System.out.println("主键返回值："+value.toString());
            }
        }
    }

    @Test
    public void testSelectRecord() throws Exception {
        ConfigOption configOption = Config.load(configFile);
        // 初始化BcosSDK对象
        BcosSDK sdk = new BcosSDK(configOption);
        // 获取Client对象，此处传入的群组ID为1
        Client client = sdk.getClient(Integer.valueOf(1));
        // 构造AssembleTransactionProcessor对象，需要传入client对象，CryptoKeyPair对象和abi、binary文件存放的路径。abi和binary文件需要在上一步复制到定义的文件夹中。
        CryptoKeyPair keyPair = client.getCryptoSuite().createKeyPair();

        AssembleTransactionProcessor transactionProcessor = TransactionProcessorFactory.createAssembleTransactionProcessor(client, keyPair, "src/main/resources/abi/", "src/main/resources/bin");


        String recordid = "2";
        // 创建调用交易函数的参数，此处为传入一个参数
        List<Object> params = new ArrayList<>();
        params.add(recordid);
        // 调用HelloWorld合约，合约地址为helloWorldAddress， 调用函数名为『set』，函数参数类型为params
        TransactionResponse transactionResponse = transactionProcessor.sendTransactionAndGetResponseByContractLoader("Record", "0x34a9d8a36b69c3a7a9b0fd373385b26886dc8c22", "getResult", params);
        List<Object> returnValues = transactionResponse.getReturnObject();
        if (returnValues != null) {
            for (Object value : returnValues) {
                System.out.println("主键返回值："+value.toString());
            }
        }
    }

    @Test
    public void testUpdateRecord() throws Exception {
        ConfigOption configOption = Config.load(configFile);
        // 初始化BcosSDK对象
        BcosSDK sdk = new BcosSDK(configOption);
        // 获取Client对象，此处传入的群组ID为1
        Client client = sdk.getClient(Integer.valueOf(1));
        // 构造AssembleTransactionProcessor对象，需要传入client对象，CryptoKeyPair对象和abi、binary文件存放的路径。abi和binary文件需要在上一步复制到定义的文件夹中。
        CryptoKeyPair keyPair = client.getCryptoSuite().createKeyPair();

        AssembleTransactionProcessor transactionProcessor = TransactionProcessorFactory.createAssembleTransactionProcessor(client, keyPair, "src/main/resources/abi/", "src/main/resources/bin");


        String recordid = "2";
        String description = "{\"name\": \"张三\", \"age\": 24, \"gender\": true}";
        String remark = "2024年3月17 14:26";

        // 创建调用交易函数的参数，此处为传入一个参数
        List<Object> params = new ArrayList<>();
        params.add(recordid);
        params.add(description);
        params.add(remark);
        // 调用HelloWorld合约，合约地址为helloWorldAddress， 调用函数名为『set』，函数参数类型为params
        TransactionResponse transactionResponse = transactionProcessor.sendTransactionAndGetResponseByContractLoader("Record", "0x34a9d8a36b69c3a7a9b0fd373385b26886dc8c22", "update", params);
        List<Object> returnValues = transactionResponse.getReturnObject();
        if (returnValues != null) {
            for (Object value : returnValues) {
                System.out.println("主键返回值："+value.toString());
            }
        }
    }

}