江津数据采集 增加历史数据采集

dc3-center/dc3-center-auth/src/main/java/io/github/pnoker/center/auth/service/AuthService.java

@@ -5,7 +5,7 @@ import io.github.pnoker.common.model.AuthUser;
 import io.github.pnoker.common.model.UserLogin;
 
 /**
- * User Manage Service
+ * User Manage services
  *
  * @author: linys
  * @since: 2023.04.02

dc3-gateway/pom.xml

@@ -190,6 +190,11 @@
             <version>30.1.1-jre</version> <!-- 请根据需要使用最新版本 -->
         </dependency>
 
+        <dependency>
+            <groupId>com.oracle.database.jdbc</groupId>
+            <artifactId>ojdbc8</artifactId>
+            <version>19.3.0.0</version>
+        </dependency>
     </dependencies>
 
     <repositories>

dc3-gateway/src/main/java/io/github/pnoker/gateway/bizmgr/KprJiangjinWaterBizfun.java

@@ -3,19 +3,26 @@ package io.github.pnoker.gateway.bizmgr;
 import com.alibaba.fastjson.JSONObject;
 import io.github.pnoker.gateway.SpringContextUtil;
 import io.github.pnoker.gateway.bizmgr.baseInit.KprBaseInitFun;
+import io.github.pnoker.gateway.comtool.TimeTool;
 import io.github.pnoker.gateway.comtool.jiangjinThread.KafkaConsumer;
+import io.github.pnoker.gateway.dbdao.DBMgrProxy;
 import io.github.pnoker.gateway.utils.InfulxDbUtil;
 import io.github.pnoker.gateway.utils.InfulxJiangjinDbUtil;
 import org.influxdb.dto.Point;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.util.CollectionUtils;
 
 import java.math.BigDecimal;
 import java.time.*;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.temporal.ChronoField;
 import java.time.temporal.ChronoUnit;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
@@ -34,9 +41,9 @@ public class KprJiangjinWaterBizfun {
 
     public static InfulxJiangjinDbUtil infulxJiangjinDbUtil = null;//infulx工具类对象
 
-    public static Point createPointFromJson(String deviceType, JSONObject jsonObject,String cmCode,List<String> params) {
+    public static Point createPointFromJson(String deviceType,String standardCode,Map<String,Object> mapEntity,String cmCode,List<String> params) {
         // 获取时间戳
-        long nanoTimestamp = convertToNanoTimestamp(jsonObject.getLong("collectionTime"));
+        long nanoTimestamp = convertToNanoTimestamp(mapEntity.get("QCQUISITION_TIME").toString());
         if(nanoTimestamp==0L){
             return null;
         }
@@ -46,12 +53,8 @@ public class KprJiangjinWaterBizfun {
                 .time(nanoTimestamp, TimeUnit.NANOSECONDS);
 
         // 遍历 JSON 对象的键值对，并添加到 Point.Builder 中
-        for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
-            String key = entry.getKey();
-            if (!key.equals("collectionTime")) {
-                processField(pointBuilder,key, entry.getValue(),params);
-            }
-        }
+
+        processField(pointBuilder,standardCode, mapEntity.get("VAL"),params);
         if(!pointBuilder.hasFields()){
             return null;
         }
@@ -103,31 +106,168 @@ public class KprJiangjinWaterBizfun {
 
 
     //获取CST 纳秒时间戳
-    private static long convertToNanoTimestamp(Long dateTimeString) {
+    private static long convertToNanoTimestamp(String dateTimeString) {
+        // 定义时间格式，支持可选的小数秒部分
+        DateTimeFormatter formatter = new DateTimeFormatterBuilder()
+                .appendPattern("yyyy-MM-dd HH:mm:ss")
+                .optionalStart()
+                .appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true)
+                .optionalEnd()
+                .toFormatter();
+
         // 解析字符串为 LocalDateTime 对象
-        LocalDateTime dateTime = Instant.ofEpochMilli(dateTimeString)
-                .atZone(ZoneId.systemDefault())
-                .toLocalDateTime();
+        LocalDateTime dateTime = LocalDateTime.parse(dateTimeString, formatter);
+
         // 指定时区为CST（Asia/Shanghai）
         ZoneId shanghaiZoneId = ZoneId.of("Asia/Shanghai");
-        // 将LocalDateTime对象转换为ZonedDateTime对象
+
+        // 将 LocalDateTime 对象转换为 ZonedDateTime 对象
         ZonedDateTime zonedDateTime = dateTime.atZone(shanghaiZoneId);
-        // 转换为秒级别的时间戳
-        long epochSecond = dateTime.toEpochSecond(ZoneOffset.UTC);
-        // 将ZonedDateTime对象转换为Instant对象（UTC时间点）
+
+        // 将 ZonedDateTime 对象转换为 Instant 对象（UTC时间点）
         Instant instant = zonedDateTime.toInstant();
+
         // 计算从1970年1月1日00:00:00 UTC以来的纳秒数
         long nanosecondsSinceEpoch = ChronoUnit.NANOS.between(Instant.EPOCH, instant);
-        long currentTimeNanos = System.currentTimeMillis() * 1_000_000L;
-        if(nanosecondsSinceEpoch>currentTimeNanos){
-            return 0L;
-        }
-        return nanosecondsSinceEpoch;
+
+        // 每分钟的纳秒数
+        long nanosPerMinute = 60L * 1_000_000_000L;
+
+        // 四舍五入到最接近的整分的纳秒值
+        long roundedNanos = Math.round((double) nanosecondsSinceEpoch / nanosPerMinute) * nanosPerMinute;
+
+        // 输出调试信息
+//        System.out.println("解析的时间: " + dateTime);
+//        System.out.println("时区转换后的时间: " + zonedDateTime);
+//        System.out.println("计算的纳秒数: " + nanosecondsSinceEpoch);
+//        System.out.println("最接近整分的纳秒数: " + roundedNanos);
+
+        return roundedNanos;
     }
 
     //TODO 处理kafka所有已存在数据
     public static void InitHistory(){
-        KafkaConsumer kafkaConsumerDemo = new KafkaConsumer("10.127.16.85:9092", "jiangjin");
-        kafkaConsumerDemo.doConsume();
+//        KafkaConsumer kafkaConsumerDemo = new KafkaConsumer("10.127.16.85:9092", "jiangjin");
+//        kafkaConsumerDemo.doConsume();
+    }
+
+    //TODO 数据库视图采集
+    //TODO 按设备的最新时间作为视图查询条件
+    public static void InitRealDb(){
+        try {
+            int count = DBMgrProxy.getInstance().applyJiangjinDbApi().getTabWaterRealCount("");
+            if(count>0){
+                List<Map<String,Object>> mapList = DBMgrProxy.getInstance().applyJiangjinDbApi().getListWaterReal("");
+                if(!CollectionUtils.isEmpty(mapList)){
+                    //TODO 首先进行特殊数据处理
+                    int i = 1;
+                    for (Map<String,Object> map:mapList){
+                        //TODO 不存在过滤的就执行
+                        if(!KprBaseInitFun.getInstance().closeTag.contains(map.get("TAG_CODE").toString())){
+                            //TODO 业务过程
+                            //TODO 根据设备号得到设定好的对应的设备类型名
+                            Optional<String> foundKey = KprBaseInitFun.getInstance().jiangjinTypeList.entrySet().stream()
+                                    .filter(entry -> entry.getValue().contains(map.get("DEVICE_TYPE_CODE"))) // 过滤出包含特定值的 entry
+                                    .map(Map.Entry::getKey) // 提取 key
+                                    .findFirst(); // 找到第一个匹配的 key
+                            if(foundKey.isPresent()) {
+                                String deviceType = foundKey.get().split("_")[1];
+                                //第三方对应的字段集
+                                List<String> params = KprBaseInitFun.getInstance().jiangjinParams.get(deviceType);
+                                //deviceType为表名
+                                //time为当前数据time的纳秒时间戳,已经做过整点处理了
+                                Point pointNanos = createPointFromJson(deviceType,
+                                        map.get("TAG_STANDARD_CODE").toString(),
+                                        map
+                                        , map.get("DEVICE_CODE").toString()
+                                        , params);
+                                if (pointNanos != null) {
+                                    KprJiangjinWaterBizfun.infulxJiangjinDbUtil.insert(pointNanos);
+                                }
+                            }
+                            i++;
+                        }
+                    }
+                }else{
+                    log.error(mStrClassName+";实时数据采集为空:"+ TimeTool.convertUTC2DateStr(TimeTool.getCurMsUTC(),TimeTool.TIMESTAMP_FORMAT)
+                            +"InitRealDbNullError");
+                }
+            }
+        }catch(Exception ex){
+            ex.printStackTrace();
+            log.error(mStrClassName+";InitRealDbError:"+ex.getLocalizedMessage());
+        }
+    }
+
+    //TODO 历史数据,根据调用传递的开始时间作为历史数据接入的起始时间
+    public static void initHistoryDb(LocalDateTime startDateTime){
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        System.out.println("历史数据执行:"+startDateTime.format(formatter));
+        if(startDateTime==null){
+            return;
+        }
+        try{
+            //TODO 按每天六小时从起始时间循环到今天的0点
+            LocalDateTime todayMidnight = LocalDateTime.now().toLocalDate().atTime(1, 0);
+
+            // 循环从 startDateTime 开始，每 6 小时一次，直到今天 0 点
+            LocalDateTime currentDateTime = startDateTime;//每次循环查询的起始时间
+            while(currentDateTime.isBefore(todayMidnight)) {
+                String startStr = currentDateTime.format(formatter);
+                String endStr = currentDateTime.plusHours(6).format(formatter);
+                String extend = " QCQUISITION_TIME >= TO_DATE('" + startStr + "', 'YYYY-MM-DD HH24:MI:SS') " +
+                        " AND QCQUISITION_TIME <= TO_DATE('" + endStr + "', 'YYYY-MM-DD HH24:MI:SS') ";
+                int count = DBMgrProxy.getInstance().applyJiangjinDbApi().getTabWaterHistoryCount(extend);
+                if(count>0){
+                    int pageNum = count % 5000 == 0 ? count / 5000 : (count / 5000) + 1;//总页数
+
+                    Integer limit = 5000;
+                    if (pageNum <= 1) {
+                        limit = count;//说明总数比第一页小
+                    }
+                    for (int i = 0; i < pageNum; i++) {
+                        Integer offset = i * limit;
+                        List<Map<String,Object>> mapList = DBMgrProxy.getInstance().applyJiangjinDbApi()
+                                .getPageListWaterHistory(offset+limit,offset,extend);
+                        if(!CollectionUtils.isEmpty(mapList)){
+                            for (Map<String,Object> map:mapList){
+                                //TODO 不存在过滤的就执行
+                                if(!KprBaseInitFun.getInstance().closeTag.contains(map.get("TAG_CODE").toString())){
+                                    //TODO 业务过程
+                                    //TODO 根据设备号得到设定好的对应的设备类型名
+                                    Optional<String> foundKey = KprBaseInitFun.getInstance().jiangjinTypeList.entrySet().stream()
+                                            .filter(entry -> entry.getValue().contains(map.get("DEVICE_TYPE_CODE"))) // 过滤出包含特定值的 entry
+                                            .map(Map.Entry::getKey) // 提取 key
+                                            .findFirst(); // 找到第一个匹配的 key
+                                    if(foundKey.isPresent()) {
+                                        String deviceType = foundKey.get().split("_")[1];
+                                        //第三方对应的字段集
+                                        List<String> params = KprBaseInitFun.getInstance().jiangjinParams.get(deviceType);
+                                        //deviceType为表名
+                                        //time为当前数据time的纳秒时间戳,已经做过整点处理了
+                                        Point pointNanos = createPointFromJson(deviceType,
+                                                map.get("TAG_STANDARD_CODE").toString(),
+                                                map
+                                                , map.get("DEVICE_CODE").toString()
+                                                , params);
+                                        if (pointNanos != null) {
+                                            KprJiangjinWaterBizfun.infulxJiangjinDbUtil.insert(pointNanos);
+                                        }
+                                    }
+                                }
+                            }
+                        }else{
+                            log.error(mStrClassName+";历史数据采集为空:"+ TimeTool.convertUTC2DateStr(TimeTool.getCurMsUTC(),TimeTool.TIMESTAMP_FORMAT)
+                                    +"initHistoryDbNullError");
+                        }
+                    }
+                    System.out.println(startStr+"到"+endStr+"数据整理完成:"+count);
+                }
+                currentDateTime = currentDateTime.plusHours(6); // 增加 6 小时
+            }
+        }catch(Exception ex){
+            ex.printStackTrace();
+            log.error(mStrClassName+";initHistoryDbError:"+ex.getLocalizedMessage());
+        }
     }
 }

dc3-gateway/src/main/java/io/github/pnoker/gateway/bizmgr/baseInit/KprBaseInitFun.java

@@ -24,7 +24,9 @@ public class KprBaseInitFun {
 
     //TODO 江津相关
     public Map<String,List<String>> jiangjinParams = new HashMap<>();
+    public Map<String,List<String>> jiangjinTypeList = new HashMap<>();
     public Map<String,List<String>> jiangjinDeviceList = new HashMap<>();
+    public List<String> closeTag = new ArrayList<>();//忽略的标签
 
     public Map<String,String> jiangjinMeasurementMap = new HashMap<>();
 
@@ -46,7 +48,8 @@ public class KprBaseInitFun {
     public void init(){
         try {
             initDangyang();
-            initJiangjin();
+//            initJiangjin();
+            initJiangjinDb();
         }catch(Exception ex){
             ex.printStackTrace();
         }
@@ -172,6 +175,99 @@ public class KprBaseInitFun {
         jiangjinMeasurementMap.put("LiquidLevel","LiquidLevel");
     }
 
+    public void initJiangjinDb()throws Exception{
+        InputStream inputStream = getConfigStream("application-jiangjin.yml");
+        Properties properties = new Properties();
+        properties.load(inputStream);
+
+        closeTag = Arrays.asList(properties.getProperty("CloseTag").split(","));
+
+        List<String> VoltageSwitchgear=Arrays.asList(properties.getProperty("VoltageSwitchgear").split(","));
+        List<String> WaterValve=Arrays.asList(properties.getProperty("WaterValve").split(","));
+        List<String> VariableFrequencyDrive=Arrays.asList(properties.getProperty("VariableFrequencyDrive").split(","));
+        List<String> WaterQuality=Arrays.asList(properties.getProperty("WaterQuality").split(","));
+        List<String> DifferentialPressure=Arrays.asList(properties.getProperty("DifferentialPressure").split(","));
+        List<String> GenTransEquip=Arrays.asList(properties.getProperty("GenTransEquip").split(","));
+        List<String> ElectricMotor=Arrays.asList(properties.getProperty("ElectricMotor").split(","));
+        List<String> WaterPump=Arrays.asList(properties.getProperty("WaterPump").split(","));
+        List<String> AirCompressor=Arrays.asList(properties.getProperty("AirCompressor").split(","));
+        List<String> RootsBlower=Arrays.asList(properties.getProperty("RootsBlower").split(","));
+        List<String> ThMeter=Arrays.asList(properties.getProperty("ThMeter").split(","));
+        List<String> SludgeIntfMeter=Arrays.asList(properties.getProperty("SludgeIntfMeter").split(","));
+        List<String> WaterMeter=Arrays.asList(properties.getProperty("WaterMeter").split(","));
+        List<String> SmokeDetector=Arrays.asList(properties.getProperty("SmokeDetector").split(","));
+        List<String> LiquidLevelDiffer=Arrays.asList(properties.getProperty("LiquidLevelDiffer").split(","));
+        List<String> LiquidLevel=Arrays.asList(properties.getProperty("LiquidLevel").split(","));
+
+        jiangjinParams.put("VoltageSwitchgear",VoltageSwitchgear);
+        jiangjinParams.put("WaterValve",WaterValve);
+        jiangjinParams.put("VariableFrequencyDrive",VariableFrequencyDrive);
+        jiangjinParams.put("WaterQuality",WaterQuality);
+        jiangjinParams.put("DifferentialPressure",DifferentialPressure);
+        jiangjinParams.put("GenTransEquip",GenTransEquip);
+        jiangjinParams.put("ElectricMotor",ElectricMotor);
+        jiangjinParams.put("WaterPump",WaterPump);
+        jiangjinParams.put("AirCompressor",AirCompressor);
+        jiangjinParams.put("RootsBlower",RootsBlower);
+        jiangjinParams.put("ThMeter",ThMeter);
+        jiangjinParams.put("SludgeIntfMeter",SludgeIntfMeter);
+        jiangjinParams.put("WaterMeter",WaterMeter);
+        jiangjinParams.put("SmokeDetector",SmokeDetector);
+        jiangjinParams.put("LiquidLevelDiffer",LiquidLevelDiffer);
+        jiangjinParams.put("LiquidLevel",LiquidLevel);
+
+        List<String> Type_VoltageSwitchgear=Arrays.asList(properties.getProperty("Type_VoltageSwitchgear").split(","));
+        List<String> Type_WaterValve=Arrays.asList(properties.getProperty("Type_WaterValve").split(","));
+        List<String> Type_VariableFrequencyDrive=Arrays.asList(properties.getProperty("Type_VariableFrequencyDrive").split(","));
+        List<String> Type_WaterQuality=Arrays.asList(properties.getProperty("Type_WaterQuality").split(","));
+        List<String> Type_DifferentialPressure=Arrays.asList(properties.getProperty("Type_DifferentialPressure").split(","));
+        List<String> Type_GenTransEquip=Arrays.asList(properties.getProperty("Type_GenTransEquip").split(","));
+        List<String> Type_ElectricMotor=Arrays.asList(properties.getProperty("Type_ElectricMotor").split(","));
+        List<String> Type_WaterPump=Arrays.asList(properties.getProperty("Type_WaterPump").split(","));
+        List<String> Type_AirCompressor=Arrays.asList(properties.getProperty("Type_AirCompressor").split(","));
+        List<String> Type_RootsBlower=Arrays.asList(properties.getProperty("Type_RootsBlower").split(","));
+        List<String> Type_ThMeter=Arrays.asList(properties.getProperty("Type_ThMeter").split(","));
+        List<String> Type_SludgeIntfMeter=Arrays.asList(properties.getProperty("Type_SludgeIntfMeter").split(","));
+        List<String> Type_WaterMeter=Arrays.asList(properties.getProperty("Type_WaterMeter").split(","));
+        List<String> Type_SmokeDetector=Arrays.asList(properties.getProperty("Type_SmokeDetector").split(","));
+        List<String> Type_LiquidLevelDiffer=Arrays.asList(properties.getProperty("Type_LiquidLevelDiffer").split(","));
+        List<String> Type_LiquidLevel=Arrays.asList(properties.getProperty("Type_LiquidLevel").split(","));
+
+        jiangjinTypeList.put("Type_VoltageSwitchgear",Type_VoltageSwitchgear);
+        jiangjinTypeList.put("Type_WaterValve",Type_WaterValve);
+        jiangjinTypeList.put("Type_VariableFrequencyDrive",Type_VariableFrequencyDrive);
+        jiangjinTypeList.put("Type_WaterQuality",Type_WaterQuality);
+        jiangjinTypeList.put("Type_DifferentialPressure",Type_DifferentialPressure);
+        jiangjinTypeList.put("Type_GenTransEquip",Type_GenTransEquip);
+        jiangjinTypeList.put("Type_ElectricMotor",Type_ElectricMotor);
+        jiangjinTypeList.put("Type_WaterPump",Type_WaterPump);
+        jiangjinTypeList.put("Type_AirCompressor",Type_AirCompressor);
+        jiangjinTypeList.put("Type_RootsBlower",Type_RootsBlower);
+        jiangjinTypeList.put("Type_ThMeter",Type_ThMeter);
+        jiangjinTypeList.put("Type_SludgeIntfMeter",Type_SludgeIntfMeter);
+        jiangjinTypeList.put("Type_WaterMeter",Type_WaterMeter);
+        jiangjinTypeList.put("Type_SmokeDetector",Type_SmokeDetector);
+        jiangjinTypeList.put("Type_LiquidLevelDiffer",Type_LiquidLevelDiffer);
+        jiangjinTypeList.put("Type_LiquidLevel",Type_LiquidLevel);
+
+        jiangjinMeasurementMap.put("VoltageSwitchgear","VoltageSwitchgear");
+        jiangjinMeasurementMap.put("WaterValve","WaterValve");
+        jiangjinMeasurementMap.put("VariableFrequencyDrive","VariableFrequencyDrive");
+        jiangjinMeasurementMap.put("WaterQuality","WaterQuality");
+        jiangjinMeasurementMap.put("DifferentialPressure","DifferentialPressure");
+        jiangjinMeasurementMap.put("GenTransEquip","GenTransEquip");
+        jiangjinMeasurementMap.put("ElectricMotor","ElectricMotor");
+        jiangjinMeasurementMap.put("WaterPump","WaterPump");
+        jiangjinMeasurementMap.put("AirCompressor","AirCompressor");
+        jiangjinMeasurementMap.put("RootsBlower","RootsBlower");
+        jiangjinMeasurementMap.put("ThMeter","ThMeter");
+        jiangjinMeasurementMap.put("SludgeIntfMeter","SludgeIntfMeter");
+        jiangjinMeasurementMap.put("WaterMeter","WaterMeter");
+        jiangjinMeasurementMap.put("SmokeDetector","SmokeDetector");
+        jiangjinMeasurementMap.put("LiquidLevelDiffer","LiquidLevelDiffer");
+        jiangjinMeasurementMap.put("LiquidLevel","LiquidLevel");
+    }
+
     public InputStream getConfigStream(String configFileName) {
         InputStream inputStream = null;
         try {

dc3-gateway/src/main/java/io/github/pnoker/gateway/comtool/ResponseCode.java

@@ -92,7 +92,7 @@ public enum ResponseCode {
     BUSINESS_DB_REQ_FAILED(65530,"The DB operation failed."),
     BUSINESS_API_ABOLISH(65531,"The Api has been abolished."),
     BUSINESS_BUSY(65532,"Business is busy, please try again."),
-    SERVICE_OFFLINE(65533, "Service offline, please turn off offline mode"),
+    SERVICE_OFFLINE(65533, "services offline, please turn off offline mode"),
     STATUS_UNKNOWN(65534,"Unknown reason,see the message/data for reason."),
     RESULT_UNKNOWN(65535,"Unknown reason,see the message/data for reason.");
 

dc3-gateway/src/main/java/io/github/pnoker/gateway/comtool/ScheduleTaskMgr.java

@@ -19,6 +19,8 @@ import org.springframework.web.bind.annotation.PostMapping;
 import javax.annotation.PostConstruct;
 import javax.annotation.Resource;
 import java.sql.Time;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.concurrent.Executors;
@@ -239,12 +241,27 @@ public class ScheduleTaskMgr {
             @Override
             public void run() {
                 try {
-                    KprJiangjinWaterBizfun.InitHistory();
+                    KprJiangjinWaterBizfun.InitRealDb();
                 }catch(Exception ex){
 
                 }
             }
         },7000);
+        new Timer().schedule(new TimerTask() {
+            @Override
+            public void run() {
+                try {
+                    KprJiangjinWaterBizfun.initHistoryDb(LocalDate.now().withDayOfMonth(1).atStartOfDay());
+                }catch(Exception ex){
+
+                }
+            }
+        },8000);
+    }
+
+    @Scheduled(cron = "5 * * * * ?")
+    public void executeTask() {
+        KprJiangjinWaterBizfun.InitRealDb();
     }
 
 }

dc3-gateway/src/main/java/io/github/pnoker/gateway/config/MainSourceConfiguration.java

@@ -2,6 +2,7 @@ package io.github.pnoker.gateway.config;
 
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
+import io.github.pnoker.gateway.dbdao.DBMgrProxy;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.mybatis.spring.SqlSessionFactoryBean;
 import org.mybatis.spring.SqlSessionTemplate;
@@ -104,4 +105,10 @@ public class MainSourceConfiguration {
     public void init(){
         GlobalData.getInstance().setPostGisValid("org.postgis.DriverWrapper".equals(driveClass));
     }
+
+    @Bean
+    public DBMgrProxy startDBMgrProxy(){
+        DBMgrProxy.getInstance().init();
+        return DBMgrProxy.getInstance();
+    }
 }

dc3-gateway/src/main/java/io/github/pnoker/gateway/config/OrcaleDataSourceConfig.java

@@ -0,0 +1,59 @@
+package io.github.pnoker.gateway.config;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.sql.DataSource;
+
+/**
+ * @ClassName OrcaleDataSourceConfig
+ * @Description: TODO
+ * @Author LX
+ * @Date 2024/5/21
+ * @Version V1.0
+ **/
+@Configuration
+public class OrcaleDataSourceConfig {
+    @Bean(name = "primaryDataSource")
+    public DataSource primaryDataSource(@Value("${spring.datasource.primary.url}") String url,
+                                        @Value("${spring.datasource.primary.username}") String username,
+                                        @Value("${spring.datasource.primary.password}") String password,
+                                        @Value("${spring.datasource.primary.driver-class-name}") String driverClassName) {
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl(url);
+        config.setUsername(username);
+        config.setPassword(password);
+        config.setDriverClassName(driverClassName);
+        config.setInitializationFailTimeout(-1);
+        return new HikariDataSource(config);
+    }
+
+//    @Bean(name = "secondaryDataSource")
+//    public DataSource secondaryDataSource(@Value("${spring.datasource.secondary.url}") String url,
+//                                          @Value("${spring.datasource.secondary.username}") String username,
+//                                          @Value("${spring.datasource.secondary.password}") String password,
+//                                          @Value("${spring.datasource.secondary.driver-class-name}") String driverClassName) {
+//        HikariConfig config = new HikariConfig();
+//        config.setJdbcUrl(url);
+//        config.setUsername(username);
+//        config.setPassword(password);
+//        config.setDriverClassName(driverClassName);
+//        return new HikariDataSource(config);
+//    }
+
+    @Bean(name = "oneTemplate")
+    public JdbcTemplate primaryJdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
+        return new JdbcTemplate(dataSource);
+    }
+
+//    @Bean(name = "twoTemplate")
+//    public JdbcTemplate secondaryJdbcTemplate(@Qualifier("secondaryDataSource") DataSource dataSource) {
+//        return new JdbcTemplate(dataSource);
+//    }
+
+}

