redis缓存

web/runeconomy-jjyx/src/main/java/com/gyee/runeconomy/controller/bmk/MyTest.java

@@ -1,10 +1,18 @@
 package com.gyee.runeconomy.controller.bmk;
 
+import com.alibaba.fastjson.JSON;
+import com.gyee.common.model.StringUtils;
 import com.gyee.common.util.DoubleUtils;
 import com.gyee.runeconomy.init.CacheContext;
-import com.gyee.runeconomy.model.auto.ProBasicOrganizeTree;
+import com.gyee.runeconomy.model.auto.*;
+import com.gyee.runeconomy.model.fitting.ProBasicEquipmentBranchPoint;
+import com.gyee.runeconomy.model.fitting.ProBasicOrganizeEquipment;
 import com.gyee.runeconomy.model.fitting.ProEconInPowerCurveFitting;
+import com.gyee.runeconomy.service.auto.*;
+import com.gyee.runeconomy.service.fitting.IProBasicEquipmentBranchPointService;
+import com.gyee.runeconomy.service.fitting.IProBasicOrganizeEquipmentService;
 import com.gyee.runeconomy.service.fitting.IProEconInPowerCurveFittingService;
+import com.gyee.runeconomy.util.redis.RedisService;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
@@ -12,18 +20,45 @@ import org.springframework.stereotype.Component;
 import javax.annotation.Resource;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @Component
-@Order(2)
+@Order(1)
 public class MyTest implements CommandLineRunner {
 
     @Resource
+    private IProBasicOrganizeTreeService proBasicOrganizeTreeService;
+    @Resource
+    private IProBasicOrganizeEquipmentService proBasicOrganizeEquipmentService;
+    @Resource
+    private RedisService redisService;
+    @Resource
+    private IProEconWtPowerCurveFittingService wtPowerCurveFittingService;
+    @Resource
     private IProEconInPowerCurveFittingService inPowerCurveFittingService;
+    @Resource
+    private IProBasicEquipmentPointService proBasicEquipmentPointService;
+    @Resource
+    private IProBasicPowerstationPointService proBasicPowerstationPointService;
+    @Resource
+    private IProBasicBranchService proBasicBranchService;
+    @Resource
+    private IProEconEquipmentmodelService proEconEquipmentmodelService;
+    @Resource
+    private IProBasicModelPowerService proBasicModelPowerService;
+    @Resource
+    private IProEconPowerstationInfoDay7Service proEconPowerstationInfoDay7Service;
+    @Resource
+    private IProEconPowerstationInfoDay1Service proEconPowerstationInfoDay1Service;
+    @Resource
+    private IProBasicMeterPointService proBasicMeterPointService;
+    @Resource
+    private IProBasicEquipmentBranchPointService proBasicEquipmentBranchPointService;
 
     @Override
     public void run(String... args) throws Exception {
-        int count = inPowerCurveFittingService.count();
+        /*int count = inPowerCurveFittingService.count();
         if (count < 10000) {
             List<ProBasicOrganizeTree> collect = CacheContext.wtls.stream().filter(wtl -> wtl.getEleType().equals("G")).collect(Collectors.toList());
 
@@ -42,6 +77,57 @@ public class MyTest implements CommandLineRunner {
                 }
             }
             inPowerCurveFittingService.saveBatch(list);
-        }
+        }*/
+
+        /*List<ProBasicOrganizeTree> proBasicOrganizeTrees = proBasicOrganizeTreeService.list()
+                .stream().filter(pbot -> pbot.getIsAble() == 1 && StringUtils.isNotEmpty(pbot.getParentCode())).collect(Collectors.toList());
+
+        String proBasicOrganizeTreesString = JSON.toJSONString(proBasicOrganizeTrees);
+        redisService.set("proBasicOrganizeTrees", proBasicOrganizeTreesString);
+
+        List<ProBasicOrganizeEquipment> organizeEquipmentList = proBasicOrganizeEquipmentService.list().stream().filter(pboe -> pboe.getIsAble() == 1).collect(Collectors.toList());
+        String organizeEquipmentListString = JSON.toJSONString(organizeEquipmentList);
+        redisService.set("organizeEquipmentList", organizeEquipmentListString);
+
+        List<ProEconWtPowerCurveFitting> wtPowerCurveFittingList = wtPowerCurveFittingService.list();
+        String wtPowerCurveFittingListString = JSON.toJSONString(wtPowerCurveFittingList);
+        redisService.set("wtPowerCurveFittingList", wtPowerCurveFittingListString);
+        List<ProEconInPowerCurveFitting> inPowerCurveFittingList = inPowerCurveFittingService.list();
+        String inPowerCurveFittingListString = JSON.toJSONString(inPowerCurveFittingList);
+        redisService.set("inPowerCurveFittingList", inPowerCurveFittingListString);
+
+        List<ProBasicEquipmentPoint> proBasicEquipmentPointList = proBasicEquipmentPointService.list();
+        String proBasicEquipmentPointListString = JSON.toJSONString(proBasicEquipmentPointList);
+        redisService.set("proBasicEquipmentPointList", proBasicEquipmentPointListString);
+        List<ProBasicPowerstationPoint> proBasicPowerstationPoint = proBasicPowerstationPointService.list();
+        String proBasicPowerstationPointString = JSON.toJSONString(proBasicPowerstationPoint);
+        redisService.set("proBasicPowerstationPoint", proBasicPowerstationPointString);
+
+        List<ProBasicBranch> bnls = proBasicBranchService.list();
+        String bnlsString = JSON.toJSONString(bnls);
+        redisService.set("bnls", bnlsString);
+
+        List<ProEconEquipmentmodel> equipmentmodels = proEconEquipmentmodelService.list();
+        String equipmentmodelsString = JSON.toJSONString(equipmentmodels);
+        redisService.set("equipmentmodels", equipmentmodelsString);
+
+        List<ProBasicModelPower> mpls = proBasicModelPowerService.list();
+        String mplsString = JSON.toJSONString(mpls);
+        redisService.set("mpls", mplsString);
+
+        List<ProEconPowerstationInfoDay7> station7ls = proEconPowerstationInfoDay7Service.list().stream().filter(i -> i.getId() != null).collect(Collectors.toList());
+        String station7lsString = JSON.toJSONString(station7ls);
+        redisService.set("station7ls", station7lsString);
+
+        List<ProEconPowerstationInfoDay1> station1ls = proEconPowerstationInfoDay1Service.list().stream().filter(i -> i.getId() != null).collect(Collectors.toList());
+        String station1lsString = JSON.toJSONString(station1ls);
+        redisService.set("station1ls", station1lsString);
+
+        List<ProBasicMeterPoint> meterpoints = proBasicMeterPointService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        String meterpointsString = JSON.toJSONString(meterpoints);
+        redisService.set("meterpoints", meterpointsString);
+        List<ProBasicEquipmentBranchPoint> proBasicEquipmentBranchPointList = proBasicEquipmentBranchPointService.list();
+        String proBasicEquipmentBranchPointListString = JSON.toJSONString(proBasicEquipmentBranchPointList);
+        redisService.set("proBasicEquipmentBranchPointList", proBasicEquipmentBranchPointListString);*/
     }
 }

