<!-- IoTDB JDBC驅(qū)動(dòng) -->
<dependency>
         <groupId>org.apache.iotdb</groupId>
         <artifactId>iotdb-jdbc</artifactId>
         <version>1.2.0</version>
</dependency>
<!-- Spring Boot JDBC starter（可選，用于簡(jiǎn)化JDBC操作） -->
<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- 連接池（推薦HikariCP，Spring Boot默認(rèn)集成） -->
<dependency>
         <groupId>com.zaxxer</groupId>
         <artifactId>HikariCP</artifactId>
         <version>5.0.1</version>
</dependency>

<!-- MyBatis整合Spring Boot -->
<dependency>
         <groupId>org.mybatis.spring.boot</groupId>
         <artifactId>mybatis-spring-boot-starter</artifactId>
         <version>2.3.1</version>
</dependency>
<!-- 分頁(yè)插件（可選） -->
<dependency>
         <groupId>com.github.pagehelper</groupId>
         <artifactId>pagehelper-spring-boot-starter</artifactId>
         <version>1.4.6</version>
</dependency>

spring:
       datasource:
         # IoTDB JDBC URL格式：jdbc:iotdb://<host>:<port>/\[?<params>]
         url: jdbc:iotdb://localhost:6667/?enableAutoCreateSchema=true\&timeZone=UTC+8
         username: root  # 默認(rèn)用戶名
         password: root  # 默認(rèn)密碼
         driver-class-name: org.apache.iotdb.jdbc.IoTDBDriver
         # HikariCP連接池配置
         hikari:
           maximum-pool-size: 10  # 最大連接數(shù)（根據(jù)業(yè)務(wù)調(diào)整）
           minimum-idle: 2        # 最小空閑連接數(shù)
           idle-timeout: 300000   # 空閑連接超時(shí)時(shí)間（5分鐘）
           connection-timeout: 30000  # 連接超時(shí)時(shí)間（30秒）
           max-lifetime: 1800000  # 連接最大生命周期（30分鐘）

import org.apache.iotdb.jdbc.IoTDBDriver;
import java.sql.*;
@Service
public class IoTDBNativeService {
         // IoTDB連接信息
         private static final String URL = "jdbc:iotdb://localhost:6667/";
         private static final String USER = "root";
         private static final String PASSWORD = "root";
         // 寫(xiě)入時(shí)序數(shù)據(jù)（單條）
         public void insertSingleData() throws SQLException {
             try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
                  PreparedStatement pstmt = conn.prepareStatement(
                      "INSERT INTO root.sensor.demo(timestamp, temperature, humidity) VALUES(?, ?, ?)")) {
                 // 設(shè)置參數(shù)：時(shí)間戳（毫秒級(jí)）、溫度、濕度
                 pstmt.setLong(1, System.currentTimeMillis());
                 pstmt.setFloat(2, 25.6f);
                 pstmt.setInt(3, 60);
                 pstmt.executeUpdate();
                 System.out.println("數(shù)據(jù)寫(xiě)入成功");
             }
         }
         // 查詢時(shí)序數(shù)據(jù)（時(shí)間范圍）
         public void queryDataByTimeRange() throws SQLException {
             String sql = "SELECT temperature, humidity " +
                          "FROM root.sensor.demo " +
                          "WHERE time >= ? AND time <= ?";
             try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
                  PreparedStatement pstmt = conn.prepareStatement(sql)) {
                 // 設(shè)置查詢時(shí)間范圍（1小時(shí)內(nèi)數(shù)據(jù)）
                 long endTime = System.currentTimeMillis();
                 long startTime = endTime - 3600 * 1000;
                 pstmt.setLong(1, startTime);
                 pstmt.setLong(2, endTime);
                 // 處理查詢結(jié)果
                 try (ResultSet rs = pstmt.executeQuery()) {
                     while (rs.next()) {
                         System.out.printf("時(shí)間戳：%d, 溫度：%f, 濕度：%d%n",
                             rs.getLong("time"),  // IoTDB默認(rèn)時(shí)間列名為"time"
                             rs.getFloat("temperature"),
                             rs.getInt("humidity"));
                     }
                 }
             }
         }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
