sis/realtime/generation-service/src/main/java/com/gyee/generation/init/CacheContext.java

package com.gyee.generation.init;


import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.gyee.common.model.StringUtils;
import com.gyee.generation.model.auto.*;
import com.gyee.generation.service.auto.*;
import com.gyee.generation.util.redis.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @ClassName : CacheContext
 * @Author : xieshengjie
 * @Date: 2021/5/18 9:35
 * @Description : 缓存
 */
@Component
public class CacheContext implements CommandLineRunner {
    Logger logger = LoggerFactory.getLogger(CacheContext.class);

    @Resource
    private IWindturbineService windturbineService;
    @Resource
    private ILineService lineService;
    @Resource
    private IProjectService projectService;
    @Resource
    private IWindpowerstationService windpowerstationService;
    @Resource
    private IMeterpointService meterpointService;
    @Resource
    private IEquipmentmodelService equipmentmodelService;
    @Resource
    private IWindturbinestatusdiService windturbinestatusdiService;
    @Resource
    private IWindturbinepowerService windturbinepowerService;
    @Resource
    private RedisService redisService;
    @Value("${runWindpowerstation}")
    private String runWindpowerstation;

    public static List<Windturbine> wtls = new ArrayList<>();
    public static List<Project> projects = new ArrayList<>();
    public static List<Line>  lines = new ArrayList<>();
    public static List<Windpowerstation>  wpls = new ArrayList<>();
    public static List<Meterpoint>  meterpoints = new ArrayList<>();
    public static Map<String,Meterpoint>  meterpointMap = new HashMap<>();
    public static Map<String,List<Project>> wppromap = new HashMap<>();
    public static Map<String,List<Line>> prolinemap = new HashMap<>();
    public static Map<String,List<Windturbine>> linewtmap = new HashMap<>();
    public static Map<String, Map<String, Windturbinetestingpointnew>> wtpAimap = new HashMap<>();// 风电机测点AI表
    public static Map<String,Map<String, Windpowerstationpointnew>> linepointmap =new HashMap<>();
    public static Map<String,Map<String, Windpowerstationpointnew>> propointmap =new HashMap<>();
    public static Map<String,Map<String, Windpowerstationpointnew>> wppointmap =new HashMap<>();
    public static Map<String,Project> proMap = new HashMap<>();
    public static Map<String,List<Windturbinestatusdi>> statusMap = new HashMap<>();
    public static Map<String,Map<Double,Double>> zbzglMap = new HashMap<>();
    public static Map<String,Equipmentmodel> modelMap = new HashMap<>();
    public static Map<String,Map<Double,Double>> zzsglMap = new HashMap<>();
    public static Map<String,Double> modelpower = new HashMap<>();
    @Override
    public void run(String... args) throws Exception {
        logger.info("缓存开始------------------------------------------------------------");
        List<String> runWpids = Arrays.asList(runWindpowerstation.split(","));
        logger.info(runWpids.get(0)+"------------------"+runWpids.size());

        List<Equipmentmodel> equipmentmodels = equipmentmodelService.list();
        equipmentmodels.stream().forEach(e->{
            modelMap.put(e.getId(),e);
        });

        wtls = windturbineService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationid())).collect(Collectors.toList());
        logger.info(wtls.size()+"");
        wtls.forEach(wt->{
            Equipmentmodel equipmentmodel = modelMap.get(wt.getModelid());
            modelpower.put(wt.getId(),equipmentmodel.getPowerproduction());

            String wtString = redisService.get(wt.getId());
            Map<String, Windturbinetestingpointnew> stringWindturbinetestingpointnewMap = JSONObject.parseObject(wtString, new TypeReference<Map<String, Windturbinetestingpointnew>>() {
            });
            wtpAimap.put(wt.getId(),stringWindturbinetestingpointnewMap);

            if (linewtmap.containsKey(wt.getLineid())){
                linewtmap.get(wt.getLineid()).add(wt);
            }else {
                List<Windturbine> lines = new ArrayList<>();
                lines.add(wt);
                linewtmap.put(wt.getLineid(),lines);
            }
        });

        projects = projectService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationid())).collect(Collectors.toList());
        projects.stream().forEach(p->{
            proMap.put(p.getId(),p);
            if (wppromap.containsKey(p.getWindpowerstationid())){
                wppromap.get(p.getWindpowerstationid()).add(p);
            }else {
                List<Project> prolist = new ArrayList<>();
                prolist.add(p);
                wppromap.put(p.getWindpowerstationid(),prolist);
            }
            String pjString = redisService.get(p.getId());
            Map<String, Windpowerstationpointnew> stringWindpowerstationpointnewMap = JSONObject.parseObject(pjString, new TypeReference<Map<String, Windpowerstationpointnew>>() {
            });
            propointmap.put(p.getId(),stringWindpowerstationpointnewMap);

        });

        lines = lineService.list().stream().filter(i-> StringUtils.isNotNull(proMap.get(i.getProjectid())) && runWpids.contains(proMap.get(i.getProjectid()).getWindpowerstationid())).collect(Collectors.toList());
        lines.stream().forEach(l->{
            if (prolinemap.containsKey(l.getProjectid())){
                prolinemap.get(l.getProjectid()).add(l);
            }else {
                List<Line> lineList = new ArrayList<>();
                lineList.add(l);
                prolinemap.put(l.getProjectid(),lineList);
            }
            String lnString = redisService.get(l.getId());
            Map<String, Windpowerstationpointnew> stringWindpowerstationpointnewMap = JSONObject.parseObject(lnString, new TypeReference<Map<String, Windpowerstationpointnew>>() {
            });
            linepointmap.put(l.getId(),stringWindpowerstationpointnewMap);
        });

        wpls = windpowerstationService.list().stream().filter(i->runWpids.contains(i.getId())).collect(Collectors.toList());;
        meterpoints = meterpointService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationid())).collect(Collectors.toList());
        meterpoints.stream().forEach(meterpoint -> {
            meterpointMap.put(meterpoint.getId(),meterpoint);
        });


        wpls.stream().forEach(wp->{
            String wpString = redisService.get(wp.getId());
            Map<String, Windpowerstationpointnew> stringMapMap = JSONObject.parseObject(wpString, new TypeReference<Map<String, Windpowerstationpointnew>>() {
            });
            wppointmap.put(wp.getId(),stringMapMap);
        });

        String sszzt = redisService.get("SSZZT");
         statusMap = JSONObject.parseObject(sszzt, new TypeReference<Map<String,List<Windturbinestatusdi>>>() {
        });



        String zbzgl = redisService.get("ZBZGL");
        zbzglMap = JSONObject.parseObject(zbzgl, new TypeReference<Map<String,Map<Double,Double>>>() {
        });

        List<Windturbinepower> windturbinepowerList = windturbinepowerService.list().stream().filter(windturbinepower -> runWindpowerstation.contains(windturbinepower.getWindpowerstationid())).collect(Collectors.toList());
        windturbinepowerList.stream().forEach(w -> {
            if (zzsglMap.containsKey(w.getWindturbineid())){
                zzsglMap.get(w.getWindturbineid()).put(w.getSpeed(),w.getTheorypower());
            }else {
                Map<Double,Double> tempMap = new HashMap<>();
                tempMap.put(w.getSpeed(),w.getTheorypower());
                zzsglMap.put(w.getWindturbineid(),tempMap);
            }

        });

//        String wpString = redisService.get("PRODUCT-WP");
//        wppointmap = JSONObject.parseObject(wpString, new TypeReference<Map<String, Map<String, Windpowerstationpointnew>>>() {
//        });
//        String pjString = redisService.get("PRODUCT-PJ");
//        propointmap = JSONObject.parseObject(pjString, new TypeReference<Map<String, Map<String, Windpowerstationpointnew>>>() {
//        });
//        String lnString = redisService.get("PRODUCT-LN");
//        linepointmap = JSONObject.parseObject(lnString, new TypeReference<Map<String, Map<String, Windpowerstationpointnew>>>() {
//        });

//        String wtString = redisService.get("PRODUCT-WT");
//        wtpAimap = JSONObject.parseObject(wtString, new TypeReference<Map<String, Map<String, Windturbinetestingpointnew>>>() {
//        });
        logger.info("缓存结束------------------------------------------------------------");
    }
}