开发指南
萌新必读

国产信创数据库（DM 达梦、大金、OpenGauss、瀚高、OceanBase、TiDB、GaussDB、PolarDB、神通、Vastbase、MogDB、TongRDS、CacheDB）

# 1. DM 达梦数据库

# 1.1 如何安装？

可以使用 Windows 或 Docker 等多种方式。

注意，建议从达梦官网 (opens new window) 下载较新的 DM8 服务端安装包或官方 Docker 镜像，不推荐使用年代久远的第三方镜像。“DM8”或 Docker 镜像的标签不能代表实际版本，需要以下面 SQL 查询到的完整服务端版本为准。

如何确认达梦的版本？

使用应用连接数据库的同一账号，连接应用实际使用的数据库，执行如下只读 SQL：

-- ① 查询服务端的完整版本
SELECT * FROM v$version;
-- ② 检查 FIND_IN_SET 函数是否可用，应返回 2
SELECT FIND_IN_SET('b', 'a,b,c') FROM DUAL;

达梦官方现行手册 (opens new window) 中列出了 FIND_IN_SET 函数，项目的部分查询会用到它。如果第 ② 条 SQL 提示函数无法识别，优先评估升级达梦服务端，升级后再复测；只升级 JDBC 驱动，无法为服务端补充函数。

本地验证使用的是 DM 服务端 8.1.3.162、JDBC 驱动 8.1.3.140，第 ② 条 SQL 返回 2。这只是本地验证的示例，不是官方要求的最低版本，也不代表当前最新版本。

# 1.1.1 Windows 方式

参考官方文档 (opens new window)

① 访问 https://eco.dameng.com/download/ (opens new window) 地址，点击“开发版 (X86平台)”选项，进行下载。

② 傻瓜式安装、数据库实例化，一路下去就好，不用修改任何参数。

# 1.1.2 Docker 方式

参考官方文档 (opens new window)

① 访问 https://eco.dameng.com/download/ (opens new window) 地址，点击“Docker 镜像”选项，进行下载。

② 执行如下脚本，启动 Docker 服务：

docker load -i dm8_20240715_x86_rh6_rq_single.tar

docker run -d -p 5236:5236 \
    --restart=unless-stopped \
    --name dm8_test \
    --privileged=true \
    -e PAGE_SIZE=16 \
    -e LD_LIBRARY_PATH=/opt/dmdbms/binn \
    -e EXTENT_SIZE=32 \
    -e BLANK_PAD_MODE=1 \
    -e LOG_SIZE=1024 \
    -e UNICODE_FLAG=1 \
    -e LENGTH_IN_CHAR=1 \
    -e INSTANCE_NAME=dm8_test \
    -v $PWD/dm8_test:/opt/dmdbms/data \
    dm8_single:dm8_20240715_rev232765_x86_rh6_64

上述命令中的 dm8_20240715 只是 20240715 版本的示例，不是最新的镜像版本。实际以从官网下载的安装包，以及 docker load 导入后输出的镜像名为准。注意，更换镜像不等于升级，已有的数据目录不要直接挂载给其它版本的镜像使用，已有数据的升级请按达梦官方的升级、迁移流程处理。

备注：可以尝试使用大小写不敏感配置 -e CASE_SENSITIVE=N。需要停止并删除容器后，删除 dm8_test 目录，重新docker run。删除目录会清空其中的数据，仅适用于可以丢弃的全新测试实例；已有数据的实例，请按达梦官方的迁移流程处理。

# 1.2 如何导入数据？

使用 DM 管理工具 (opens new window) 进行数据的导入。如果你不是很了解，已可以看看文档：

具体步骤如下：

① 使用 DM 管理工具，新建一个名字为 RUOYI_VUE_PRO 的 schema 模式。如下图所示：

新建模式

为什么名字是 RUOYI_VUE_PRO 呢？

因为稍后使用的 sql/dm/ruoyi-vue-pro-dm8.sql 文件，使用的 schema 是它噢。后续跑通了，你可以按照自己的修改。

② 点击 DM 管理工具的 [执行 -> 执行脚本] 菜单，选中项目中的 sql/dm/ruoyi-vue-pro-dm8.sql 文件，之后点击 [绿色箭头] 进行执行即可。

友情提示：如果你不想 DM 管理工具，也可以使用其它工具：

# 1.3 如何启动项目？

① 修改 yudao-spring-boot-starter-mybatis 模块的 pom.xml 文件，将 DM 依赖的 DmJdbcDriver18 的 optional 移除（注意，需要使用 IDEA 刷新下 Maven 的依赖）。如下图所示：

数据库依赖

② 修改 application-local.yaml 配置文件，将数据库的 url、username、password 修改为 DM 数据库。例如说：

数据库连接配置

③ 后续启动项目，就可以了。

疑问：启动报“无效的模式名[RUOYI_VUE_PRO]”错误，怎么解决？

可以把上图的 url 中的 ?schema=RUOYI_VUE_PRO 部分去掉后，再重启下，试试看。

# 1.4 常见问题？

# 1.4.1 大小写敏感？

参考《详解 DM 数据库字符串大小写敏感》 (opens new window) 文档

# 1.4.2 Quartz 定时任务？

Quartz 定时任务，已经适配，直接参考《定时任务》使用。

实现思路非常简单：

Quartz 初始化使用 tables_oracle (opens new window) 脚本，去掉前面的 delete 和 drop 部分
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass 使用 org.quartz.impl.jdbcjobstore.StdJDBCDelegate 类。不过网上也有人说使用 org.quartz.impl.jdbcjobstore.oracle.OracleDelegate 类，我暂时没跑成功

# 1.4.3 Flowable 工作流？

Flowable 工作流的适配，可参考《工作流（达梦适配）》。

短期内暂时没时间适配，欢迎你搞了之后，pull request 贡献给项目，从而帮助到更多人！

# 2. KingbaseES 大金数据库

# 2.1 如何安装？

可以使用 Windows 或 Docker 等多种方式。

注意，目前我们使用的是 V008R006C008B0020 的版本。

# 2.1.1 Windows 方式

参考官方文档 (opens new window)

# 2.1.2 Docker 方式

参考官方文档 (opens new window)

① 访问 https://www.kingbase.com.cn/xzzx/index.htm (opens new window) 地址，点击左侧的“软件版本 -> 数据库” 菜单，再点击“docker镜像”选项，进行下载：

x86_64 版本 (opens new window) 【Windows 选择这个】
aarch64 版本 (opens new window) 【MacBook Apple Silicon 选择这个】

② 执行如下脚本，启动 Docker 服务：

docker load -i kdb_x86_64_V009R001C001B0025.tar

docker run -d -p 54321:54321 \
    --restart=unless-stopped \
    --name kingbase_test \
    --privileged=true \
    -e NEED_START=yes  \
    -e DB_USER=root  \
    -e DB_PASSWORD=123456  \
    -e DB_MODE=oracle  \
    kingbase_v009r001c001b0025_single_x86:v1

# 2.2 如何导入数据？

① 使用 Navicat 工具，选择 PostgreSQL 数据库，即可连接。如下图所示：

连接大金数据库

② 选择 test 数据库的 public 模式，右键选择“运行 SQL 文件”，选择项目中的 sql/kingbase/ruoyi-vue-pro.sql 文件，之后点击 [开始] 按钮。

# 2.3 如何启动项目？

① 修改 yudao-spring-boot-starter-mybatis 模块的 pom.xml 文件，将 KingbaseES 依赖的 kingbasees-jdbc 的 optional 移除（注意，需要使用 IDEA 刷新下 Maven 的依赖）。如下图所示：

数据库依赖

② 修改 application-local.yaml 配置文件，将数据库的 url、username、password 修改为 KingbaseES 数据库。例如说：

数据库连接配置

③ 后续启动项目，就可以了。

# 2.4 常见问题？

# 2.4.1 Quartz 定时任务？

Quartz 定时任务，已经适配，直接参考《定时任务》使用。

实现思路非常简单：

Quartz 初始化使用 tables_postgres (opens new window) 脚本
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass 使用 org.quartz.impl.jdbcjobstore.StdJDBCDelegate 类。

# 2.4.2 Flowable 工作流？

Flowable 工作流的适配，可参考如下文章：

短期内暂时没时间适配，欢迎你搞了之后，pull request 贡献给项目，从而帮助到更多人！

# 3. 华为 OpenGauss

# 3.1 如何安装？

可以使用 Linux 或 Docker 等多种方式。

注意，目前我们使用的是 openGauss 5.0.0 的版本。

友情提示：openGauss 不支持 Windows 系统，所以请使用 Linux 或 Docker 等方式。

# 3.1.1 Docker 方式

执行如下脚本，启动 Docker 服务：

docker run -d \
  --name opengauss-test \
  --restart unless-stopped \
  -e GS_USERNAME=root \
  -e GS_PASSWORD=Yudao@2024 \
  -e LD_LIBRARY_PATH=/usr/local/opengauss/lib:/usr/lib \
  -p 5432:5432 \
  opengauss/opengauss:5.0.0

# 3.2 如何导入数据？

① 参考《用 JetBrains DataGrip 连接 Huawei openGauss》 (opens new window) 文档，连接 openGauss 数据库。

疑问：为什么不使用 Navicat 进行连接？

因为 Navicat 不支持 openGauss 数据库，而使用 PostgreSQL 进行连接，会出现 “none of the server's SASL authentication mechanisms are supported” 报错。

② 选择 postgres 数据库，右键选择“SQL Scripts -> Run SQL Script...”，选择项目中的 sql/opengauss/ruoyi-vue-pro.sql 文件，之后执行。