@Service
public class IoTDBJdbcTemplateService {
         @Autowired
         private JdbcTemplate jdbcTemplate;
         // 批量寫(xiě)入數(shù)據(jù)（高效）
         public void batchInsertData(List<Object\[]> dataList) {
             String sql = "INSERT INTO root.sensor.demo(timestamp, temperature, humidity) VALUES(?, ?, ?)";
             // 批量執(zhí)行（推薦一次批量1000-5000條，平衡性能與內(nèi)存）
             jdbcTemplate.batchUpdate(sql, dataList);
             System.out.printf("批量寫(xiě)入成功，共%d條數(shù)據(jù)", dataList.size());
         }
         // 分頁(yè)查詢數(shù)據(jù)
         public List<Map<String, Object>> queryDataWithPage(long startTime, long endTime, int pageNum, int pageSize) {
             // IoTDB分頁(yè)通過(guò)LIMIT和OFFSET實(shí)現(xiàn)
             String sql = String.format(
                 "SELECT time, temperature, humidity " +
                 "FROM root.sensor.demo " +
                 "WHERE time >= ? AND time <= ? " +
                 "ORDER BY time DESC " +
                 "LIMIT %d OFFSET %d",
                 pageSize, (pageNum - 1) * pageSize
             );
             return jdbcTemplate.queryForList(sql, startTime, endTime);
         }
         // 創(chuàng)建時(shí)間序列（手動(dòng)模式，enableAutoCreateSchema=false時(shí)需調(diào)用）
         public void createTimeSeries() {
             String sql = "CREATE TIMESERIES root.sensor.demo.temperature " +
                          "WITH DATATYPE=FLOAT, ENCODING=RLE, COMPRESSOR=SNAPPY; " +
                          "CREATE TIMESERIES root.sensor.demo.humidity " +
                          "WITH DATATYPE=INT32, ENCODING=PLAIN, COMPRESSOR=SNAPPY";
             jdbcTemplate.execute(sql);
             System.out.println("時(shí)間序列創(chuàng)建成功");
         }
}

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
@Mapper
public interface IoTDBMapper {
         // 插入單條數(shù)據(jù)
         void insertData(@Param("timestamp") long timestamp,
                         @Param("temperature") float temperature,
                         @Param("humidity") int humidity);
         // 時(shí)間范圍查詢（帶參數(shù)）
         List<Map<String, Object>> queryByTimeRange(@Param("startTime") long startTime,
                                                    @Param("endTime") long endTime);
         // 分頁(yè)查詢（使用PageHelper插件）
         List<Map<String, Object>> queryWithPage(@Param("startTime") long startTime,
                                                 @Param("endTime") long endTime);
}

