refactor(data): 便携式设备数据补召功能重构

- 移除接口中的方法注释以简化代码结构
- 替换Spring事务注解为动态数据源事务注解
- 删除未使用的导入包和注释掉的代码行
- 简化数据拆分服务实现类中的复杂逻辑
- 添加时间间隔处理逻辑用于不同数据表的定时入库
- 优化数据映射过程中的null值处理机制
- 重构字段值设置方法以提高类型安全性和错误处理能力

cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/IPqdDataSplitService.java

@@ -13,13 +13,5 @@ import java.util.Map;
  */
 public interface IPqdDataSplitService {
 
-    /**
-     * 将PqdData数据拆分到不同的表中
-     *
-     * @param pqdDataList 原始PqdData数据列表
-     * @return 包含两部分数据：
-     *         - "splitData": 已拆分到各表的数据 Map<表名, 数据列表>
-     *         - "remainingPqdData": 未匹配的PqdData数据（仍需插入InfluxDB）
-     */
     Map<String, Object> splitPqdData(List<PqdData> pqdDataList);
 }

cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/PortableOfflLogServiceImpl.java

@@ -2,6 +2,7 @@ package com.njcn.csdevice.service.impl;
 
 import cn.hutool.core.util.IdUtil;
 import com.alibaba.nacos.shaded.com.google.gson.Gson;
+import com.baomidou.dynamic.datasource.annotation.DSTransactional;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -54,7 +55,6 @@ import org.apache.commons.collections4.ListUtils;
 import org.apache.commons.io.FilenameUtils;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -188,7 +188,7 @@ public class PortableOfflLogServiceImpl extends ServiceImpl<PortableOfflLogMappe
     }
 
     @Override
