Spring Boot 2.4.2 与 FISCO BCOS 2.7.2 深度整合实战：从零构建企业级区块链应用

最近在做一个供应链金融的项目，团队决定引入区块链技术来确保交易数据的不可篡改和多方透明。选型时，我们重点考察了国内几个主流的开源联盟链平台，最终敲定了FISCO BCOS。原因很简单：它文档齐全、社区活跃，而且与Java生态，特别是Spring Boot的集成路径相对清晰。但真动手把Spring Boot 2.4.2和FISCO BCOS 2.7.2对接起来，从环境配置、智能合约开发部署，再到最终通过区块链浏览器验证结果，这一路上还是踩了不少坑。这篇文章，我就把自己趟出来的完整路径，结合一些关键的实践细节，系统地梳理一遍。无论你是刚开始接触联盟链的Java开发者，还是正在寻找Spring Boot与国产区块链稳定整合方案的技术负责人，希望这些经验能帮你少走弯路。

1. 环境准备与项目初始化

在开始编码之前，一个稳定、兼容的开发环境是基石。这里的环境准备不仅仅是安装软件，更重要的是理清各个组件之间的版本依赖关系，避免后续出现令人头疼的兼容性问题。

我强烈建议使用IntelliJ IDEA作为开发IDE，它对Maven和Spring Boot的支持非常出色。首先，我们需要确保本地Java环境符合要求。FISCO BCOS的Java SDK 2.7.2官方推荐使用JDK 8或JDK 11。考虑到Spring Boot 2.4.2对JDK 11的良好支持，以及后续的语言特性，这里我们统一使用JDK 11。你可以通过以下命令验证：

java -version

接下来是项目骨架的搭建。我们通过Spring Initializr或者直接在IDEA中创建一个新的Maven项目。最关键的一步是pom.xml中依赖版本的管理。很多初学者在这里容易犯错，引入过高版本的Spring Boot依赖，导致与Java SDK不兼容。下面是我经过多次测试后确认稳定的依赖配置核心部分：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.2</version> <!-- 核心版本，已验证兼容 -->
</parent>

<properties>
    <java.version>11</java.version>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

关于FISCO BCOS节点的搭建，本文不会赘述，请严格按照官方文档进行操作。你需要的是一个至少拥有一个群组（Group）的链在本地运行。一个简单的验证方式是使用控制台连接并查询块高。同时，我强烈建议一并部署WeBASE-Front（区块链浏览器）。它不仅仅是一个查询工具，后续在合约编译、SDK证书获取等方面会为我们提供极大的便利。假设你的节点和WeBASE-Front都已正常运行，那么我们的基础环境就准备好了。

注意：请务必记录下节点的RPC监听地址（通常是ip:20200格式）以及WeBASE-Front的访问地址（通常是ip:5002）。这些信息在后续配置中会频繁用到。

2. Spring Boot项目核心配置与SDK集成

环境就绪后，我们要在Spring Boot项目中引入FISCO BCOS Java SDK，并完成基础配置。这个过程的核心是将区块链网络的连接信息安全、灵活地纳入Spring的配置管理体系。

首先，在pom.xml的<dependencies>部分添加关键依赖：

<dependencies>
    <!-- Spring Boot Web Starter (提供Web能力) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- FISCO BCOS Java SDK -->
    <dependency>
        <groupId>org.fisco-bcos.java-sdk</groupId>
        <artifactId>fisco-bcos-java-sdk</artifactId>
        <version>2.7.2</version>
    </dependency>
    <!-- 其他工具类依赖，如Lombok简化代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

添加依赖后，下一步是准备SDK连接所需的证书文件。这些文件位于你搭建的FISCO BCOS节点的nodes/${ip}/sdk/目录下，主要包括：

  • ca.crt
  • sdk.crt
  • sdk.key

将这些文件复制到Spring Boot项目的src/main/resources/conf目录下。绝对不要将这些证书文件提交到公开的代码仓库，建议通过.gitignore进行忽略。