<?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.iotdb.mapper.IoTDBMapper">
         <!-- 插入數(shù)據(jù) -->
         <insert id="insertData">
             INSERT INTO root.sensor.demo(timestamp, temperature, humidity)
             VALUES(#{timestamp}, #{temperature}, #{humidity})
         </insert>
         <!-- 時(shí)間范圍查詢 -->
         <select id="queryByTimeRange" resultType="java.util.Map">
             SELECT time, temperature, humidity
             FROM root.sensor.demo
             WHERE time >= #{startTime} AND time <= #{endTime}
             ORDER BY time ASC
         </select>
         <!-- 分頁(yè)查詢（PageHelper自動(dòng)攔截添加LIMIT） -->
         <select id="queryWithPage" resultType="java.util.Map">
             SELECT time, temperature, humidity
             FROM root.sensor.demo
             WHERE time >= #{startTime} AND time <= #{endTime}
             ORDER BY time DESC
         </select>
</mapper>

import com.example.iotdb.mapper.IoTDBMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
@Service
public class IoTDBMyBatisService {
         @Autowired
         private IoTDBMapper ioTDBMapper;
         // 分頁(yè)查詢（使用PageHelper）
         public List<Map<String, Object>> queryWithPageHelper(long startTime, long endTime, int pageNum, int pageSize) {
             // 開(kāi)啟分頁(yè)（PageHelper會(huì)自動(dòng)對(duì)下一次查詢生效）
             PageHelper.startPage(pageNum, pageSize);
             return ioTDBMapper.queryWithPage(startTime, endTime);
         }
}

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
</dependency>

management:
       endpoints:
         web:
           exposure:
             include: hikaricp,health,info  # 暴露HikariCP監(jiān)控端點(diǎn)
       endpoint:
         hikaricp:
           enabled: true  # 啟用HikariCP監(jiān)控

# IoTDB服務(wù)端配置（iotdb-engine.properties）
storage_group_partition_strategy=MONTH  # 存儲(chǔ)組按月份分區(qū)
time_partition_interval=86400000        # 時(shí)間分區(qū)間隔（1天，單位：毫秒）
compressor=SNAPPY                       # 全局壓縮算法（SNAPPY/LZ4）

<dependency>
         <groupId>org.springframework.retry</groupId>
         <artifactId>spring-retry</artifactId>
         <version>1.3.4</version>
</dependency>
<dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.9.19</version>
</dependency>

import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
import java.sql.SQLException;
@Service
public class IoTDBRetryService {
         // 連接失敗時(shí)重試3次，間隔1秒
         @Retryable(value = SQLException.class, maxAttempts = 3, backoff = @Backoff(delay = 1000))
         public void insertWithRetry(long timestamp, float temperature, int humidity) throws SQLException {
             // 數(shù)據(jù)插入邏輯（同4.1/4.2）
         }
}

import org.apache.iotdb.session.Session;
import org.apache.iotdb.tsfile.write.record.Tablet;
import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
public class IoTDBSessionService {
         private Session session;
         // 初始化Session連接
         public void initSession() throws Exception {
             session = new Session("localhost", 6667, "root", "root");
             session.open();
             // 設(shè)置批量寫(xiě)入?yún)?shù)
             session.setBatchSize(5000);
             session.setFetchSize(5000);
}
	 // 批量寫(xiě)入數(shù)據(jù)（Session API 核心優(yōu)勢(shì)：低開(kāi)銷、高吞吐量）
public void batchInsertWithSession (List timestamps, List temperatures, List humidities) throws Exception {
	 // 1. 定義時(shí)間序列路徑（格式：root. 存儲(chǔ)組。設(shè)備。測(cè)量值）
	 String deviceId = "root.sensor.demo";
	 // 2. 定義測(cè)量值 schema（數(shù)據(jù)類型、編碼方式）
	 List measurements = new ArrayList<>();
	 List schemas = new ArrayList<>();
	 // 添加溫度測(cè)量值（FLOAT 類型，RLE 編碼適合連續(xù)數(shù)值）
	 measurements.add ("temperature");
	 schemas.add (new MeasurementSchema ("temperature", TSDataType.FLOAT, TSEncoding.RLE));
	 // 添加濕度測(cè)量值（INT32 類型，PLAIN 編碼適合離散數(shù)值）
	 measurements.add ("humidity");
	 schemas.add (new MeasurementSchema ("humidity", TSDataType.INT32, TSEncoding.PLAIN));
	 // 3. 創(chuàng)建 Tablet（IoTDB 批量數(shù)據(jù)載體，比 JDBC Batch 更高效）
	 Tablet tablet = new Tablet (deviceId, schemas, timestamps.size ());
	 // 4. 填充數(shù)據(jù)（按列填充，減少 IO 開(kāi)銷）
	 int row = 0;
	 for (Long timestamp : timestamps) {
	 // 設(shè)置時(shí)間戳
	 tablet.addTimestamp (row, timestamp);
	 // 設(shè)置溫度值（第 0 列）
	 tablet.addValue (measurements.get (0), row, temperatures.get (row));
	 // 設(shè)置濕度值（第 1 列）
	 tablet.addValue (measurements.get (1), row, humidities.get (row));
	 row++;
	 }
	 // 5. 執(zhí)行批量寫(xiě)入（Session 會(huì)自動(dòng)處理連接復(fù)用和數(shù)據(jù)分片）
	 session.insertTablet (tablet);
	 System.out.printf ("Session API 批量寫(xiě)入成功，共 % d 條數(shù)據(jù)", timestamps.size ());
	 }
	 // 時(shí)間范圍查詢（Session API 支持更靈活的結(jié)果格式）
	 public List<Map<String, Object>> queryWithSession (long startTime, long endTime) throws Exception {
	 List<Map<String, Object>> resultList = new ArrayList<>();
	 // 1. 定義查詢參數(shù)
	 String deviceId = "root.sensor.demo";
	 List measurements = Arrays.asList ("temperature", "humidity");
	 // 2. 執(zhí)行查詢（返回 ResultSet，支持流式處理）
	 try (SessionDataSet resultSet = session.executeQuery (deviceId, measurements, startTime, endTime)) {
	 // 3. 解析查詢結(jié)果
	 while (resultSet.hasNext ()) {
	      Map<String, Object> dataMap = new HashMap<>();
	      // 獲取時(shí)間戳
	      dataMap.put ("timestamp", resultSet.nextTimestamp ());
	      // 獲取測(cè)量值（按順序匹配 measurements 列表）
	      dataMap.put ("temperature", resultSet.nextFloat ());
	      dataMap.put ("humidity", resultSet.nextInt ());
	      resultList.add (dataMap);
	   }
	}
	 return resultList;
}
// 關(guān)閉 Session 連接（建議在服務(wù)銷毀時(shí)調(diào)用）
@PreDestroy
public void closeSession () throws Exception {
	 if (session != null && session.isOpen ()) {
	   session.close ();
	   System.out.println ("Session 連接已關(guān)閉");
	 }
   }
}

### 7.1 Session API 與 JDBC 對(duì)比
| 特性                | Session API                          | JDBC                          |
|---------------------|--------------------------------------|-------------------------------|
| 性能                | 高（直接基于RPC，無(wú)JDBC協(xié)議開(kāi)銷）    | 中（需適配JDBC規(guī)范，額外開(kāi)銷）|
| 批量寫(xiě)入效率        | 極高（Tablet載體，按列存儲(chǔ)）         | 中等（Statement Batch，按行處理）|
| 功能完整性          | 專注時(shí)序數(shù)據(jù)操作（寫(xiě)入、查詢、刪除） | 支持標(biāo)準(zhǔn)SQL操作（DDL、DML）   |
| 易用性              | 需熟悉IoTDB特有API                   | 通用SQL語(yǔ)法，學(xué)習(xí)成本低       |
| 適用場(chǎng)景            | 高并發(fā)寫(xiě)入（如設(shè)備實(shí)時(shí)上報(bào)數(shù)據(jù)）     | 復(fù)雜查詢、多數(shù)據(jù)源兼容場(chǎng)景    |
## 八、項(xiàng)目實(shí)戰(zhàn)：完整業(yè)務(wù)流程示例
以“溫濕度傳感器數(shù)據(jù)采集”為例，整合上述技術(shù)實(shí)現(xiàn)端到端業(yè)務(wù)邏輯。
### 8.1 實(shí)體類定義（封裝傳感器數(shù)據(jù)）
\`\`\`java
public class SensorData {
         // 設(shè)備ID
         private String deviceId;
         // 采集時(shí)間戳（毫秒級(jí)）
         private long timestamp;
         // 溫度（℃）
         private float temperature;
         // 濕度（%RH）
         private int humidity;
         // 省略getter/setter/構(gòu)造方法
}

@Service
public class SensorDataService {
         @Autowired
         private IoTDBSessionService sessionService;
         // 初始化Session（項(xiàng)目啟動(dòng)時(shí)執(zhí)行）
         @PostConstruct
         public void init() {
             try {
                 sessionService.initSession();
             } catch (Exception e) {
                 throw new RuntimeException("Session初始化失敗", e);
             }
         }
         // 接收傳感器數(shù)據(jù)并批量寫(xiě)入（支持重試）
         @Retryable(value = {Exception.class}, maxAttempts = 3, backoff = @Backoff(delay = 2000))
         public void batchSaveSensorData(List<SensorData> dataList) throws Exception {
             // 1. 數(shù)據(jù)預(yù)處理：按設(shè)備分組（Session API按設(shè)備寫(xiě)入更高效）
             Map<String, List<SensorData>> dataGroupByDevice = dataList.stream()
                     .collect(Collectors.groupingBy(SensorData::getDeviceId));
             // 2. 按設(shè)備批量寫(xiě)入
             for (Map.Entry<String, List<SensorData>> entry : dataGroupByDevice.entrySet()) {
                 String deviceId = entry.getKey();
                 List<SensorData> deviceDataList = entry.getValue();
                 // 3. 轉(zhuǎn)換為Session API所需格式
                 List<Long> timestamps = deviceDataList.stream().map(SensorData::getTimestamp).collect(Collectors.toList());
                 List<Float> temperatures = deviceDataList.stream().map(SensorData::getTemperature).collect(Collectors.toList());
                 List<Integer> humidities = deviceDataList.stream().map(SensorData::getHumidity).collect(Collectors.toList());
                 // 4. 調(diào)用Session API寫(xiě)入
                 sessionService.batchInsertWithSession(timestamps, temperatures, humidities);
             }
         }
         // 查詢指定設(shè)備的歷史數(shù)據(jù)（帶分頁(yè)）
         public PageInfo<SensorData> querySensorData(String deviceId, long startTime, long endTime, int pageNum, int pageSize) throws Exception {
             // 1. 調(diào)用Session API查詢?cè)紨?shù)據(jù)
             List<Map<String, Object>> rawDataList = sessionService.queryWithSession(startTime, endTime);
             // 2. 數(shù)據(jù)轉(zhuǎn)換與分頁(yè)（手動(dòng)分頁(yè)，避免內(nèi)存溢出）
             List<SensorData> sensorDataList = rawDataList.stream()
                     .map(map -> new SensorData(
                             deviceId,
                             (Long) map.get("timestamp"),
                             (Float) map.get("temperature"),
                             (Integer) map.get("humidity")
                     )).collect(Collectors.toList());
             // 3. 分頁(yè)處理（使用PageHelper工具類）
             PageHelper.startPage(pageNum, pageSize);
             Page<SensorData> page = new Page<>(sensorDataList);
             return new PageInfo<>(page);
         }
         // 重試失敗回調(diào)
         @Recover
         public void recover(Exception e) {
             System.err.println("數(shù)據(jù)寫(xiě)入重試失敗：" + e.getMessage());
             // 此處可添加告警邏輯（如發(fā)送郵件、短信通知運(yùn)維人員）
         }
}

@RestController
@RequestMapping("/api/sensor")
public class SensorDataController {
         @Autowired
         private SensorDataService sensorDataService;
         // 批量接收傳感器數(shù)據(jù)（POST請(qǐng)求）
         @PostMapping("/data/batch")
         public ResponseEntity<String> batchSave(@RequestBody List<SensorData> dataList) {
             try {
                 sensorDataService.batchSaveSensorData(dataList);
                 return ResponseEntity.ok("數(shù)據(jù)接收成功，共" + dataList.size() + "條");
             } catch (Exception e) {
                 return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                         .body("數(shù)據(jù)處理失?。? + e.getMessage());
             }
         }
         // 查詢歷史數(shù)據(jù)（GET請(qǐng)求）
         @GetMapping("/data/history")
         public ResponseEntity<PageInfo<SensorData>> queryHistory(
                 @RequestParam String deviceId,
                 @RequestParam long startTime,
                 @RequestParam long endTime,
                 @RequestParam(defaultValue = "1") int pageNum,
                 @RequestParam(defaultValue = "20") int pageSize) {
             try {
                 PageInfo<SensorData> pageInfo = sensorDataService.querySensorData(
                         deviceId, startTime, endTime, pageNum, pageSize);
                 return ResponseEntity.ok(pageInfo);
             } catch (Exception e) {
                 return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                         .body(null);
             }
         }
}

# 堆內(nèi)存大小（根據(jù)實(shí)際情況調(diào)整）
jvm_options=-Xms8g -Xmx8g
# 緩存大?。ㄌ嵘樵冃阅埽?
query_cache_size=1024MB
chunk_cache_size=2048MB

# 刷盤(pán)策略（周期性刷盤(pán)，單位：毫秒）
flush_interval=30000
# 內(nèi)存塊大小（越大寫(xiě)入效率越高，建議16MB-64MB）
page_size=32MB

# 時(shí)間分區(qū)策略（MONTH/DAY/HOUR，高頻數(shù)據(jù)建議按小時(shí)分區(qū)）
storage_group_partition_strategy=DAY
time_partition_interval=86400000

spring:
       datasource:
         hikari:
           maximum-pool-size: 20  # 高頻寫(xiě)入場(chǎng)景可適當(dāng)增大
           connection-timeout: 5000  # 縮短連接超時(shí)時(shí)間，快速失敗
           idle-timeout: 600000  # 空閑連接超時(shí)10分鐘，減少資源占用