Merge branch 'master' of http://114.215.146.132:3000/Mqy/Wisdom-Data into mqy20260511

 Conflicts:

	iot-platform/src/main/java/com/iot/platform/task/VehicleSyncTask.java

deploy/deploy.sh

@@ -19,6 +19,7 @@ REMOTE_DIR="${REMOTE_DIR:-/opt/iot-platform}"
 APP_NAME="iot-platform"
 LOCAL_JAR=""
 DO_BUILD=false
+NO_ROLLBACK=false
 
 # 颜色
 RED='\033[0;31m'
@@ -33,14 +34,19 @@ while [[ $# -gt 0 ]]; do
             DO_BUILD=true
             shift
             ;;
+        --no-rollback)
+            NO_ROLLBACK=true
+            shift
+            ;;
         --jar)
             LOCAL_JAR="$2"
             shift 2
             ;;
         --help|-h)
-            echo "用法: ./deploy.sh [--build] [--jar <path>]"
-            echo "  --build     本地执行 mvn clean package"
-            echo "  --jar       指定要部署的 jar 文件路径"
+            echo "用法: ./deploy.sh [--build] [--no-rollback] [--jar <path>]"
+            echo "  --build        本地执行 mvn clean package"
+            echo "  --no-rollback  健康检查失败时不自动回滚，保留新版本用于排查"
+            echo "  --jar          指定要部署的 jar 文件路径"
             exit 0
             ;;
         *)
@@ -127,7 +133,7 @@ echo -e "${GREEN}[5/6] 服务已启动${NC}"
 
 # 步骤 6: 健康检查
 echo -e "${YELLOW}[6/6] 健康检查...${NC}"
-if ssh "${SERVER_USER}@${SERVER_HOST}" "bash ${REMOTE_DIR}/bin/health-check.sh localhost 8887 30"; then
+if ssh "${SERVER_USER}@${SERVER_HOST}" "bash ${REMOTE_DIR}/bin/health-check.sh localhost 8887 60"; then
     echo -e "${GREEN}[6/6] 健康检查通过，部署成功!${NC}"
     echo ""
     echo "========================================"
@@ -142,10 +148,17 @@ if ssh "${SERVER_USER}@${SERVER_HOST}" "bash ${REMOTE_DIR}/bin/health-check.sh l
     ssh "${SERVER_USER}@${SERVER_HOST}" "systemctl status ${APP_NAME} --no-pager"
     exit 0
 else
-    echo -e "${RED}[6/6] 健康检查失败! 执行回滚...${NC}"
+    echo -e "${RED}[6/6] 健康检查失败!${NC}"
+
+    if [ "$NO_ROLLBACK" = true ]; then
+        echo -e "${YELLOW}[no-rollback] 已启用不回滚模式，保留新版本用于排查${NC}"
+        echo -e "${YELLOW}排查命令:${NC}"
+        echo "  ssh ${SERVER_USER}@${SERVER_HOST} 'journalctl -u ${APP_NAME} -f'"
+        echo "  ssh ${SERVER_USER}@${SERVER_HOST} 'systemctl status ${APP_NAME}'"
+        exit 1
+    fi
 
-    # 回滚
-    echo -e "${YELLOW}[rollback] 停止服务...${NC}"
+    echo -e "${YELLOW}[rollback] 执行回滚...${NC}"
     ssh "${SERVER_USER}@${SERVER_HOST}" "systemctl stop ${APP_NAME} || true"
 
     if ssh "${SERVER_USER}@${SERVER_HOST}" "test -f ${REMOTE_DIR}/backup/${BACKUP_NAME}"; then
@@ -156,7 +169,7 @@ else
         "
         sleep 3
 
-        if ssh "${SERVER_USER}@${SERVER_HOST}" "bash ${REMOTE_DIR}/bin/health-check.sh localhost 8887 30"; then
+        if ssh "${SERVER_USER}@${SERVER_HOST}" "bash ${REMOTE_DIR}/bin/health-check.sh localhost 8887 60"; then
             echo -e "${GREEN}[rollback] 回滚成功，旧版本已恢复${NC}"
         else
             echo -e "${RED}[rollback] 回滚后健康检查仍失败，请手动排查!${NC}"

iot-platform/pom.xml

@@ -3,9 +3,9 @@
          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">
     <parent>
-        <artifactId>ruoyi</artifactId>
-        <groupId>com.ruoyi</groupId>
-        <version>3.9.0</version>
+        <groupId>com.iot.platform</groupId>
+        <artifactId>wisdom-data</artifactId>
+        <version>1.0.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <packaging>jar</packaging>

iot-platform/src/main/java/com/iot/platform/service/TDengineService.java