# 3.3 如何启动项目？

① 修改 yudao-spring-boot-starter-mybatis 模块的 pom.xml 文件，将 openGauss 依赖的 opengauss 的 optional 移除（注意，需要使用 IDEA 刷新下 Maven 的依赖）。如下图所示：

数据库依赖

② 修改 application-local.yaml 配置文件，将数据库的 url、username、password 修改为 openGauss 数据库。例如说：

数据库连接配置

::: 疑问：为什么 jdbc 使用 postgres 数据库连接？

因为 openGauss 是兼容 PostgreSQL 的，所以 JDBC 驱动使用的是 org.postgresql.Driver。这样，后续和 Quartz 定时任务、Flowable 工作流等等，都是可以兼容的。 :::

③ 后续启动项目，就可以了。

# 3.4 常见问题？

# 3.4.1 Quartz 定时任务？

Quartz 定时任务，已经适配，直接参考《定时任务》使用。

实现思路非常简单（因为 jdbc 使用 postgres 数据库连接）：

Quartz 初始化使用 tables_postgres (opens new window) 脚本

# 3.4.2 Flowable 工作流？

Flowable 工作流，已经适配，直接参考《工作流》使用。

也是因为 jdbc 使用 postgres 数据库连接，所以无需去兼容。

# 4. HighGo 瀚高数据库

# 4.1 如何安装？

可以使用 Linux 或 Docker 等多种方式。

注意，目前项目按照 PostgreSQL 兼容模式适配瀚高数据库，并在瀚高企业版 6.0.4 上完成了组件级验证（见《4.4.5 验证范围？》）。

# 4.1.1 Docker 方式

① 下载瀚高官方 Docker 镜像，并加载镜像文件。加载后，将镜像打成本地标签：

docker load -i <highgo-image>.tar
docker tag <image>:<tag> highgo:local

② 在项目 sql/tools 目录下运行：

docker compose up -d highgo

注意：highgo 服务属于 highgo profile，执行 docker compose up -d 时不会启动，需要像上面一样指定服务名。不同瀚高镜像的数据目录可能不同，如果容器无法启动，请按镜像实际 PGDATA 修改 docker-compose.yaml 中的 highgo 数据卷挂载目录。

# 4.2 如何导入数据？

有手动导入、Docker 一键导入两种方式，任选其一即可，不要混用。下面先介绍手动导入，适用于任意方式安装的瀚高数据库：

① 使用 DataGrip、DBeaver 等数据库工具，选择 PostgreSQL 数据库类型，连接瀚高数据库。默认端口为 5866，账号、密码以安装时设置或镜像说明为准。

注意，如果数据库开启了 SM3 等 PostgreSQL 驱动不支持的认证方式，选择 PostgreSQL 类型会连接失败，需要在工具中配置瀚高的 JDBC 驱动后再连接。

② 创建一个名字为 ruoyi-vue-pro 的数据库（名字带 -，SQL 中需要写成 CREATE DATABASE "ruoyi-vue-pro";），在该数据库中先执行项目中的 sql/highgo/quartz.sql 文件，再执行 sql/highgo/ruoyi-vue-pro.sql 文件。

友情提示：如果使用 Docker，也可以直接导入（无需执行上述手动步骤）：

在项目 sql/tools 目录下运行，使用 postgres:14.2 镜像中的 psql 客户端，创建 ruoyi-vue-pro 数据库并导入上述 SQL 文件：

HIGHGO_PASSWORD='数据库密码' docker compose run --rm highgo-init

默认使用瀚高的 highgo 账号连接 highgo 数据库执行建库，可以通过 HIGHGO_USER、HIGHGO_MAINTENANCE_DB 环境变量修改；密码以镜像或安装时的实际设置为准，脚本不会修改数据库的认证配置。

注意，导入脚本只允许创建全新的数据库，数据库已存在（包括空库）或重复执行时，会拒绝导入并返回失败；导入失败时会保留数据库，便于排查。该方式只适用于 PostgreSQL 客户端支持的认证方式（例如说 md5、scram-sha-256），数据库开启 SM3 等专有认证时，请使用瀚高客户端按上述步骤手动导入。

友情提示

瀚高数据库兼容 PostgreSQL，所以项目 SQL、Quartz、Flowable 都按照 PostgreSQL 兼容模式处理。

# 4.3 如何启动项目？

① 在每个连接数据库的服务（例如说 yudao-module-system-server、yudao-module-infra-server，以及你启动的其它业务服务）的 pom.xml 中，引入 PostgreSQL JDBC 驱动，版本由 Spring Boot 统一管理，无需填写（使用瀚高 JDBC 驱动时，见《4.4.4 使用瀚高 JDBC 驱动？》）。yudao-gateway 不连接数据库，无需引入：

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>

使用 yudao-server 单体启动模式时，它依赖了这些服务模块，会一并引入驱动。

注意：只在 `yudao-dependencies` 中声明，是无法引入驱动的！

yudao-dependencies 是 Maven BOM，<dependencyManagement> 只统一依赖的版本，不会把 jar 包引入到项目中。yudao-spring-boot-starter-mybatis 中的 postgresql 依赖也是 <optional>true</optional>，不会传递到各个服务。所以，需要在最终运行的服务模块的 <dependencies> 中引入。

打包后，可以执行 unzip -l yudao-module-system/yudao-module-system-server/target/yudao-module-system-server.jar | grep postgresql，确认 BOOT-INF/lib 中包含驱动。

② 修改每个连接数据库的服务的数据源配置，将数据库的 url、username、password 修改为瀚高数据库。gateway-server 不连接数据库，无需修改。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      druid:
        validation-query: SELECT 1
      datasource:
        master:
          url: jdbc:postgresql://127.0.0.1:5866/ruoyi-vue-pro
          driver-class-name: org.postgresql.Driver
          username: highgo
          password: ${HIGHGO_PASSWORD}

注意，如果本地配置里 validation-query 仍然是 SELECT 1 FROM DUAL，需要改成 SELECT 1，否则 PostgreSQL/瀚高会因为不存在 DUAL 表导致连接校验失败。

username、password 需要填写数据库实际的账号和密码，以安装时设置或镜像说明为准。上面使用的是瀚高默认的 highgo 账号，密码通过 HIGHGO_PASSWORD 环境变量设置。如果配置了 slave 等多个数据源，也需要同步修改对应配置。

使用 Nacos 配置中心时：

服务的 application.yaml 会先加载本地的 application-{profile}.yaml，再加载 Nacos 中的 ${spring.application.name}-${spring.profiles.active}.yaml（例如说 system-server-local.yaml），Nacos 的优先级更高。

如果 Nacos 中已经配置了 spring.datasource.dynamic.datasource 的 master、slave 等数据源，需要在 Nacos 中按上述 YAML 修改，否则本地的修改会被覆盖。每个服务对应各自的 Data ID，需要逐个修改。修改后，以启动日志中数据源连接的地址为准，确认连接的是 5866 端口。

疑问：为什么 jdbc 使用 postgres 数据库连接？

因为瀚高数据库兼容 PostgreSQL，所以 JDBC 驱动使用的是 org.postgresql.Driver。项目会根据 url 将数据库识别为 PostgreSQL，自动使用 INPUT 主键（配合 SQL 脚本中的序列）。这样，后续和 Flowable 工作流等等，都是可以兼容的。

③ 后续启动项目，就可以了。

# 4.4 常见问题？

# 4.4.1 Quartz 定时任务？

Quartz 定时任务，已经适配，直接参考《定时任务》使用。

实现思路非常简单（因为 jdbc 使用 postgres 数据库连接）：

Quartz 初始化使用项目中的 sql/highgo/quartz.sql 脚本，来自 Quartz 官方的 tables_postgres.sql (opens new window)

# 4.4.2 Flowable 工作流？

Flowable 工作流，已经适配，直接参考《工作流》使用。

也是因为 jdbc 使用 postgres 数据库连接，所以无需去兼容。

# 4.4.3 启动报找不到 Driver？

启动时报 SQLException，提示找不到 org.postgresql.Driver、com.highgo.jdbc.Driver 等驱动类，说明该服务没有引入对应的 JDBC 驱动。

常见原因是：只在 yudao-dependencies 的 <dependencyManagement> 中声明了驱动依赖。它只管理版本，不会引入 jar 包。按照《4.3 如何启动项目？》的步骤，在每个连接数据库的服务的 pom.xml 的 <dependencies> 中引入，并刷新 Maven 依赖后重新启动。

# 4.4.4 使用瀚高 JDBC 驱动？

瀚高官方 JDBC 文档 (opens new window) 中的驱动类为 com.highgo.jdbc.Driver，url 格式为 jdbc:highgo://ip:端口号/数据库名，驱动需要和数据库版本、JDK 版本匹配。

一般使用 PostgreSQL 驱动即可。如果数据库开启了 SM3（国密）等 PostgreSQL 驱动不支持的认证方式，或者需要使用瀚高驱动的专有能力，则使用与数据库版本匹配的瀚高驱动：

① 在每个连接数据库的服务的 pom.xml 中，引入瀚高驱动 com.highgo:HgdbJdbc，版本按数据库版本及厂商说明选择：

<dependency>
    <groupId>com.highgo</groupId>
    <artifactId>HgdbJdbc</artifactId>
    <version>与数据库匹配的版本</version>
</dependency>

② 修改每个服务的数据源配置，url 与 driver-class-name 需要配对。使用 Nacos 配置中心时，同样需要在 Nacos 中逐个服务修改：