现在，我们来创建核心的配置文件application.yml。这里采用YAML格式，结构更清晰：

server:
  port: 8080

fisco:
  config:
    crypto-material:
      cert-path: "classpath:conf" # 证书路径，指向resources下的conf目录
    network:
      peers:
        - "127.0.0.1:20200" # 替换为你的节点实际IP和端口
    # 账户配置（如果使用pem文件）
    account:
      key-store-dir: "classpath:account"
      account-file-format: "pem"
    # 线程池配置（可选，用于性能调优）
    thread-pool:
      channel-processor-thread-size: 16

为了让Spring Boot能优雅地加载这些配置，我们创建一个配置属性类FiscoConfigProperties：

package com.example.blockchain.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

@Data
@Component
@ConfigurationProperties(prefix = "fisco.config")
public class FiscoConfigProperties {
    private Map<String, Object> cryptoMaterial;
    private Map<String, List<String>> network;
    private Map<String, Object> account;
    private Map<String, Object> threadPool;
}

接下来是SDK实例化的核心。我们创建一个BcosSDKBean配置类，使用@PostConstruct确保在Spring容器启动后初始化SDK客户端：

package com.example.blockchain.service;

import lombok.extern.slf4j.Slf4j;
import org.fisco.bcos.sdk.BcosSDK;
import org.fisco.bcos.sdk.config.ConfigOption;
import org.fisco.bcos.sdk.config.exceptions.ConfigException;
import org.fisco.bcos.sdk.config.model.ConfigProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Slf4j
@Configuration
public class BcosSDKBean {

    @Autowired
    private FiscoConfigProperties configProperties;

    private BcosSDK bcosSDK;

    @PostConstruct
    public void init() throws ConfigException {
        ConfigProperty configProperty = new ConfigProperty();
        // 组装配置属性
        configProperty.setCryptoMaterial(configProperties.getCryptoMaterial());
        configProperty.setNetwork(configProperties.getNetwork());
        configProperty.setAccount(configProperties.getAccount());
        configProperty.setThreadPool(configProperties.getThreadPool());

        ConfigOption configOption = new ConfigOption(configProperty);
        bcosSDK = new BcosSDK(configOption);
        log.info("FISCO BCOS SDK 初始化成功。");
    }

    @Bean
    public BcosSDK getBcosSDK() {
        return this.bcosSDK;
    }
}

完成以上步骤后，你可以编写一个简单的REST接口来测试连接是否成功。创建一个BlockController，注入BcosSDK，并查询当前块高：

package com.example.blockchain.controller;

import org.fisco.bcos.sdk.BcosSDK;
import org.fisco.bcos.sdk.client.Client;
import org.fisco.bcos.sdk.model.TransactionReceipt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigInteger;

@RestController
@RequestMapping("/api/chain")
public class BlockController {

    @Autowired
    private BcosSDK bcosSDK;

    @GetMapping("/blockNumber")
    public String getBlockNumber() {
        // 获取指定群组（这里为group1）的客户端
        Client client = bcosSDK.getClient(Integer.valueOf(1));
        BigInteger blockNumber = client.getBlockNumber().getBlockNumber();
        return "当前区块链块高: " + blockNumber.toString();
    }
}

启动Spring Boot应用，访问 http://localhost:8080/api/chain/blockNumber。如果返回了具体的块高数字，恭喜你，Spring Boot与FISCO BCOS的基础连接通道已经打通了。这是所有后续操作的基础。

3. 智能合约的开发、编译与部署

区块链应用的核心逻辑封装在智能合约中。这一节，我们将完整走通合约编写、编译为Java类、并通过Spring Boot应用部署上链的流程。

首先，我们设计一个简单的“学生信息管理”合约StudentStorage.sol作为示例。这个合约包含了数据的增删改查，能很好地展示合约与应用的交互。

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.24; // 注意FISCO BCOS 2.x 兼容的Solidity版本

