爆肝3小时！解决ruoyi 框架 +TDengine+SpringBoot+动态数据源所有报错，从踩坑到落地全流程（附可直接复制代码）

爆肝3小时！解决ruoyi 框架 +TDengine+SpringBoot+动态数据源所有报错，从踩坑到落地全流程（附可直接复制代码）

前言：作为一名IoT后端开发者，最近在项目中集成TDengine时序数据库时，被各种报错折磨到崩溃！从最开始的this operation is NOT supported currently!，到后来的9728错误、事务报错，再到动态数据源兼容问题，踩遍了全网能遇到的所有坑，耗时3天终于彻底搞定。

相信很多小伙伴在集成TDengine时，都会遇到和我一样的问题：明明SQL在命令行能跑，一到Java代码里就报错；换了连接池就崩，关了事务还报错；驱动选不对，怎么配都不行。

这篇文章不搞虚的，全程以“报错场景+底层原因+解决方案”的形式，把TDengine+SpringBoot+MyBatis+dynamic-datasource整合的所有坑一次性讲透，所有代码均可直接复制粘贴使用，新手也能快速落地，避免再走我走过的弯路！

一、先晒踩过的“致命报错”（你大概率也遇到过）

在开始正文前，先给大家盘点一下我这3天踩过的核心报错，看看你是不是也中枪了：

1. java.sql.SQLFeatureNotSupportedException: this operation is NOT supported currently!（出现频率最高，几乎每个环节都可能触发）

2. uncategorized SQLException; SQL state []; error code [9728]; TDengine ERROR (0x2600): sql: CREATE TABLE IF NOT EXISTS xxx（建表/插入时必报）

3. Druid连接池整合后，启动就报错，换成HikariCP还是有问题

4. dynamic-datasource动态数据源切换时，TDengine报错，MySQL正常

5. MyBatis用#{} 报错，换成${}就正常，却担心SQL注入

这些报错看似杂乱无章，其实根源就3个：TDengine本身的特性限制、驱动选择错误、配置细节不到位。下面我们逐个拆解，从根源解决问题。

二、核心前提：搞懂TDengine的3个“反人类”特性（避免踩坑的关键）

很多报错的本质，是我们用操作MySQL的思维去操作TDengine，而TDengine作为时序数据库，和关系型数据库有本质区别，这3个特性必须记死：

1. 不支持事务（天生不支持，再怎么配置都没用）

TDengine的设计初衷是“高速写入、存储时序数据”，主打一个高效，所以直接砍掉了事务、回滚等功能。这就意味着，Spring的事务管理机制一介入，就会调用TDengine不支持的commit()、rollback()、setAutoCommit(false)方法，直接报错。

2. 不支持JDBC预编译（${}是唯一选择，或选对驱动）

MySQL/Oracle支持#{} 预编译（生成?占位符），但TDengine的原生驱动、REST驱动（RS）都不支持预编译，一用#{} 就报错。只有WebSocket驱动（WS）支持预编译，能正常使用#{} 。

三、实战落地：从0到1整合TDengine（避坑版全配置）

下面我们一步步来，从依赖引入、驱动选择、配置文件、MyBatis写法，到动态数据源整合，每一步都标注避坑点，所有代码均可直接复制。

1. 依赖引入（避坑：不要乱加依赖，排除冲突）

核心依赖：TDengine JDBC驱动、SpringBoot、MyBatis、dynamic-datasource、HikariCP（必选，Druid绝对不能用）。