spring:
  datasource:
    dynamic:
      druid:
        validation-query: SELECT 1
      datasource:
        master:
          url: jdbc:highgo://127.0.0.1:5866/ruoyi-vue-pro
          driver-class-name: com.highgo.jdbc.Driver
          username: highgo
          password: ${HIGHGO_PASSWORD}

项目会将 jdbc:highgo: 的 url 也识别为 PostgreSQL，与 PostgreSQL 驱动一样，自动使用 INPUT 主键，无需额外配置。

注意，目前只有 master-jdk17 分支包含该识别处理，其它分支请使用 PostgreSQL 驱动。

# 4.4.5 验证范围？

在瀚高企业版 6.0.4 的试用镜像上，分别使用 PostgreSQL 驱动和瀚高驱动 6.2.2，完成了组件级验证：sql/highgo 中的项目 SQL 和 Quartz SQL 原样导入，JDBC 元数据识别、序列主键、MyBatis Plus 增删改查与分页，代码生成读取表和字段注释，Quartz 持久化任务执行，Flowable 建表、审批与定时器。

注意，验证使用的是第三方打包的试用镜像，不是瀚高官方发布的镜像，正式环境请通过瀚高官方渠道获取安装介质和授权。这是组件级验证，不是完整微服务的启动验收，没有覆盖全部业务服务及服务间调用，也没有覆盖 SM3 等专有认证方式。如果用于正式环境，请按你使用的服务完整回归。

# 5. OceanBase 数据库

# 5.1 如何安装？

可以使用 Linux 或 Docker 等多种方式。

注意，目前我们使用的是 OceanBase 社区版 4.4.2.1 的 MySQL 模式。

# 5.1.1 Docker 方式

参考官方文档 (opens new window)

在项目 sql/tools 目录下运行：

docker compose up -d --wait --wait-timeout 300 oceanbase

注意：Docker 建议至少分配 8 GB 内存；同时运行 MySQL、Elasticsearch 等服务时，建议分配 12 GB 或更多。启动失败时，可执行 docker compose logs oceanbase，检查内存和租户初始化日志。

# 5.2 如何导入数据？

① 使用 DataGrip、DBeaver 等数据库工具，选择 MySQL 数据库类型，连接 OceanBase 数据库。默认地址为 127.0.0.1:2881，账号为 root@test，密码为 123456。

② 创建一个名字为 ruoyi-vue-pro、字符集为 utf8mb4 的数据库，依次执行项目中的 sql/oceanbase/ruoyi-vue-pro.sql、sql/oceanbase/quartz.sql 文件。

友情提示：如果使用 Docker，也可以直接导入：

在项目 sql/tools 目录下运行，自动创建数据库并导入上述 SQL 文件：

docker compose exec oceanbase bash /tmp/create_schema.sh

注意，导入脚本会重建同名表，仅用于初始化测试数据库。

# 5.3 如何启动项目？

① 项目已经引入 MySQL JDBC 驱动，无需新增 OceanBase 驱动依赖。

② 修改 application-local.yaml 配置文件，将数据库的 url、username、password 修改为 OceanBase 数据库。例如说：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:mysql://127.0.0.1:2881/ruoyi-vue-pro?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root@test
          password: 123456

注意，root@test 连接的是 MySQL 模式的 test 租户。如果配置了 slave 等多个数据源，也需要同步修改对应配置。

疑问：为什么 jdbc 使用 mysql 数据库连接？

因为 OceanBase 的 MySQL 模式兼容 MySQL 协议，所以 JDBC 驱动使用的是 com.mysql.cj.jdbc.Driver，初始化 SQL 也直接复用 MySQL 脚本。

③ 后续启动项目，就可以了。

# 5.4 常见问题？

# 5.4.1 Quartz 定时任务？

Quartz 的初始化 SQL 已验证可以导入，对应项目中的 sql/oceanbase/quartz.sql 文件。使用方式可参考《定时任务》。

# 5.4.2 Flowable 工作流？

Flowable 工作流，已经适配，直接参考《工作流》使用。

也是因为 jdbc 使用 mysql 数据库连接，所以无需去兼容。

# 6. TiDB 数据库

TiDB 是 PingCAP 开源的分布式数据库，兼容 MySQL 协议。项目把它作为可选数据库：默认仍然使用 MySQL，接入 TiDB 只需要修改数据源配置，不需要修改代码。

# 6.1 如何安装？

可以使用 Docker 或 TiUP 等多种方式。

注意，目前我们使用的是 TiDB v8.5.8 版本，PD、TiKV、TiDB 各 1 个节点，仅用于开发测试。生产环境请参考官方部署文档 (opens new window)。

# 6.1.1 Docker 方式

在项目 sql/tools 目录下运行：

docker compose up -d --wait --wait-timeout 300 tidb

注意：TiDB 相关服务属于 tidb profile，执行 docker compose up -d 时不会启动，不影响原有的 MySQL 等服务。端口只绑定本机 127.0.0.1:4000，数据保存在 tidb_pd、tidb_tikv 数据卷中。启动失败时，可执行 docker compose logs tidb-pd tidb-tikv tidb 检查日志。

# 6.1.2 TiUP 方式

参考官方文档 (opens new window)，安装 TiUP 后执行：

tiup playground v8.5.8 --db 1 --pd 1 --kv 1 --tiflash 0

注意，未指定 --tag 时，结束 playground 后会自动清理集群数据。如需保留数据，可以指定标签启动，例如说 tiup playground v8.5.8 --tag yudao-tidb --db 1 --pd 1 --kv 1 --tiflash 0，后续使用相同的 --tag 启动即可继续使用原数据。

TiUP 启动的集群，root 账号默认没有密码，导入数据前建议先设置密码。

# 6.2 如何导入数据？

有手动导入、Docker 一键导入两种方式，任选其一即可，不要混用。下面先介绍手动导入，适用于 TiUP 等任意方式安装的 TiDB：

① 使用 DataGrip、DBeaver 等数据库工具，选择 MySQL 数据库类型，连接 TiDB 数据库。默认地址为 127.0.0.1:4000，账号为 root。

注意，新安装的 TiDB（包括 Docker 方式首次启动）root 账号默认没有密码，只有执行下方的 tidb-init 才会自动设置为 123456。手动导入时，建议先执行如下 SQL 设置密码：

ALTER USER 'root'@'%' IDENTIFIED BY '123456';

② 创建一个名字为 ruoyi-vue-pro、字符集为 utf8mb4 的数据库，依次执行项目中的 sql/mysql/ruoyi-vue-pro.sql、sql/mysql/quartz.sql 文件。

③ 稍后《6.3 如何启动项目？》中数据源的 password，需要按你实际设置的 root 密码填写。

友情提示：如果使用 Docker，也可以直接导入（无需执行上述手动步骤）：

在项目 sql/tools 目录下运行，将 root 密码设置为 123456，自动创建数据库并导入上述 SQL 文件：

docker compose run --rm tidb-init

注意，导入脚本只允许创建全新的数据库。如果已经按上述步骤手动创建了 ruoyi-vue-pro 数据库（包括空库），或者重复执行时，脚本会拒绝导入并返回失败，避免重建已有的同名表；导入失败时会保留数据库，便于排查。docker-compose.yaml 中的 TIDB_PASSWORD 只允许字母、数字和 _ . @ # % + = - 字符。如需重新初始化，执行 docker compose down tidb tidb-tikv tidb-pd 后，删除 ruoyi-vue-pro_tidb_pd、ruoyi-vue-pro_tidb_tikv 数据卷。

疑问：为什么没有 `sql/tidb` 目录？

TiDB 兼容 MySQL 语法，项目的 MySQL 脚本使用 utf8mb4 字符集，可以直接导入，所以不再单独维护一份 TiDB 脚本。

# 6.3 如何启动项目？

① 项目已经引入 MySQL JDBC 驱动，无需新增 TiDB 驱动依赖。

② 修改每个连接数据库的服务（例如说 system-server、infra-server，以及你启动的其它业务服务）的数据源配置，将数据库的 url、username、password 修改为 TiDB 数据库。gateway-server 不连接数据库，无需修改。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:mysql://127.0.0.1:4000/ruoyi-vue-pro?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: 123456

注意，如果配置了 slave 等多个数据源，也需要同步修改对应配置。

使用 Nacos 配置中心时：

疑问：为什么 jdbc 使用 mysql 数据库连接？

因为 TiDB 兼容 MySQL 协议，所以 JDBC 驱动使用的是 com.mysql.cj.jdbc.Driver，项目会按 MySQL 处理分页、代码生成等数据库差异，初始化 SQL 也直接复用 MySQL 脚本。

③ 后续启动项目，就可以了。

# 6.4 常见问题？

# 6.4.1 Quartz 定时任务？

Quartz 的初始化 SQL 直接复用项目中的 sql/mysql/quartz.sql 文件。使用方式可参考《定时任务》。

Quartz 通过 SELECT ... FOR UPDATE 获取集群锁，依赖 TiDB 默认的悲观事务模式，请不要把 tidb_txn_mode 修改为 optimistic。

# 6.4.2 Flowable 工作流？

Flowable 工作流按 MySQL 数据库识别 TiDB，bpm-server 启动时自动创建工作流相关的表，使用方式可参考《工作流》。

# 6.4.3 事务与兼容边界？

TiDB 兼容 MySQL 协议，但并不等同于 MySQL，使用前需要注意以下差异，详细说明见《与 MySQL 兼容性对比》 (opens new window)：