-    @Transactional(rollbackFor = {Exception.class})
+    @DSTransactional
     public void importEquipment(UploadDataParam uploadDataParam){
         String lineId = uploadDataParam.getLineId();
         //获取监测点信息
@@ -348,7 +348,6 @@ public class PortableOfflLogServiceImpl extends ServiceImpl<PortableOfflLogMappe
                             .eq(WlRecord::getEndTime,wlRecord.getEndTime()).update();
                     wlRecordService.save(wlRecord);
 
-
                     //如果明确返回了state 那么当前文件解析出错
                     if(response.getState() != null){
                         portableOfflLog.setState(response.getState());
@@ -366,7 +365,6 @@ public class PortableOfflLogServiceImpl extends ServiceImpl<PortableOfflLogMappe
                                 List<PqdData> sublistAsOriginalListType = new ArrayList<>(sliceList);
                                 Map<String, Object> map = pqdDataSplitService.splitPqdData(sublistAsOriginalListType);
                                 insertData(map);
-//                                pqdDataMapper.insertBatch(sublistAsOriginalListType);
                             }
                             //min结果集解析入库后就不需要在解析了
                             minFlag = false;
@@ -703,8 +701,7 @@ public class PortableOfflLogServiceImpl extends ServiceImpl<PortableOfflLogMappe
 
     public void insertData(Map<String, Object> map) {
         //13张表
-        Map<String, List<?>> splitData = (Map<String, List<?>>) map.get("splitData");
+        map.forEach((key, value) -> {
-        splitData.forEach((key, value) -> {
             switch (key) {
                 case "data_v":
                     dataVMapper.insertBatch((List<DataV>) value);
@@ -713,10 +710,26 @@ public class PortableOfflLogServiceImpl extends ServiceImpl<PortableOfflLogMappe
                     dataIMapper.insertBatch((List<DataI>) value);
                     break;
                 case "data_flicker":
-                    dataFlicker.insertBatch((List<DataFlicker>) value);
+                    //10分钟入一组
+                    List<DataFlicker> list = (List<DataFlicker>) value;
+                    if (!CollectionUtils.isEmpty(list)) {
+                        list.forEach(item->{
+                            Instant time = getTime(item.getTime(),600);
+                            item.setTime(time);
+                        });
+                        dataFlicker.insertBatch(list);
+                    }
                     break;
                 case "data_fluc":
-                    dataFluc.insertBatch((List<DataFluc>) value);
+                    //10分钟入一组
+                    List<DataFluc> list2 = (List<DataFluc>) value;
+                    if (!CollectionUtils.isEmpty(list2)) {
+                        list2.forEach(item->{
+                            Instant time = getTime(item.getTime(),600);
+                            item.setTime(time);
+                        });
+                        dataFluc.insertBatch(list2);
+                    }
                     break;
                 case "data_harmphasic_i":
                     dataHarmPhasicI.insertBatch((List<DataHarmPhasicI>) value);
@@ -743,18 +756,29 @@ public class PortableOfflLogServiceImpl extends ServiceImpl<PortableOfflLogMappe
                     dataInHarmV.insertBatch((List<DataInHarmV>) value);
                     break;
                 case "data_plt":
-                    dataPlt.insertBatch((List<DataPlt>) value);
+                    //2小时入一组
+                    List<DataPlt> list3 = (List<DataPlt>) value;
+                    if (!CollectionUtils.isEmpty(list3)) {
+                        list3.forEach(item->{
+                            Instant time = getTime(item.getTime(),7200);
+                            item.setTime(time);
+                        });
+                        dataPlt.insertBatch(list3);
+                    }
+                    break;
+                case "pqd_data":
+                    pqdDataMapper.insertBatch((List<PqdData>) value);
                     break;
                 default:
                     log.warn("不支持的目标表: {}", key);
                     break;
             }
         });
+    }
 
-        //其余数据
+    public Instant getTime(Instant time, Integer interval) {
-        List<PqdData> remainingPqdData = (List<PqdData>) map.get("remainingPqdData");
+        long originalTimeSec = time.getEpochSecond();
-        if (!CollectionUtils.isEmpty(remainingPqdData)) {
+        long newTimeSec = (originalTimeSec / interval) * interval;
-            pqdDataMapper.insertBatch(remainingPqdData);
+        return Instant.ofEpochSecond(newTimeSec);
-        }
     }
 }

cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/PqdDataSplitServiceImpl.java

@@ -35,26 +35,11 @@ import java.util.stream.Stream;
 @Service
 @RequiredArgsConstructor
 public class PqdDataSplitServiceImpl implements IPqdDataSplitService {
-
     private final RedisUtil redisUtil;
     private final EpdFeignClient epdFeignClient;
     private final DicDataFeignClient dicDataFeignClient;
-
     @Override
     public Map<String, Object> splitPqdData(List<PqdData> pqdDataList) {
-        Map<String, Object> result = new HashMap<>();
-
-        if (CollectionUtils.isEmpty(pqdDataList)) {
-            result.put("splitData", Collections.emptyMap());
-            result.put("remainingPqdData", Collections.emptyList());
-            return result;
-        }
-
-        log.info("开始拆分PqdData数据，共{}条记录", pqdDataList.size());
-
-        Map<String, List<?>> splitDataMap = new HashMap<>();
-        List<PqdData> remainingPqdData = new ArrayList<>();
-
         //获取表映射关系
         Map<String,String> map1 = new Gson().fromJson(String.valueOf(redisUtil.getObjectByKey(AppRedisKey.ELE_EPD_PQD)), Map.class);
         //获取字段映射关系
@@ -68,7 +53,6 @@ public class PqdDataSplitServiceImpl implements IPqdDataSplitService {
         List<EleEpdPqd> resultList = epdList.stream()
                 .flatMap(item -> {
                     if (item.getHarmStart() != null && item.getHarmEnd() != null) {
-                        // 生成从 harmStart 到 harmEnd 的新对象
                         List<EleEpdPqd> expandedList = new ArrayList<>();
                         for (int i = item.getHarmStart(); i <= item.getHarmEnd(); i++) {
                             EleEpdPqd newItem = copyEleEpdPqd(item);
@@ -78,66 +62,319 @@ public class PqdDataSplitServiceImpl implements IPqdDataSplitService {
                         }
                         return expandedList.stream();
                     } else {
-                        // 保持原对象
                         return Stream.of(item);
                     }
                 })
                 .collect(Collectors.toList());
         Map<String,List<EleEpdPqd>> map2 = resultList.stream().collect(Collectors.groupingBy(EleEpdPqd::getName,LinkedHashMap::new,Collectors.toList()));
+        Map<String,Object> map3 = new HashMap<>();
+        List<Object> list1 = new ArrayList<>();
+        List<Object> list2 = new ArrayList<>();
+        List<Object> list3 = new ArrayList<>();
+        List<Object> list4 = new ArrayList<>();
+        List<Object> list5 = new ArrayList<>();
+        List<Object> list6 = new ArrayList<>();
+        List<Object> list7 = new ArrayList<>();
+        List<Object> list8 = new ArrayList<>();
+        List<Object> list9 = new ArrayList<>();
+        List<Object> list10 = new ArrayList<>();
+        List<Object> list11 = new ArrayList<>();
+        List<Object> list12 = new ArrayList<>();
+        List<Object> list13 = new ArrayList<>();
+        List<Object> list14 = new ArrayList<>();
 
-        try {
-            for (PqdData pqdData : pqdDataList) {
-                boolean hasMatchedField = false;
 
-                Map<String, Object> fieldValues = extractFieldValues(pqdData);
 
-                for (Map.Entry<String, Object> entry : fieldValues.entrySet()) {
+        for (PqdData item : pqdDataList) {
-                    String sourceFieldName = StringUtils.capitalize(entry.getKey());
+            Map<String, Object> map = extractFieldValues(item);
-                    Object value = entry.getValue();
 
-                    if (value == null || isCommonField(sourceFieldName)) {
+            DataV dataV = new DataV();
-                        continue;
+            dataV.setTime(item.getTime());
-                    }
+            dataV.setLineId(item.getLineId());
-                    String tableName = map1.get(sourceFieldName);
+            dataV.setPhaseType(item.getPhaseType());
-                    String otherName = sourceFieldName;
+            dataV.setValueType(item.getValueType());
-                    List<EleEpdPqd> v = map2.get(sourceFieldName);
+            dataV.setClDid(item.getClDid());
-                    if (!CollectionUtils.isEmpty(v)) {
+            dataV.setProcess(item.getProcess());
-                        otherName = toCamelCase(v.get(0).getOtherName());
+            dataV.setQualityFlag("0");
-                    }
 
-                    if (StrUtil.isBlank(tableName) || StrUtil.isBlank(otherName)) {
+            DataI dataI = new DataI();
-                        continue;
+            dataI.setTime(item.getTime());
-                    }
+            dataI.setLineId(item.getLineId());
+            dataI.setPhaseType(item.getPhaseType());
+            dataI.setValueType(item.getValueType());
+            dataI.setClDid(item.getClDid());
+            dataI.setProcess(item.getProcess());
+            dataI.setQualityFlag("0");
 
-                    hasMatchedField = true;
+            DataFlicker dataFlicker = new DataFlicker();
+            dataFlicker.setTime(item.getTime());
+            dataFlicker.setLineId(item.getLineId());
+            dataFlicker.setPhaseType(item.getPhaseType());
+            dataFlicker.setValueType(item.getValueType());
+            dataFlicker.setClDid(item.getClDid());
+            dataFlicker.setProcess(item.getProcess());
+            dataFlicker.setQualityFlag("0");
 
-                    if (!splitDataMap.containsKey(tableName)) {
+            DataFluc dataFluc = new DataFluc();
-                        splitDataMap.put(tableName, new ArrayList<>());
+            dataFluc.setTime(item.getTime());
-                    }
+            dataFluc.setLineId(item.getLineId());
+            dataFluc.setPhaseType(item.getPhaseType());
+            dataFluc.setValueType(item.getValueType());
+            dataFluc.setClDid(item.getClDid());
+            dataFluc.setProcess(item.getProcess());
+            dataFluc.setQualityFlag("0");
 
-                    createAndAddTargetData((List<Object>) splitDataMap.get(tableName), tableName, pqdData, otherName, value);
+            DataHarmPhasicI dataHarmPhasicI = new DataHarmPhasicI();
+            dataHarmPhasicI.setTime(item.getTime());
+            dataHarmPhasicI.setLineId(item.getLineId());
+            dataHarmPhasicI.setPhaseType(item.getPhaseType());
+            dataHarmPhasicI.setValueType(item.getValueType());
+            dataHarmPhasicI.setClDid(item.getClDid());
+            dataHarmPhasicI.setProcess(item.getProcess());
+            dataHarmPhasicI.setQualityFlag("0");
+
+            DataHarmPhasicV dataHarmPhasicV = new DataHarmPhasicV();
+            dataHarmPhasicV.setTime(item.getTime());
+            dataHarmPhasicV.setLineId(item.getLineId());
+            dataHarmPhasicV.setPhaseType(item.getPhaseType());
+            dataHarmPhasicV.setValueType(item.getValueType());
+            dataHarmPhasicV.setClDid(item.getClDid());
+            dataHarmPhasicV.setProcess(item.getProcess());
+            dataHarmPhasicV.setQualityFlag("0");
+
+            DataHarmPowerP dataHarmPowerP = new DataHarmPowerP();
+            dataHarmPowerP.setTime(item.getTime());
+            dataHarmPowerP.setLineId(item.getLineId());
+            dataHarmPowerP.setPhaseType(item.getPhaseType());
+            dataHarmPowerP.setValueType(item.getValueType());
+            dataHarmPowerP.setClDid(item.getClDid());
+            dataHarmPowerP.setProcess(item.getProcess());
+            dataHarmPowerP.setQualityFlag("0");
+
+            DataHarmPowerQ dataHarmPowerQ = new DataHarmPowerQ();
+            dataHarmPowerQ.setTime(item.getTime());
+            dataHarmPowerQ.setLineId(item.getLineId());
+            dataHarmPowerQ.setPhaseType(item.getPhaseType());
+            dataHarmPowerQ.setValueType(item.getValueType());
+            dataHarmPowerQ.setClDid(item.getClDid());
+            dataHarmPowerQ.setProcess(item.getProcess());
+            dataHarmPowerQ.setQualityFlag("0");
+
+            DataHarmPowerS dataHarmPowerS = new DataHarmPowerS();
+            dataHarmPowerS.setTime(item.getTime());
+            dataHarmPowerS.setLineId(item.getLineId());
+            dataHarmPowerS.setPhaseType(item.getPhaseType());
+            dataHarmPowerS.setValueType(item.getValueType());
+            dataHarmPowerS.setClDid(item.getClDid());
+            dataHarmPowerS.setProcess(item.getProcess());
+            dataHarmPowerS.setQualityFlag("0");
+
+            DataHarmRateV dataHarmRateV = new DataHarmRateV();
+            dataHarmRateV.setTime(item.getTime());
+            dataHarmRateV.setLineId(item.getLineId());
+            dataHarmRateV.setPhaseType(item.getPhaseType());
+            dataHarmRateV.setValueType(item.getValueType());
+            dataHarmRateV.setClDid(item.getClDid());
+            dataHarmRateV.setProcess(item.getProcess());
+            dataHarmRateV.setQualityFlag("0");
+
+            DataHarmRateI dataHarmRateI = new DataHarmRateI();
+            dataHarmRateI.setTime(item.getTime());
+            dataHarmRateI.setLineId(item.getLineId());
+            dataHarmRateI.setPhaseType(item.getPhaseType());
+            dataHarmRateI.setValueType(item.getValueType());
+            dataHarmRateI.setClDid(item.getClDid());
+            dataHarmRateI.setProcess(item.getProcess());
+            dataHarmRateI.setQualityFlag("0");
+
+            DataInHarmV dataInHarmV = new DataInHarmV();
+            dataInHarmV.setTime(item.getTime());
+            dataInHarmV.setLineId(item.getLineId());
+            dataInHarmV.setPhaseType(item.getPhaseType());
+            dataInHarmV.setValueType(item.getValueType());
+            dataInHarmV.setClDid(item.getClDid());
+            dataInHarmV.setProcess(item.getProcess());
+            dataInHarmV.setQualityFlag("0");
+
+            DataPlt dataPlt = new DataPlt();
+            dataPlt.setTime(item.getTime());
+            dataPlt.setLineId(item.getLineId());
+            dataPlt.setPhaseType(item.getPhaseType());
+            dataPlt.setValueType(item.getValueType());
+            dataPlt.setClDid(item.getClDid());
+            dataPlt.setProcess(item.getProcess());
+            dataPlt.setQualityFlag("0");
+
+            PqdData pqdData = new PqdData();
+            pqdData.setTime(item.getTime());
+            pqdData.setLineId(item.getLineId());
+            pqdData.setPhaseType(item.getPhaseType());
+            pqdData.setValueType(item.getValueType());
+            pqdData.setClDid(item.getClDid());
+            pqdData.setProcess(item.getProcess());
+            pqdData.setQualityFlag("0");
+
+
+            boolean hasDataV = false;
+            boolean hasDataI = false;
+            boolean hasData1 = false;
+            boolean hasData2 = false;
+            boolean hasData3 = false;
+            boolean hasData4 = false;
+            boolean hasData5 = false;
+            boolean hasData6 = false;
+            boolean hasData7 = false;
+            boolean hasData8 = false;
+            boolean hasData9 = false;
+            boolean hasData10 = false;
+            boolean hasData11 = false;
+            boolean hasData12 = false;
+
+            for (Map.Entry<String, Object> entry : map.entrySet()) {
+                String fieldName = entry.getKey();
+                Object value = entry.getValue();
+                String capitalizedFieldName = StringUtils.capitalize(fieldName);
+
+                // 跳过公共字段和 null 值
+                if (isCommonField(fieldName) || value == null) {
+                    continue;
                 }
 
-                if (!hasMatchedField) {
+                String table = map1.get(capitalizedFieldName);
-                    pqdData.setQualityFlag("0");
+                if (StrUtil.isBlank(table)) {
-                    remainingPqdData.add(pqdData);
+                    continue;
+                }
+
+                List<EleEpdPqd> epdPqdList = map2.get(capitalizedFieldName);
+                if (CollectionUtils.isEmpty(epdPqdList)) {
+                    continue;
+                }
+
+                String influxdbName2 = epdPqdList.get(0).getOtherName();
+                if (StrUtil.isBlank(influxdbName2) || influxdbName2.equals(capitalizedFieldName)) {
+                    influxdbName2 = capitalizedFieldName;
+                }
+
+                if (Objects.equals(table, "data_v")) {
+                    setFieldValue(dataV, influxdbName2, value, true);
+                    hasDataV = true;
+                }
+                if (Objects.equals(table, "data_i")) {
+                    setFieldValue(dataI, influxdbName2, value, true);
+                    hasDataI = true;
+                }
+                if (Objects.equals(table, "data_flicker")) {
+                    setFieldValue(dataFlicker, influxdbName2, value, true);
+                    hasData1 = true;
+                }
+                if (Objects.equals(table, "data_fluc")) {
+                    setFieldValue(dataFluc, influxdbName2, value, true);
+                    hasData2 = true;
+                }
+                if (Objects.equals(table, "data_harmphasic_i")) {
+                    setFieldValue(dataHarmPhasicI, influxdbName2, value, true);
+                    hasData3 = true;
+                }
+                if (Objects.equals(table, "data_harmphasic_v")) {
+                    setFieldValue(dataHarmPhasicV, influxdbName2, value, true);
+                    hasData4 = true;
+                }
+                if (Objects.equals(table, "data_harmpower_p")) {
+                    setFieldValue(dataHarmPowerP, influxdbName2, value, true);
+                    hasData5 = true;
+                }
+                if (Objects.equals(table, "data_harmpower_q")) {
+                    setFieldValue(dataHarmPowerQ, influxdbName2, value, true);
+                    hasData6 = true;
+                }
+                if (Objects.equals(table, "data_harmpower_s")) {
+                    setFieldValue(dataHarmPowerS, influxdbName2, value, true);
+                    hasData7 = true;
+                }
+                if (Objects.equals(table, "data_harmrate_v")) {
+                    setFieldValue(dataHarmRateV, influxdbName2, value, true);
+                    hasData8 = true;
+                }
+                if (Objects.equals(table, "data_harmrate_i")) {
+                    setFieldValue(dataHarmRateI, influxdbName2, value, true);
+                    hasData9 = true;
+                }
+                if (Objects.equals(table, "data_inharm_v")) {
+                    setFieldValue(dataInHarmV, influxdbName2, value, true);
+                    hasData10 = true;
+                }
+                if (Objects.equals(table, "data_plt")) {
+                    setFieldValue(dataPlt, influxdbName2, value, true);
+                    hasData11 = true;
+                }
+                if (Objects.equals(table, "pqd_data")) {
+                    setFieldValue(pqdData, StringUtils.uncapitalize(influxdbName2), value, false);
+                    hasData12 = true;
                 }
             }
 
-            result.put("splitData", splitDataMap);
+            if (hasDataV) {
-            result.put("remainingPqdData", remainingPqdData);
+                list1.add(dataV);
-
+            }
-            log.info("PqdData数据拆分完成，拆分为{}个表，剩余{}条未匹配数据需插入InfluxDB",
+            if (hasDataI) {
-                    splitDataMap.size(), remainingPqdData.size());
+                list2.add(dataI);
-
+            }
-        } catch (Exception e) {
+            if (hasData1) {
-            log.error("PqdData数据拆分失败", e);
+                list3.add(dataFlicker);
-            throw new RuntimeException("PqdData数据拆分失败", e);
+            }
+            if (hasData2) {
+                list4.add(dataFluc);
+            }
+            if (hasData3) {
+                list5.add(dataHarmPhasicI);
+            }
+            if (hasData4) {
+                list6.add(dataHarmPhasicV);
+            }
+            if (hasData5) {
+                list7.add(dataHarmPowerP);
+            }
+            if (hasData6) {
+                list8.add(dataHarmPowerQ);
+            }
+            if (hasData7) {
+                list9.add(dataHarmPowerS);
+            }
+            if (hasData8) {
+                list10.add(dataHarmRateV);
+            }
+            if (hasData9) {
+                list11.add(dataHarmRateI);
+            }
+            if (hasData10) {
+                list12.add(dataInHarmV);
+            }
+            if (hasData11) {
+                list13.add(dataPlt);
+            }
+            if (hasData12) {
+                list14.add(pqdData);
+            }
         }
 
-        return result;
+        map3.put("data_v", list1);
+        map3.put("data_i", list2);
+        map3.put("data_flicker", list3);
+        map3.put("data_fluc", list4);
+        map3.put("data_harmphasic_i", list5);
+        map3.put("data_harmphasic_v", list6);
+        map3.put("data_harmpower_p", list7);
+        map3.put("data_harmpower_q", list8);
+        map3.put("data_harmpower_s", list9);
+        map3.put("data_harmrate_v", list10);
+        map3.put("data_harmrate_i", list11);
+        map3.put("data_inharm_v", list12);
+        map3.put("data_plt", list13);
+        map3.put("pqd_data", list14);
+        return map3;
     }
 
+
     private Map<String, Object> extractFieldValues(PqdData pqdData) {
         Map<String, Object> fieldValues = new HashMap<>();
         Field[] fields = PqdData.class.getDeclaredFields();
@@ -148,15 +385,17 @@ public class PqdDataSplitServiceImpl implements IPqdDataSplitService {
                 Object value = field.get(pqdData);
                 if (value != null) {
                     fieldValues.put(field.getName(), value);
+                } else {
+                    fieldValues.put(field.getName(), 0.0d);
                 }
             } catch (IllegalAccessException e) {
                 log.warn("获取字段 {} 的值失败", field.getName(), e);
             }
         }
-
         return fieldValues;
     }
 
+
     private boolean isCommonField(String fieldName) {
         Set<String> commonFields = new HashSet<>(Arrays.asList(
                 "time", "lineId", "phasicType", "valueType", "clDid",
@@ -165,231 +404,35 @@ public class PqdDataSplitServiceImpl implements IPqdDataSplitService {
         return commonFields.contains(fieldName);
     }
 
-    private void createAndAddTargetData(List<Object> dataList, String tableName,
+    private void setFieldValue(Object obj, String fieldName, Object value, boolean isCamelCase) {
-                                        PqdData pqdData, String targetField, Object value) {
-        switch (tableName.toLowerCase()) {
-            case "data_v":
-                dataList.add(createRStatDataVD(pqdData, targetField, value));
-                break;
-            case "data_i":
-                dataList.add(createRStatDataID(pqdData, targetField, value));
-                break;
-            case "data_flicker":
-                dataList.add(createRStatDataFlicker(pqdData, targetField, value));
-                break;
-            case "data_fluc":
-                dataList.add(createRStatDataFluc(pqdData, targetField, value));
-                break;
-            case "data_harmphasic_i":
-                dataList.add(createRStatDataHarmphasicI(pqdData, targetField, value));
-                break;
-            case "data_harmphasic_v":
-                dataList.add(createRStatDataHarmphasicV(pqdData, targetField, value));
-                break;
-            case "data_harmpower_p":
-                dataList.add(createRStatDataHarmpowerP(pqdData, targetField, value));
-                break;
-            case "data_harmpower_q":
-                dataList.add(createRStatDataHarmpowerQ(pqdData, targetField, value));
-                break;
-            case "data_harmpower_s":
-                dataList.add(createRStatDataHarmpowerS(pqdData, targetField, value));
-                break;
-            case "data_harmrate_v":
-                dataList.add(createRStatDataHarmrateV(pqdData, targetField, value));
-                break;
-            case "data_harmrate_i":
-                dataList.add(createRStatDataHarmrateI(pqdData, targetField, value));
-                break;
-            case "data_inharm_v":
-                dataList.add(createRStatDataInharmV(pqdData, targetField, value));
-                break;
-            case "data_plt":
-                dataList.add(createRStatDataPlt(pqdData, targetField, value));
-                break;
-            default:
-                log.warn("不支持的目标表: {}", tableName);
-                break;
-        }
-    }
-
-    private Object createRStatDataVD(PqdData pqdData, String targetField, Object value) {
-        DataV data = new DataV();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataID(PqdData pqdData, String targetField, Object value) {
-        DataI data = new DataI();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setValueType(pqdData.getPhaseType());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataFlicker(PqdData pqdData, String targetField, Object value) {
-        DataFlicker data = new DataFlicker();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataFluc(PqdData pqdData, String targetField, Object value) {
-        DataFluc data = new DataFluc();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmphasicI(PqdData pqdData, String targetField, Object value) {
-        DataHarmPhasicI data = new DataHarmPhasicI();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmphasicV(PqdData pqdData, String targetField, Object value) {
-        DataHarmPhasicV data = new DataHarmPhasicV();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmpowerP(PqdData pqdData, String targetField, Object value) {
-        DataHarmPowerP data = new DataHarmPowerP();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmpowerQ(PqdData pqdData, String targetField, Object value) {
-        DataHarmPowerQ data = new DataHarmPowerQ();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmpowerS(PqdData pqdData, String targetField, Object value) {
-        DataHarmPowerS data = new DataHarmPowerS();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmrateV(PqdData pqdData, String targetField, Object value) {
-        DataHarmRateV data = new DataHarmRateV();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataHarmrateI(PqdData pqdData, String targetField, Object value) {
-        DataHarmRateI data = new DataHarmRateI();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataInharmV(PqdData pqdData, String targetField, Object value) {
-        DataInHarmV data = new DataInHarmV();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private Object createRStatDataPlt(PqdData pqdData, String targetField, Object value) {
-        DataPlt data = new DataPlt();
-        data.setTime(pqdData.getTime());
-        data.setLineId(pqdData.getLineId());
-        data.setPhaseType(pqdData.getPhaseType());
-        data.setValueType(pqdData.getValueType());
-        data.setClDid(pqdData.getClDid());
-        data.setProcess(pqdData.getProcess());
-        data.setQualityFlag("0");
-        setFieldValue(data, targetField, value);
-        return data;
-    }
-
-    private void setFieldValue(Object obj, String fieldName, Object value) {
         try {
-            String camelCaseFieldName = toCamelCase(fieldName);
+            String camelCaseFieldName = fieldName;
+            if (isCamelCase) {
+                camelCaseFieldName = toCamelCase(fieldName);
+            }
             Field field = obj.getClass().getDeclaredField(camelCaseFieldName);
             field.setAccessible(true);
+            if (value == null) {
+                Class<?> fieldType = field.getType();
+                if (fieldType == Double.class || fieldType == double.class) {
+                    value = 0.0D;
+                } else if (fieldType == Integer.class || fieldType == int.class) {
+                    value = 0;
+                } else if (fieldType == Float.class || fieldType == float.class) {
+                    value = 0.0F;
+                } else if (fieldType == Long.class || fieldType == long.class) {
+                    value = 0L;
+                } else {
+                    return;
+                }
+            }
             field.set(obj, value);
-        } catch (NoSuchFieldException | IllegalAccessException e) {
+        } catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {
             log.warn("设置字段 {} 的值失败", fieldName, e);
         }
     }
 
+
     public static String toCamelCase(String input) {
         if (input == null || input.isEmpty()) {
             return input;