pom.xml配置（复制即用，版本可根据自己的项目调整）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	
    <groupId>com.ruoyi</groupId>
    <artifactId>ruoyi</artifactId>
    <version>3.9.2</version>

    <name>ruoyi</name>
    <url>http://www.ruoyi.vip</url>
    <description>若依管理系统</description>
    
    <properties>
        <ruoyi.version>3.9.2</ruoyi.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>17</java.version>
        <spring-boot.version>4.0.3</spring-boot.version>
        <mybatis-plus.version>3.5.14</mybatis-plus.version>
        <mybatis-spring-boot.version>4.0.1</mybatis-spring-boot.version>
        <druid.version>1.2.28</druid.version>
        <yauaa.version>8.1.0</yauaa.version>
        <kaptcha.version>2.3.3</kaptcha.version>
        <pagehelper.boot.version>2.1.1</pagehelper.boot.version>
        <fastjson.version>2.0.61</fastjson.version>
        <oshi.version>6.10.0</oshi.version>
        <commons.io.version>2.21.0</commons.io.version>
        <poi.version>4.1.2</poi.version>
        <velocity.version>2.3</velocity.version>
        <jwt.version>0.9.1</jwt.version>
        <jaxb-api.version>2.3.1</jaxb-api.version>
        <springdoc.version>3.0.2</springdoc.version>
        <lombok.version>1.18.32</lombok.version> <!-- JDK8~21 兼容稳定版 -->
        <hutool.version>5.8.25</hutool.version>
        <mqttv3.version>1.2.5</mqttv3.version>
        <taos.version>3.8.2</taos.version>
        <dynamic-datasource.version>4.5.0</dynamic-datasource.version>
    </properties>

    <!-- 依赖声明 -->
    <dependencyManagement>
        <dependencies>

            <!-- SpringBoot的依赖配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis-spring-boot.version}</version>
            </dependency>
            <dependency>
                <groupId>org.eclipse.paho</groupId>
                <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
                <version>${mqttv3.version}</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>dynamic-datasource-spring-boot4-starter</artifactId>
                <version>${dynamic-datasource.version}</version>
            </dependency>

            <!-- TDengine JDBC -->
            <dependency>
                <groupId>com.taosdata.jdbc</groupId>
                <artifactId>taos-jdbcdriver</artifactId>
                <version>${taos.version}</version>
            </dependency>
            <!-- 阿里数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-4-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>

            <!-- 解析客户端操作系统、浏览器等 -->
            <dependency>
                <groupId>nl.basjes.parse.useragent</groupId>
                <artifactId>yauaa</artifactId>
                <version>${yauaa.version}</version>
            </dependency>

            <!-- pagehelper 分页插件 -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>${pagehelper.boot.version}</version>

            </dependency>

            <dependency>
                <groupId>javax.xml.bind</groupId>
                <artifactId>jaxb-api</artifactId>
                <version>${jaxb-api.version}</version>
            </dependency>

            <!-- 获取系统信息 -->
            <dependency>
                <groupId>com.github.oshi</groupId>
                <artifactId>oshi-core</artifactId>
                <version>${oshi.version}</version>
            </dependency>

            <!-- spring-doc -->
            <dependency>
                <groupId>org.springdoc</groupId>
                <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
                <version>${springdoc.version}</version>
            </dependency>

            <!-- io常用工具类 -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.io.version}</version>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>

            <!-- excel工具 -->
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>${poi.version}</version>
            </dependency>

            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>


            <!-- velocity代码生成使用模板 -->
            <dependency>
                <groupId>org.apache.velocity</groupId>
                <artifactId>velocity-engine-core</artifactId>
                <version>${velocity.version}</version>
            </dependency>

            <!-- 阿里JSON解析器 -->
            <dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
                <version>${fastjson.version}</version>
            </dependency>

            <!-- Token生成与解析-->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>${jwt.version}</version>
            </dependency>

            <!-- 验证码 -->
            <dependency>
                <groupId>pro.fessional</groupId>
                <artifactId>kaptcha</artifactId>
                <version>${kaptcha.version}</version>
            </dependency>

            <!-- 定时任务-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-quartz</artifactId>
                <version>${ruoyi.version}</version>
            </dependency>

            <!-- 代码生成-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-generator</artifactId>
                <version>${ruoyi.version}</version>
            </dependency>

            <!-- 核心模块-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-framework</artifactId>
                <version>${ruoyi.version}</version>
            </dependency>

            <!-- 系统模块-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-system</artifactId>
                <version>${ruoyi.version}</version>
            </dependency>

            <!-- 通用工具-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-common</artifactId>
                <version>${ruoyi.version}</version>
            </dependency>

            <!-- 通用工具-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-scispace</artifactId>
                <version>${ruoyi.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <modules>
        <module>ruoyi-admin</module>
        <module>ruoyi-framework</module>
        <module>ruoyi-system</module>
        <module>ruoyi-quartz</module>
        <module>ruoyi-generator</module>
        <module>ruoyi-common</module>
        <module>ruoyi-scispace</module>
    </modules>
    <packaging>pom</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <parameters>true</parameters>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

避坑点：① 不要引入Druid依赖，即使引入了也要排除，Druid会调用TDengine不支持的方法，必报错；② TDengine驱动版本和服务端版本尽量一致，避免兼容性问题。

2. 驱动选择（关键！选对驱动，少踩80%的坑）

TDengine有3种驱动：RS（REST）、WS（WebSocket）、原生（JNI），很多报错都是驱动选错导致的。这里直接给结论：生产环境首选WS驱动，测试/跨平台选RS驱动，原生驱动坚决不推荐。

3种驱动核心区别（一眼看懂，避免选错）：

3. application.yml配置（最关键，避坑细节全标注）

这里以“dynamic-datasource（动态数据源）+ WS驱动 + HikariCP”为例，配置文件复制即用，关键避坑点用注释标注：

server:
  port: 8080

spring:
  autoconfigure:
    exclude:
      # 必须排除这两个自动配置，否则会触发事务和数据源冲突
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
      - org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration
  datasource:
    dynamic:
      # 避坑1：关闭严格模式，忽略TDengine不支持的方法
      strict: false
      # 避坑2：全局关闭事务，TDengine不支持事务
      enableTx: false
      # 主数据源（MySQL），根据自己的MySQL配置修改
      primary: mysql
      datasource:
        # MySQL数据源（正常配置即可）
        mysql:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/your_mysql_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
          username: root
          password: 123456
          hikari:
            maximum-pool-size: 5
            minimum-idle: 1
            idle-timeout: 60000
        # TDengine数据源（重点配置）
        tdengine:
          # 避坑3：选择WS驱动，支持预编译
          driver-class-name: com.taosdata.jdbc.ws.WebSocketDriver
          # 避坑4：URL用TAOS-WS前缀，端口6041（taosAdapter端口），必须指定数据库名
          url: jdbc:TAOS-WS://localhost:6041/your_tdengine_db?useSSL=false
          username: root
          password: taosdata
          hikari:
            # 避坑5：关闭连接检测，TDengine不支持connection-test-query
            connection-test-query: ""
            validation-timeout: 0
            # 避坑6：设置异常覆盖类，避免驱动报错无法捕获
            exception-override-class-name: com.taosdata.jdbc.TSDBSQLException
            # 避坑7：关闭只读，TDengine不支持只读模式
            read-only: false
            # 避坑8：自动提交开启，TDengine不支持事务，必须自动提交
            auto-commit: true
            maximum-pool-size: 5
            minimum-idle: 1
            idle-timeout: 60000

# MyBatis配置（正常配置即可）
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.tdengine.entity
  configuration:
    map-underscore-to-camel-case: true

避坑点总结：这8个避坑点少一个都可能报错，尤其是strict: false、enableTx: false、connection-test-query: ""，这三个是解决NOT supported报错的核心。

4. MyBatis写法（避坑：useGeneratedKeys必须关，表名必须带库名）

结合前面的特性，MyBatis的XML和接口写法有两个强制要求：① 必须显式写“库名.表名”；② 必须关闭useGeneratedKeys（TDengine没有自增主键）。

（1）Mapper接口（避坑：加2个注解，关闭事务和主键返回）

package com.example.tdengine.mapper;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.example.tdengine.entity.SensorData;
import org.apache.ibatis.annotations.Options;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.annotation.Propagation;

public interface TDengineMapper {

    // 避坑1：指定数据源为tdengine（和yml中tdengine数据源名称一致）
    @DS("tdengine")
    // 避坑2：关闭事务，TDengine不支持事务
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    // 避坑3：关闭主键返回，TDengine没有自增主键
    @Options(useGeneratedKeys = false)
    void insertSensorData(SensorData data);
}

（2）Mapper XML（避坑：库名.表名，WS驱动可用#{}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.tdengine.mapper.TDengineMapper">

    <insert id="insertSensorData" useGeneratedKeys="false"&gt;
        <!-- 避坑1：必须写 库名.表名，否则报9728错误 -->
        insert into your_tdengine_db.sensor_data (
            ts, temp, humi, co2, nh3, hcho, o2, tvoc, pm25, pm10, light, noise, ph
        ) values (
            <!-- 避坑2：TDengine时间戳用NOW（不用加括号），自动获取当前时间 -->
            NOW,
            <!-- 避坑3：WS驱动支持#{}, 避免SQL注入，RS驱动必须用${} -->
            #{temp},
            #{humi},
            #{co2},
            #{nh3},
            #{hcho},
            #{o2},
            #{tvoc},
            #{pm25},
            #{pm10},
            #{light},
            #{noise},
            #{ph}
        )
    </insert>

</mapper>

补充：如果用的是RS驱动，需要把XML中的#{} 全部换成${}，其他写法不变。

5. 实体类（简单适配，和表结构对应即可）

package com.example.tdengine.entity;

import lombok.Data;

@Data
public class SensorData {
    // ts是TDengine的主键（时间戳），无需手动赋值，XML中用NOW自动生成
    private Long ts;
    private Double temp; // 温度
    private Double humi; // 湿度
    private Double co2; // 二氧化碳
    private Double nh3; // 氨气
    private Double hcho; // 甲醛
    private Double o2; // 氧气
    private Double tvoc; // 总挥发性有机物
    private Double pm25; // PM2.5
    private Double pm10; // PM10
    private Double light; // 光照
    private Double noise; // 噪音
    private Double ph; // PH值
}

四、常见报错解决方案（对症下药，遇到直接查）

前面已经讲了全配置，但实际开发中可能还是会遇到报错，这里整理了5个最常见的报错，给出直接解决方案，不用再查全网：

报错1：java.sql.SQLFeatureNotSupportedException: this operation is NOT supported currently!

【原因】：调用了TDengine不支持的JDBC方法（事务、预编译、主键返回等）。

【解决方案】：

1. yml中设置enableTx: false，接口加@Transactional(propagation = Propagation.NOT_SUPPORTED)；

2. Mapper接口和XML中加useGeneratedKeys="false"；

3. 确认用的是HikariCP，没有用Druid；

4. 如果用RS驱动，确认所有#{} 都换成了${}。

报错2：error code [9728]; TDengine ERROR (0x2600): sql: CREATE TABLE IF NOT EXISTS xxx

【原因】：没有指定“库名.表名”，TDengine不知道操作哪个数据库。

【解决方案】：所有SQL中，表名前面加上数据库名，写成数据库名.表名。

报错3：Druid连接池整合后启动报错

【原因】：Druid会自动调用TDengine不支持的方法（如setReadOnly、getMetaData等）。

【解决方案】：彻底删除Druid依赖，改用HikariCP（前面的pom.xml已配置）。

报错4：动态数据源切换时，TDengine报错，MySQL正常

【原因】：dynamic-datasource的严格模式开启，或没有给TDengine关闭事务。

【解决方案】：yml中设置strict: false、enableTx: false，TDengine数据源的hikari配置加上exception-override-class-name: com.taosdata.jdbc.TSDBSQLException。

报错5：加载libtaosnative.so或libtaosws.so失败

【原因】：使用了原生驱动，或WS驱动依赖的动态链接库缺失。

【解决方案】：改用WS驱动（纯Java，无依赖），或按照TDengine官方文档安装对应的动态链接库，配置环境变量LD_LIBRARY_PATH。

五、最终总结（必背铁律，避免再踩坑）

整合TDengine的核心，就是“顺应它的特性，不要用MySQL的思维去要求它”，记住这6条铁律，再也不会报错：

1. 连接池：只用HikariCP，禁用Druid（天生不兼容）；

2. 驱动：生产用WS，测试用RS，原生坚决不用；

3. 事务：必须关闭（@Transactional(propagation = Propagation.NOT_SUPPORTED)）；

4. 主键：必须关闭useGeneratedKeys（TDengine没有自增主键）；

5. SQL：必须写库名.表名，WS驱动用#{}, RS驱动用${}；

6. 配置：关闭strict模式、关闭事务、关闭连接检测。

按照上面的配置，我已经成功将TDengine整合到项目中，稳定运行至今，没有再出现任何报错。所有代码都经过实际测试，可直接复制粘贴使用，节省你踩坑的时间。

如果觉得这篇文章对你有帮助，欢迎点赞、收藏、转发，让更多小伙伴避免踩坑～ 有其他报错或疑问，评论区留言，我会第一时间回复！

附：数据库配置

# 数据源配置
spring:
    datasource:
        dynamic:
            primary: master # 默认使用master库
            strict: false   # 不使用严格模式
            datasource:
                master:
                    url: jdbc:mysql://localhost:3306/scispace?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
                    username: root
                    password: rootme@123
                    driver-class-name: com.mysql.cj.jdbc.Driver
                    type: com.alibaba.druid.pool.DruidDataSource
                    druid:
                        initialSize: 5
                        minIdle: 5
                        maxActive: 11
                        validationQuery: SELECT 1
                tdengine:
#                    driver-class-name: com.taosdata.jdbc.rs.RestfulDriver
#                    url: jdbc:TAOS-RS://127.0.0.1:6041/sensordata?timezone=UTC-8
                    driver-class-name: com.taosdata.jdbc.TSDBDriver
                    url: jdbc:TAOS://127.0.0.1:6030/sensordata?timezone=UTC-8
#                    driver-class-name: com.taosdata.jdbc.ws.WebSocketDriver
#                    url: jdbc:TAOS-WS://127.0.0.1:6041/sensordata?timezone=UTC-8
                    username: root #admscispace
                    password: taosdata #rootme@123
                        # 关键配置：关闭所有不支持的特性
                    type: com.alibaba.druid.pool.DruidDataSource
                    druid:
                        initialSize: 5
                        minIdle: 5
                        maxActive: 11
                        validationQuery: SELECT 1
#                    type: com.zaxxer.hikari.HikariDataSource
#                    hikari:
#                            auto-commit: true
#                            read-only: false
#                            transaction-isolation-level: -1
#                            exception-override-class-name: com.taosdata.jdbc.TSDBSQLException
#                            # 禁用连接检测（非常关键）
#                            connection-test-query: ""
#                            validation-timeout: 0
#                            idle-timeout: 60000
#                            max-lifetime: 1800000
#                            maximum-pool-size: 5
                # 从库数据源
                slave:
                    # 从数据源开关/默认关闭
                    url: jdbc:mysql://localhost:3306/scispace?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
                    username: root
                    password: rootme@123
                    driver-class-name: com.mysql.cj.jdbc.Driver
                    type: com.alibaba.druid.pool.DruidDataSource
                    druid:
                        initialSize: 5
                        minIdle: 5
                        maxActive: 11
                        validationQuery: SELECT 1
        druid:
            # 从库数据源
            # 初始连接数
            initialSize: 5
            # 最小连接池数量
            minIdle: 10
            # 最大连接池数量
            maxActive: 20
            # 配置获取连接等待超时的时间
            maxWait: 60000
            # 配置连接超时时间
            connectTimeout: 30000
            # 配置网络超时时间
            socketTimeout: 60000
            # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            timeBetweenEvictionRunsMillis: 60000
            # 配置一个连接在池中最小生存的时间，单位是毫秒
            minEvictableIdleTimeMillis: 300000
            # 配置一个连接在池中最大生存的时间，单位是毫秒
            maxEvictableIdleTimeMillis: 900000
            # 配置检测连接是否有效
            validationQuery: SELECT 1 FROM DUAL
            testWhileIdle: true
            testOnBorrow: false
            testOnReturn: false
            webStatFilter: 
                enabled: true
            statViewServlet:
                enabled: true
                # 设置白名单，不填则允许所有访问
                allow:
                url-pattern: /druid/*
                # 控制台管理用户名和密码
                login-username: ruoyi
                login-password: 123456
            filter:
                stat:
                    enabled: true
                    # 慢SQL记录
                    log-slow-sql: true
                    slow-sql-millis: 1000
                    merge-sql: true
                wall:
                    config:
                        multi-statement-allow: true
    data:
        redis:
            host: 127.0.0.1
            port: 6379
            database: 0
            password: rootme@123
            timeout: 30s
            lettuce:
                pool:
                    min-idle: 0
                    max-idle: 8
                    max-active: 8
                    max-wait: -1ms

#TDengine #SpringBoot #MyBatis #动态数据源 #Java后端 #时序数据库 #IoT开发 #避坑指南 #TDengine整合 #HikariCP