不支持存储过程、函数、触发器、事件，以及 SKIP LOCKED、XA 语法、FULLTEXT 全文索引、SPATIAL 空间类型等。如果你自己扩展的业务使用了这些特性，需要改写。
默认使用悲观事务，REPEATABLE-READ 隔离级别实际为快照隔离，并且不支持间隙锁（GAP Lock）。依赖间隙锁防止并发插入的逻辑，需要改为使用唯一索引等方式保证。
AUTO_INCREMENT 自增编号只保证唯一，在单个 TiDB 节点内递增，但不保证连续：每个 TiDB 节点默认批量缓存 30000 个编号，重启后可能跳号。项目没有把自增主键改为 AUTO_RANDOM，编号的含义保持不变；部署多个 TiDB 节点、需要全局递增时，可参考《AUTO_INCREMENT》 (opens new window) 的 MySQL 兼容模式。
不支持 XA 语法，所以不能使用依赖 XA 的分布式事务模式。项目默认不启用 Seata、ShardingSphere，接入 TiDB 也不会自动开启它们。
目前在真实的 TiDB v8.5.8（PD、TiKV、TiDB）集群上，完成了组件级验证：项目初始化 SQL 和 Quartz SQL 导入，JDBC 元数据识别、自增主键、事务回滚，MyBatis Plus 增删改查与分页，代码生成读取表和字段注释，Quartz 定时任务执行，Flowable 建表、审批、异步任务与定时器。这是组件级验证，不是完整微服务的启动验收，没有覆盖全部业务服务及服务间调用。如果用于正式环境，请按你使用的服务完整回归。

# 7. 华为 GaussDB 数据库

华为 GaussDB 是华为的商用数据库，与第 3 节的 openGauss 社区版不是同一个产品，需要使用 GaussDB 的原生 JDBC 驱动。项目按 PG 兼容模式 接入 GaussDB 集中式版，复用 sql/opengauss 脚本，默认仍然使用 MySQL。

# 7.1 如何安装？

可以使用 Linux 等方式，GaussDB 没有官方 Docker 镜像。

注意，目前我们使用的是 GaussDB 混合云开发者版 V2.0-10.0.0（内核 507.0.T1）。GaussDB 的分布式版、GaussDB(DWS) 数据仓库，没有经过验证。

# 7.1.1 Linux 方式

① 访问华为云 GaussDB 下载页 (opens new window)，下载对应操作系统、CPU 架构的开发者版安装包，以及 JDBC 驱动包。开发者版的官方声明是：仅供个人学习、适配验证或测试，不得用于商业用途，也不提供高可用、升级能力。正式环境请通过华为官方渠道获取商用版本。

② 按安装包中的官方说明完成安装、启动。

注意，内存较小的机器启动失败时，可以检查 max_process_memory 参数。测试中设置为 1GB 会被 GaussDB 拒绝，设置为 2GB 后可以正常启动。

③ 创建项目连接使用的账号（具有 CREATEDB 权限），并在 gs_hba.conf（不是 pg_hba.conf）中为该账号、客户端地址配置密码认证（例如说 sha256），然后重新加载配置。GaussDB 的初始用户不允许远程连接，请不要把认证方式改为 trust。

# 7.2 如何导入数据？

GaussDB 默认创建的是 A（Oracle）兼容模式的数据库，项目脚本需要使用 PG 兼容模式、UTF8 编码的数据库。

同时，GaussDB 已经内置了 dual 视图（sys.dual、pg_catalog.dual），sql/opengauss/ruoyi-vue-pro.sql 开头的 DROP TABLE IF EXISTS dual 会报 "dual" is not a table 错误。导入时需要跳过创建 dual 表的一段，不要删除或修改内置的 dual 视图，其余 SQL 保持不变。

有脚本导入、手动导入两种方式，任选其一即可，不要混用。

① 脚本导入：在安装了 GaussDB gsql 客户端的机器上（例如说以数据库安装用户登录 GaussDB 服务器，并复制项目的 sql 目录），在项目 sql/tools 目录下执行：

GAUSSDB_PORT='数据库端口' GAUSSDB_USER='数据库账号' GAUSSDB_PASSWORD='数据库密码' bash gaussdb/create_schema.sh

脚本会创建 PG 兼容模式（DBCOMPATIBILITY = 'PG'）、UTF8 编码的 ruoyi-vue-pro 数据库，先导入 sql/opengauss/quartz.sql，再导入跳过 dual 段的 sql/opengauss/ruoyi-vue-pro.sql。GAUSSDB_HOST 为空时，使用本机 Unix Socket 连接。

注意，脚本只允许创建全新的数据库，数据库已存在（包括空库）或重复执行时，会拒绝导入并返回失败；dual 段的格式与预期不一致、或者没有检测到 GaussDB 内置的 dual 视图时，也会拒绝导入。导入失败时会保留数据库，便于排查。

② 手动导入：使用 gsql 等工具，执行如下 SQL 创建数据库，并确认 SHOW sql_compatibility; 的结果为 PG：

CREATE DATABASE "ruoyi-vue-pro" ENCODING 'UTF8' DBCOMPATIBILITY = 'PG';

在该数据库中，先执行 sql/opengauss/quartz.sql 文件，再执行去掉 dual 段后的 sql/opengauss/ruoyi-vue-pro.sql 文件。去掉 dual 段，可以使用如下命令生成新文件：

sed '/^-- Table structure for dual$/,/^-- @formatter:on$/d' sql/opengauss/ruoyi-vue-pro.sql > ruoyi-vue-pro-without-dual.sql

# 7.3 如何启动项目？

① 在每个连接数据库的服务（例如说 yudao-module-system-server、yudao-module-infra-server，以及你启动的其它业务服务）的 pom.xml 中，引入 GaussDB JDBC 驱动。yudao-gateway 不连接数据库，无需引入：

<dependency>
    <groupId>com.huaweicloud.gaussdb</groupId>
    <artifactId>gaussdbjdbc</artifactId>
    <version>506.0.0.b058</version>
</dependency>

也可以使用开发者版驱动包中，与 JDK 版本对应的 gaussdbjdbc.jar，通过本地 Maven 私服等方式引入。

注意，com.huaweicloud:gaussdbjdbc 是另一个坐标，不包含 GaussDB 的驱动类，不要混淆。

② 修改每个连接数据库的服务的数据源配置，将数据库的 url、username、password 修改为 GaussDB 数据库。gateway-server 不连接数据库，无需修改。使用 Nacos 配置中心时，Nacos 中的配置优先级更高，需要在 Nacos 中逐个服务修改，详见《4.3 如何启动项目？》。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:gaussdb://127.0.0.1:8000/ruoyi-vue-pro
          driver-class-name: com.huawei.gaussdb.jdbc.Driver
          username: yudao
          password: ${GAUSSDB_PASSWORD}

username、password 需要填写 7.1 中创建的账号和密码，端口以安装时的设置为准。validation-query 保持默认的 SELECT 1 FROM DUAL 即可，使用的是 GaussDB 内置的 dual 视图。

疑问：项目是如何适配 GaussDB 的？

项目会将 jdbc:gaussdb: 的 url 识别为 PostgreSQL，自动使用 INPUT 主键（配合 SQL 脚本中的序列）；代码生成器也按 PostgreSQL 生成菜单 SQL。GaussDB 驱动返回的数据库产品名是 GaussDB，项目也会识别它。MyBatis Plus 的分页，使用其自带的 GaussDB 方言。

注意，目前只有 master-jdk17 分支包含该识别处理。

③ 后续启动项目，就可以了。

# 7.4 常见问题？

# 7.4.1 Quartz 定时任务？

Quartz 的初始化 SQL 直接复用项目中的 sql/opengauss/quartz.sql 文件。使用方式可参考《定时任务》。

# 7.4.2 Flowable 工作流？

Flowable 无法识别 GaussDB 这个数据库产品名。项目在没有显式设置 Flowable 的 databaseType 时，bpm-server 会按 PostgreSQL 创建工作流相关的表；如果你自己设置了 databaseType，项目不会覆盖。使用方式可参考《工作流》。

# 7.4.3 验证范围？

在 GaussDB 混合云开发者版 V2.0-10.0.0（内核 507.0.T1）PG 兼容模式的数据库上，分别使用 Maven 中的驱动 506.0.0.b058、开发者版驱动包中的 JDK 17 驱动，完成了组件级验证：sql/opengauss 中的 Quartz SQL 原样导入、项目 SQL 跳过 dual 段后导入（共 59 张表），sql/tools/gaussdb/create_schema.sh 的全新导入、拒绝已存在数据库，JDBC 元数据识别、序列主键、事务回滚，MyBatis Plus 增删改查与分页，代码生成读取表和字段注释，Quartz 持久化任务执行，Flowable 建表、审批与定时器。

注意，这是组件级验证，不是完整微服务的启动验收，没有覆盖全部业务服务及服务间调用，也没有覆盖 A 兼容模式、分布式版及商用版本。如果用于正式环境，请按你使用的服务完整回归。

# 8. 阿里 PolarDB 数据库

阿里云 PolarDB 包含多个产品，协议和项目的接入方式各不相同，需要先确认你使用的是哪一个：

产品	JDBC 驱动	项目 SQL	说明
PolarDB PostgreSQL 版（开源 PolarDB for PostgreSQL）	PostgreSQL 驱动，`jdbc:postgresql:`	`sql/postgresql`	已在 PolarDB for PostgreSQL 17 上完成组件级验证
PolarDB PostgreSQL 版（云数据库）	PostgreSQL 驱动，`jdbc:postgresql:`	`sql/postgresql`	接入方式同上，没有在云实例上验证
PolarDB MySQL 版（云数据库）	MySQL 驱动，`jdbc:mysql:`	`sql/mysql`	兼容 MySQL 协议，没有在云实例上验证
PolarDB-X（分布式版）	MySQL 驱动，`jdbc:mysql:`	`sql/mysql`	尚未验证通过，见《8.4.3 PolarDB-X 是否支持？》
PolarDB PostgreSQL 版（兼容 Oracle）	PolarDB 驱动，`jdbc:polardb:`	无	暂不支持，见《8.4.4 PolarDB 兼容 Oracle 是否支持？》

