refactor(service): 全面优化 TdEngineService 资源管理与代码质量

- 资源管理：loadStableColumnsFromDB / ensureColumnsExist / ensureTableExists
  统一改为 try-with-resources，消除手动 close 的冗长代码
- 缓存策略：getStableColumns 使用 computeIfAbsent 解决多线程竞态条件；
  缓存满时改为淘汰最老的 20% 条目，替代粗暴 clear()
- 列数计算：insertBatchInternal 中扣除 existingColumns 与 columnTypes 的交集，
  避免重复计算导致不必要的插入拒绝
- 缓存更新：ensureColumnsExist 循环结束后统一更新 stableColumnCache
- 连接池配置：IotProperties.TDengine 新增 HikariCP 配置项，initDataSource 改为读取配置
- 日志级别：loadStableColumnsFromDB 表不存在场景 error→debug；
  formatValue 超长截断 info→debug
- ZoneOffset.of("+8") 提取为 static final ZONE_OFFSET_8，避免重复创建

iot-platform/src/main/java/com/iot/platform/config/IotProperties.java

         private String username = "";
         private String password = "";
 
+        // HikariCP 连接池配置（默认值与之前硬编码保持一致）
+        private int maximumPoolSize = 20;
+        private int minimumIdle = 5;
+        private long connectionTimeout = 10000;
+        private long idleTimeout = 30000;
+        private long maxLifetime = 600000;
+        private long leakDetectionThreshold = 0;
+        private long validationTimeout = 3000;
+        private String connectionTestQuery = "SELECT NOW()";
+
         public String getUrl() {
             return url;
         }
         public void setPassword(String password) {
             this.password = password;
         }
+
+        public int getMaximumPoolSize() {
+            return maximumPoolSize;
+        }
+
+        public void setMaximumPoolSize(int maximumPoolSize) {
+            this.maximumPoolSize = maximumPoolSize;
+        }
+
+        public int getMinimumIdle() {
+            return minimumIdle;
+        }
+
+        public void setMinimumIdle(int minimumIdle) {
+            this.minimumIdle = minimumIdle;
+        }
+
+        public long getConnectionTimeout() {
+            return connectionTimeout;
+        }
+
+        public void setConnectionTimeout(long connectionTimeout) {
+            this.connectionTimeout = connectionTimeout;
+        }
+
+        public long getIdleTimeout() {
+            return idleTimeout;
+        }
+
+        public void setIdleTimeout(long idleTimeout) {
+            this.idleTimeout = idleTimeout;
+        }
+
+        public long getMaxLifetime() {
+            return maxLifetime;
+        }
+
+        public void setMaxLifetime(long maxLifetime) {
+            this.maxLifetime = maxLifetime;
+        }
+
+        public long getLeakDetectionThreshold() {
+            return leakDetectionThreshold;
+        }
+
+        public void setLeakDetectionThreshold(long leakDetectionThreshold) {
+            this.leakDetectionThreshold = leakDetectionThreshold;
+        }
+
+        public long getValidationTimeout() {
+            return validationTimeout;
+        }
+
+        public void setValidationTimeout(long validationTimeout) {
+            this.validationTimeout = validationTimeout;
+        }
+
+        public String getConnectionTestQuery() {
+            return connectionTestQuery;
+        }
+
+        public void setConnectionTestQuery(String connectionTestQuery) {
+            this.connectionTestQuery = connectionTestQuery;
+        }
     }
 }

iot-platform/src/main/java/com/iot/platform/mqtt/MqttChargeStationConsumer.java

 
     @Override
     protected void processMessage(String content, String topic) throws Exception {
-        List<Map<String, Object>> messageList = JSON.parseObject(content, new TypeReference<List<Map<String, Object>>>() {});
+        List<Map<String, Object>> messageList = JSON.parseObject(
+                content, new TypeReference<List<Map<String, Object>>>() {});
         processMessageAndWriteToTdEngine(messageList, topic);
     }
 