contract StudentStorage {
    struct Student {
        uint256 id;
        string name;
        uint256 score;
    }

    // 学生ID到学生详情的映射
    mapping(uint256 => Student) private students;
    // 下一个可用的学生ID
    uint256 public nextStudentId;

    // 事件，用于日志记录
    event StudentAdded(uint256 indexed id, string name);
    event StudentUpdated(uint256 indexed id, string name);
    event StudentDeleted(uint256 indexed id);

    constructor() public {
        nextStudentId = 1;
    }

    // 添加学生
    function addStudent(string memory _name, uint256 _score) public returns (uint256) {
        uint256 newId = nextStudentId;
        students[newId] = Student(newId, _name, _score);
        nextStudentId++;
        emit StudentAdded(newId, _name);
        return newId;
    }

    // 根据ID查询学生
    function getStudent(uint256 _id) public view returns (uint256 id, string memory name, uint256 score) {
        Student memory s = students[_id];
        require(s.id != 0, "Student does not exist.");
        return (s.id, s.name, s.score);
    }

    // 更新学生信息
    function updateStudent(uint256 _id, string memory _name, uint256 _score) public {
        require(students[_id].id != 0, "Student does not exist.");
        students[_id].name = _name;
        students[_id].score = _score;
        emit StudentUpdated(_id, _name);
    }

    // 删除学生（实际是将ID置零，Solidity mapping无法真正删除）
    function deleteStudent(uint256 _id) public {
        require(students[_id].id != 0, "Student does not exist.");
        delete students[_id];
        emit StudentDeleted(_id);
    }
}

合约写好后，需要将其编译成Java类才能被我们的Spring Boot应用调用。这里我推荐两种方式，各有优劣：

方式一：使用WeBASE-Front在线编译（推荐给初学者）

  1. 打开浏览器，访问部署好的WeBASE-Front（如 http://127.0.0.1:5002/WeBASE-Front）。
  2. 导航到“合约管理” -> “合约IDE”。
  3. 将上述Solidity代码粘贴到编辑器中，点击“编译”。
  4. 编译成功后，找到“导出Java项目”或类似功能。
  5. 输入你的Java包名（例如 com.example.blockchain.contract），然后下载生成的ZIP文件。
  6. 解压后，将里面的Java文件（如 StudentStorage.java）拷贝到Spring Boot项目的 src/main/java 对应包路径下。

方式二：使用FISCO BCOS控制台的sol2java.sh脚本（更贴近生产流程） 这种方式需要你已搭建好FISCO BCOS控制台。将StudentStorage.sol文件放入控制台目录下的 contracts/solidity 中，然后执行：

./sol2java.sh com.example.blockchain.contract

命令执行后，会在 console/output 目录下生成对应的Java文件，将其复制到你的项目中即可。

提示：无论采用哪种方式，生成的Java包装类都包含了与Solidity合约中函数一一对应的Java方法，以及deploy（部署）和load（加载已部署合约）两个关键静态方法。这是我们后续操作的基础。

有了合约的Java包装类，我们就可以在Spring Boot服务中部署它了。创建一个ContractService：

package com.example.blockchain.service;

import com.example.blockchain.contract.StudentStorage; // 这是生成的合约Java类
import lombok.extern.slf4j.Slf4j;
import org.fisco.bcos.sdk.BcosSDK;
import org.fisco.bcos.sdk.client.Client;
import org.fisco.bcos.sdk.crypto.keypair.CryptoKeyPair;
import org.fisco.bcos.sdk.model.TransactionReceipt;
import org.fisco.bcos.sdk.transaction.model.exception.ContractException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.math.BigInteger;

@Slf4j
@Service
public class ContractService {

    @Autowired
    private BcosSDK bcosSDK;

    private StudentStorage studentStorage;
    private String contractAddress;

    /**
     * 部署智能合约
     */
    public String deployContract() throws ContractException {
        Client client = bcosSDK.getClient(Integer.valueOf(1));
        CryptoKeyPair cryptoKeyPair = client.getCryptoSuite().getCryptoKeyPair(); // 使用SDK默认账户

        // 部署合约，会返回交易回执
        StudentStorage deployedContract = StudentStorage.deploy(client, cryptoKeyPair);
        this.contractAddress = deployedContract.getContractAddress();
        this.studentStorage = deployedContract;

        log.info("智能合约部署成功，地址: {}", contractAddress);
        return contractAddress;
    }