dc3-gateway/src/main/java/io/github/pnoker/gateway/dbdao/DBMgrProxy.java

@@ -1,6 +1,7 @@
 package io.github.pnoker.gateway.dbdao;
 
 import io.github.pnoker.gateway.SpringContextUtil;
+import io.github.pnoker.gateway.dbdao.jiangjinSource.services.JiangjinService;
 import io.github.pnoker.gateway.dbdao.services.intef.*;
 
 /**
@@ -18,6 +19,8 @@ public class DBMgrProxy {
     private volatile DeviceKindService deviceKindService= null;
     private volatile TypeDefineService typeDefineService= null;
 
+    private volatile JiangjinService jiangjinService = null;
+
     private static volatile DBMgrProxy msInstance = null;
     public static DBMgrProxy getInstance(){
         if (msInstance == null){
@@ -43,6 +46,8 @@ public class DBMgrProxy {
             deviceKindService = (DeviceKindService)SpringContextUtil.getBean(DeviceKindService.class);
         if (typeDefineService == null)
             typeDefineService = (TypeDefineService)SpringContextUtil.getBean(TypeDefineService.class);
+        if (jiangjinService == null)
+            jiangjinService = (JiangjinService)SpringContextUtil.getBean(JiangjinService.class);
     }
 
     public XuChangCustomerWaterConfigService applyXuchangCustomerWaterConfigApi() { return xuchangCustomerWaterConfigService; }
@@ -50,4 +55,5 @@ public class DBMgrProxy {
     public XuChangCustomerMeterDayReadService applyXuChangCustomerMeterDayReadApi() { return xuChangCustomerMeterDayReadService; }
     public DeviceKindService applyDeviceKineApi() { return deviceKindService; }
     public TypeDefineService applyTypeDefineApi() { return typeDefineService; }
+    public JiangjinService applyJiangjinDbApi() { return jiangjinService; }
 }

dc3-gateway/src/main/java/io/github/pnoker/gateway/dbdao/jiangjinSource/JiangjinRealListDao.java

@@ -0,0 +1,96 @@
+package io.github.pnoker.gateway.dbdao.jiangjinSource;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.stereotype.Repository;
+import org.springframework.util.StringUtils;
+
+import javax.annotation.Resource;
+import javax.sql.DataSource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @ClassName JiangjinRealListDao
+ * @Description: TODO
+ * @Author LX
+ * @Date 2024/11/28
+ * @Version V1.0
+ **/
+@Slf4j
+@Repository
+public class JiangjinRealListDao {
+    @Resource
+    private JdbcTemplate oneTemplate;
+
+    //TODO orcale相关
+    //TODO 获取满足条件的实时水量数据总数
+    public Integer getTabWaterRealCount(String extend){
+        try {
+            String sql = "select count(1)  from cqda.v_jiangjin_real_list ";
+            if(!StringUtils.isEmpty(extend)){
+                sql += extend;
+            }
+            int count = oneTemplate.queryForObject(sql, Integer.class);
+            return count;
+        }catch(Exception ex){
+            return null;
+        }
+    }
+
+    //TODO 获取实时水量数据
+    public List<Map<String,Object>> getListWaterReal(String extend){
+        try {
+            String sql = "SELECT * "+
+                    " FROM cqda.v_jiangjin_real_list " +
+                            " ORDER BY QCQUISITION_TIME DESC ";
+            List<Map<String, Object>> tableData = oneTemplate.queryForList(sql+extend);
+            return tableData;
+        }catch(Exception ex){
+            return null;
+        }
+    }
+
+    //TODO 获取满足条件的历史水量数据总数
+    public Integer getTabWaterHistoryCount(String extend){
+        try {
+            String sql = "select count(1)  from cqda.V_JIANGJIN_HISTORY ";
+            if(!StringUtils.isEmpty(extend)){
+                sql += " WHERE "+extend;
+            }
+            int count = oneTemplate.queryForObject(sql, Integer.class);
+            return count;
+        }catch(Exception ex){
+            return null;
+        }
+    }
+
+    //TODO 获取满足条件的历史水量数据
+    public List<Map<String,Object>> getPageListWaterHistory(int limit,int offset,String extend){
+        try {
+            String sql = "SELECT TAG_CODE, DEVICE_TYPE_CODE, TAG_STANDARD_CODE, DEVICE_CODE, QCQUISITION_TIME, VAL " +
+                    "FROM ( " +
+                    "    SELECT t.TAG_CODE, t.DEVICE_TYPE_CODE, t.TAG_STANDARD_CODE, t.DEVICE_CODE, t.QCQUISITION_TIME, t.VAL, " +
+                    "           ROW_NUMBER() OVER (ORDER BY t.QCQUISITION_TIME) AS rn " +
+                    "    FROM cqda.V_JIANGJIN_HISTORY t " +
+                    "    WHERE "+extend+
+                    ") subquery_alias " +
+                    "WHERE rn BETWEEN :offset AND :limit";
+
+            Map<String, Object> params = new HashMap<>();
+            params.put("offset", Integer.valueOf(offset));  // 确保是整数
+            params.put("limit", Integer.valueOf(limit));    // 确保是整数
+
+            NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(oneTemplate.getDataSource());
+            List<Map<String, Object>> tableData = namedParameterJdbcTemplate.queryForList(sql, params);
+            return tableData;
+        }catch(Exception ex){
+            ex.printStackTrace();
+            return null;
+        }
+    }
+}