下面以开源的 PolarDB for PostgreSQL 为例，项目不需要修改代码，直接按 PostgreSQL 使用。

# 8.1 如何安装？

可以使用 Docker 等方式。

注意，目前我们使用的是 PolarDB for PostgreSQL 17（SELECT version() 为 PostgreSQL 17.11、PolarDB 17.11.1.0）的单机实例镜像，仅用于开发测试。

# 8.1.1 Docker 方式

参考官方文档 (opens new window)，执行如下命令，启动 Docker 服务：

docker run -d \
  --name polardb-pg-test \
  --restart unless-stopped \
  --shm-size 256m \
  -p 127.0.0.1:15438:5432 \
  polardb/polardb_pg_local_instance:17

注意，该镜像初始化的 postgres 账号使用 trust 认证（无需密码），所以端口只绑定本机 127.0.0.1:15438，仅用于测试。官方文档中的 --privileged、--cap-add 参数，在上述单机实例中不是必需的。

# 8.2 如何导入数据？

① 使用 DataGrip、DBeaver 等数据库工具，选择 PostgreSQL 数据库类型，连接 PolarDB 数据库。地址为 127.0.0.1:15438，账号为 postgres。

② 创建一个名字为 ruoyi-vue-pro 的数据库（名字带 -，SQL 中需要写成 CREATE DATABASE "ruoyi-vue-pro";），在该数据库中先执行项目中的 sql/postgresql/quartz.sql 文件，再执行 sql/postgresql/ruoyi-vue-pro.sql 文件。

# 8.3 如何启动项目？

① 在每个连接数据库的服务（例如说 yudao-module-system-server、yudao-module-infra-server，以及你启动的其它业务服务）的 pom.xml 中，引入 PostgreSQL JDBC 驱动，版本由 Spring Boot 统一管理，无需填写。yudao-gateway 不连接数据库，无需引入：

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>

② 修改每个连接数据库的服务的数据源配置，将数据库的 url、username、password 修改为 PolarDB 数据库。gateway-server 不连接数据库，无需修改。使用 Nacos 配置中心时，Nacos 中的配置优先级更高，需要在 Nacos 中逐个服务修改，详见《4.3 如何启动项目？》。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:postgresql://127.0.0.1:15438/ruoyi-vue-pro
          driver-class-name: org.postgresql.Driver
          username: postgres
          password: # 镜像使用 trust 认证，无需填写

使用云数据库时，url、username、password 修改为云实例的连接地址和账号即可。

疑问：为什么 jdbc 使用 postgres 数据库连接？

因为 PolarDB PostgreSQL 版兼容 PostgreSQL，驱动返回的数据库产品名也是 PostgreSQL，所以项目按 PostgreSQL 处理主键、代码生成，Flowable 也自动识别为 PostgreSQL，无需额外配置。

③ 后续启动项目，就可以了。

# 8.4 常见问题？

# 8.4.1 Quartz 定时任务？

Quartz 的初始化 SQL 直接复用项目中的 sql/postgresql/quartz.sql 文件。使用方式可参考《定时任务》。

# 8.4.2 Flowable 工作流？

Flowable 工作流按 PostgreSQL 数据库识别 PolarDB PostgreSQL 版，bpm-server 启动时自动创建工作流相关的表，使用方式可参考《工作流》。

# 8.4.3 PolarDB-X 是否支持？

PolarDB-X 兼容 MySQL 协议，理论上可以复用 sql/mysql 脚本和 MySQL 驱动，但目前还没有验证通过：

在 polardbx/polardb-x 官方 all-in-one 镜像 v2.5.0（CN 5.4.21）的低内存测试环境中，导入项目 SQL 时出现内存不足、连接中断，没有完成导入。官方建议该镜像分配 12 GB 以上内存。
DRDS 模式的数据库在没有开启外键支持时，导入 sql/mysql/quartz.sql 会报 Do not support foreign key 错误；开启外键支持后的 DRDS、AUTO 模式，同样因为上述资源问题没有完成导入。

所以，暂时不能认为 PolarDB-X 已经适配。如需使用，请在资源充足的环境中，按 MySQL 的方式完整回归。

# 8.4.4 PolarDB 兼容 Oracle 是否支持？

暂不支持。PolarDB PostgreSQL 版（兼容 Oracle）需要使用阿里云的 PolarDB 驱动（jdbc:polardb:），目前项目使用的 MyBatis Plus 版本无法识别该 url，分页等功能无法使用，也没有对应的项目 SQL。

# 8.4.5 验证范围？

在 PolarDB for PostgreSQL 17 的官方单机实例镜像上，使用 PostgreSQL 驱动完成了组件级验证：sql/postgresql 中的项目 SQL 和 Quartz SQL 原样导入（共 60 张表），JDBC 元数据识别、序列主键、事务回滚，MyBatis Plus 增删改查与分页，代码生成读取表和字段注释，Quartz 持久化任务执行，Flowable 建表、审批与定时器。

注意，这是组件级验证，不是完整微服务的启动验收，没有覆盖全部业务服务及服务间调用，也没有在 PolarDB 的云数据库上验证。如果用于正式环境，请按你使用的服务完整回归。

# 9. 神通数据库

神通数据库是天津神舟通用的国产数据库。项目支持 神通数据库 V7 的原生模式（JDBC 驱动 com.oscar.Driver，url 格式为 jdbc:oscar://ip:端口/数据库名），可以使用普通的增删改查、代码生成、Flowable 工作流（bpm-server）、Quartz 定时任务（iot-server）等功能，复用 sql/opengauss 脚本，默认仍然使用 MySQL。

# 9.1 如何安装？

可以使用 Linux 等方式。安装介质和授权，请通过神通官方下载中心 (opens new window) 获取，需要注册登录，并按介质中的官方说明完成安装、启动。

注意，目前我们使用的是神通数据库 7.0.14。

# 9.2 如何导入数据？

① 使用具有创建账号权限的管理员账号，执行如下 SQL，创建项目连接使用的账号。其中，yudao、数据库密码 修改为你实际使用的账号和密码：

CREATE USER yudao WITH PASSWORD '数据库密码';

神通会自动创建与账号同名的模式，后续使用该账号导入的表都创建在这个模式中。url 中的 currentSchema 参数不生效，所以各服务连接时也要使用这个账号。

② 神通已经内置了 dual，且 varchar 的最大长度为 8000，所以不能直接导入 sql/opengauss/ruoyi-vue-pro.sql。在项目 sql/tools 目录下执行如下命令，生成临时脚本：只跳过创建 dual 表的一段，并将 varchar(10240) 改为 text，其余 SQL 保持不变：

sed -e '/^-- Table structure for dual$/,/^-- @formatter:on$/d' -e 's/varchar(10240)/text/' ../opengauss/ruoyi-vue-pro.sql > /tmp/ruoyi-vue-pro-shentong.sql

③ 使用 yudao 账号，通过神通的客户端或其它 JDBC 工具，执行 /tmp/ruoyi-vue-pro-shentong.sql 文件。

④ 导入完成后，继续使用 yudao 账号执行如下 SQL，让 system_menu 的主键默认使用 system_menu_seq 序列。代码生成的菜单 SQL 插入菜单时不指定主键，需要依赖它：

ALTER TABLE system_menu ALTER COLUMN id SET DEFAULT nextval('system_menu_seq');

⑤ 如需使用 IoT 模块（yudao-module-iot-server 基于 Quartz 实现定时任务），在项目 sql/tools 目录下执行如下命令，生成 Quartz 的临时脚本：只将 bytea 字段改为神通的 BLOB（bytea 字段在神通上无法读取任务数据），其余 SQL 保持不变：

sed 's/ bytea / BLOB /' ../opengauss/quartz.sql > /tmp/quartz-shentong.sql

然后使用 iot-server 连接数据库的账号，执行 /tmp/quartz-shentong.sql 文件，Quartz 的表需要创建在 iot-server 连接的数据库中。注意，该 Quartz 脚本用于全新初始化，不支持把已有数据的 bytea 字段转换为 BLOB。

⑥ 如需使用工作流（bpm-server），还需要导入 BPM 模块的 bpm_ 业务表，详见《9.4.2 Flowable 工作流？》。

上述步骤与项目 sql/tools/README.md (opens new window) 中「神通数据库」部分一致。

# 9.3 如何启动项目？

① 在每个连接数据库的服务（例如说 yudao-module-system-server、yudao-module-infra-server，以及你启动的其它业务服务）的 pom.xml 中，引入神通 JDBC 驱动。项目的 yudao-dependencies、yudao-spring-boot-starter-mybatis 不包含该驱动，需要显式引入。yudao-gateway 不连接数据库，无需引入：

<dependency>
    <groupId>com.shentongdata</groupId>
    <artifactId>oscarJDBC8</artifactId>
    <version>4.1.152</version>
</dependency>

注意，该驱动是 Maven 中央仓库上 com.shentongdata 发布的版本，不是神通官方下载中心的配套认证版本。请使用本文列出的驱动版本：安装介质自带的 7.20 驱动实测不支持 Connection.getSchema()，代码生成会报 AbstractMethodError，不建议替换为该驱动。