    /**
     * 加载已部署的智能合约
     * @param address 合约地址
     */
    public void loadContract(String address) throws ContractException {
        Client client = bcosSDK.getClient(Integer.valueOf(1));
        CryptoKeyPair cryptoKeyPair = client.getCryptoSuite().getCryptoKeyPair();
        this.studentStorage = StudentStorage.load(address, client, cryptoKeyPair);
        this.contractAddress = address;
        log.info("智能合约加载成功，地址: {}", address);
    }

    // 提供合约调用方法的包装
    public BigInteger addStudent(String name, BigInteger score) throws ContractException {
        TransactionReceipt receipt = studentStorage.addStudent(name, score);
        log.info("添加学生交易哈希: {}", receipt.getTransactionHash());
        // 解析回执中的事件日志，获取生成的学生ID（这里简化处理，实际应从日志解析）
        return studentStorage.getAddStudentOutput(receipt).getValue1();
    }

    public StudentStorage.Student getStudent(BigInteger id) throws ContractException {
        return studentStorage.getStudent(id);
    }

    // ... 其他合约方法的包装
}

然后，创建一个控制器ContractController，提供部署和加载合约的HTTP接口：

package com.example.blockchain.controller;

import com.example.blockchain.service.ContractService;
import org.fisco.bcos.sdk.transaction.model.exception.ContractException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigInteger;

@RestController
@RequestMapping("/api/contract")
public class ContractController {

    @Autowired
    private ContractService contractService;

    @PostMapping("/deploy")
    public String deploy() throws ContractException {
        return contractService.deployContract();
    }

    @PostMapping("/load")
    public String load(@RequestParam String address) throws ContractException {
        contractService.loadContract(address);
        return "合约加载成功: " + address;
    }

    @PostMapping("/student")
    public String addStudent(@RequestParam String name, @RequestParam Integer score) throws ContractException {
        BigInteger studentId = contractService.addStudent(name, BigInteger.valueOf(score));
        return "学生添加成功，ID: " + studentId;
    }

    @GetMapping("/student/{id}")
    public Object getStudent(@PathVariable Integer id) throws ContractException {
        return contractService.getStudent(BigInteger.valueOf(id));
    }
}

启动应用，你可以先用POST请求调用 /api/contract/deploy 来部署合约，成功后你会得到一个合约地址（如 0x1234...）。将这个地址通过 /api/contract/load 接口加载到服务中，之后就可以通过 /api/contract/student 等接口与链上的智能合约进行交互了。每一次成功的调用都会产生一个链上交易，并被区块链网络共识和记录。

4. 通过区块链浏览器验证与监控

合约部署和调用成功后，如何验证这些操作确实被区块链网络记录了呢？这就需要用到我们之前部署的WeBASE-Front区块链浏览器。它为我们提供了一个可视化的窗口，来审视链上发生的一切。

首先，确保你的WeBASE-Front服务正在运行，并通过浏览器访问其Web界面。在首页，你应该能看到区块链的概览信息，包括当前块高、交易总数、节点状态等。这和我们之前通过API查询的块高应该是一致的。

验证合约部署：

  1. 在WeBASE-Front侧边栏，导航到“合约管理” -> “已部署合约”。
  2. 在合约列表页面，点击“新增合约”。
  3. 在弹出的窗口中，输入你通过Spring Boot应用部署后得到的合约地址（如 0x1234...）。
  4. 输入合约名称（如 StudentStorage），并从你本地上传合约的ABI文件。ABI文件在你之前编译合约时就会生成（如果使用WeBASE-Front编译，可以直接在编译详情页找到；如果使用sol2java.sh，则在生成目录的abi子文件夹下）。
  5. 点击“确定”保存。保存成功后，该合约就会出现在你的合约列表中。点击合约名称，你可以看到合约的详细信息，包括字节码、ABI，以及一个交互界面。