@@ -9,15 +9,11 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 
-import java.io.ByteArrayOutputStream;
 import java.sql.*;
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.zip.*;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-
-@Service
+@Service("tdengineService")
 public class TDengineService {
     private static final Logger log = LoggerFactory.getLogger(TDengineService.class);
 
@@ -34,15 +30,15 @@ public class TDengineService {
     private HikariDataSource dataSource;
     private volatile boolean dataSourceInitialized = false;
 
-    // === 新增：缓存超级表结构 (key = dbName.stableName) ===
+    // === 缓存超级表结构 (key = dbName.stableName) ===
     private final Map<String, Set<String>> stableColumnCache = new ConcurrentHashMap<>();
     private static final int MAX_CACHE_SIZE = 1000;
 
-    // JSON 列名，用于存储所有动态字段
-    private static final String JSON_COLUMN_NAME = "ext_data";
+    // 允许的列名字符
+    private static final String ALLOWED_COLUMNS = "^[a-zA-Z_][a-zA-Z0-9_]*$";
 
-    // ObjectMapper 线程安全，可复用
-    private static final ObjectMapper objectMapper = new ObjectMapper();
+    // TDengine 超级表最大列数限制
+    private static final int MAX_COLUMNS_PER_STABLE = 4096;
 
     private synchronized void initDataSource() {
         if (dataSourceInitialized) {
@@ -72,7 +68,7 @@ public class TDengineService {
     }
 
     /**
-     * 手动获取连接
+     * 获取连接
      */
     public Connection getConnection() throws SQLException {
         if (!dataSourceInitialized) {
@@ -86,7 +82,7 @@ public class TDengineService {
     }
 
     /**
-     * 手动关闭连接
+     * 关闭连接
      */
     public void closeConnection(Connection conn) {
         if (conn != null) {
@@ -111,7 +107,7 @@ public class TDengineService {
     }
 
     private boolean isValidFieldName(String name) {
-        return name != null && name.matches("^[a-zA-Z0-9_]+$");
+        return name != null && name.matches(ALLOWED_COLUMNS);
     }
 
     // === 缓存工具方法 ===
@@ -129,15 +125,12 @@ public class TDengineService {
             return cached;
         }
 
-        // 缓存未命中，查 DB
         Set<String> columns = loadStableColumnsFromDB(dbName, stableName);
-        if (!columns.isEmpty()) {
-            if (stableColumnCache.size() >= MAX_CACHE_SIZE) {
-                stableColumnCache.clear();
-                log.warn("TDengine 超级表缓存已达上限({})，已清空", MAX_CACHE_SIZE);
-            }
-            stableColumnCache.put(key, columns);
+        if (stableColumnCache.size() >= MAX_CACHE_SIZE) {
+            stableColumnCache.clear();
+            log.warn("TDengine 超级表缓存已达上限({})，已清空", MAX_CACHE_SIZE);
         }
+        stableColumnCache.put(key, columns);
         return columns;
     }
 
@@ -151,7 +144,7 @@ public class TDengineService {
         try {
             conn = getConnection();
             stmt = conn.createStatement();
-            stmt.setQueryTimeout(5); // ⭐ 防止无限等待
+            stmt.setQueryTimeout(5);
             rs = stmt.executeQuery(sql);
             while (rs.next()) {
                 columns.add(rs.getString(1));
@@ -169,7 +162,7 @@ public class TDengineService {
     }
 
     // ==========================================
-    // 初始化表结构
+    // 初始化表结构（按列存储，无 ext_data）
     // ==========================================
     private void initTableStructure(String dbName, String supertablename, String table, Set<String> fieldNames) throws SQLException {
         Connection conn = null;
@@ -181,10 +174,9 @@ public class TDengineService {
 
             stmt.executeUpdate("CREATE DATABASE IF NOT EXISTS " + wrapName(dbName));
 
-            // 创建超级表：固定 ts + surfacename + ext_data(VARCHAR)
-            // 注：TDengine 2.x JSON 类型只能用于 TAGS，不能用于普通列
+            // 创建超级表：固定 ts + surfacename，无 ext_data 列
             String stableSql = String.format(
-                    "CREATE STABLE IF NOT EXISTS %s.%s (ts TIMESTAMP, surfacename VARCHAR(64), ext_data VARCHAR(8192)) TAGS (location BINARY(64))",
+                    "CREATE STABLE IF NOT EXISTS %s.%s (ts TIMESTAMP, surfacename VARCHAR(64)) TAGS (location BINARY(64))",
                     wrapName(dbName),
                     wrapName(supertablename)
             );
@@ -192,16 +184,12 @@ public class TDengineService {
 
             // 更新缓存：固定列
             String key = getStableKey(dbName, supertablename);
-            if (stableColumnCache.size() >= MAX_CACHE_SIZE) {
-                stableColumnCache.clear();
-                log.warn("TDengine 超级表缓存已达上限({})，已清空", MAX_CACHE_SIZE);
-            }
             Set<String> fixedCols = new HashSet<>();
             fixedCols.add("ts");
             fixedCols.add("surfacename");
-            fixedCols.add("ext_data");
             stableColumnCache.put(key, fixedCols);
 
+            // 创建子表
             String tableSql = String.format(
                     "CREATE TABLE IF NOT EXISTS %s.%s USING %s.%s TAGS ('%s')",
                     wrapName(dbName),
@@ -219,17 +207,17 @@ public class TDengineService {
     }
 
     // ==========================================
-    // 批量插入
+    // 批量插入（按列存储）
     // ==========================================
     public void insertBatch(String dbName, String table, List<Map<String, Object>> dataList) throws SQLException {
         if (dataList == null || dataList.isEmpty()) return;
 
         String supertablename = table.contains("_") ? table.substring(0, table.lastIndexOf('_')) : table;
 
-        // 初始化表结构（固定为 ts + surfacename + ext_data）
+        // 初始化表结构
         initTableStructure(dbName, supertablename, table, Collections.emptySet());
 
-        // 分批处理，每批最多 50 条记录（避免 SQL 过长）
+        // 分批处理，每批最多 50 条记录
         int batchSize = 50;
         int totalBatches = (dataList.size() + batchSize - 1) / batchSize;
 
@@ -248,23 +236,65 @@ public class TDengineService {
      * 内部方法：插入一批数据
      */
     private void insertBatchInternal(String dbName, String supertablename, String table, List<Map<String, Object>> dataList) throws SQLException {
-        // 确保表存在（可能有竞态条件）
         ensureTableExists(dbName, supertablename, table);
 
+        // 收集所有动态列名及其数据类型
+        Map<String, String> columnTypes = new LinkedHashMap<>();
+        for (Map<String, Object> data : dataList) {
+            if (data == null) continue;
+            for (Map.Entry<String, Object> entry : data.entrySet()) {
+                String key = entry.getKey();
+                if (isValidFieldName(key) && !isReservedColumn(key) && !columnTypes.containsKey(key)) {
+                    columnTypes.put(key, getValueType(entry.getValue()));
+                }
+            }
+        }
+
+        // 获取当前列数
+        Set<String> existingColumns = getStableColumns(dbName, supertablename);
+        int totalColumns = existingColumns.size() + columnTypes.size();
+
+        // 检查列数是否超限
+        if (totalColumns > MAX_COLUMNS_PER_STABLE) {
+            log.error("超级表总列数({})超过限制({})，跳过本次插入 | 表: {}.{}",
+                    totalColumns, MAX_COLUMNS_PER_STABLE, dbName, table);
+            return;
+        }
+
+        // 确保所有列都存在（自动 ALTER 添加新列）
+        ensureColumnsExist(dbName, supertablename, columnTypes);
+
+        // 重新获取列数以确保一致性
+        existingColumns = getStableColumns(dbName, supertablename);
+        if (existingColumns.size() >= MAX_COLUMNS_PER_STABLE) {
+            log.error("超级表列数已达上限({})，停止插入数据 | 表: {}.{}",
+                    MAX_COLUMNS_PER_STABLE, dbName, table);
+            return;
+        }
+
+        // 构建 SQL
         StringBuilder sqlBuilder = new StringBuilder();
         sqlBuilder.append("INSERT INTO ").append(wrapName(dbName)).append(".").append(wrapName(table))
-                .append(" (ts, surfacename, ext_data) VALUES ");
+                .append(" (ts, surfacename");
+
+        for (String col : columnTypes.keySet()) {
+            sqlBuilder.append(", ").append(wrapName(col));
+        }
+        sqlBuilder.append(") VALUES ");
 
         boolean hasData = false;
         for (Map<String, Object> data : dataList) {
             if (data == null) continue;
 
-            // 将动态字段转为 JSON 并 GZIP 压缩
-            String extJson = buildDynamicJson(data);
-            String compressed = compressToBase64(extJson);
+            sqlBuilder.append("(NOW(), '").append(escapeValue(supertablename)).append("'");
 
-            sqlBuilder.append("(NOW(), '").append(escapeValue(supertablename)).append("', '")
-                    .append(escapeValue(compressed)).append("'),");
+            for (Map.Entry<String, String> entry : columnTypes.entrySet()) {
+                String col = entry.getKey();
+                String colType = entry.getValue();
+                Object value = data.get(col);
+                sqlBuilder.append(", ").append(formatValue(value, col, colType));
+            }
+            sqlBuilder.append("),");
             hasData = true;
         }
 
@@ -281,7 +311,6 @@ public class TDengineService {
             stmt.setQueryTimeout(30);
             stmt.executeUpdate(finalSql);
         } catch (SQLException e) {
-            // 表不存在时尝试重建表后重试
             if (e.getMessage().contains("Table does not exist")) {
                 log.warn("表不存在，重建表: {}", table);
                 initTableStructure(dbName, supertablename, table, Collections.emptySet());
@@ -296,20 +325,44 @@ public class TDengineService {
     }
 
     /**
-     * 重试插入（表重建后）
+     * 重试插入
      */
     private void insertBatchRetry(String dbName, String supertablename, String table, List<Map<String, Object>> dataList) throws SQLException {
+        Map<String, String> columnTypes = new LinkedHashMap<>();
+        for (Map<String, Object> data : dataList) {
+            if (data == null) continue;
+            for (Map.Entry<String, Object> entry : data.entrySet()) {
+                String key = entry.getKey();
+                if (isValidFieldName(key) && !isReservedColumn(key) && !columnTypes.containsKey(key)) {
+                    columnTypes.put(key, getValueType(entry.getValue()));
+                }
+            }
+        }
+
+        ensureColumnsExist(dbName, supertablename, columnTypes);
+
         StringBuilder sqlBuilder = new StringBuilder();
         sqlBuilder.append("INSERT INTO ").append(wrapName(dbName)).append(".").append(wrapName(table))
-                .append(" (ts, surfacename, ext_data) VALUES ");
+                .append(" (ts, surfacename");
+
+        for (String col : columnTypes.keySet()) {
+            sqlBuilder.append(", ").append(wrapName(col));
+        }
+        sqlBuilder.append(") VALUES ");
 
         boolean hasData = false;
         for (Map<String, Object> data : dataList) {
             if (data == null) continue;
-            String extJson = buildDynamicJson(data);
-            String compressed = compressToBase64(extJson);
-            sqlBuilder.append("(NOW(), '").append(escapeValue(supertablename)).append("', '")
-                    .append(escapeValue(compressed)).append("'),");
+
+            sqlBuilder.append("(NOW(), '").append(escapeValue(supertablename)).append("'");
+
+            for (Map.Entry<String, String> entry : columnTypes.entrySet()) {
+                String col = entry.getKey();
+                String colType = entry.getValue();
+                Object value = data.get(col);
+                sqlBuilder.append(", ").append(formatValue(value, col, colType));
+            }
+            sqlBuilder.append("),");
             hasData = true;
         }
 
@@ -334,7 +387,166 @@ public class TDengineService {
     }
 
     /**
-     * 确保表存在（检查+创建）
+     * 判断是否为保留列（ts, surfacename）
+     */
+    private boolean isReservedColumn(String columnName) {
+        return "ts".equalsIgnoreCase(columnName) || "surfacename".equalsIgnoreCase(columnName);
+    }
+
+    /**
+     * 判断值类型，返回 TDengine 对应的数据类型
+     */
+    private String getValueType(Object value) {
+        if (value == null) {
+            return "VARCHAR";
+        }
+        if (value instanceof Boolean) {
+            return "BOOL";
+        }
+        if (value instanceof Integer || value instanceof Long) {
+            return "BIGINT";
+        }
+        if (value instanceof Float || value instanceof Double) {
+            return "DOUBLE";
+        }
+        // 时间类型（Date, Timestamp, LocalDateTime 等）
+        if (value instanceof java.util.Date || value instanceof java.sql.Timestamp
+                || value instanceof java.time.LocalDateTime || value instanceof java.time.Instant) {
+            return "TIMESTAMP";
+        }
+        return "VARCHAR";
+    }
+
+    /**
+     * 根据 TDengine 列类型获取创建列的 SQL 类型
+     */
+    private String getColumnTypeForDDL(String tdType, String columnName) {
+        // 特殊列名使用较长长度
+        if ("device_id".equalsIgnoreCase(columnName)) {
+            return "VARCHAR(100)";
+        }
+        switch (tdType) {
+            case "BOOL":
+            case "BIGINT":
+            case "DOUBLE":
+            case "TIMESTAMP":
+                return tdType;
+            case "VARCHAR":
+            default:
+                return "VARCHAR(38)";
+        }
+    }
+
+    /**
+     * 格式化值
+     */
+    private String formatValue(Object value, String columnName, String columnType) {
+        if (value == null) {
+            return "NULL";
+        }
+        String strValue = value.toString();
+
+        // 数字类型不做长度校验
+        if ("DOUBLE".equals(columnType) || "BIGINT".equals(columnType) || "BOOL".equals(columnType)) {
+            if (value instanceof Boolean) {
+                return (Boolean) value ? "1" : "0";
+            }
+            return strValue;
+        }
+
+        // TIMESTAMP 类型处理
+        if ("TIMESTAMP".equals(columnType)) {
+            if (value instanceof java.util.Date) {
+                return String.valueOf(((java.util.Date) value).getTime());
+            }
+            if (value instanceof java.sql.Timestamp) {
+                return String.valueOf(((java.sql.Timestamp) value).getTime());
+            }
+            if (value instanceof java.time.LocalDateTime) {
+                return String.valueOf(((java.time.LocalDateTime) value).toInstant(java.time.ZoneOffset.of("+8")).toEpochMilli());
+            }
+            if (value instanceof java.time.Instant) {
+                return String.valueOf(((java.time.Instant) value).toEpochMilli());
+            }
+        }
+
+        // 字符串类型校验长度
+        int maxLen = "device_id".equalsIgnoreCase(columnName) ? 100 : 38;
+        if (strValue.length() > maxLen) {
+            log.warn("字段值超长，跳过存储 | 列: {} | 值长度: {} | 最大: {} | 前{}字符: {}",
+                    columnName, strValue.length(), maxLen, maxLen, strValue.substring(0, maxLen));
+            return "NULL";
+        }
+        return "'" + escapeValue(strValue) + "'";
+    }
+
+    /**
+     * 确保列存在，如有新列则 ALTER 添加（根据类型添加对应列）
+     */
+    private void ensureColumnsExist(String dbName, String supertablename, Map<String, String> columnTypes) throws SQLException {
+        Set<String> existingColumns = getStableColumns(dbName, supertablename);
+
+        // 检查是否已达到列数上限
+        if (existingColumns.size() >= MAX_COLUMNS_PER_STABLE) {
+            log.error("超级表列数已达上限({})，停止添加新列 | 表: {}.{}", MAX_COLUMNS_PER_STABLE, dbName, supertablename);
+            return;
+        }
+
+        Connection conn = null;
+        Statement stmt = null;
+        try {
+            conn = getConnection();
+            stmt = conn.createStatement();
+            stmt.setQueryTimeout(10);
+
+            for (Map.Entry<String, String> entry : columnTypes.entrySet()) {
+                String col = entry.getKey();
+                String colType = entry.getValue();
+
+                // 再次检查列数上限
+                if (existingColumns.size() >= MAX_COLUMNS_PER_STABLE) {
+                    log.error("超级表列数已达上限({})，跳过添加列 | 列: {} | 表: {}.{}",
+                            MAX_COLUMNS_PER_STABLE, col, dbName, supertablename);
+                    continue;
+                }
+
+                if (!existingColumns.contains(col)) {
+                    String ddlType = getColumnTypeForDDL(colType, col);
+                    String alterSql = String.format(
+                            "ALTER STABLE %s.%s ADD COLUMN %s %s",
+                            wrapName(dbName),
+                            wrapName(supertablename),
+                            wrapName(col),
+                            ddlType
+                    );
+                    try {
+                        stmt.executeUpdate(alterSql);
+                        log.info("超级表添加列: {}.{} -> {} ({})", dbName, supertablename, col, ddlType);
+                        existingColumns.add(col);
+                    } catch (SQLException e) {
+                        if (e.getMessage().contains("already exists") || e.getMessage().contains("duplicate")) {
+                            existingColumns.add(col);
+                        } else if (e.getMessage().contains("too many columns")) {
+                            log.error("超级表列数超限，无法添加列 | 列: {} | 表: {}.{} | 错误: {}",
+                                    col, dbName, supertablename, e.getMessage());
+                        } else {
+                            throw e;
+                        }
+                    }
+
+                    // 更新缓存
+                    String key = getStableKey(dbName, supertablename);
+                    stableColumnCache.put(key, existingColumns);
+                }
+            }
+        } finally {
+            if (stmt != null) try { stmt.close(); } catch (SQLException ignored) {}
+            closeConnection(conn);
+        }
+    }
+
+    /**
+     * 确保表存在
      */
     private void ensureTableExists(String dbName, String supertablename, String table) throws SQLException {
         Connection conn = null;
@@ -345,7 +557,7 @@ public class TDengineService {
             stmt = conn.createStatement();
             stmt.setQueryTimeout(5);
 
-            // 检查超级表是否存在（使用 information_schema）
+            // 检查超级表是否存在
             String checkStableSql = String.format(
                     "SELECT * FROM information_schema.ins_tables WHERE table_name = '%s' AND db_name = '%s'",
                     escapeValue(supertablename), escapeValue(dbName));
@@ -390,47 +602,6 @@ public class TDengineService {
         }
     }
 
-    /**
-     * 将动态字段构建为 JSON 字符串（排除 topic、ts、surfacename）
-     */
-    private String buildDynamicJson(Map<String, Object> data) {
-        if (data == null) return "{}";
-        Map<String, Object> dynamic = new LinkedHashMap<>();
-        for (Map.Entry<String, Object> entry : data.entrySet()) {
-            String key = entry.getKey();
-            if ("topic".equalsIgnoreCase(key) || "ts".equalsIgnoreCase(key)
-                    || "surfacename".equalsIgnoreCase(key)) {
-                continue;
-            }
-            Object value = entry.getValue();
-            if (value != null && !value.toString().trim().isEmpty()) {
-                dynamic.put(key, value);
-            }
-        }
-        try {
-            return objectMapper.writeValueAsString(dynamic);
-        } catch (Exception e) {
-            throw new IllegalStateException("JSON 序列化失败，数据可能丢失: " + dynamic, e);
-        }
-    }
-
-    /**
-     * GZIP 压缩字符串
-     */
-    private String compressToBase64(String data) {
-        if (data == null || data.isEmpty()) return "";
-        try {
-            ByteArrayOutputStream bos = new ByteArrayOutputStream();
-            try (GZIPOutputStream gzip = new GZIPOutputStream(bos)) {
-                gzip.write(data.getBytes("UTF-8"));
-            }
-            byte[] compressed = Base64.getEncoder().encode(bos.toByteArray());
-            return new String(compressed);
-        } catch (Exception e) {
-            throw new IllegalStateException("GZIP 压缩失败: " + e.getMessage(), e);
-        }
-    }
-
     @Deprecated
     public void addToBatch(String dbName, String table, Map<String, Object> dataMap) throws SQLException {
         List<Map<String, Object>> list = new ArrayList<>();
@@ -438,9 +609,9 @@ public class TDengineService {
         insertBatch(dbName, table, list);
     }
 
-    // ==========================================
-    // 可选：清除缓存（用于运维或测试）
-    // ==========================================
+    /**
+     * 清除缓存
+     */
     public void clearStableColumnCache() {
         stableColumnCache.clear();
         log.info("清除了 TDengine 超级表结构缓存");
@@ -448,7 +619,6 @@ public class TDengineService {
 
     public void close() {
         log.info("关闭 TDengine 服务...");
-        // batchExecutor 由 Spring 管理生命周期，不在这里 shutdown
         if (dataSource != null) {
             dataSource.close();
         }

iot-platform/src/main/java/com/iot/platform/task/VehicleSyncTask.java

@@ -1,327 +0,0 @@
-package com.iot.platform.task;
-
-import com.iot.platform.domain.SysCar;
-import com.iot.platform.domain.SysDevice;
-import com.iot.platform.domain.SysDeviceControl;
-import com.iot.platform.config.IotProperties;
-import com.iot.platform.service.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.dao.DataAccessException;
-import org.springframework.data.redis.RedisConnectionFailureException;
-import org.springframework.data.redis.core.RedisCallback;
-import org.springframework.data.redis.core.ScanOptions;
-import org.springframework.data.redis.core.StringRedisTemplate;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Component;
-import org.springframework.web.client.RestClientException;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-@Component
-public class VehicleSyncTask {
-
-//    private static final Logger log = LoggerFactory.getLogger(VehicleSyncTask.class);
-//
-//    private final SysCarService sysCarService;
-//    private final SysDeviceService sysDeviceService;
-//    private final StringRedisTemplate stringRedisTemplate;
-//    private final SysrealtimeService sysrealtimeService;
-//    private final SysDeviceVoService sysDeviceVoService;
-//    private final SysDeviceControlService sysDeviceControlService;
-//    private final RestTemplate restTemplate;
-//    private final IotProperties iotProperties;
-//
-//    public VehicleSyncTask(SysCarService sysCarService,
-//                           SysDeviceService sysDeviceService,
-//                           StringRedisTemplate stringRedisTemplate,
-//                           SysrealtimeService sysrealtimeService,
-//                           SysDeviceVoService sysDeviceVoService,
-//                           SysDeviceControlService sysDeviceControlService,
-//                           RestTemplate restTemplate,
-//                           IotProperties iotProperties) {
-//        this.sysCarService = sysCarService;
-//        this.sysDeviceService = sysDeviceService;
-//        this.stringRedisTemplate = stringRedisTemplate;
-//        this.sysrealtimeService = sysrealtimeService;
-//        this.sysDeviceVoService = sysDeviceVoService;
-//        this.sysDeviceControlService = sysDeviceControlService;
-//        this.restTemplate = restTemplate;
-//        this.iotProperties = iotProperties;
-//    }
-//
-//    private boolean tryLock(String lockKey, long expireSeconds) {
-//        Boolean acquired = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "1", expireSeconds, TimeUnit.SECONDS);
-//        return Boolean.TRUE.equals(acquired);
-//    }
-//
-//    private void unlock(String lockKey) {
-//        Boolean deleted = stringRedisTemplate.delete(lockKey);
-//        if (!Boolean.TRUE.equals(deleted)) {
-//            log.warn("分布式锁释放失败: {}", lockKey);
-//        }
-//    }
-//
-//    /**
-//     * 更新车辆的控制器信息
-//     * 30秒更新一次
-//     */
-//    @Scheduled(fixedDelay = 30000)
-//    public void updateSysCar() {
-//        String lockKey = "lock:vehicle-sync:updateSysCar";
-//        if (!tryLock(lockKey, 60)) {
-//            log.debug("获取锁失败，跳过本次执行: {}", lockKey);
-//            return;
-//        }
-//        try {
-//            doUpdateSysCar();
-//        } finally {
-//            unlock(lockKey);
-//        }
-//    }
-//
-//    private void doUpdateSysCar() {
-//        List<SysCar> sysCarList = sysCarService.selectcontrollerId();
-//        for (SysCar sysCar : sysCarList) {
-//            try {
-//                if (sysCar.getControllerId() == null || sysCar.getControllerId().isEmpty()) {
-//                    continue;
-//                }
-//                SysDevice latitude = sysDeviceService.selectsysdevice(sysCar.getControllerId(), "纬度");
-//                SysDevice longitude = sysDeviceService.selectsysdevice(sysCar.getControllerId(), "经度");
-//
-//                String redisKeyPattern = "workorder:coordinate:" + sysCar.getControllerId() + ":*";
-//                Set<String> keys = scanKeys(redisKeyPattern);
-//
-//                if (keys == null || keys.isEmpty()) {
-//                    updateCarPosition(sysCar, latitude, longitude);
-//                } else {
-//                    for (String key : keys) {
-//                        Map<Object, Object> coordinateMap = stringRedisTemplate.opsForHash().entries(key);
-//                        Object cachedLat = coordinateMap.get("latitude");
-//                        Object cachedLon = coordinateMap.get("longitude");
-//                        if (cachedLat != null && cachedLat.equals(latitude.getV()) && cachedLon != null && cachedLon.equals(longitude.getV())) {
-//                            continue;
-//                        }
-//                        updateCarPosition(sysCar, latitude, longitude);
-//                    }
-//                }
-//            } catch (DataAccessException e) {
-//                log.error("更新车辆位置失败 carId={}: {}", sysCar.getCarId(), e.getMessage(), e);
-//            } catch (Exception e) {
-//                log.error("更新车辆位置异常 carId={}: {}", sysCar.getCarId(), e.getMessage(), e);
-//            }
-//        }
-//    }
-//
-//    private void updateCarPosition(SysCar sysCar, SysDevice latitude, SysDevice longitude) {
-//        String redisKey = "workorder:coordinate:" + sysCar.getControllerId();
-//        stringRedisTemplate.opsForHash().put(redisKey, "latitude", latitude.getV());
-//        stringRedisTemplate.opsForHash().put(redisKey, "longitude", longitude.getV());
-//        stringRedisTemplate.persist(redisKey);
-//
-//        String position = latitude.getV() + "," + longitude.getV();
-//        sysCarService.updatecarposition(position, sysCar.getCarId());
-//        String url = iotProperties.getMqtt().getVehicleTriggerUrl() + "?carId=" + sysCar.getCarId();
-//        try {
-//            restTemplate.postForObject(url, null, String.class);
-//        } catch (RestClientException e) {
-//            log.warn("触发webhook失败 carId={}: {}", sysCar.getCarId(), e.getMessage());
-//        }
-//    }
-//
-//    private Set<String> scanKeys(String pattern) {
-//        Set<String> keys = new HashSet<>();
-//        ScanOptions options = ScanOptions.scanOptions().match(pattern).count(100).build();
-//        try {
-//            stringRedisTemplate.execute((RedisCallback<Void>) connection -> {
-//                org.springframework.data.redis.core.Cursor<byte[]> cursor = connection.scan(options);
-//                while (cursor.hasNext()) {
-//                    keys.add(new String(cursor.next()));
-//                }
-//                cursor.close();
-//                return null;
-//            });
-//        } catch (RedisConnectionFailureException e) {
-//            log.warn("Redis SCAN 连接失败 pattern={}: {}", pattern, e.getMessage());
-//        } catch (Exception e) {
-//            log.error("Redis SCAN 失败 pattern={}: {}", pattern, e.getMessage(), e);
-//        }
-//        return keys;
-//    }
-//
-////    @Scheduled(fixedDelay = 30000)
-////    public void insertDevice() {
-////        String lockKey = "lock:vehicle-sync:insertDevice";
-////        if (!tryLock(lockKey, 60)) {
-////            log.debug("获取锁失败，跳过本次执行: {}", lockKey);
-////            return;
-////        }
-////        try {
-////            doInsertDevice();
-////        } finally {
-////            unlock(lockKey);
-////        }
-////    }
-////
-////    private void doInsertDevice() {
-////        Set<String> activeKeys;
-////        try {
-////            activeKeys = stringRedisTemplate.opsForSet().members("DSB:active:devices");
-////        } catch (Exception e) {
-////            log.warn("redis中无数据");
-////            return;
-////        }
-////        try {
-////            if (activeKeys == null || activeKeys.isEmpty()) {
-////                log.info("redis中无数据");
-////                return;
-////            }
-////            List<SysDeviceControl> sysDeviceControlList = sysDeviceControlService.selectdevice("device");
-////            for (String redisKey : activeKeys) {
-////                Map<Object, Object> dataMap = stringRedisTemplate.opsForHash().entries(redisKey);
-////                if (dataMap == null || dataMap.isEmpty()) {
-////                    stringRedisTemplate.opsForSet().remove("DSB:active:devices", redisKey);
-////                    continue;
-////                }
-////                String[] parts = redisKey.split(":", 3);
-////                if (parts.length != 3 || !"DSB".equals(parts[0])) {
-////                    log.warn("跳过非法 key: {}", redisKey);
-////                    continue;
-////                }
-////                String controllerId = parts[1];
-////                Integer count = sysDeviceVoService.selectcount(controllerId);
-////                if (count != null && count > 0) {
-////                    StringBuilder keyvalue = new StringBuilder();
-////                    for (int i = 0; i < sysDeviceControlList.size(); i++) {
-////                        for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
-////                            String fieldKey = entry.getKey().toString();
-////                            String fieldvalue = entry.getValue().toString();
-////                            if (sysDeviceControlList.get(i).getControllerName().equals(fieldKey)) {
-////                                keyvalue.append(fieldKey).append("=/'").append(fieldvalue).append("/'");
-////                                if (i < sysDeviceControlList.size() - 1) {
-////                                    keyvalue.append(",");
-////                                }
-////                            }
-////                        }
-////                    }
-////                    boolean updated = sysDeviceVoService.updatesysdevice(keyvalue.toString(), controllerId);
-////                    if (!updated) {
-////                        log.warn("更新设备配置失败: controllerId={}", controllerId);
-////                    }
-////                } else {
-////                    StringBuilder key = new StringBuilder();
-////                    StringBuilder value = new StringBuilder();
-////                    for (int i = 0; i < sysDeviceControlList.size(); i++) {
-////                        for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
-////                            String fieldKey = entry.getKey().toString();
-////                            String fieldvalue = entry.getValue().toString();
-////                            if (sysDeviceControlList.get(i).getControllerName().equals(fieldKey)) {
-////                                key.append(fieldKey);
-////                                value.append(fieldvalue);
-////                                if (i < sysDeviceControlList.size() - 1) {
-////                                    key.append(",");
-////                                    value.append(",");
-////                                }
-////                            }
-////                        }
-////                    }
-////                    boolean inserted = sysDeviceVoService.insertdevice(key.toString(), value.toString());
-////                    if (!inserted) {
-////                        log.warn("插入设备配置失败: controllerId={}", controllerId);
-////                    }
-////                }
-////            }
-////        } catch (RedisConnectionFailureException e) {
-////            log.warn("Redis 连接失败，跳过本次同步: {}", e.getMessage());
-////        } catch (DataAccessException e) {
-////            log.error("数据库操作失败: {}", e.getMessage(), e);
-////        } catch (Exception e) {
-////            log.error("同步设备配置失败: {}", e.getMessage(), e);
-////        }
-////    }
-//
-//    /**
-//     * 更新数据库实时数据
-//     */
-//    @Scheduled(fixedDelay = 30000)
-//    public void syncRedisToMySQL() {
-//        String lockKey = "lock:vehicle-sync:syncRedisToMySQL";
-//        if (!tryLock(lockKey, 60)) {
-//            log.debug("获取锁失败，跳过本次执行: {}", lockKey);
-//            return;
-//        }
-//        try {
-//            doSyncRedisToMySQL();
-//        } finally {
-//            unlock(lockKey);
-//        }
-//    }
-//
-//    private void doSyncRedisToMySQL() {
-//        Set<String> activeKeys = stringRedisTemplate.opsForSet().members("DSB:active:devices");
-//        if (activeKeys == null || activeKeys.isEmpty()) return;
-//
-//        for (String redisKey : activeKeys) {
-//            try {
-//                Map<Object, Object> dataMap = stringRedisTemplate.opsForHash().entries(redisKey);
-//                if (dataMap == null || dataMap.isEmpty()) {
-//                    stringRedisTemplate.opsForSet().remove("DSB:active:devices", redisKey);
-//                    continue;
-//                }
-//
-//                String[] parts = redisKey.split(":", 3);
-//                if (parts.length != 3 || !"DSB".equals(parts[0])) {
-//                    log.warn("跳过非法 key: {}", redisKey);
-//                    continue;
-//                }
-//                String controllerId = parts[1];
-//
-//                try {
-//                    sysrealtimeService.createrealtime(controllerId);
-//                } catch (Exception e) {
-//                    log.error("创建表失败: {} | {}", controllerId, e.getMessage(), e);
-//                    continue;
-//                }
-//
-//                String createTime = getStringValue(dataMap, "createTime");
-//                String timestamp = getStringValue(dataMap, "timestamp");
-//                String deviceId = getStringValue(dataMap, "device_id");
-//                if (createTime == null || timestamp == null || deviceId == null) {
-//                    continue;
-//                }
-//
-//                List<String> existingKeys = sysrealtimeService.selectAllKeys(controllerId);
-//                Set<String> existingKeySet = existingKeys != null ? new HashSet<>(existingKeys) : Collections.emptySet();
-//
-//                for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
-//                    String fieldKey = entry.getKey().toString();
-//                    if ("createTime".equals(fieldKey) || "timestamp".equals(fieldKey) || "device_id".equals(fieldKey)) {
-//                        continue;
-//                    }
-//                    String fieldValue = getStringValue(dataMap, fieldKey);
-//                    if (fieldValue == null) continue;
-//
-//                    if (existingKeySet.contains(fieldKey)) {
-//                        sysrealtimeService.updatetables(controllerId, createTime, fieldValue, timestamp, fieldKey, deviceId);
-//                    } else {
-//                        sysrealtimeService.inserttables(controllerId, createTime, deviceId, timestamp, fieldKey, fieldValue);
-//                    }
-//                }
-//            } catch (RedisConnectionFailureException e) {
-//                log.error("Redis 连接失败: {} | {}", redisKey, e.getMessage());
-//            } catch (DataAccessException e) {
-//                log.error("数据库操作失败: {} | {}", redisKey, e.getMessage(), e);
-//            } catch (Exception e) {
-//                log.error("同步设备失败: {} | {}", redisKey, e.getMessage(), e);
-//            }
-//        }
-//    }
-//
-//    private String getStringValue(Map<Object, Object> map, String key) {
-//        Object val = map.get(key);
-//        return val == null ? null : val.toString().trim();
-//    }
-}

iot-platform/src/test/java/com/iot/platform/service/TDengineServiceTest.java

@@ -83,69 +83,225 @@ class TDengineServiceTest {
     }
 
     @Test
-    @DisplayName("buildDynamicJson: 应排除 topic/ts/surfacename")
-    void buildDynamicJson_excludesReservedKeys() throws Exception {
-        Method method = TDengineService.class.getDeclaredMethod("buildDynamicJson", Map.class);
+    @DisplayName("getValueType: Boolean 返回 BOOL")
+    void getValueType_boolean_returnsBool() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
         method.setAccessible(true);
 
-        Map<String, Object> data = new LinkedHashMap<>();
-        data.put("topic", "test/topic");
-        data.put("ts", "1234567890");
-        data.put("surfacename", "s1");
-        data.put("temperature", "25.5");
-        data.put("humidity", "60");
+        assertThat(method.invoke(tdengineService, Boolean.TRUE)).isEqualTo("BOOL");
+        assertThat(method.invoke(tdengineService, Boolean.FALSE)).isEqualTo("BOOL");
+    }
+
+    @Test
+    @DisplayName("getValueType: Integer 返回 BIGINT")
+    void getValueType_integer_returnsBigint() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
+        method.setAccessible(true);
 
-        String result = (String) method.invoke(tdengineService, data);
-        assertThat(result).contains("temperature", "humidity");
-        assertThat(result).doesNotContain("topic", "ts", "surfacename");
+        assertThat(method.invoke(tdengineService, 123)).isEqualTo("BIGINT");
+        assertThat(method.invoke(tdengineService, Integer.valueOf(456))).isEqualTo("BIGINT");
     }
 
     @Test
-    @DisplayName("buildDynamicJson: 空值和空字符串应被过滤")
-    void buildDynamicJson_filtersEmptyValues() throws Exception {
-        Method method = TDengineService.class.getDeclaredMethod("buildDynamicJson", Map.class);
+    @DisplayName("getValueType: Long 返回 BIGINT")
+    void getValueType_long_returnsBigint() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
         method.setAccessible(true);
 
-        Map<String, Object> data = new LinkedHashMap<>();
-        data.put("valid", "value");
-        data.put("empty", "");
-        data.put("nullVal", null);
+        assertThat(method.invoke(tdengineService, 123L)).isEqualTo("BIGINT");
+    }
+
+    @Test
+    @DisplayName("getValueType: Float 返回 DOUBLE")
+    void getValueType_float_returnsDouble() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, 12.34f)).isEqualTo("DOUBLE");
+    }
+
+    @Test
+    @DisplayName("getValueType: Double 返回 DOUBLE")
+    void getValueType_double_returnsDouble() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
+        method.setAccessible(true);
 
-        String result = (String) method.invoke(tdengineService, data);
-        assertThat(result).contains("valid");
-        assertThat(result).doesNotContain("empty", "nullVal");
+        assertThat(method.invoke(tdengineService, 56.78)).isEqualTo("DOUBLE");
+        assertThat(method.invoke(tdengineService, Double.valueOf(99.99))).isEqualTo("DOUBLE");
     }
 
     @Test
-    @DisplayName("buildDynamicJson: null 输入应返回空 JSON")
-    void buildDynamicJson_nullInput_returnsEmptyJson() throws Exception {
-        Method method = TDengineService.class.getDeclaredMethod("buildDynamicJson", Map.class);
+    @DisplayName("getValueType: java.util.Date 返回 TIMESTAMP")
+    void getValueType_date_returnsTimestamp() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
         method.setAccessible(true);
 
-        assertThat(method.invoke(tdengineService, (Map<String, Object>) null)).isEqualTo("{}");
+        assertThat(method.invoke(tdengineService, new java.util.Date())).isEqualTo("TIMESTAMP");
     }
 
     @Test
-    @DisplayName("compressToBase64: 应压缩并返回非空字符串")
-    void compressToBase64_compressesData() throws Exception {
-        Method method = TDengineService.class.getDeclaredMethod("compressToBase64", String.class);
+    @DisplayName("getValueType: java.sql.Timestamp 返回 TIMESTAMP")
+    void getValueType_timestamp_returnsTimestamp() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
         method.setAccessible(true);
 
-        String input = "{\"temperature\":25.5,\"humidity\":60}";
-        String result = (String) method.invoke(tdengineService, input);
+        assertThat(method.invoke(tdengineService, new java.sql.Timestamp(System.currentTimeMillis()))).isEqualTo("TIMESTAMP");
+    }
+
+    @Test
+    @DisplayName("getValueType: java.time.LocalDateTime 返回 TIMESTAMP")
+    void getValueType_localDateTime_returnsTimestamp() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
+        method.setAccessible(true);
 
-        assertThat(result).isNotEmpty();
-        assertThat(result).isNotEqualTo(input); // should be compressed
+        assertThat(method.invoke(tdengineService, java.time.LocalDateTime.now())).isEqualTo("TIMESTAMP");
     }
 
     @Test
-    @DisplayName("compressToBase64: null 或空字符串应返回空")
-    void compressToBase64_nullOrEmpty_returnsEmpty() throws Exception {
-        Method method = TDengineService.class.getDeclaredMethod("compressToBase64", String.class);
+    @DisplayName("getValueType: java.time.Instant 返回 TIMESTAMP")
+    void getValueType_instant_returnsTimestamp() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
         method.setAccessible(true);
 
-        assertThat(method.invoke(tdengineService, (String) null)).isEqualTo("");
-        assertThat(method.invoke(tdengineService, "")).isEqualTo("");
+        assertThat(method.invoke(tdengineService, java.time.Instant.now())).isEqualTo("TIMESTAMP");
+    }
+
+    @Test
+    @DisplayName("getValueType: String 返回 VARCHAR")
+    void getValueType_string_returnsVarchar() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "test")).isEqualTo("VARCHAR");
+        assertThat(method.invoke(tdengineService, "")).isEqualTo("VARCHAR");
+    }
+
+    @Test
+    @DisplayName("getValueType: null 返回 VARCHAR")
+    void getValueType_null_returnsVarchar() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getValueType", Object.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, null)).isEqualTo("VARCHAR");
+    }
+
+    @Test
+    @DisplayName("getColumnTypeForDDL: BOOL/BIGINT/DOUBLE/TIMESTAMP 直接返回")
+    void getColumnTypeForDDL_directTypes() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getColumnTypeForDDL", String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "BOOL")).isEqualTo("BOOL");
+        assertThat(method.invoke(tdengineService, "BIGINT")).isEqualTo("BIGINT");
+        assertThat(method.invoke(tdengineService, "DOUBLE")).isEqualTo("DOUBLE");
+        assertThat(method.invoke(tdengineService, "TIMESTAMP")).isEqualTo("TIMESTAMP");
+    }
+
+    @Test
+    @DisplayName("getColumnTypeForDDL: VARCHAR 返回 VARCHAR(32)")
+    void getColumnTypeForDDL_varchar_returnsWithLength() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("getColumnTypeForDDL", String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "VARCHAR")).isEqualTo("VARCHAR(32)");
+    }
+
+    @Test
+    @DisplayName("formatValue: null 返回 NULL")
+    void formatValue_null_returnsNull() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, null, "col", "VARCHAR")).isEqualTo("NULL");
+    }
+
+    @Test
+    @DisplayName("formatValue: DOUBLE 类型直接返回数字字符串")
+    void formatValue_double_returnsNumberString() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, 12.34, "col", "DOUBLE")).isEqualTo("12.34");
+    }
+
+    @Test
+    @DisplayName("formatValue: BIGINT 类型直接返回数字字符串")
+    void formatValue_bigint_returnsNumberString() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, 123L, "col", "BIGINT")).isEqualTo("123");
+    }
+
+    @Test
+    @DisplayName("formatValue: BOOL 类型 true 返回 1")
+    void formatValue_bool_true_returns1() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, true, "col", "BOOL")).isEqualTo("1");
+        assertThat(method.invoke(tdengineService, false, "col", "BOOL")).isEqualTo("0");
+    }
+
+    @Test
+    @DisplayName("formatValue: VARCHAR 类型超过32字符返回 NULL")
+    void formatValue_varchar_exceedsLength_returnsNull() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        String longStr = "12345678901234567890123456789012345"; // 35 chars
+        assertThat(method.invoke(tdengineService, longStr, "col", "VARCHAR")).isEqualTo("NULL");
+    }
+
+    @Test
+    @DisplayName("formatValue: VARCHAR 类型32字符内正常返回")
+    void formatValue_varchar_withinLength_returnsQuoted() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "test", "col", "VARCHAR")).isEqualTo("'test'");
+    }
+
+    @Test
+    @DisplayName("formatValue: VARCHAR 类型包含单引号应转义")
+    void formatValue_varchar_withQuote_escapes() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "it's", "col", "VARCHAR")).isEqualTo("'it''s'");
+    }
+
+    @Test
+    @DisplayName("formatValue: TIMESTAMP 类型 java.util.Date 转为毫秒")
+    void formatValue_timestamp_date_returnsMillis() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("formatValue", Object.class, String.class, String.class);
+        method.setAccessible(true);
+
+        java.util.Date date = new java.util.Date(1234567890000L);
+        String result = (String) method.invoke(tdengineService, date, "col", "TIMESTAMP");
+        assertThat(result).isEqualTo("1234567890000");
+    }
+
+    @Test
+    @DisplayName("isReservedColumn: ts 和 surfacename 返回 true")
+    void isReservedColumn_reservedNames() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("isReservedColumn", String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "ts")).isEqualTo(true);
+        assertThat(method.invoke(tdengineService, "TS")).isEqualTo(true);
+        assertThat(method.invoke(tdengineService, "surfacename")).isEqualTo(true);
+        assertThat(method.invoke(tdengineService, "Surfacename")).isEqualTo(true);
+    }
+
+    @Test
+    @DisplayName("isReservedColumn: 其他列名返回 false")
+    void isReservedColumn_otherNames() throws Exception {
+        Method method = TDengineService.class.getDeclaredMethod("isReservedColumn", String.class);
+        method.setAccessible(true);
+
+        assertThat(method.invoke(tdengineService, "temperature")).isEqualTo(false);
+        assertThat(method.invoke(tdengineService, "voltage")).isEqualTo(false);
     }
 
     @Test