② 修改每个连接数据库的服务的数据源配置，将数据库的 url、username、password 修改为神通数据库。yudao-gateway 不连接数据库，无需修改。使用 Nacos 配置中心时，Nacos 中的配置优先级更高，需要在 Nacos 中逐个服务修改，详见《4.3 如何启动项目？》。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:oscar://127.0.0.1:2003/OSRDB
          driver-class-name: com.oscar.Driver
          username: yudao
          password: ${SHENTONG_PASSWORD}

username、password 需要填写 9.2 中创建的账号和密码，端口、数据库名以安装时的设置为准。如果配置了 slave 等多个数据源，也需要同步修改对应配置。validation-query 保持默认的 SELECT 1 FROM DUAL 即可，使用的是神通内置的 dual。

疑问：项目是如何适配神通的？

项目会识别 jdbc:oscar: 的 url，以及神通驱动返回的数据库产品名 OSCAR，自动使用 INPUT 主键，复用 MyBatis Plus 的 PostgreKeyGenerator，通过 nextval('序列名') 获取主键（配合 SQL 脚本中的序列），业务的 DO、Mapper 无需修改。MyBatis Plus 的分页，使用其对神通的内置支持；代码生成器按 Oracle、达梦的写法生成菜单 SQL。Flowable 无法识别神通的数据库产品名，bpm-server 会在未设置 flowable.database-type 时，将其按 oracle 处理。

注意，目前只有 master-jdk17 分支包含该识别处理。

③ 后续启动项目，就可以了。

# 9.4 常见问题？

# 9.4.1 Quartz 定时任务？

iot-server 基于 Quartz 实现定时任务，Quartz 的表需要在 iot-server 连接的数据库中创建。sql/opengauss/quartz.sql 使用的 bytea 字段在神通上无法读取任务数据，需要按 9.2 中第 ⑤ 步改为 BLOB 后，在全新的库中导入。

Quartz 使用默认的 StdJDBCDelegate，不需要设置 driverDelegateClass；也不要开启 useProperties，因为任务参数包含 Long 等非字符串类型。

# 9.4.2 Flowable 工作流？

神通驱动返回的数据库产品名为 OSCAR，Flowable 无法自动识别。bpm-server 会在未设置 flowable.database-type 时，将其按 oracle 处理，使用 Flowable 内置的 Oracle 建表脚本（BLOB、CLOB 字段及大写的表名）。如果显式设置了 flowable.database-type（包括 Nacos 中优先级更高的配置），以显式设置为准，神通需要设置为 oracle，不要设置为 postgres。

Flowable 按默认的 flowable.database-schema-update: true，自动创建 Flowable 引擎的 ACT_、FLW_ 表，但不会创建 BPM 模块的 bpm_ 业务表。和其它数据库一样，开启工作流前，需要先按《工作流 · 功能开启》获取 BPM 的 SQL，转换为神通可以执行的 SQL（包括 bpm_ 表对应的序列）后导入。只导入 9.2 中的项目 SQL，无法使用工作流的业务功能。

# 9.4.3 代码生成？

代码生成可以导入神通中的表。神通会将未加引号的表名、字段名转为大写，生成的类名、字段名与其它数据库一致；表和字段的中文注释、从数据库同步字段都可以使用，text 字段会生成为 String 类型。

生成的菜单 SQL 与 Oracle、达梦一样使用匿名块，依赖 9.2 中第 ④ 步设置的主键默认值；结尾的 / 是部分客户端使用的块结束符。

# 9.4.4 验证范围？

在神通数据库 7.0.14 上，使用 Maven 中央仓库的驱动 4.1.152，基于 master-jdk17 分支完成了验证：按 9.2 全新导入项目 SQL，启动 system-server、infra-server 并登录，用户、角色分配菜单、租户、站内信、数据源配置等功能的增删改查与分页，代码生成的导入表、预览、下载、同步字段，以及生成的单表代码编译后的增删改查、Excel 导出，生成的菜单 SQL 执行。

Quartz、工作流同样基于上述环境验证（单机，未验证集群下的故障切换）：

Quartz：按 9.2 中第 ⑤ 步在全新的库中导入，通过 iot-server 实际使用的 Quartz 任务管理（IotSchedulerManager），验证了定时任务的新增、暂停、修改、执行、删除，以及调度器重启后任务数据的读回；没有通过 HTTP 接口验证。
工作流：启动 bpm-server、system-server 并登录，Flowable 按 oracle 自动创建引擎表；按项目的表结构创建了验证用到的 bpm_ 业务表（不是完整的 BPM 业务 SQL）。流程模型的新增、查询、导出、部署，流程定义的查询，流程实例的发起、查询；重启 bpm-server 后，流程模型 XML、8800 个字符的中文流程变量、嵌套的 Map 流程变量都可以正确读回；此外还验证了流程模型列表、流程实例取消、流程模型的清理与删除。

注意，测试使用的是第三方公开的社区镜像（镜像标签为 7.0.8，实际版本为 7.0.14），不是神舟通用官方发布的镜像，正式环境请通过官方渠道获取安装介质和授权。验证时直接访问 system-server、infra-server、bpm-server，没有经过 yudao-gateway，也没有使用 Nacos 配置中心；没有覆盖树表、主子表等代码生成模式，生成的前端代码，通过管理后台完成的流程审批等其它 BPM 业务功能，以及其它业务服务和神通版本。如果用于正式环境，请按你使用的服务完整回归。

# 10. Vastbase G100 海量数据库

Vastbase G100 是海量数据的国产数据库，支持 A（Oracle）、B（MySQL）、PG、MSSQL 等兼容模式。项目按 PG 兼容模式 接入，复用 sql/opengauss 脚本，默认仍然使用 MySQL。

# 10.1 如何安装？

可以使用 Linux 等方式。安装介质和授权，请通过海量数据官网 (opens new window) 申请，安装说明见官方文档 (opens new window)。

注意，目前我们使用的是 Vastbase G100 V2.2 Build 15。

① 使用官方安装程序全新安装时，可以按官方文档选择生成 90 天的试用授权。试用授权过期后，数据库会限制使用，正式环境请向海量数据获取正式授权。

② 安装时，需要将数据库实例的兼容模式选择为 PG。兼容模式在实例初始化时确定，CREATE DATABASE 不支持 DBCOMPATIBILITY 参数，创建数据库后无法再修改。

# 10.2 如何导入数据？

① 使用 Vastbase 的 vsql 客户端，以初始用户执行如下 SQL，创建项目连接使用的账号和数据库。其中，yudao、数据库密码 修改为你实际使用的账号和密码：

CREATE USER yudao PASSWORD '数据库密码';
CREATE DATABASE "ruoyi-vue-pro" OWNER yudao ENCODING 'UTF8';

② 连接 ruoyi-vue-pro 数据库，确认 SHOW sql_compatibility; 的结果为 PG，并给账号授予 public 模式的权限。即使账号是数据库的所有者，也需要授权，否则导入时无法建表：

GRANT USAGE, CREATE ON SCHEMA public TO yudao;

③ 使用 yudao 账号，在 ruoyi-vue-pro 数据库中先执行 sql/opengauss/quartz.sql 文件，再执行去掉 dual 段后的 sql/opengauss/ruoyi-vue-pro.sql 文件。

Vastbase 与 GaussDB 一样已经内置了 dual 视图，不要删除或修改它。去掉 dual 段，可以使用如下命令生成新文件：

sed '/^-- Table structure for dual$/,/^-- @formatter:on$/d' sql/opengauss/ruoyi-vue-pro.sql > ruoyi-vue-pro-without-dual.sql

# 10.3 如何启动项目？

① 在每个连接数据库的服务（例如说 yudao-module-system-server、yudao-module-infra-server，以及你启动的其它业务服务）的 pom.xml 中，引入 Vastbase 的 JDBC 驱动（p 版，驱动类为 org.postgresql.Driver）。yudao-gateway 不连接数据库，无需引入：

<dependency>
    <groupId>cn.com.vastdata</groupId>
    <artifactId>vastbase-jdbc</artifactId>
    <version>2.16p</version>
</dependency>

注意，p 版驱动与 PostgreSQL 官方驱动 org.postgresql:postgresql 的包名、类名相同，两者只能引入一个。

② 修改每个连接数据库的服务的数据源配置，将数据库的 url、username、password 修改为 Vastbase 数据库。gateway-server 不连接数据库，无需修改。使用 Nacos 配置中心时，Nacos 中的配置优先级更高，需要在 Nacos 中逐个服务修改，详见《4.3 如何启动项目？》。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:postgresql://127.0.0.1:5432/ruoyi-vue-pro
          driver-class-name: org.postgresql.Driver
          username: yudao
          password: ${VASTBASE_PASSWORD}

端口以安装时的设置为准。

疑问：为什么 jdbc 使用 postgres 数据库连接？

因为 PG 兼容模式下，Vastbase 的 p 版驱动使用 jdbc:postgresql: 的 url，返回的数据库产品名也是 PostgreSQL，所以项目按 PostgreSQL 处理主键、代码生成，Flowable 也自动识别为 PostgreSQL，无需额外配置。

Vastbase 的 v 版驱动（cn.com.vastbase.Driver，jdbc:vastbase:）可以连接，但项目不会将 jdbc:vastbase: 识别为 PostgreSQL，请使用 p 版驱动。

③ 后续启动项目，就可以了。

# 10.4 常见问题？

# 10.4.1 Quartz 定时任务？

Quartz 的初始化 SQL 直接复用项目中的 sql/opengauss/quartz.sql 文件。使用方式可参考《定时任务》。

# 10.4.2 Flowable 工作流？