dc3-gateway/src/main/java/io/github/pnoker/gateway/dbdao/jiangjinSource/services/JiangjinService.java

@@ -0,0 +1,19 @@
+package io.github.pnoker.gateway.dbdao.jiangjinSource.services;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @ClassName JiangjinService
+ * @Description: TODO
+ * @Author LX
+ * @Date 2024/11/28
+ * @Version V1.0
+ **/
+public interface JiangjinService {
+    public Integer getTabWaterRealCount(String extend);
+    public List<Map<String,Object>> getListWaterReal(String extend);
+
+    public Integer getTabWaterHistoryCount(String extend);
+    public List<Map<String,Object>> getPageListWaterHistory(int limit,int offset,String extend);
+}

dc3-gateway/src/main/java/io/github/pnoker/gateway/dbdao/jiangjinSource/services/impl/JiangjinServiceImpl.java

@@ -0,0 +1,43 @@
+package io.github.pnoker.gateway.dbdao.jiangjinSource.services.impl;
+
+import io.github.pnoker.gateway.dbdao.jiangjinSource.JiangjinRealListDao;
+import io.github.pnoker.gateway.dbdao.jiangjinSource.services.JiangjinService;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @ClassName JiangjinServiceImpl
+ * @Description: TODO
+ * @Author LX
+ * @Date 2024/11/28
+ * @Version V1.0
+ **/
+@Service
+public class JiangjinServiceImpl implements JiangjinService{
+
+    @Resource
+    private JiangjinRealListDao jiangjinRealListDao;
+
+    @Override
+    public Integer getTabWaterRealCount(String extend) {
+        return jiangjinRealListDao.getTabWaterRealCount(extend);
+    }
+
+    @Override
+    public List<Map<String, Object>> getListWaterReal(String extend) {
+        return jiangjinRealListDao.getListWaterReal(extend);
+    }
+
+    @Override
+    public Integer getTabWaterHistoryCount(String extend) {
+        return jiangjinRealListDao.getTabWaterHistoryCount(extend);
+    }
+
+    @Override
+    public List<Map<String, Object>> getPageListWaterHistory(int limit, int offset, String extend) {
+        return jiangjinRealListDao.getPageListWaterHistory(limit,offset,extend);
+    }
+}