@@ -161,8 +317,6 @@ class TDengineServiceTest {
         Map<String, Object> data = new HashMap<>();
         data.put("key", "value");
 
-        // addToBatch 现在声明 throws SQLException，尝试连接 TDengine 会失败
-        // 本地环境缺少 TDengine 驱动时会抛出各种异常（UnsatisfiedLinkError / NoClassDefFoundError / IllegalStateException）
         assertThatThrownBy(() -> tdengineService.addToBatch("db", "table", data))
                 .isInstanceOf(Throwable.class);
     }
@@ -171,21 +325,18 @@ class TDengineServiceTest {
     @DisplayName("clearStableColumnCache: 应清空缓存不抛异常")
     void clearStableColumnCache_clearsWithoutError() {
         tdengineService.clearStableColumnCache();
-        // Should not throw
     }
 
     @Test
     @DisplayName("close: 应关闭数据源不抛异常")
     void close_closesDataSource() {
         tdengineService.close();
-        // Should not throw even if dataSource is null
     }
 
     @Test
     @DisplayName("closeConnection: null 连接应安全处理")
     void closeConnection_nullConnection_safe() {
         tdengineService.closeConnection(null);
-        // Should not throw
     }
 
     @Test
@@ -193,8 +344,7 @@ class TDengineServiceTest {
     void getConnection_initFails_throwsException() {
         when(tdengineConfig.getUrl()).thenReturn("jdbc:TAOS://invalid:6030/test");
 
-        // 本地环境缺少 TDengine 驱动时会抛出 NoClassDefFoundError / UnsatisfiedLinkError
         assertThatThrownBy(() -> tdengineService.getConnection())
                 .isInstanceOf(Throwable.class);
     }
-}
+}

