KeyTableFile.java 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330
  1. package com.acquisition.config;
  2. import org.springframework.stereotype.Service;
  3. import java.io.File;
  4. import java.sql.*;
  5. import java.text.SimpleDateFormat;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8. @Service
  9. public class KeyTableFile {
  10. // 生成keytable.sqlite3文件
  11. public void generateKeyTableFile(String dataFolderPath, List<List<Object>> configExcelData, int startCol, int endCol, int dbName) throws Exception {
  12. // 提取指定列范围的数据
  13. List<List<Object>> dataToWrite = new ArrayList<>();
  14. // 从configExcelData中获取第startCol到endCol列的数据
  15. for (List<Object> row : configExcelData) {
  16. // 只取指定范围的列
  17. List<Object> rowData = row.subList(startCol, endCol + 1); // 提取列范围的数据
  18. dataToWrite.add(rowData);
  19. }
  20. // 根据提取的数据生成sqlite3文件
  21. String keytableDir = dataFolderPath + "\\keytable";
  22. File directory = new File(keytableDir);
  23. if (directory.exists() && directory.isDirectory()) {
  24. File[] files = directory.listFiles();
  25. if (files != null) {
  26. for (File file : files) {
  27. if (file.isFile()) {
  28. file.delete();
  29. }
  30. }
  31. }
  32. }
  33. File keytableDirFile = new File(keytableDir);
  34. if (!keytableDirFile.exists()) {
  35. keytableDirFile.mkdir(); // 创建 keytable 目录
  36. }
  37. String sqliteFilePath = null;
  38. if (dbName == 1) {
  39. sqliteFilePath = keytableDir + "\\keytable.sqlite3";
  40. } else if (dbName == 2) {
  41. sqliteFilePath = keytableDir + "\\gddlly.db";
  42. }
  43. // 写入SQLite数据库
  44. writeToSQLite(dataToWrite, sqliteFilePath, dbName);
  45. }
  46. // 写入SQLite数据库
  47. // /**
  48. // * 读取配置Excel文件并返回数据列表
  49. // *所有字段数据类型为整数
  50. // * @return 数据列表
  51. // * @throws Exception 读取文件时发生的异常
  52. // */
  53. // private void writeToSQLite(List<List<String>> data, String sqliteFilePath) {
  54. // try (Connection conn = DriverManager.getConnection("jdbc:sqlite:" + sqliteFilePath)) {
  55. // // 获取列名(假设第一行是列名)
  56. // List<String> columnNames = data.get(0); // 第一行作为列名
  57. //
  58. // // 创建表格
  59. // String createTableSQL = "CREATE TABLE IF NOT EXISTS key_table (";
  60. //
  61. // // 检查每列的数据类型
  62. // for (int i = 0; i < columnNames.size(); i++) {
  63. // String columnType = "TEXT"; // 默认列类型为 TEXT
  64. //
  65. // // 遍历当前列的所有数据来检查是否包含数字
  66. // for (int rowIdx = 1; rowIdx < data.size(); rowIdx++) { // 从第二行开始检查数据
  67. // String cellValue = data.get(rowIdx).get(i).trim();
  68. // // 如果列中任何数据是数字,将列的数据类型设置为 INTEGER
  69. // if (cellValue.matches("-?\\d+(\\.\\d+)?")) { // 允许整数或浮动数字
  70. // columnType = "INTEGER";
  71. // break;
  72. // }
  73. // }
  74. //
  75. // createTableSQL += columnNames.get(i) + " " + columnType; // 使用原始列名和类型
  76. // if (i < columnNames.size() - 1) {
  77. // createTableSQL += ", ";
  78. // }
  79. // }
  80. // createTableSQL += ");";
  81. //
  82. // // 执行创建表格语句
  83. // try (Statement stmt = conn.createStatement()) {
  84. // stmt.execute(createTableSQL);
  85. // }
  86. //
  87. // // 插入数据
  88. // StringBuilder insertSQL = new StringBuilder("INSERT INTO key_table VALUES (");
  89. // for (int i = 0; i < columnNames.size() - 1; i++) {
  90. // insertSQL.append("?, ");
  91. // }
  92. // insertSQL.append("?);"); // 最后一列不需要逗号
  93. //
  94. // try (PreparedStatement pstmt = conn.prepareStatement(insertSQL.toString())) {
  95. // for (int rowIdx = 1; rowIdx < data.size(); rowIdx++) { // 从第二行开始处理数据
  96. // List<String> row = data.get(rowIdx);
  97. // for (int colIdx = 0; colIdx < row.size(); colIdx++) {
  98. // String value = row.get(colIdx).trim();
  99. //
  100. // // 判断值是否为数字并设定相应的数据类型
  101. // if (value.matches("-?\\d+(\\.\\d+)?")) {
  102. // // 如果是浮动数字,转换为整数
  103. // try {
  104. // double numericValue = Double.parseDouble(value);
  105. // // 如果是浮动数字,四舍五入并转为整数
  106. // if (numericValue % 1 != 0) {
  107. // pstmt.setInt(colIdx + 1, (int) Math.round(numericValue)); // 插入整数
  108. // } else {
  109. // pstmt.setInt(colIdx + 1, (int) numericValue); // 插入整数
  110. // }
  111. // } catch (NumberFormatException e) {
  112. // pstmt.setString(colIdx + 1, value); // 如果无法解析为数字,插入为字符串
  113. // }
  114. // } else {
  115. // pstmt.setString(colIdx + 1, value); // 插入文本
  116. // }
  117. // }
  118. // pstmt.addBatch(); // 添加批处理
  119. // }
  120. // pstmt.executeBatch(); // 执行批量插入
  121. // }
  122. // } catch (SQLException e) {
  123. // e.printStackTrace();
  124. // }
  125. // }
  126. // /**
  127. // * 读取配置Excel文件并返回数据列表
  128. // *指定字段数据类型
  129. // * @return 数据列表
  130. // * @throws Exception 读取文件时发生的异常
  131. // */
  132. // private void writeToSQLite(List<List<String>> data, String sqliteFilePath) {
  133. // try (Connection conn = DriverManager.getConnection("jdbc:sqlite:" + sqliteFilePath)) {
  134. // List<String> columnNames = data.get(0); // 第一行作为列名
  135. //
  136. // // 创建表格(表名改为 key_table)
  137. // String createTableSQL = "CREATE TABLE IF NOT EXISTS key_table (";
  138. // for (int i = 0; i < columnNames.size(); i++) {
  139. // String colName = columnNames.get(i);
  140. // String columnType = "TEXT";
  141. //
  142. // for (int rowIdx = 1; rowIdx < data.size(); rowIdx++) {
  143. // String cellValue = data.get(rowIdx).get(i).trim();
  144. // if (cellValue.matches("-?\\d+(\\.\\d+)?")) {
  145. // if (colName.endsWith("valid") ||colName.endsWith("addr")) {
  146. // columnType = "INTEGER";
  147. // } else {
  148. // columnType = "REAL";
  149. // }
  150. // break;
  151. // }
  152. // }
  153. //
  154. // createTableSQL += colName + " " + columnType;
  155. // if (i < columnNames.size() - 1) {
  156. // createTableSQL += ", ";
  157. // }
  158. // }
  159. // createTableSQL += ");";
  160. //
  161. // try (Statement stmt = conn.createStatement()) {
  162. // stmt.execute(createTableSQL);
  163. // }
  164. //
  165. // // 插入数据
  166. // StringBuilder insertSQL = new StringBuilder("INSERT INTO key_table VALUES (");
  167. // for (int i = 0; i < columnNames.size() - 1; i++) {
  168. // insertSQL.append("?, ");
  169. // }
  170. // insertSQL.append("?);");
  171. //
  172. // try (PreparedStatement pstmt = conn.prepareStatement(insertSQL.toString())) {
  173. // for (int rowIdx = 1; rowIdx < data.size(); rowIdx++) {
  174. // List<String> row = data.get(rowIdx);
  175. // for (int colIdx = 0; colIdx < row.size(); colIdx++) {
  176. // String colName = columnNames.get(colIdx);
  177. // String value = row.get(colIdx).trim();
  178. //
  179. // if (value.matches("-?\\d+(\\.\\d+)?")) {
  180. // try {
  181. // double numericValue = Double.parseDouble(value);
  182. //
  183. // if (colName.endsWith("valid")) {
  184. // pstmt.setInt(colIdx + 1, (int) Math.round(numericValue));
  185. // } else {
  186. // double rounded = Math.round(numericValue * 10.0) / 10.0;
  187. // pstmt.setDouble(colIdx + 1, rounded);
  188. // }
  189. // } catch (NumberFormatException e) {
  190. // pstmt.setString(colIdx + 1, value);
  191. // }
  192. // } else {
  193. // pstmt.setString(colIdx + 1, value);
  194. // }
  195. // }
  196. // pstmt.addBatch();
  197. // }
  198. // pstmt.executeBatch();
  199. // }
  200. // } catch (SQLException e) {
  201. // e.printStackTrace();
  202. // }
  203. // }
  204. // /**
  205. // * 读取配置Excel文件并返回数据列表
  206. // *自动判断字段数据类型
  207. // * @return 数据列表
  208. // * @throws Exception 读取文件时发生的异常
  209. // */
  210. public void writeToSQLite(List<List<Object>> data, String sqliteFilePath, int dbName) {
  211. if (data == null || data.isEmpty()) return;
  212. try (Connection conn = DriverManager.getConnection("jdbc:sqlite:" + sqliteFilePath)) {
  213. List<Object> columnNamesRaw = data.get(0);
  214. List<String> columnNames = new ArrayList<>();
  215. for (Object obj : columnNamesRaw) {
  216. columnNames.add(obj != null ? obj.toString().trim() : "col");
  217. }
  218. List<String> columnTypes = new ArrayList<>();
  219. // 推断每列数据类型
  220. for (int col = 0; col < columnNames.size(); col++) {
  221. String type = "TEXT"; // 默认是文本
  222. for (int row = 1; row < data.size(); row++) {
  223. if (col >= data.get(row).size()) continue;
  224. Object value = data.get(row).get(col);
  225. if (value == null) continue;
  226. if (value instanceof Integer || value instanceof Long) {
  227. type = "INTEGER";
  228. } else if (value instanceof Double || value instanceof Float) {
  229. type = "REAL";
  230. } else if (value instanceof Boolean) {
  231. type = "INTEGER"; // SQLite 没有 BOOLEAN 类型,用 INTEGER 表示 true/false
  232. } else if (value instanceof Date) {
  233. type = "TEXT"; // 或 "NUMERIC",取决于是否存时间戳
  234. } else {
  235. type = "TEXT";
  236. break; // 只要出现非数字,就默认整列是 TEXT
  237. }
  238. }
  239. columnTypes.add(type);
  240. }
  241. // 创建表
  242. StringBuilder createTableSQL = new StringBuilder("CREATE TABLE IF NOT EXISTS key_table (");
  243. if (dbName == 1) {
  244. createTableSQL = new StringBuilder("CREATE TABLE IF NOT EXISTS key_table (");
  245. } else if (dbName == 2) {
  246. createTableSQL = new StringBuilder("CREATE TABLE IF NOT EXISTS point (");
  247. }
  248. for (int i = 0; i < columnNames.size(); i++) {
  249. createTableSQL.append(columnNames.get(i)).append(" ").append(columnTypes.get(i));
  250. if (i < columnNames.size() - 1) createTableSQL.append(", ");
  251. }
  252. createTableSQL.append(");");
  253. try (Statement stmt = conn.createStatement()) {
  254. stmt.execute(createTableSQL.toString());
  255. }
  256. // 插入数据
  257. StringBuilder insertSQL = new StringBuilder("INSERT INTO key_table VALUES (");
  258. if (dbName == 1) {
  259. insertSQL = new StringBuilder("INSERT INTO key_table VALUES (");
  260. } else if (dbName == 2) {
  261. insertSQL = new StringBuilder("INSERT INTO point VALUES (");
  262. }
  263. for (int i = 0; i < columnNames.size(); i++) {
  264. insertSQL.append("?");
  265. if (i < columnNames.size() - 1) insertSQL.append(",");
  266. }
  267. insertSQL.append(");");
  268. try (PreparedStatement pstmt = conn.prepareStatement(insertSQL.toString())) {
  269. for (int rowIdx = 1; rowIdx < data.size(); rowIdx++) {
  270. List<Object> row = data.get(rowIdx);
  271. for (int colIdx = 0; colIdx < columnNames.size(); colIdx++) {
  272. Object value = colIdx < row.size() ? row.get(colIdx) : null;
  273. String type = columnTypes.get(colIdx);
  274. if (value == null) {
  275. pstmt.setNull(colIdx + 1, Types.NULL);
  276. } else if (type.equals("INTEGER")) {
  277. if (value instanceof Boolean) {
  278. pstmt.setInt(colIdx + 1, ((Boolean) value) ? 1 : 0);
  279. } else {
  280. pstmt.setInt(colIdx + 1, ((Number) value).intValue());
  281. }
  282. } else if (type.equals("REAL")) {
  283. pstmt.setDouble(colIdx + 1, ((Number) value).doubleValue());
  284. } else if (type.equals("TEXT")) {
  285. if (value instanceof Date) {
  286. pstmt.setString(colIdx + 1, new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format((Date) value));
  287. } else {
  288. pstmt.setString(colIdx + 1, value.toString());
  289. }
  290. } else {
  291. pstmt.setObject(colIdx + 1, value);
  292. }
  293. }
  294. pstmt.addBatch();
  295. }
  296. pstmt.executeBatch();
  297. }
  298. } catch (SQLException e) {
  299. e.printStackTrace();
  300. }
  301. }
  302. }