dc3-gateway/src/main/java/io/github/pnoker/gateway/fallback/GatewayFallback.java

@@ -45,7 +45,7 @@ public class GatewayFallback implements HandlerFunction<ServerResponse> {
     public Mono<ServerResponse> handle(ServerRequest serverRequest) {
         log.info(serverRequest.toString());
         Optional<Object> originalUris = serverRequest.attribute(ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR);
-        originalUris.ifPresent(originalUri -> log.error("Request Url:{} , Service Fallback", originalUri));
+        originalUris.ifPresent(originalUri -> log.error("Request Url:{} , services Fallback", originalUri));
         R<String> response = R.fail("No available server for this request");
         return ServerResponse
                 .status(HttpStatus.INTERNAL_SERVER_ERROR.value())

dc3-gateway/src/main/resources/application.yml

@@ -139,6 +139,11 @@ spring:
         test-on-return: false
         idle-timeout: 30000
         connection-timeout: 30000
+      primary:
+            url: jdbc:oracle:thin:@10.127.16.117:1521/ORCLPDB1
+            username: v_jiangjin
+            password: JiangJin@1127
+            driver-class-name: oracle.jdbc.driver.OracleDriver
   jpa:
     show-sql: false
 
@@ -225,4 +230,13 @@ jiangjin:
 #    database: iot
     serverUrl: http://10.101.16.13:8086
 #    username: kpr
-#    password: kpr.2024dy.influxdb
+#    password: kpr.2024dy.influxdb
+
+# oracle数据源
+#spring:
+#  datasource:
+#    primary:
+#      url: jdbc:oracle:thin:@10.127.16.117:1521/ORCLPDB1
+#      username: v_jiangjin
+#      password: JiangJin@1127
+#      driver-class-name: oracle.jdbc.driver.OracleDriver