iot-platform/src/test/java/com/iot/platform/task/VehicleSyncTaskTest.java

@@ -1,209 +0,0 @@
-package com.iot.platform.task;
-
-import com.iot.platform.config.IotProperties;
-import com.iot.platform.domain.SysCar;
-import com.iot.platform.domain.SysDevice;
-import com.iot.platform.service.*;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.mockito.junit.jupiter.MockitoSettings;
-import org.mockito.quality.Strictness;
-import org.springframework.dao.DataAccessException;
-import org.springframework.data.redis.RedisConnectionFailureException;
-import org.springframework.data.redis.core.StringRedisTemplate;
-import org.springframework.data.redis.core.ValueOperations;
-import org.springframework.web.client.RestClientException;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.*;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-@MockitoSettings(strictness = Strictness.LENIENT)
-class VehicleSyncTaskTest {
-
-    @Mock
-    private SysCarService sysCarService;
-    @Mock
-    private SysDeviceService sysDeviceService;
-    @Mock
-    private StringRedisTemplate stringRedisTemplate;
-    @Mock
-    private SysrealtimeService sysrealtimeService;
-    @Mock
-    private SysDeviceVoService sysDeviceVoService;
-    @Mock
-    private SysDeviceControlService sysDeviceControlService;
-    @Mock
-    private SysWorkorderService sysWorkorderService;
-    @Mock
-    private SysIndicatorsService sysIndicatorsService;
-
-    @Mock
-    private RestTemplate restTemplate;
-    @Mock
-    private IotProperties iotProperties;
-    @Mock
-    private IotProperties.Mqtt mqttConfig;
-
-    @InjectMocks
-    private VehicleSyncTask task;
-
-    @Mock
-    private ValueOperations<String, String> valueOps;
-
-    @BeforeEach
-    void setUp() {
-        when(stringRedisTemplate.opsForValue()).thenReturn(valueOps);
-        when(iotProperties.getMqtt()).thenReturn(mqttConfig);
-        when(mqttConfig.getVehicleTriggerUrl()).thenReturn("https://esos-iot.com:9443/syscar/trigger");
-    }
-
-    @Test
-    @DisplayName("updateSysCar: 获取锁失败时应跳过执行")
-    void updateSysCar_lockFail_skipsExecution() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(false);
-
-        task.updateSysCar();
-
-        verify(sysCarService, never()).selectcontrollerId();
-    }
-
-    @Test
-    @DisplayName("updateSysCar: 获取锁成功时应执行车辆位置更新")
-    void updateSysCar_lockSuccess_executesUpdate() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(true);
-
-        SysCar car = new SysCar();
-        car.setCarId("1");
-        car.setControllerId("CTRL001");
-        when(sysCarService.selectcontrollerId()).thenReturn(Collections.singletonList(car));
-
-        SysDevice lat = new SysDevice();
-        lat.setV("31.2304");
-        SysDevice lon = new SysDevice();
-        lon.setV("121.4737");
-        when(sysDeviceService.selectsysdevice("CTRL001", "纬度")).thenReturn(lat);
-        when(sysDeviceService.selectsysdevice("CTRL001", "经度")).thenReturn(lon);
-
-        when(stringRedisTemplate.opsForHash()).thenReturn(mock(org.springframework.data.redis.core.HashOperations.class));
-        when(stringRedisTemplate.delete(anyString())).thenReturn(true);
-
-        task.updateSysCar();
-
-        verify(sysCarService).selectcontrollerId();
-    }
-
-    @Test
-    @DisplayName("updateSysCar: 单条记录异常时不应中断整个批次")
-    void updateSysCar_singleRecordException_continuesBatch() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(true);
-
-        SysCar car1 = new SysCar();
-        car1.setCarId("1");
-        car1.setControllerId("CTRL001");
-        SysCar car2 = new SysCar();
-        car2.setCarId("2");
-        car2.setControllerId("CTRL002");
-        when(sysCarService.selectcontrollerId()).thenReturn(Arrays.asList(car1, car2));
-
-        // car1 正常
-        SysDevice lat1 = new SysDevice();
-        lat1.setV("31.2304");
-        SysDevice lon1 = new SysDevice();
-        lon1.setV("121.4737");
-        when(sysDeviceService.selectsysdevice("CTRL001", "纬度")).thenReturn(lat1);
-        when(sysDeviceService.selectsysdevice("CTRL001", "经度")).thenReturn(lon1);
-
-        // car2 抛异常
-        when(sysDeviceService.selectsysdevice("CTRL002", "纬度"))
-                .thenThrow(new DataAccessException("DB error") {});
-
-        when(stringRedisTemplate.opsForHash()).thenReturn(mock(org.springframework.data.redis.core.HashOperations.class));
-        when(stringRedisTemplate.delete(anyString())).thenReturn(true);
-
-        task.updateSysCar();
-
-        // car1 正常执行，car2 异常被捕获，两者都应该尝试
-        verify(sysDeviceService).selectsysdevice("CTRL001", "纬度");
-        verify(sysDeviceService).selectsysdevice("CTRL002", "纬度");
-    }
-
-    @Test
-    @DisplayName("insertDevice: Redis 连接失败时应跳过执行")
-    void insertDevice_redisConnectionFailure_skipsGracefully() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(true);
-        when(stringRedisTemplate.opsForSet()).thenThrow(
-                new RedisConnectionFailureException("Redis down"));
-        when(stringRedisTemplate.delete(anyString())).thenReturn(true);
-
-        task.insertDevice();
-
-        verify(sysDeviceControlService, never()).selectdevice(anyString());
-    }
-
-    @Test
-    @DisplayName("insertDevice: 空数据时应直接返回")
-    void insertDevice_emptyData_returnsEarly() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(true);
-
-        org.springframework.data.redis.core.SetOperations setOps = mock(org.springframework.data.redis.core.SetOperations.class);
-        when(stringRedisTemplate.opsForSet()).thenReturn(setOps);
-        when(setOps.members("DSB:active:devices")).thenReturn(Collections.emptySet());
-        when(stringRedisTemplate.delete(anyString())).thenReturn(true);
-
-        task.insertDevice();
-
-        verify(sysDeviceControlService, never()).selectdevice(anyString());
-    }
-
-    @Test
-    @DisplayName("syncRedisToMySQL: 空活跃 key 时应直接返回")
-    void syncRedisToMySQL_emptyKeys_returnsEarly() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(true);
-
-        org.springframework.data.redis.core.SetOperations setOps = mock(org.springframework.data.redis.core.SetOperations.class);
-        when(stringRedisTemplate.opsForSet()).thenReturn(setOps);
-        when(setOps.members("DSB:active:devices")).thenReturn(null);
-        when(stringRedisTemplate.delete(anyString())).thenReturn(true);
-
-        task.syncRedisToMySQL();
-
-        verify(sysrealtimeService, never()).createrealtime(anyString());
-    }
-
-
-    @Test
-    @DisplayName("webhook 调用失败时不应中断主流程")
-    void updateCarPosition_webhookFailure_continues() {
-        when(valueOps.setIfAbsent(anyString(), eq("1"), anyLong(), any())).thenReturn(true);
-
-        SysCar car = new SysCar();
-        car.setCarId("1");
-        car.setControllerId("CTRL001");
-        when(sysCarService.selectcontrollerId()).thenReturn(Collections.singletonList(car));
-
-        SysDevice lat = new SysDevice();
-        lat.setV("31.2304");
-        SysDevice lon = new SysDevice();
-        lon.setV("121.4737");
-        when(sysDeviceService.selectsysdevice("CTRL001", "纬度")).thenReturn(lat);
-        when(sysDeviceService.selectsysdevice("CTRL001", "经度")).thenReturn(lon);
-
-        when(stringRedisTemplate.opsForHash()).thenReturn(mock(org.springframework.data.redis.core.HashOperations.class));
-        when(stringRedisTemplate.delete(anyString())).thenReturn(true);
-        when(restTemplate.postForObject(anyString(), isNull(), eq(String.class)))
-                .thenThrow(new RestClientException("Connection refused"));
-
-        // 不应抛异常
-        task.updateSysCar();
-    }
-}

pom.xml

@@ -4,16 +4,14 @@
          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.0</version>
+    <groupId>com.iot.platform</groupId>
+    <artifactId>wisdom-data</artifactId>
+    <version>1.0.0</version>
 
-    <name>iot-platform</name>
-    <url>http://www.ruoyi.vip</url>
+    <name>wisdom-data</name>
     <description>IoT储能运营平台</description>
 
     <properties>
-        <ruoyi.version>3.9.0</ruoyi.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>