-    private void processMessageAndWriteToTdEngine(List<Map<String, Object>> dataList, String topic) throws Exception {
+    private void processMessageAndWriteToTdEngine(List<Map<String, Object>> dataList, String topic)
+            throws Exception {
+
         if (dataList == null || dataList.isEmpty()) {
             return;
         }

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

 import org.springframework.stereotype.Service;
 
 import java.sql.*;
+import java.time.ZoneOffset;
 import java.util.*;
 import java.util.concurrent.*;
 
     // 默认 VARCHAR 字段长度限制
     private static final int DEFAULT_VARCHAR_LENGTH = 38;
 
+    // 东八区时区偏移（避免重复创建）
+    private static final ZoneOffset ZONE_OFFSET_8 = ZoneOffset.of("+8");
+
     private synchronized void initDataSource() {
         if (dataSourceInitialized) {
             return;
         }
         try {
+            IotProperties.TDengine tdCfg = iotProperties.getTdengine();
             HikariConfig config = new HikariConfig();
-            config.setJdbcUrl(iotProperties.getTdengine().getUrl());
-            config.setUsername(iotProperties.getTdengine().getUsername());
-            config.setPassword(iotProperties.getTdengine().getPassword());
+            config.setJdbcUrl(tdCfg.getUrl());
+            config.setUsername(tdCfg.getUsername());
+            config.setPassword(tdCfg.getPassword());
             config.setDriverClassName("com.taosdata.jdbc.TSDBDriver");
-            config.setMaximumPoolSize(20);
-            config.setMinimumIdle(5);
-            config.setConnectionTimeout(10000);
-            config.setIdleTimeout(30000);
-            config.setMaxLifetime(600000);
-            config.setLeakDetectionThreshold(0);
-            config.setConnectionTestQuery("SELECT NOW()");
-            config.setValidationTimeout(3000);
+            config.setMaximumPoolSize(tdCfg.getMaximumPoolSize());
+            config.setMinimumIdle(tdCfg.getMinimumIdle());
+            config.setConnectionTimeout(tdCfg.getConnectionTimeout());
+            config.setIdleTimeout(tdCfg.getIdleTimeout());
+            config.setMaxLifetime(tdCfg.getMaxLifetime());
+            config.setLeakDetectionThreshold(tdCfg.getLeakDetectionThreshold());
+            config.setConnectionTestQuery(tdCfg.getConnectionTestQuery());
+            config.setValidationTimeout(tdCfg.getValidationTimeout());
             this.dataSource = new HikariDataSource(config);
             log.info("TdEngine 连接池初始化完成");
         } catch (Exception e) {
             return cached;
         }
 
-        Set<String> columns = loadStableColumnsFromDB(dbName, stableName);
-        if (stableColumnCache.size() >= MAX_CACHE_SIZE) {
-            stableColumnCache.clear();
-            log.warn("TdEngine 超级表缓存已达上限({})，已清空", MAX_CACHE_SIZE);
-        }
-        stableColumnCache.put(key, columns);
-        return columns;
+        // 使用 computeIfAbsent 保证原子性，避免多线程重复加载
+        return stableColumnCache.computeIfAbsent(key, k -> {
+            Set<String> columns = loadStableColumnsFromDB(dbName, stableName);
+            // 缓存满时淘汰最老的 20% 条目
+            if (stableColumnCache.size() >= MAX_CACHE_SIZE) {
+                int toRemove = Math.max(1, MAX_CACHE_SIZE / 5);
+                Iterator<String> it = stableColumnCache.keySet().iterator();
+                for (int i = 0; i < toRemove && it.hasNext(); i++) {
+                    it.next();
+                    it.remove();
+                }
+                log.warn("TdEngine 超级表缓存已达上限({})，已淘汰 {} 个条目", MAX_CACHE_SIZE, toRemove);
+            }
+            return columns;
+        });
     }
 
     private Set<String> loadStableColumnsFromDB(String dbName, String stableName) {
         Set<String> columns = new HashSet<>();
         String sql = String.format("DESCRIBE %s.%s", wrapName(dbName), wrapName(stableName));
-        Connection conn = null;
-        Statement stmt = null;
-        ResultSet rs = null;
-
-        try {
-            conn = getConnection();
-            stmt = conn.createStatement();
+        try (Connection conn = getConnection();
+             Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery(sql)) {
             stmt.setQueryTimeout(5);
-            rs = stmt.executeQuery(sql);
             while (rs.next()) {
                 columns.add(rs.getString(1));
             }
         } catch (SQLException e) {
             if (!e.getMessage().contains("Table does not exist") && !e.getMessage().contains("invalid name")) {
-                log.error("查询超级表列失败: {}.{} | {}", dbName, stableName, e.getMessage());
-            }
-        } finally {
-            if (rs != null) {
-                try {
-                    rs.close();
-                } catch (SQLException e) {
-                    log.debug("关闭 ResultSet 时发生异常: {}", e.getMessage());
-                }
+                log.debug("查询超级表列失败: {}.{} | {}", dbName, stableName, e.getMessage());
             }
-            if (stmt != null) {
-                try {
-                    stmt.close();
-                } catch (SQLException e) {
-                    log.debug("关闭 Statement 时发生异常: {}", e.getMessage());
-                }
-            }
-            closeConnection(conn);
         }
         return columns;
     }
         }
 
         Set<String> existingColumns = getStableColumns(dbName, superTableName);
-        int totalColumns = existingColumns.size() + columnTypes.size();
+        // 计算实际新增列数（扣除已有列的交集）
+        int newColumns = 0;
+        for (String col : columnTypes.keySet()) {
+            if (!existingColumns.contains(col)) {
+                newColumns++;
+            }
+        }
+        int totalColumns = existingColumns.size() + newColumns;
         if (totalColumns > MAX_COLUMNS_PER_STABLE) {
             log.error("超级表总列数({})超过限制({})，跳过本次插入 | 表: {}.{}",
                     totalColumns, MAX_COLUMNS_PER_STABLE, dbName, table);
             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) {
+        if (value instanceof java.util.Date || value instanceof java.time.LocalDateTime
+                || value instanceof java.time.Instant) {
             return "TIMESTAMP";
         }
         return "VARCHAR";
             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());
+                return String.valueOf(((java.time.LocalDateTime) value)
+                        .toInstant(ZONE_OFFSET_8).toEpochMilli());
             }
             if (value instanceof java.time.Instant) {
                 return String.valueOf(((java.time.Instant) value).toEpochMilli());
             }
         }
         if (strValue.length() > maxLen) {
-            log.info("字段值超长，截断存储 | 列: {} | 值长度: {} | 最大: {} | 截断后: {}...",
+            log.debug("字段值超长，截断存储 | 列: {} | 值长度: {} | 最大: {} | 截断后: {}...",
                     columnName, strValue.length(), maxLen, strValue.substring(0, maxLen));
             strValue = strValue.substring(0, maxLen);
         }
             return;
         }
 