Flowable 工作流按 PostgreSQL 数据库识别 Vastbase，bpm-server 启动时自动创建工作流相关的表，使用方式可参考《工作流》。

# 10.4.3 验证范围？

在 Vastbase G100 V2.2 Build 15 的 PG 兼容模式实例上，使用 p 版驱动 2.16p 完成了组件级验证：sql/opengauss 中的 Quartz SQL 原样导入、项目 SQL 跳过 dual 段后导入（共 59 张表），JDBC 元数据识别、序列主键、事务回滚，MyBatis Plus 增删改查与分页，代码生成读取表和字段注释，Quartz 持久化任务执行，Flowable 建表、审批与定时器。

注意，验证使用的是第三方公开镜像中附带的官方安装程序，在全新目录中安装并生成的试用授权，不是海量数据官方发布的镜像，正式环境请通过官方渠道获取安装介质和授权。这是组件级验证，不是完整微服务的启动验收，没有覆盖全部业务服务及服务间调用，也没有覆盖 A、B、MSSQL 兼容模式及 v 版驱动。如果用于正式环境，请按你使用的服务完整回归。

# 11. 云和恩墨 MogDB 数据库

MogDB 是云和恩墨基于 openGauss 的商用数据库。项目按 PG 兼容模式 接入，原样复用 sql/opengauss 脚本，默认仍然使用 MySQL。

# 11.1 如何安装？

可以使用 Linux 或 Docker 等多种方式。

注意，目前我们使用的是 MogDB 5.0.0 的官方容器镜像，官方说明该镜像仅用于测试，正式环境请参考官方文档 (opens new window) 安装。

# 11.1.1 Docker 方式

在项目 sql/tools 目录下运行：

docker compose up -d mogdb

注意，mogdb 服务属于 mogdb profile，执行 docker compose up -d 时不会启动，需要像上面一样指定服务名。端口只绑定本机 127.0.0.1:15432，omm、mogdb 用户的密码为 docker-compose.yaml 中的 GS_PASSWORD。

# 11.2 如何导入数据？

MogDB 默认创建的是 A（Oracle）兼容模式的数据库，varchar(n) 按字节计算长度，导入项目脚本时会在中文数据处报 value too long for type character varying(32) 错误，所以需要使用 PG 兼容模式、UTF8 编码的数据库。

有手动导入、Docker 一键导入两种方式，任选其一即可，不要混用。

① 手动导入：使用 gsql 等工具，执行如下 SQL 创建数据库（mogdb 为项目连接使用的账号）：

CREATE DATABASE "ruoyi-vue-pro" OWNER mogdb ENCODING 'UTF8' DBCOMPATIBILITY = 'PG';

使用 mogdb 账号，在该数据库中先执行 sql/opengauss/quartz.sql 文件，再执行 sql/opengauss/ruoyi-vue-pro.sql 文件。

② Docker 一键导入：在项目 sql/tools 目录下运行，自动创建上述数据库并导入 SQL 文件：

docker compose exec -u omm mogdb bash /tmp/create_schema.sh

注意，导入脚本只允许创建全新的数据库，数据库已存在（包括空库）或重复执行时，会拒绝导入并返回失败；导入失败时会保留数据库，便于排查。如需重新初始化，执行 docker compose down mogdb 后，删除 ruoyi-vue-pro_mogdb 数据卷。

# 11.3 如何启动项目？

① 在每个连接数据库的服务（例如说 yudao-module-system-server、yudao-module-infra-server，以及你启动的其它业务服务）的 pom.xml 中，引入 openGauss JDBC 驱动，版本由 yudao-dependencies 统一管理（7.0.0-og），无需填写。yudao-gateway 不连接数据库，无需引入：

<dependency>
    <groupId>org.opengauss</groupId>
    <artifactId>opengauss-jdbc</artifactId>
</dependency>

yudao-spring-boot-starter-mybatis 中的 opengauss-jdbc 依赖是 <optional>true</optional>，不会传递到各个服务，所以需要在最终运行的服务模块中引入。

也可以使用云和恩墨发布的 io.mogdb:opengauss-jdbc:5.0.1-og 驱动，两者的驱动类名相同，只能引入一个。

② 修改每个连接数据库的服务的数据源配置，将数据库的 url、username、password 修改为 MogDB 数据库。gateway-server 不连接数据库，无需修改。使用 Nacos 配置中心时，Nacos 中的配置优先级更高，需要在 Nacos 中逐个服务修改，详见《4.3 如何启动项目？》。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  datasource:
    dynamic:
      datasource:
        master:
          url: jdbc:opengauss://127.0.0.1:15432/ruoyi-vue-pro
          driver-class-name: org.opengauss.Driver
          username: mogdb
          password: Yudao@2024

omm 初始用户不允许远程连接，项目使用 mogdb 用户。validation-query 保持默认的 SELECT 1 FROM DUAL 即可，sql/opengauss 脚本会创建 dual 表。

疑问：项目是如何适配 MogDB 的？

项目会将 jdbc:opengauss: 的 url 识别为 PostgreSQL，自动使用 INPUT 主键（配合 SQL 脚本中的序列）；代码生成器也按 PostgreSQL 生成菜单 SQL。

7.0.0-og 驱动返回的数据库产品名是 openGauss，5.0.1-og 驱动返回的是 PostgreSQL，项目都会识别。

注意，目前只有 master-jdk17 分支包含该识别处理。

③ 后续启动项目，就可以了。

# 11.4 常见问题？

# 11.4.1 Quartz 定时任务？

Quartz 的初始化 SQL 直接复用项目中的 sql/opengauss/quartz.sql 文件。使用方式可参考《定时任务》。

# 11.4.2 Flowable 工作流？

Flowable 无法识别 openGauss 这个数据库产品名。项目在没有显式设置 Flowable 的 databaseType 时，bpm-server 会按 PostgreSQL 创建工作流相关的表；如果你自己设置了 databaseType，项目不会覆盖。使用方式可参考《工作流》。

# 11.4.3 验证范围？

在 MogDB 5.0.0 官方容器镜像 PG 兼容模式的数据库上，分别使用 org.opengauss:opengauss-jdbc:7.0.0-og、io.mogdb:opengauss-jdbc:5.0.1-og 驱动，完成了组件级验证：sql/opengauss 中的项目 SQL 和 Quartz SQL 原样导入（共 60 张表），sql/tools/mogdb/create_schema.sh 的全新导入、拒绝已存在数据库，JDBC 元数据识别、序列主键、事务回滚，MyBatis Plus 增删改查与分页，代码生成读取表和字段注释，Quartz 持久化任务执行，Flowable 建表、审批与定时器。

注意，这是组件级验证，不是完整微服务的启动验收，没有覆盖全部业务服务及服务间调用，也没有覆盖 A 兼容模式。如果用于正式环境，请按你使用的服务完整回归。

# 12. 东方通 TongRDS 缓存

TongRDS 用于替换 Redis，提供缓存、登录令牌、分布式锁、限流和消息等能力。它不替换 MySQL 等关系型数据库，也不需要导入项目 SQL。

TongWeb、TongHttpServer 的部署，可参考《东方通服务器部署》。

# 12.1 如何安装？

可以使用 Linux 或 Docker 等多种方式。安装介质、授权和配置说明，可通过东方通官方资料中心 (opens new window) 获取。授权缺失或过期时，需要获取对应版本的有效授权。

注意，本节使用的是第三方公开镜像中的 TongRDS 2.2.1.3 Lite。

# 12.1.1 Docker 方式

① 创建 JVM 参数文件，将堆上限设置为 2 GB：

mkdir -p tongrds-test
cat > tongrds-test/external.vmoptions <<'EOF'
-Xms128m
-Xmx2g
-server
-XX:+UseG1GC
-XX:MaxGCPauseMillis=100
EOF

② 执行如下命令，创建并启动测试容器：

docker create --name tongrds-test --platform linux/amd64 \
  --memory 3g --memory-swap 3g \
  -p 127.0.0.1:16381:6379 \
  snapcastify/tongrds@sha256:beedc840193aa6a884c303833a7e412f26a3ceee5e2c1252bd04b618fc8d8946

docker cp tongrds-test/external.vmoptions tongrds-test:/opt/pmemdb/bin/external.vmoptions
docker start tongrds-test
docker logs tongrds-test

该公开镜像 (opens new window) 是 AMD64 架构，Apple Silicon 使用 Docker 的模拟运行能力。镜像内的 TongRDS 使用 JDK 8，与后端应用的 JDK 版本独立。

③ 使用 redis-cli 检查连接和版本：

REDISCLI_AUTH=123456 redis-cli -h 127.0.0.1 -p 16381 PING
REDISCLI_AUTH=123456 redis-cli -h 127.0.0.1 -p 16381 INFO server

PING 应返回 PONG，INFO server 应显示 TongRDS 的版本和授权模式。默认密码为 123456，上述端口只绑定本机，用于测试；正式部署需要按产品说明配置密码、网络和数据持久化。

# 12.2 如何启动项目？

① 修改 application-local.yaml 中的 Redis 地址和密码，保留原有关系型数据库配置：

spring:
  data:
    redis:
      host: 127.0.0.1
      port: 16381
      database: 0
      password: ${TONGRDS_PASSWORD}

以上适用于 Spring Boot 3.x 项目；Spring Boot 2.x 项目使用 spring.redis 配置前缀。

② 设置 TONGRDS_PASSWORD=123456 后启动项目。后端位于 Docker 容器内时，请使用 TongRDS 的容器网络地址，不能使用后端容器自身的 127.0.0.1。

项目继续使用现有 Redis 客户端依赖，不需要添加 TongRDS JDBC 驱动。