查看交易与事件：

  1. 在侧边栏导航到“交易信息” -> “交易列表”。这里列出了链上所有的交易。
  2. 找到你刚才通过Spring Boot接口添加学生时产生的交易。你可以通过交易哈希（在应用日志中打印了）来精确查找，或者根据时间、块高筛选。
  3. 点击交易哈希，进入交易详情页。这里包含了丰富的信息：
    • 交易状态：0x0 表示成功。
    • 输入/输出：可以看到调用合约方法时传入的参数编码和解码后的结果。
    • 事件日志：这是非常重要的部分。回顾我们的合约，在addStudent函数中我们定义了StudentAdded事件。在交易详情页的“日志”部分，你应该能看到这个事件被触发的记录，里面包含了事件索引（学生ID）和其他数据。这证明了我们的应用不仅发起了交易，而且合约逻辑确实被执行了。

监控与调试： WeBASE-Front还提供了强大的监控功能。在“区块链概览”或“节点管理”页面，你可以实时查看网络的TPS、出块情况、节点共识状态等。这对于生产环境的运维至关重要。

为了让我们Spring Boot应用内部也能更好地追踪交易，我们可以增强ContractService中的日志记录，将关键信息与区块链浏览器链接起来：

// 在ContractService的addStudent方法中增强日志
public BigInteger addStudent(String name, BigInteger score) throws ContractException {
    TransactionReceipt receipt = studentStorage.addStudent(name, score);
    String txHash = receipt.getTransactionHash();
    log.info("添加学生交易已发送。");
    log.info("交易哈希: {}", txHash);
    log.info("区块链浏览器查看链接: http://127.0.0.1:5002/WeBASE-Front/#/transactionDetail/{}?groupId=1", txHash); // 示例链接
    log.info("交易状态码: {}", receipt.getStatus());
    if (!receipt.getStatus().equals("0x0")) {
        log.error("交易执行失败: {}", receipt.getMessage());
        throw new RuntimeException("链上交易执行失败: " + receipt.getMessage());
    }
    return studentStorage.getAddStudentOutput(receipt).getValue1();
}

通过将交易哈希与区块链浏览器直接关联，我们在排查问题或向他人展示成果时，就能提供一个无可辩驳的、透明的验证途径。这种“代码操作”与“链上验证”的闭环，是开发区块链应用必备的思维习惯。

5. 生产级考量与进阶实践

当应用从Demo走向生产环境时，我们会面临一系列新的挑战。这一部分，我结合项目中的实际经验，分享几个关键的进阶实践点。

账户管理与权限控制： 在之前的例子中，我们默认使用了SDK内置的账户来发送交易。在生产环境中，这通常是不够的。你需要管理多个外部账户，并为不同的业务操作分配不同的账户密钥。FISCO BCOS SDK支持加载PEM或PKCS12格式的账户文件。

// 示例：从指定文件加载PEM格式账户
public CryptoKeyPair loadAccountFromPem(String pemFilePath, String password) throws IOException {
    // 实际项目中，文件路径和密码应从安全配置中心获取
    File pemFile = new File(pemFilePath);
    ECKeyPair ecKeyPair = PEMKeyStore.loadECKeyPair(pemFile.getAbsolutePath(), password);
    return new CryptoKeyPair(ecKeyPair);
}

// 在部署或调用合约时，使用特定账户
public String deployContractWithSpecificAccount(CryptoKeyPair specificKeyPair) throws ContractException {
    Client client = bcosSDK.getClient(Integer.valueOf(1));
    // 使用传入的特定账户密钥对
    StudentStorage deployedContract = StudentStorage.deploy(client, specificKeyPair);
    return deployedContract.getContractAddress();
}

性能优化与异步调用： 区块链交易需要网络共识，因此是相对耗时的操作。在Web应用中同步等待交易确认可能会阻塞请求线程。SDK提供了异步调用接口，我们可以利用Spring的@Async等功能进行优化。