-        Connection conn = null;
-        Statement stmt = null;
-        try {
-            conn = getConnection();
-            stmt = conn.createStatement();
+        try (Connection conn = getConnection(); Statement stmt = conn.createStatement()) {
             stmt.setQueryTimeout(10);
 
             for (Map.Entry<String, String> entry : columnTypes.entrySet()) {
                             throw e;
                         }
                     }
-
-                    // 更新缓存
-                    String key = getStableKey(dbName, superTableName);
-                    stableColumnCache.put(key, existingColumns);
-                }
-            }
-        } finally {
-            if (stmt != null) {
-                try {
-                    stmt.close();
-                } catch (SQLException e) {
-                    log.debug("关闭 Statement 时发生异常: {}", e.getMessage());
                 }
             }
-            closeConnection(conn);
+
+            // 循环结束后统一更新缓存
+            String key = getStableKey(dbName, superTableName);
+            stableColumnCache.put(key, existingColumns);
         }
     }
 
                     + ", superTableName=" + superTableName + ", table=" + table);
         }
 
-        Connection conn = null;
-        PreparedStatement pstmt = null;
-        Statement stmt = null;
-        ResultSet rs = null;
-        try {
-            conn = getConnection();
-
+        try (Connection conn = getConnection()) {
             // 检查超级表是否存在 — 使用 PreparedStatement 防止 SQL 注入
             String checkStableSql = "SELECT * FROM information_schema.ins_tables WHERE table_name = ? AND db_name = ?";
-            pstmt = conn.prepareStatement(checkStableSql);
-            pstmt.setString(1, superTableName);
-            pstmt.setString(2, dbName);
-            pstmt.setQueryTimeout(5);
-            rs = pstmt.executeQuery();
-            boolean stableExists = rs.next();
-
-            if (!stableExists) {
-                closeQuietly(rs, pstmt);
-                rs = null;
-                pstmt = null;
-                log.info("超级表不存在，创建: {}.{}", dbName, superTableName);
-                initTableStructure(dbName, superTableName, table);
-                return;
+            try (PreparedStatement pstmt = conn.prepareStatement(checkStableSql)) {
+                pstmt.setString(1, superTableName);
+                pstmt.setString(2, dbName);
+                pstmt.setQueryTimeout(5);
+                try (ResultSet rs = pstmt.executeQuery()) {
+                    if (!rs.next()) {
+                        log.info("超级表不存在，创建: {}.{}", dbName, superTableName);
+                        initTableStructure(dbName, superTableName, table);
+                        return;
+                    }
+                }
             }
 
-            closeQuietly(rs, pstmt);
-            rs = null;
-            pstmt = null;
-
             // 检查子表是否存在 — 使用 PreparedStatement 防止 SQL 注入
-            String checkTableSql = "SELECT * FROM information_schema.ins_tables WHERE table_name = ? AND db_name = ? AND table_type = 'CHILD_TABLE'";
-            pstmt = conn.prepareStatement(checkTableSql);
-            pstmt.setString(1, table);
-            pstmt.setString(2, dbName);
-            pstmt.setQueryTimeout(5);
-            rs = pstmt.executeQuery();
-            boolean tableExists = rs.next();
-
-            if (!tableExists) {
-                String tableSql = String.format(
-                        "CREATE TABLE IF NOT EXISTS %s.%s USING %s.%s TAGS ('%s')",
-                        wrapName(dbName),
-                        wrapName(table),
-                        wrapName(dbName),
-                        wrapName(superTableName),
-                        escapeValue(superTableName)
-                );
-                stmt = conn.createStatement();
-                stmt.setQueryTimeout(5);
-                stmt.executeUpdate(tableSql);
-                log.info("子表创建成功: {}", table);
+            String checkTableSql = "SELECT * FROM information_schema.ins_tables " +
+                    "WHERE table_name = ? AND db_name = ? AND table_type = 'CHILD_TABLE'";
+            try (PreparedStatement pstmt = conn.prepareStatement(checkTableSql)) {
+                pstmt.setString(1, table);
+                pstmt.setString(2, dbName);
+                pstmt.setQueryTimeout(5);
+                try (ResultSet rs = pstmt.executeQuery()) {
+                    if (!rs.next()) {
+                        String tableSql = String.format(
+                                "CREATE TABLE IF NOT EXISTS %s.%s USING %s.%s TAGS ('%s')",
+                                wrapName(dbName),
+                                wrapName(table),
+                                wrapName(dbName),
+                                wrapName(superTableName),
+                                escapeValue(superTableName)
+                        );
+                        try (Statement stmt = conn.createStatement()) {
+                            stmt.setQueryTimeout(5);
+                            stmt.executeUpdate(tableSql);
+                            log.info("子表创建成功: {}", table);
+                        }
+                    }
+                }
             }
         } catch (SQLException e) {
             throw new SQLException("检查表存在性失败: " + dbName + "." + table + " | " + e.getMessage(), e);
-        } finally {
-            closeQuietly(rs, pstmt, stmt);
-            closeConnection(conn);
         }
     }