web/runeconomy-jjyx/src/main/java/com/gyee/runeconomy/init/CacheContext.java

@@ -32,7 +32,7 @@ import java.util.stream.Collectors;
  * @Description : 缓存
  */
 @Component
-@Order(1)
+@Order(2)
 public class CacheContext implements CommandLineRunner {
     Logger logger = LoggerFactory.getLogger(CacheContext.class);
 
@@ -95,7 +95,6 @@ public class CacheContext implements CommandLineRunner {
     private IProEconWtPowerCurveFittingService wtPowerCurveFittingService;
     @Resource
     private IProEconInPowerCurveFittingService inPowerCurveFittingService;
-
     @Resource
     private IProBasicEquipmentBranchPointService proBasicEquipmentBranchPointService;
 
@@ -199,25 +198,36 @@ public class CacheContext implements CommandLineRunner {
     @Override
     public void run(String... args) throws Exception {
         logger.info("缓存开始------------------------------------------------------------");
-        proBasicOrganizeTrees = proBasicOrganizeTreeService.list();
-        proBasicOrganizeTrees = proBasicOrganizeTrees.stream().filter(pbot -> pbot.getIsAble() == 1 && StringUtils.isNotEmpty(pbot.getParentCode())).collect(Collectors.toList());
+
+        //proBasicOrganizeTrees = proBasicOrganizeTreeService.list();
+        //proBasicOrganizeTrees = proBasicOrganizeTrees.stream().filter(pbot -> pbot.getIsAble() == 1 && StringUtils.isNotEmpty(pbot.getParentCode())).collect(Collectors.toList());
+
+        proBasicOrganizeTrees = JSONObject.parseObject(redisService.get("proBasicOrganizeTrees"), new TypeReference<List<ProBasicOrganizeTree>>() {});
         proBasicOrganizeTreesMap = proBasicOrganizeTrees.stream().collect(Collectors.toMap(ProBasicOrganizeTree::getId, Function.identity()));
 
-        organizeEquipmentList = proBasicOrganizeEquipmentService.list().stream().filter(pboe -> pboe.getIsAble() == 1).collect(Collectors.toList());
+        //organizeEquipmentList = proBasicOrganizeEquipmentService.list().stream().filter(pboe -> pboe.getIsAble() == 1).collect(Collectors.toList());
+        //wtPowerCurveFittingList = wtPowerCurveFittingService.list();
+        //inPowerCurveFittingList = inPowerCurveFittingService.list();
+        organizeEquipmentList = JSONObject.parseObject(redisService.get("organizeEquipmentList"), new TypeReference<List<ProBasicOrganizeEquipment>>() {});
         organizeEquipmentList = organizeEquipmentList.stream().filter(oe->"IN".equals(oe.getEqType())).collect(Collectors.toList());
-        wtPowerCurveFittingList = wtPowerCurveFittingService.list();
-        inPowerCurveFittingList = inPowerCurveFittingService.list();
+        wtPowerCurveFittingList = JSONObject.parseObject(redisService.get("wtPowerCurveFittingList"), new TypeReference<List<ProEconWtPowerCurveFitting>>() {});
+        inPowerCurveFittingList = JSONObject.parseObject(redisService.get("inPowerCurveFittingList"), new TypeReference<List<ProEconInPowerCurveFitting>>() {});
         inPowerCurveFittingMap = inPowerCurveFittingList.stream().collect(Collectors.groupingBy(ProEconInPowerCurveFitting::getInverterId));
 
-        proBasicEquipmentPointList = proBasicEquipmentPointService.list();
-        proBasicPowerstationPoint = proBasicPowerstationPointService.list();
-        proBasicEquipmentBranchPointList = proBasicEquipmentBranchPointService.list();
+        //proBasicEquipmentPointList = proBasicEquipmentPointService.list();
+        //proBasicPowerstationPoint = proBasicPowerstationPointService.list();
+        //proBasicEquipmentBranchPointList = proBasicEquipmentBranchPointService.list();
+        proBasicEquipmentPointList = JSONObject.parseObject(redisService.get("proBasicEquipmentPointList"), new TypeReference<List<ProBasicEquipmentPoint>>() {});
+        proBasicPowerstationPoint = JSONObject.parseObject(redisService.get("proBasicPowerstationPoint"), new TypeReference<List<ProBasicPowerstationPoint>>() {});
+        proBasicEquipmentBranchPointList = JSONObject.parseObject(redisService.get("proBasicEquipmentBranchPointList"), new TypeReference<List<ProBasicEquipmentBranchPoint>>() {});
 
 
         //List<String> pbotids = proBasicOrganizeTrees.stream().map(pbot -> pbot.getId()).collect(Collectors.toList());
         //Map<String, Object> pbotidMap = redisService.batchGetKeys(pbotids);
 
-        bnls = proBasicBranchService.list();
+        //bnls = proBasicBranchService.list();
+        bnls = JSONObject.parseObject(redisService.get("bnls"), new TypeReference<List<ProBasicBranch>>() {});
+        bnlsMap = bnls.stream().collect(Collectors.toMap(ProBasicBranch::getId, Function.identity()));
         bnlsMap = bnls.stream().collect(Collectors.toMap(ProBasicBranch::getId, Function.identity()));
         //List<String> bnlids = bnls.stream().map(bnl -> bnl.getId()).collect(Collectors.toList());
         //Map<String, Object> objectMap = redisService.batchGetKeys(bnlids);
@@ -236,11 +246,13 @@ public class CacheContext implements CommandLineRunner {
             }
         });*/
 
-        equipmentmodels = proEconEquipmentmodelService.list();
+        //equipmentmodels = proEconEquipmentmodelService.list();
+        equipmentmodels = JSONObject.parseObject(redisService.get("equipmentmodels"), new TypeReference<List<ProEconEquipmentmodel>>() {});
         equipmentmodels.stream().forEach(e -> {
             modelMap.put(e.getId(), e);
         });
-        mpls = proBasicModelPowerService.list();
+        //mpls = proBasicModelPowerService.list();
+        mpls = JSONObject.parseObject(redisService.get("mpls"), new TypeReference<List<ProBasicModelPower>>() {});
         mpls.sort(Comparator.comparing(ProBasicModelPower::getSpeed));
         if (!mpls.isEmpty()) {
 
@@ -257,20 +269,18 @@ public class CacheContext implements CommandLineRunner {
             }
         }
 
-        treels = proBasicOrganizeTreeService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        treels = proBasicOrganizeTrees.stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
 
         //树形方阵
-        sqls = proBasicOrganizeTreeService.list().stream().filter(i -> i.getOrgType().equals("AG") && i.getIsAble() == 1).collect(Collectors.toList());
+        sqls = proBasicOrganizeTrees.stream().filter(i -> i.getOrgType().equals("AG") && i.getIsAble() == 1).collect(Collectors.toList());
         if (!sqls.isEmpty()) {
             for (ProBasicOrganizeTree sq : sqls) {
                 sqmap.put(sq.getParentCode(), sq);
             }
         }
-        List<ProBasicOrganizeTree> proBasicOrganizeTrees = proBasicOrganizeTreeService.list();
-        proBasicOrganizeTrees = proBasicOrganizeTrees.stream().filter(pbot -> pbot.getIsAble() == 1).collect(Collectors.toList());
-
 
-        station7ls = proEconPowerstationInfoDay7Service.list().stream().filter(i -> i.getId() != null).collect(Collectors.toList());
+        //station7ls = proEconPowerstationInfoDay7Service.list().stream().filter(i -> i.getId() != null).collect(Collectors.toList());
+        station7ls = JSONObject.parseObject(redisService.get("station7ls"), new TypeReference<List<ProEconPowerstationInfoDay7>>() {});
         if (!station7ls.isEmpty()) {
             for (ProEconPowerstationInfoDay7 sq : station7ls) {
                 station7map.put(sq.getForeignKeyId(), sq);
@@ -278,7 +288,8 @@ public class CacheContext implements CommandLineRunner {
 
         }
 
-        station1ls = proEconPowerstationInfoDay1Service.list().stream().filter(i -> i.getId() != null).collect(Collectors.toList());
+        //station1ls = proEconPowerstationInfoDay1Service.list().stream().filter(i -> i.getId() != null).collect(Collectors.toList());
+        station1ls = JSONObject.parseObject(redisService.get("station1ls"), new TypeReference<List<ProEconPowerstationInfoDay1>>() {});
         if (!station1ls.isEmpty()) {
             for (ProEconPowerstationInfoDay1 sq : station1ls) {
                 station1map.put(sq.getForeignKeyId(), sq);
@@ -287,7 +298,7 @@ public class CacheContext implements CommandLineRunner {
         }
 
         //三级公司
-        cpls = proBasicOrganizeTreeService.list().stream().filter(i -> i.getIsAble().equals(1) && i.getOrgType().contains("ZGS")).collect(Collectors.toList());
+        cpls = proBasicOrganizeTrees.stream().filter(i -> i.getIsAble().equals(1) && i.getOrgType().contains("ZGS")).collect(Collectors.toList());
         if (!cpls.isEmpty()) {
             for (ProBasicOrganizeTree sq : cpls) {
                 cpmap.put(sq.getId(), sq);
@@ -382,7 +393,7 @@ public class CacheContext implements CommandLineRunner {
             }
         }
 
-        wpls = proBasicOrganizeTreeService.list().stream().filter(i -> i.getIsAble() == 1 && i.getOrgType().contains("STA")).collect(Collectors.toList());
+        wpls = proBasicOrganizeTrees.stream().filter(i -> i.getIsAble() == 1 && i.getOrgType().contains("STA")).collect(Collectors.toList());
         for (ProBasicOrganizeTree wp : wpls) {
             if (cpwpmap.containsKey(wp.getOrgType().contains("STA"))) {
                 cpwpmap.get(wp.getOrgType().contains("STA")).add(wp);
@@ -502,7 +513,6 @@ public class CacheContext implements CommandLineRunner {
             }
         }
 
-
         //期次场站树形
         pjls = proBasicOrganizeTrees.stream().filter(i -> i.getOrgType().contains("EG")).collect(Collectors.toList());
 
@@ -523,7 +533,7 @@ public class CacheContext implements CommandLineRunner {
         });
 
 
-        subwpls = proBasicOrganizeTreeService.list().stream().filter(i -> i.getIsAble() == 1 && i.getOrgType().contains("SBS")).collect(Collectors.toList());
+        subwpls = proBasicOrganizeTrees.stream().filter(i -> i.getIsAble() == 1 && i.getOrgType().contains("SBS")).collect(Collectors.toList());
         /*subwpls.stream().forEach(sub->{
 
             String subString = redisService.get(sub.getId());
@@ -534,7 +544,8 @@ public class CacheContext implements CommandLineRunner {
         });*/
 
 
-        weawpls = proBasicWeatherStationService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        //weawpls = proBasicWeatherStationService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        weawpls = JSONObject.parseObject(redisService.get("weawpls"), new TypeReference<List<ProBasicWeatherStation>>() {});
         /*weawpls.stream().forEach(weather -> {
 
             String subString = redisService.get(weather.getId());
@@ -573,7 +584,8 @@ public class CacheContext implements CommandLineRunner {
                 cpwpmap.put(wp.getOrgType().contains("ZGS"), wps);
             }
         }
-        meterpoints = proBasicMeterPointService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        //meterpoints = proBasicMeterPointService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        meterpoints = JSONObject.parseObject(redisService.get("meterpoints"), new TypeReference<List<ProBasicMeterPoint>>() {});
         meterpoints.stream().forEach(meterpoint -> {
             meterpointMap.put(meterpoint.getId(), meterpoint);
         });