@Service
public class AsyncContractService {
    @Autowired
    private BcosSDK bcosSDK;

    @Async // 需要配合@EnableAsync使用
    public CompletableFuture<String> asyncAddStudent(String name, BigInteger score) throws ContractException {
        Client client = bcosSDK.getClient(Integer.valueOf(1));
        CryptoKeyPair cryptoKeyPair = client.getCryptoSuite().getCryptoKeyPair();
        StudentStorage contract = StudentStorage.load(contractAddress, client, cryptoKeyPair);

        // 使用异步方式发送交易
        CompletableFuture<TransactionReceipt> futureReceipt = contract.addStudentAsync(name, score);
        return futureReceipt.thenApply(receipt -> {
            if (receipt.getStatus().equals("0x0")) {
                return "学生添加成功，交易哈希: " + receipt.getTransactionHash();
            } else {
                throw new RuntimeException("异步交易失败: " + receipt.getMessage());
            }
        });
    }
}

错误处理与重试机制： 网络波动、节点暂时不可用、Gas不足（在支持Gas的模型中）等都可能导致交易失败。一个健壮的生产系统需要完善的错误处理和重试策略。

@Slf4j
@Service
public class RobustContractService {
    private static final int MAX_RETRIES = 3;

    public String robustContractCall(Callable<String> contractCall) {
        int attempts = 0;
        while (attempts < MAX_RETRIES) {
            try {
                return contractCall.call();
            } catch (ContractException e) {
                attempts++;
                log.warn("合约调用失败，第{}次重试。错误: {}", attempts, e.getMessage());
                if (attempts == MAX_RETRIES) {
                    log.error("合约调用重试{}次后仍失败。", MAX_RETRIES);
                    throw new RuntimeException("合约操作失败", e);
                }
                // 指数退避等待
                try {
                    Thread.sleep((long) (Math.pow(2, attempts) * 1000));
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("重试被中断", ie);
                }
            } catch (Exception e) {
                // 非合约异常，直接抛出
                throw new RuntimeException("系统异常", e);
            }
        }
        throw new RuntimeException("未知错误");
    }
}

配置外部化与安全： 绝对不要将证书、私钥、节点地址等敏感信息硬编码在代码或项目内的配置文件中。在生产环境中，应该使用Spring Cloud Config、Apollo等配置中心，或者至少使用环境变量、Kubernetes Secrets来管理。

# application-prod.yml (不提交到仓库)
fisco:
  config:
    network:
      peers:
        - "${FISCO_PEER_1:127.0.0.1:20200}" # 从环境变量读取
    crypto-material:
      cert-path: "${FISCO_CERT_PATH:/secure/volume/conf}" # 从挂载卷读取

最后，监控与告警也必不可少。除了依赖区块链浏览器，你还可以在Spring Boot应用中集成Micrometer，将关键指标（如交易发送成功率、平均延迟、SDK连接状态）暴露给Prometheus，并配置Grafana看板和告警规则，实现对区块链应用性能的全方位掌控。

# 区块链 # 智能合约
Logo
乐奇 Rokid 开放社区

更多推荐

FPC与机器人的双向赋能，解锁智能装备进化新势能

如果说AI算法、算力芯片是智能眼镜的“智慧大脑”，光学模组是智能眼镜的“视觉窗口”，那么FPC就是贯穿整机、连接所有功能模块的“柔性神经脉络”。方寸之间的柔性突破，破解了智能眼镜“轻薄形态”与“全能功能”的核心矛盾，是穿戴智能设备实现形态革新、体验升级的底层核心。未来，随着AR沉浸式技术、AI大模型、穿戴硬件技术的持续进化，智能眼镜将朝着更轻薄、更智能、更多场景、更高稳定性的方向持续迭代，对高端精

avatar 乐奇 Rokid 开放社区
cover

智能眼镜新品扎堆：AR、VR、MR到底怎么分？

avatar 乐奇 Rokid 开放社区
cover

AI眼镜里面有晶振吗？智能眼镜的时钟系统

avatar 乐奇 Rokid 开放社区