# 12.3 常见问题？

# 12.3.1 空 pending 报错？

TongRDS 2.2.1.3 在消费组没有待处理消息时，XPENDING 返回 RESP 错误 -null，导致 opsForStream().pending() 抛出 InvalidDataAccessApiUsageException，影响项目的待处理消息重发任务。

可以在 yudao-server 模块的 cn.iocoder.yudao.server.config 包中增加如下连接工厂，只兼容该特定响应。非空摘要继续使用原 Redisson 实现；异常响应还需要通过原始 XINFO GROUPS 确认消费组存在、待处理数量确实为零。

友情提示

下面的代码在 Redisson 4.7.0、redisson-spring-data-35 上验证通过，用于处理 TongRDS 2.2.1.3 的空 pending 响应。

查看完整兼容代码

package cn.iocoder.yudao.server.config;

import org.redisson.api.RedissonClient;
import org.redisson.client.RedisException;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.decoder.ListMultiDecoder2;
import org.redisson.client.protocol.decoder.ObjectListReplayDecoder;
import org.redisson.spring.data.connection.RedissonConnection;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.redisson.spring.data.connection.RedissonStreamCommands;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisStreamCommands;
import org.springframework.data.redis.connection.stream.PendingMessagesSummary;

import java.util.Collections;
import java.util.List;

public class TongRdsConnectionFactory extends RedissonConnectionFactory {

    private final RedissonClient client;

    public TongRdsConnectionFactory(RedissonClient client) {
        super(client);
        this.client = client;
    }

    @Override
    public RedisConnection getConnection() {
        return new RedissonConnection(client, isFilterOkResponses()) {
            @Override
            public RedisStreamCommands streamCommands() {
                return new RedissonStreamCommands(this, redisson.getCommandExecutor()) {
                    @Override
                    public PendingMessagesSummary xPending(byte[] key, String groupName) {
                        try {
                            return super.xPending(key, groupName);
                        } catch (DataAccessException ex) {
                            Throwable cause = ex.getMostSpecificCause();
                            if (!(cause instanceof RedisException) || cause.getMessage() == null
                                    || !cause.getMessage().startsWith("null. channel:")) {
                                throw ex;
                            }
                            List<List<Object>> groups = sync(redisson.getCommandExecutor().readAsync(key,
                                    StringCodec.INSTANCE, new RedisCommand<List<List<Object>>>("XINFO", "GROUPS",
                                    new ListMultiDecoder2(new ObjectListReplayDecoder<>(), new ObjectListReplayDecoder<>())), key));
                            boolean empty = groups.stream().anyMatch(group -> isEmptyGroup(group, groupName));
                            if (!empty) {
                                throw ex;
                            }
                            return new PendingMessagesSummary(groupName, 0,
                                    org.springframework.data.domain.Range.unbounded(), Collections.emptyMap());
                        }
                    }
                };
            }
        };
    }

    private static boolean isEmptyGroup(List<Object> fields, String groupName) {
        String name = null;
        Long pending = null;
        for (int i = 0; i + 1 < fields.size(); i += 2) {
            if ("name".equals(fields.get(i))) {
                name = fields.get(i + 1).toString();
            } else if ("pending".equals(fields.get(i))) {
                pending = Long.valueOf(fields.get(i + 1).toString());
            }
        }
        return groupName.equals(name) && Long.valueOf(0).equals(pending);
    }
}

再增加 TongRdsConfiguration 配置类：

package cn.iocoder.yudao.server.config;

import org.redisson.api.RedissonClient;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "yudao.tongrds.enabled", havingValue = "true")
public class TongRdsConfiguration {

    @Bean
    public TongRdsConnectionFactory redisConnectionFactory(RedissonClient client) {
        return new TongRdsConnectionFactory(client);
    }
}

最后，在对应环境的配置文件中启用：

yudao:
  tongrds:
    enabled: true

# 13. 宝兰德 BES CacheDB 缓存

BES CacheDB 用于替换 Redis，提供缓存、登录令牌、分布式锁、限流和消息等能力。它不替换 MySQL 等关系型数据库，也不需要导入项目 SQL。

BES AppServer 的部署，可参考《宝兰德服务器部署》。

注意：本节尚未在 CacheDB 介质上验收！

本节根据项目源码中使用到的 Redis 能力整理，没有在 BES CacheDB 的实际介质上完成验证。版本号、授权方式和安装步骤，以你从宝兰德取得的介质及对应手册为准。

# 13.1 如何安装？

从宝兰德官网 (opens new window) 或商务渠道，获取对应 CPU 架构的 CacheDB 介质及有效授权，按官方手册安装，创建实例并设置端口、访问密码。

# 13.2 如何启动项目？

① 修改每个连接 Redis 的服务（例如说 system-server、infra-server，以及你启动的其它业务服务）的 Redis 地址和密码，保留原有关系型数据库配置。gateway-server 不连接 Redis，无需修改。

可以修改服务的 application-local.yaml 配置文件，例如说 yudao-module-system-server 模块的 src/main/resources/application-local.yaml：

spring:
  data:
    redis:
      host: 127.0.0.1 # CacheDB 实例地址
      port: 6379 # CacheDB 实例端口
      database: 0
      password: ${CACHEDB_PASSWORD}

以上适用于 Spring Boot 3.x 及以上的项目；Spring Boot 2.x 项目（master 分支）使用 spring.redis 配置前缀。

使用 Nacos 配置中心时：

如果 Nacos 中已经配置了 spring.data.redis，需要在 Nacos 中按上述 YAML 修改，否则本地的修改会被覆盖。每个服务对应各自的 Data ID，需要逐个修改。

② 设置 CACHEDB_PASSWORD 后启动服务。项目继续使用现有的 Redisson 客户端，不需要添加其它驱动。

# 13.3 常见问题？

# 13.3.1 如何验证 Redis 兼容性？

CacheDB 宣称兼容 Redis 协议，但项目能启动、能登录、能看到缓存数据，并不能证明 Redisson、Lua、Stream、发布订阅等能力完全兼容。例如说，东方通 TongRDS 就出现过空 pending 报错，可见《12.3.1 空 pending 报错？》。

项目使用到的 Redis 能力如下：

能力	主要命令	项目中的使用
基础读写、过期	`GET`、`SET`、`SET NX EX`、`DEL`、`EXPIRE`	缓存、登录令牌、幂等、API 签名
游标扫描	`SCAN`	Spring Cache 按前缀批量清理缓存
Lua 脚本	`EVAL`、`EVALSHA`	Redisson 分布式锁、`@RateLimiter` 限流
发布订阅	`PUBLISH`、`SUBSCRIBE`	Redisson 锁释放通知、Redis 广播消息（例如说 WebSocket 的 `redis` 发送方式）
Stream	`XADD`、`XGROUP`、`XREADGROUP`、`XACK`、`XPENDING`、`XRANGE`、`XTRIM`	Redis MQ 集群消费、待处理消息重发、过期消息清理
服务信息	`INFO`	存在 Redis Stream 消费者时，启动校验 `redis_version` 不低于 5.0

启动服务前，可以先使用 redis-cli 逐项验证。以下命令中的地址 127.0.0.1、端口 6379 和密码，需要替换为 CacheDB 实例的实际值：

export REDISCLI_AUTH='CacheDB 密码'

redis-cli -h 127.0.0.1 -p 6379 PING
redis-cli -h 127.0.0.1 -p 6379 INFO server | grep redis_version
redis-cli -h 127.0.0.1 -p 6379 SET yudao:bes:test 1 NX EX 60
redis-cli -h 127.0.0.1 -p 6379 SCAN 0 MATCH 'yudao:bes:*' COUNT 100
redis-cli -h 127.0.0.1 -p 6379 EVAL "return redis.call('GET', KEYS[1])" 1 yudao:bes:test

redis-cli -h 127.0.0.1 -p 6379 XGROUP CREATE yudao:bes:stream g1 0 MKSTREAM
MSG_ID=$(redis-cli -h 127.0.0.1 -p 6379 XADD yudao:bes:stream '*' k v)
redis-cli -h 127.0.0.1 -p 6379 XREADGROUP GROUP g1 c1 COUNT 1 STREAMS yudao:bes:stream '>'
redis-cli -h 127.0.0.1 -p 6379 XPENDING yudao:bes:stream g1
redis-cli -h 127.0.0.1 -p 6379 XRANGE yudao:bes:stream - +
redis-cli -h 127.0.0.1 -p 6379 XACK yudao:bes:stream g1 "$MSG_ID"
redis-cli -h 127.0.0.1 -p 6379 XPENDING yudao:bes:stream g1
redis-cli -h 127.0.0.1 -p 6379 XTRIM yudao:bes:stream MAXLEN 0

redis-cli -h 127.0.0.1 -p 6379 DEL yudao:bes:test yudao:bes:stream

注意，最后一次 XPENDING 是在没有待处理消息时执行的，也需要正常返回 0，不能报错。

发布订阅需要开两个终端验证，每个终端都需要单独设置密码。第一个终端执行订阅：

export REDISCLI_AUTH='CacheDB 密码'
redis-cli -h 127.0.0.1 -p 6379 SUBSCRIBE yudao:bes:channel

第二个终端执行发布，确认第一个终端收到 hello 消息：

export REDISCLI_AUTH='CacheDB 密码'
redis-cli -h 127.0.0.1 -p 6379 PUBLISH yudao:bes:channel hello

以上命令都通过后，再启动各个服务，验证登录、缓存清理、分布式锁、限流，以及你启用的 Redis MQ、WebSocket 等功能。

← 表结构变更（版本升级）面试题、简历模版、简历优化→