添加适配器模块

data-adapter/src/main/java/com/gyee/wisdom/Bootstrap.java

@@ -0,0 +1,26 @@
+package com.gyee.wisdom;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.servlet.ServletComponentScan;
+import org.springframework.cache.annotation.EnableCaching;
+
+/**
+ * @author northriver
+ */
+@EnableCaching
+@SpringBootApplication
+@ServletComponentScan
+public class Bootstrap {
+
+    public static void main(String[] args) {
+
+      SpringApplication.run(Bootstrap.class, args);
+   /*     PointList.pointListInit();
+        PointList.MapInit();
+        Thread t = new ReadAndWrite();
+        t.start();*/
+    }
+}
+
+

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/configuration/WebConfig.java

@@ -0,0 +1,22 @@
+package com.gyee.wisdom.dataadapter.configuration;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * 跨域配置
+ * @author xysn
+ */
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowedOriginPatterns("*")
+                .allowedMethods("GET","HEAD","POST","PUT","DELETE","OPTIONS")
+                .allowCredentials(true)
+                .maxAge(3600)
+                .allowedHeaders("*");
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/controller/thing/CategoryController.java

@@ -0,0 +1,36 @@
+package com.gyee.wisdom.dataadapter.controller.thing;
+
+import com.gyee.wisdom.common.data.alarm.WarningClassify;
+import com.gyee.wisdom.common.data.windturbine.PowerStation;
+import com.gyee.wisdom.common.data.windturbine.Windturbine;
+import com.gyee.wisdom.dataadapter.domain.thing.DataDictionaryService;
+import com.gyee.wisdom.dataadapter.domain.thing.StationService;
+import com.gyee.wisdom.dataadapter.domain.thing.WindturbineService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+/*
+ *
+ * @author songwb
+ */
+
+
+@RestController
+@RequestMapping("/category")
+@CrossOrigin
+public class CategoryController {
+
+    @Autowired
+    protected DataDictionaryService dataDictionaryService;
+
+    @GetMapping("/warningclassify")
+    public List<WarningClassify> getWarningClassify() {
+        return dataDictionaryService.getWarningClassify();
+    }
+
+}
+
+

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/controller/thing/ThingController.java

@@ -0,0 +1,77 @@
+package com.gyee.wisdom.dataadapter.controller.thing;
+
+import com.gyee.wisdom.common.data.alarm.WarningClassify;
+import com.gyee.wisdom.common.data.timeseries.DoubleStatData;
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import com.gyee.wisdom.common.data.timeseries.TsPointData;
+import com.gyee.wisdom.common.data.timeseries.TsPointDataList;
+import com.gyee.wisdom.common.data.windturbine.PowerStation;
+import com.gyee.wisdom.common.data.windturbine.Windturbine;
+import com.gyee.wisdom.dataadapter.domain.thing.StationService;
+import com.gyee.wisdom.dataadapter.domain.thing.WindturbineService;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsDataService;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsPointService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+
+/*
+ *
+ * @author songwb
+ */
+
+
+@RestController
+@RequestMapping("/thing")
+@CrossOrigin
+public class ThingController {
+
+    @Autowired
+    protected WindturbineService windturbineService;
+
+    @Autowired
+    protected StationService stationService;
+
+    @GetMapping("/windturbine")
+    public List<Windturbine> getWindturbines(
+            @RequestParam(value = "stationId", required = false) Optional<String> stationId,
+            @RequestParam(value = "modelId", required = false) Optional<String> modelId
+    ) {
+        if (stationId.isPresent()) {
+            if (modelId.isPresent()) {
+                return windturbineService.queryWindturbine(stationId.get(), modelId.get());
+            } else {
+                return windturbineService.findByStationId(stationId.get());
+            }
+        } else if (modelId.isPresent()) {
+            return windturbineService.findByModelId(modelId.get());
+        } else {
+            return windturbineService.find();
+        }
+    }
+
+    @GetMapping("/windturbine/{id}")
+    public Windturbine getWindturbine(
+            @PathVariable("id") String wtId
+    ) {
+        return  windturbineService.findbyid(wtId);
+    }
+
+    @GetMapping("/station")
+    public List<PowerStation> getStations() {
+        return stationService.getAll();
+    }
+
+    @GetMapping("/station/{id}")
+    public PowerStation getStation(
+            @PathVariable("id") String stId
+    ) {
+        return  stationService.getStationById(stId);
+    }
+
+
+
+}
+
+

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/controller/timeseries/TsDataController.java

@@ -0,0 +1,234 @@
+package com.gyee.wisdom.dataadapter.controller.timeseries;
+
+import com.alibaba.fastjson.JSONObject;
+import com.gyee.wisdom.common.data.timeseries.*;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsDataService;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsPointService;
+import org.apache.commons.beanutils.ConvertUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+/*
+ *
+ * @author songwb
+ */
+
+
+@RestController
+@RequestMapping("/ts")
+@CrossOrigin
+public class TsDataController {
+
+    @Autowired
+    protected TsDataService tsDataService;
+
+    @Autowired
+    protected TsPointService tsPointService;
+
+
+
+    //thingId：具体设施Id
+    //thingType：场站(station)，风机(windturbine)，升压站(electrical)
+    //uniformCode：统一编码
+    @GetMapping("/latest")
+    public Map<String, TsData> getLatest(
+            @RequestParam(value = "keys", required = false) Optional<String> keyStr,
+            @RequestParam(value = "thingType", required = false) Optional<String> thingType,
+            @RequestParam(value = "thingId", required = false) Optional<String> thingId,
+            @RequestParam(value = "uniformCodes", required = false) Optional<String> uniformCodes
+    ) {
+        if (keyStr.isPresent()) {
+            String[] tagNames = keyStr.get().split(",");
+            Map<String, TsData> data = tsDataService.getLatest(tagNames);
+            if (data == null) {
+                Map<String, TsData> nullData = new HashMap<>();
+                return nullData;
+            } else {
+                return data;
+            }
+        } else if (thingType.isPresent() && thingId.isPresent() && uniformCodes.isPresent()) {
+            String[] uCodes = uniformCodes.get().split(",");
+            return tsDataService.getLatestByUniformCodes(thingType.get(), thingId.get(), uCodes);
+        } else {
+            Map<String, TsData> nullData = new HashMap<>();
+            return nullData;
+        }
+    }
+
+    @GetMapping("/history/raw")
+    public List<TsData> getHistoryRaw(@RequestParam(value = "tagName", required = false) Optional<String> tagName,
+                                      @RequestParam(value = "thingType", required = false) Optional<String> thingType,
+                                      @RequestParam(value = "thingId", required = false) Optional<String> thingId,
+                                      @RequestParam(value = "uniformCode", required = false) Optional<String> uniformCode,
+                                      @RequestParam(value = "startTs", required = false) Optional<Long> startTs,
+                                      @RequestParam(value = "endTs", required = false) Optional<Long> endTs) {
+        if (tagName.isPresent() && startTs.isPresent() && endTs.isPresent()) {
+            List<TsData> list = tsDataService.getHistoryRaw(tagName.get(), startTs.get(), endTs.get());
+            if (list == null)
+                list = new ArrayList<>();
+            return list;
+        }
+
+        if (thingType.isPresent() && thingId.isPresent() && uniformCode.isPresent() && startTs.isPresent() && endTs.isPresent()) {
+            List<TsData> list = tsDataService.getHistoryRaw(thingType.get(), thingId.get(), uniformCode.get(), startTs.get(), endTs.get());
+            if (list == null)
+                list = new ArrayList<>();
+            return list;
+        } else {
+            List<TsData> list = new ArrayList<>();
+            return list;
+        }
+
+    }
+
+    @GetMapping("/history/snap")
+    public List<TsData> getHistorySnap(@RequestParam(value = "tagName", required = false) Optional<String> tagName,
+                                       @RequestParam(value = "thingId", required = false) Optional<String> thingId,
+                                       @RequestParam(value = "thingType", required = false) Optional<String> thingType,
+                                       @RequestParam(value = "uniformCode", required = false) Optional<String> uniformCode,
+                                       @RequestParam(value = "startTs", required = false) Optional<Long> startTs,
+                                       @RequestParam(value = "endTs", required = false) Optional<Long> endTs,
+                                       @RequestParam(value = "interval", required = false) Optional<Integer> interval) {
+        if (tagName.isPresent() && startTs.isPresent() && endTs.isPresent()) {
+            int intVal = interval.isPresent()?interval.get():60;
+            List<TsData> resultMap = tsDataService.getHistorySnap(tagName.get(), startTs.get(), endTs.get(), intVal);
+            if (resultMap == null)
+                resultMap = new ArrayList<>();
+            return resultMap;
+        } else if (thingId.isPresent() && thingType.isPresent() && uniformCode.isPresent() && startTs.isPresent() && endTs.isPresent()) {
+            int intVal = interval.isPresent()?interval.get():60;
+            List<TsData> resultMap = tsDataService.getHistorySnap(thingType.get(), thingId.get(), uniformCode.get(), startTs.get(), endTs.get(), intVal);
+            if (resultMap == null)
+                resultMap = new ArrayList<>();
+            return resultMap;
+        } else {
+            List<TsData> resultMap = new ArrayList<>();
+            return resultMap;
+        }
+    }
+
+    @GetMapping("/history/stat")
+    public List<DoubleStatData> getHistoryStat(@RequestParam(value = "tagName", required = false) Optional<String> tagName,
+                                               @RequestParam(value = "thingType", required = false) Optional<String> thingType,
+                                               @RequestParam(value = "thingId", required = false) Optional<String> thingId,
+                                               @RequestParam(value = "uniformCode", required = false) Optional<String> uniformCode,
+                                               @RequestParam(value = "startTs", required = false) Optional<Long> startTs,
+                                               @RequestParam(value = "endTs", required = false) Optional<Long> endTs,
+                                               @RequestParam(value = "interval", required = false) Optional<Integer> interval) {
+        if (tagName.isPresent() && startTs.isPresent() && endTs.isPresent()) {
+            int intVal = interval.isPresent()?interval.get():60;
+            List<DoubleStatData> list = tsDataService.getHistoryStat(tagName.get(), startTs.get(), endTs.get(), intVal);
+            if (list == null)
+                list = new ArrayList<>();
+            return list;
+        } else if (thingType.isPresent() && thingId.isPresent() && uniformCode.isPresent() && startTs.isPresent() && endTs.isPresent()) {
+            int intVal = interval.isPresent()?interval.get():60;
+            List<DoubleStatData> list = tsDataService.getHistoryStat(thingType.get(), thingId.get(), uniformCode.get(), startTs.get(), endTs.get(), intVal);
+            if (list == null)
+                list = new ArrayList<>();
+            return list;
+        } else {
+            List<DoubleStatData> list = new ArrayList<>();
+            return list;
+        }
+    }
+
+    @GetMapping("/history/section")
+    public Map<String, TsData> getHistorySection(@RequestParam(value = "tagNames", required = false) Optional<String> tagNames,
+                                                 @RequestParam(value = "thingType", required = false) Optional<String> thingType,
+                                                 @RequestParam(value = "thingId", required = false) Optional<String> thingId,
+                                                 @RequestParam(value = "uniformCodes", required = false) Optional<String> uniformCodes,
+                                                 @RequestParam(value = "ts", required = false) Optional<Long> ts) throws Exception {
+        try {
+            if (tagNames.isPresent() && ts.isPresent()) {
+                String[] tagNameArr = tagNames.get().split(",");
+                Map<String, TsData> map = tsDataService.getHistorySection(ts.get(), tagNameArr);
+                if (map == null)
+                    map = new HashMap<>();
+                return map;
+            } else if (thingType.isPresent() && thingId.isPresent() && uniformCodes.isPresent() && ts.isPresent()) {
+                String[] unifromCodeArray = uniformCodes.get().split(",");
+                Map<String, TsData> map = tsDataService.getHistorySection(ts.get(), thingId.get(), thingType.get(), unifromCodeArray);
+                if (map == null)
+                    map = new HashMap<>();
+                return map;
+            } else {
+                Map<String, TsData> map = new HashMap<>();
+                return map;
+            }
+
+        } catch (Exception e) {
+            Map<String, TsData> map = new HashMap<>();
+            return map;
+        }
+
+    }
+
+    @PostMapping("/history/batch")
+    //@ResponseBody
+    public boolean writeHistoryBatch(@RequestBody List<TsPointData> tsDataList) {
+        try {
+            tsDataService.writeHistory(tsDataList);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    @PostMapping("/history")
+   //@ResponseBody
+    public boolean writeHistory(@RequestBody TsPointData tsData) {
+        try {
+            List<TsPointData> list = new ArrayList<>();
+            list.add(tsData);
+            tsDataService.writeHistory(list);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    @PostMapping("/history/list")
+    //@ResponseBody
+    public boolean writeHistoryList(@RequestBody TsPointDataList tsData) {
+        try {
+            List<TsPointData> tsDataList = new ArrayList<>();
+            if (tsData != null) {
+                for (int i = 0; i < tsData.getTsDataList().size(); i++) {
+                    TsPointData data = new TsPointData();
+                    data.setTagName(tsData.getTagName());
+                    data.setTsData(tsData.getTsDataList().get(i));
+                    tsDataList.add(data);
+                }
+                tsDataService.writeHistory(tsDataList);
+                return true;
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+
+    }
+
+    @PostMapping("/latest/batch")
+    //@ResponseBody
+    public boolean writeLatestBatch(@RequestBody List<TsPointData> tsDataList) throws Exception {
+        return tsDataService.writeLatest(tsDataList);
+    }
+
+    @PostMapping("/latest")
+    //@ResponseBody
+    public boolean writeLatest(@RequestBody TsPointData tsData) throws Exception {
+        List<TsPointData> tsDataList = new ArrayList<>();
+        tsDataList.add(tsData);
+        return tsDataService.writeLatest(tsDataList);
+    }
+
+}
+
+

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/thing/DataDictionaryService.java

@@ -0,0 +1,23 @@
+package com.gyee.wisdom.dataadapter.domain.thing;
+
+import com.gyee.wisdom.common.data.alarm.WarningClassify;
+import com.gyee.wisdom.common.data.windturbine.Line;
+import com.gyee.wisdom.dao.alarm.WarningDao;
+import com.gyee.wisdom.dao.windturbine.ILineDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class DataDictionaryService {
+
+    @Autowired
+    protected WarningDao warningDao;
+
+    public List<WarningClassify> getWarningClassify() {
+        return warningDao.findAllWarningClassify();
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/thing/LineService.java

@@ -0,0 +1,35 @@
+package com.gyee.wisdom.dataadapter.domain.thing;
+
+import com.gyee.wisdom.common.data.windturbine.Line;
+import com.gyee.wisdom.dao.windturbine.ILineDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class LineService{
+
+    @Autowired
+    protected ILineDao jpaLineDao;
+
+    public void save(Line line){
+        jpaLineDao.save(line);
+    }
+
+    public List<Line> findAll(){
+        return jpaLineDao.findAll();
+    }
+
+    public Line findById(String id){
+        return jpaLineDao.findById(id);
+    }
+
+    public void delete(String id){
+        jpaLineDao.deletebyid(id);
+    }
+
+    public List<Line> findByprojectId(String id){
+        return jpaLineDao.findByprojectId(id);
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/thing/ModelService.java

@@ -0,0 +1,31 @@
+package com.gyee.wisdom.dataadapter.domain.thing;
+
+import com.gyee.wisdom.common.data.windturbine.EquipmentModel;
+import com.gyee.wisdom.dao.windturbine.IModelDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class ModelService {
+
+    @Autowired
+    protected IModelDao jpaModelDao;
+
+    public void save(EquipmentModel equipmentModel){
+        jpaModelDao.save(equipmentModel);
+    }
+
+    public List<EquipmentModel> findAll(){
+        return jpaModelDao.findAll();
+    }
+
+    public EquipmentModel findById(String id){
+        return jpaModelDao.findById(id);
+    }
+
+    public void delete(String id){
+        jpaModelDao.deletebyid(id);
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/thing/ProjectService.java

@@ -0,0 +1,97 @@
+package com.gyee.wisdom.dataadapter.domain.thing;
+import com.gyee.wisdom.common.data.windturbine.Line;
+import com.gyee.wisdom.common.data.windturbine.PowerStation;
+import com.gyee.wisdom.common.data.windturbine.Project;
+import com.gyee.wisdom.common.data.windturbine.Windturbine;
+import com.gyee.wisdom.dao.windturbine.ILineDao;
+import com.gyee.wisdom.dao.windturbine.IPowerStationDao;
+import com.gyee.wisdom.dao.windturbine.IProjectDao;
+import com.gyee.wisdom.dao.windturbine.IWindturbineDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class ProjectService {
+
+    @Autowired
+    protected IProjectDao jpaprojectDao;
+    @Autowired
+    protected IWindturbineDao jpawindturbineDao;
+    @Autowired
+    protected ILineDao jpalineDao;
+    @Autowired
+    protected IPowerStationDao jpapowerstationDao;
+
+    public List<Project> findAll() {
+        return jpaprojectDao.findAll();
+    }
+
+    public Project findById(String id) {
+        return jpaprojectDao.findbyid(id);
+    }
+
+    public void save(Project project) {
+        jpaprojectDao.save(project);
+    }
+
+    public void delete(String id) {
+        jpaprojectDao.delete(id);
+    }
+
+    public List<Project> findbystationId(String stationId) {
+        return jpaprojectDao.findbyStationId(stationId);
+    }
+
+    public Map<String, Map<String, String>> getProjectmap() {
+        Map<String, Map<String, String>> projectmap = new HashMap<>();
+        List<PowerStation> powerStationlist = jpapowerstationDao.getAll();
+        for (PowerStation pj : powerStationlist) {
+            Map<String, String> map = new HashMap<>();
+            projectmap.put(pj.getId(), map);
+        }
+
+        List<Project> projectlist = jpaprojectDao.findAll();
+        for(Project project:projectlist){
+            projectmap.get(project.getStationId()).put(project.getId(),project.getName());
+        }
+            return projectmap;
+        }
+
+
+    public Map<String, Map<String, String>> getLinemap() {
+        Map<String, Map<String, String>> linemap = new HashMap<>();
+        List<Project> projectlist = jpaprojectDao.findAll();
+        for (Project pj : projectlist) {
+            Map<String, String> map = new HashMap<>();
+            linemap.put(pj.getId(), map);
+        }
+
+        List<Line> linelist = jpalineDao.findAll();
+        for(Line line:linelist){
+            linemap.get(line.getProjectId()).put(line.getId(),line.getName());
+        }
+        return linemap;
+    }
+
+
+    public Map<String, Map<String, String>> getWinturbinemap() {
+        Map<String, Map<String, String>> windturbinemap = new HashMap<>();
+        List<Line> linelist = jpalineDao.findAll();
+        for (Line ln : linelist) {
+            Map<String, String> map = new HashMap<>();
+            windturbinemap.put(ln.getId(), map);
+        }
+
+        List<Windturbine> windturbinelist = jpawindturbineDao.find();
+        for(Windturbine windturbine:windturbinelist){
+            windturbinemap.get(windturbine.getModelId()).put(windturbine.getId(),windturbine.getName());
+        }
+        return windturbinemap;
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/thing/StationService.java

@@ -0,0 +1,45 @@
+package com.gyee.wisdom.dataadapter.domain.thing;
+
+import com.gyee.wisdom.common.data.windturbine.PowerStation;
+import com.gyee.wisdom.common.utils.StringUtil;
+import com.gyee.wisdom.dao.windturbine.IPowerStationDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class StationService {
+
+    @Autowired
+    protected IPowerStationDao stationDao;
+
+    public List<PowerStation> getAll() {
+        List<PowerStation> stationList = stationDao.getAll();
+        return stationList;
+    }
+
+    public PowerStation getStationById(String id) {
+        return stationDao.getStationById(id);
+    }
+
+    public void add(PowerStation newStation) {
+        stationDao.add(newStation);
+    }
+
+    public void modify(PowerStation station) {
+        if (StringUtil.isNotBlank(station.getId())) {
+            stationDao.update(station);
+        }
+    }
+
+    public void delete(PowerStation station) {
+        if (StringUtil.isNotBlank(station.getId()))
+            stationDao.delete(station.getId());
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/thing/WindturbineService.java

@@ -0,0 +1,64 @@
+package com.gyee.wisdom.dataadapter.domain.thing;
+
+import com.gyee.wisdom.common.data.windturbine.Windturbine;
+import com.gyee.wisdom.dao.windturbine.IWindturbineDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class WindturbineService {
+    @Autowired
+    protected IWindturbineDao jpawindturbineDao;
+
+    /**
+     * del:删除数据
+     *
+     * @param id
+     */
+    public void delete(String id) {
+        jpawindturbineDao.del(id);
+    }
+
+    /**
+     * chan:修改数据
+     *
+     * @param windturbine
+     */
+    public void save(Windturbine windturbine) {
+        jpawindturbineDao.save(windturbine);
+
+    }
+
+    /**
+     * seleall:查询全部
+     */
+    public List<Windturbine> find() {
+        List<Windturbine> lw = jpawindturbineDao.find();
+        return lw;
+    }
+
+    /**
+     * seleone:查询单个
+     */
+    public Windturbine findbyid(String id) {
+        return jpawindturbineDao.findbyid(id);
+    }
+
+    public List<Windturbine> findByStationId(String stationId) {
+        return jpawindturbineDao.findByStationId(stationId);
+    }
+
+    public List<Windturbine> findByModelId(String modelId) {
+        return jpawindturbineDao.findByModelId(modelId);
+    }
+
+    public List<Windturbine> queryWindturbine(String stationId, String modelId) {
+        return jpawindturbineDao.findByStationIdAndModelId(stationId, modelId);
+    }
+
+
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/timeseries/TsDataService.java

@@ -0,0 +1,228 @@
+package com.gyee.wisdom.dataadapter.domain.timeseries;
+
+import com.gyee.wisdom.common.data.timeseries.*;
+import com.gyee.wisdom.common.exception.WisdomException;
+import com.gyee.wisdom.dao.timeseries.IHistoryDao;
+import com.gyee.wisdom.dao.timeseries.ILatestDao;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+
+@Service
+@Slf4j
+public class TsDataService {
+
+
+    @Autowired
+    private ILatestDao latestDao;
+
+    @Autowired
+    private IHistoryDao historyDao;
+
+    @Autowired
+    private TsPointService tsPointService;
+
+
+    public Map<String, TsData> getLatest(String... tagNames) {
+        try {
+            List<TsPoint> tsPoints = tsPointService.getTsPoint(tagNames);
+            Map<String, TsData> result = latestDao.getTsDataLatest(tsPoints);
+            return result;
+        } catch (WisdomException e) {
+            log.error("异常点：" + tagNames.toString());
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常点：" + tagNames.toString());
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * @param thingType
+     * @param thingId
+     * @param uniformCodes
+     * @return 返回值Map中key为统一编码，value为TsData
+     * @author wanghs
+     * @date 2018-10-23
+     */
+    public Map<String, TsData> getLatestByUniformCodes(String thingType, String thingId, String... uniformCodes) {
+        try {
+            List<TsPoint> pointList = tsPointService.getTsPoint(thingType, thingId, uniformCodes);
+            Map<String, TsData> dataMap = latestDao.getTsDataLatest(pointList);
+            Map<String, TsData> resultMap = new HashMap<>();
+            for (Map.Entry<String, TsData> entry : dataMap.entrySet()) {
+                for (int i = 0; i < pointList.size(); i++) {
+                    if (entry.getKey().equals(pointList.get(i).getId()))
+                        resultMap.put(pointList.get(i).getUniformCode(), entry.getValue());
+                }
+            }
+            return resultMap;
+        } catch (WisdomException e) {
+            log.error("异常统一编码：" + uniformCodes.toString());
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常统一编码：" + uniformCodes.toString());
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public List<TsData> getHistoryRaw(String tagName, long startTs, long endTs) {
+        try {
+            TsPoint tsPoint = tsPointService.getTsPoint(tagName);
+            TsQuery tsQuery = new BaseTsQuery(tsPoint, startTs, endTs);
+            //long t1 = new Date().getTime();
+            List<TsData> obj = historyDao.getTsDataHistory(tsQuery);
+            //long t2 = new Date().getTime();
+            //System.out.println("tsxxxxxxxxxxxxx=" + (t2-t1));
+            return obj;
+        } catch (WisdomException e) {
+            log.error("异常点：" + tagName);
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常点：" + tagName);
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public List<TsData> getHistoryRaw(String thingType, String thingId, String uniformCode, long startTs, long endTs) {
+        try {
+            TsPoint tsPoint = tsPointService.getTsPoint(thingType, thingId, uniformCode);
+            TsQuery tsQuery = new BaseTsQuery(tsPoint, startTs, endTs);
+            return historyDao.getTsDataHistory(tsQuery);
+        } catch (WisdomException e) {
+            log.error("异常统一编码：" + uniformCode);
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常统一编码：" + uniformCode);
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+
+    public List<TsData> getHistorySnap(String tagName, long startTs, long endTs, int interval) {
+        try {
+            TsPoint tsPoint = tsPointService.getTsPoint(tagName);
+            TsQuery tsQuery = new BaseTsQuery(tsPoint, startTs, endTs, interval, 0, Interpolation.SNAP);
+            return historyDao.getTsDataHistory(tsQuery);
+        } catch (WisdomException e) {
+            log.error("异常点：" + tagName);
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常点：" + tagName);
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public List<TsData> getHistorySnap(String thingType, String thingId, String uniformCode, long startTs, long endTs, int interval) {
+        try {
+            TsPoint tsPoint = tsPointService.getTsPoint(thingType, thingId, uniformCode);
+            TsQuery tsQuery = new BaseTsQuery(tsPoint, startTs, endTs, interval, 0, Interpolation.SNAP);
+            return historyDao.getTsDataHistory(tsQuery);
+        } catch (WisdomException e) {
+            log.error("异常统一编码：" + uniformCode);
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常统一编码：" + uniformCode);
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public List<DoubleStatData> getHistoryStat(String tagName, long startTs, long endTs, int interval) {
+        try {
+            TsPoint tsPoint = tsPointService.getTsPoint(tagName);
+            TsQuery tsQuery = new BaseTsQuery(tsPoint, startTs, endTs, interval, 0, Interpolation.SNAP);
+            return historyDao.getDoubleStatDataHistory(tsQuery);
+        } catch (WisdomException e) {
+            log.error("异常点：" + tagName);
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常点：" + tagName);
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public List<DoubleStatData> getHistoryStat(String thingType, String thingId, String uniformCode, long startTs, long endTs, int interval) {
+        try {
+            TsPoint tsPoint = tsPointService.getTsPoint(thingType, thingId, uniformCode);
+            TsQuery tsQuery = new BaseTsQuery(tsPoint, startTs, endTs, interval, 0, Interpolation.SNAP);
+            return historyDao.getDoubleStatDataHistory(tsQuery);
+        } catch (WisdomException e) {
+            log.error("异常统一编码：" + uniformCode);
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常统一编码：" + uniformCode);
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public boolean writeHistory(List<TsPointData> dataList) throws Exception {
+        return historyDao.writeHistoryValue(dataList);
+    }
+
+    public boolean writeLatest(List<TsPointData> dataList) throws Exception {
+        return latestDao.writeLatest(dataList);
+    }
+
+    public Map<String, TsData> getHistorySection(long ts, String... tagNames) {
+        try {
+            List<TsPoint> tsPoints = tsPointService.getTsPoint(tagNames);
+            Map<String, TsData> result = historyDao.getHistorySection(tsPoints, ts);
+            return result;
+        } catch (WisdomException e) {
+            log.error("异常点：" + tagNames.toString());
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常点：" + tagNames.toString());
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public Map<String, TsData> getHistorySection(long ts, String thingId, String thingType, String... uniformCode) throws Exception {
+        try {
+            List<TsPoint> pointList = tsPointService.getTsPoint(thingType, thingId, uniformCode);
+            Map<String, TsData> dataMap = historyDao.getHistorySection(pointList, ts);
+            Map<String, TsData> resultMap = new HashMap<>();
+            for (Map.Entry<String, TsData> entry : dataMap.entrySet()) {
+                for (int i = 0; i < pointList.size(); i++) {
+                    if (entry.getKey() == pointList.get(i).getId())
+                        resultMap.put(pointList.get(i).getUniformCode(), entry.getValue());
+                }
+            }
+            return resultMap;
+        } catch (WisdomException e) {
+            log.error("异常统一编码：" + uniformCode.toString());
+            log.error(e.getMessage());
+        } catch (Exception e) {
+            log.error("异常统一编码：" + uniformCode.toString());
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/timeseries/TsPointService.java

@@ -0,0 +1,190 @@
+package com.gyee.wisdom.dataadapter.domain.timeseries;
+
+import com.gyee.wisdom.common.data.timeseries.BasicTsPoint;
+import com.gyee.wisdom.common.data.timeseries.TsDataType;
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.dao.things.IThingsPointDao;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+@Service
+@Slf4j
+public class TsPointService {
+
+    //key:测点
+    private Map<String, TsPoint> tagMap = new HashMap<>();
+
+    //key1 风机编号,key2:风机统一编码
+    private Map<String, Map<String, TsPoint>> windturbineTagMap = new HashMap<>();
+
+    @Autowired
+    private IThingsPointDao thingsPointDao;
+
+    public List<TsPoint> getTsPoint(String... tagNames) {
+        List<TsPoint> selectList = new ArrayList<>();
+        //先从缓存中获取
+
+       /* Map<String, TsPoint> tMap = tagMap.entrySet().stream()
+                .filter(s -> tagNameList.contains(s.getKey()))
+                .collect(Collectors.toMap(e -> (String) e.getKey(), e -> e.getValue()));*/
+
+       for (int i=0;i<tagNames.length;i++){
+           if(tagMap.containsKey(tagNames[i])){
+
+               selectList.add(tagMap.get(tagNames[i]));
+           }
+
+       }
+
+        if (selectList.size() > 0) {
+            return selectList;
+        }
+
+        if (tagNames.length > 1000) {
+
+            int selectCount = tagNames.length / 1000;
+            int remainder = tagNames.length % 1000;
+
+            if (remainder == 0) {
+
+                for (int i = 0; i < selectCount; i++) {
+                    String[] subTagName = Arrays.copyOfRange(tagNames, 1000 * i, 1000 * (i + 1));
+                    List<TsPoint> subList = thingsPointDao.findTsPointByIds(subTagName);
+                    selectList.addAll(subList);
+                }
+            } else {
+
+                for (int i = 0; i < selectCount; i++) {
+                    String[] subTagName = Arrays.copyOfRange(tagNames, 1000 * i, 1000 * (i + 1));
+                    List<TsPoint> subList = thingsPointDao.findTsPointByIds(subTagName);
+                    selectList.addAll(subList);
+                }
+                //将数组剩余元素进行查询
+                String[] lastTagName = Arrays.copyOfRange(tagNames, tagNames.length - remainder, tagNames.length);
+                List<TsPoint> lastSubList = thingsPointDao.findTsPointByIds(lastTagName);
+                selectList.addAll(lastSubList);
+            }
+        } else {
+            selectList = thingsPointDao.findTsPointByIds(tagNames);
+        }
+        return selectList;
+    }
+
+    public TsPoint getTsPoint(String tagName) {
+
+        TsPoint tsPoint = null;
+        if (this.tagMap.containsKey(tagName)) {
+            tsPoint = tagMap.get(tagName);
+        }
+        if (tsPoint != null) {
+            return tsPoint;
+        }
+        tsPoint = thingsPointDao.findTsPointById(tagName);
+        return tsPoint;
+    }
+
+    public List<TsPoint> getTsPoint(String thingsType, String thingsId, String... uniformCodes) {
+
+        List<TsPoint> selectList = new ArrayList<>();
+
+        //先从缓存中获取相关测点
+        Map<String, TsPoint> thingsUniformCodeMap = null;
+        if (windturbineTagMap.containsKey(thingsId)) {
+            thingsUniformCodeMap = this.windturbineTagMap.get(thingsId);
+        }
+        if (thingsUniformCodeMap != null) {
+
+       for (int i=0;i<uniformCodes.length;i++){
+           if(thingsUniformCodeMap.containsKey(uniformCodes[i])){
+               selectList.add(thingsUniformCodeMap.get(uniformCodes[i]));
+           }
+       }
+        }
+        //如果缓存中的数据大于0 则直接返回数据不进行数据库查询
+        if (selectList.size() > 0) {
+            return selectList;
+        }
+        if (uniformCodes.length > 1000) {
+            int selectCount = uniformCodes.length / 1000;
+            int remainder = uniformCodes.length % 1000;
+
+            if (remainder == 0) {
+
+                for (int i = 0; i < selectCount; i++) {
+                    String[] uniformCodeArr = Arrays.copyOfRange(uniformCodes, 1000 * i, 1000 * (i + 1));
+                    List<TsPoint> subList = thingsPointDao.findTsPointByUnformCodes(thingsType, thingsId, uniformCodeArr);
+                    selectList.addAll(subList);
+                }
+            } else {
+
+                for (int i = 0; i < selectCount; i++) {
+                    String[] uniformCodeArr = Arrays.copyOfRange(uniformCodes, 1000 * i, 1000 * (i + 1));
+                    List<TsPoint> subList = thingsPointDao.findTsPointByUnformCodes(thingsType, thingsId, uniformCodeArr);
+                    selectList.addAll(subList);
+                }
+                //将数组剩余元素进行查询
+                String[] lastUniformCode = Arrays.copyOfRange(uniformCodes, uniformCodes.length - remainder, uniformCodes.length);
+                List<TsPoint> lastSubList = thingsPointDao.findTsPointByUnformCodes(thingsType, thingsId, lastUniformCode);
+                selectList.addAll(lastSubList);
+            }
+        } else {
+            selectList = thingsPointDao.findTsPointByUnformCodes(thingsType, thingsId, uniformCodes);
+        }
+        return selectList;
+
+    }
+
+    public TsPoint getTsPoint(String thingsType, String thingsId, String uniformCode) {
+
+        TsPoint tsPoint=null;
+
+        if(windturbineTagMap.containsKey(thingsId)){
+
+            Map<String,TsPoint> mp=windturbineTagMap.get(thingsId);
+
+            if(mp.containsKey(uniformCode)){
+                tsPoint=mp.get(uniformCode);
+            }
+        }
+        if(tsPoint!=null)
+        {
+            return tsPoint;
+        }
+
+        List<TsPoint> list = thingsPointDao.findTsPointByUnformCodes(thingsType, thingsId, uniformCode);
+        return list.size() > 0 ? list.get(0) : null;
+    }
+
+    public void getAllTsPointToCache() {
+
+        try {
+            List<TsPoint> lst = thingsPointDao.getAllTsPoint();
+            for (TsPoint point : lst) {
+                if (!tagMap.containsKey(point.getId())) {
+                    tagMap.put(point.getId(), point);
+                }
+                if (!windturbineTagMap.containsKey(point.getThingId())) {
+                    Map<String, TsPoint> uniformCodeMap = new HashMap<>();
+                    uniformCodeMap.put(point.getUniformCode(), point);
+                    windturbineTagMap.put(point.getThingId(), uniformCodeMap);
+                } else {
+                    Map<String, TsPoint> uniformCodeMap = windturbineTagMap.get(point.getThingId());
+
+                    if (!uniformCodeMap.containsKey(point.getUniformCode())) {
+                        uniformCodeMap.put(point.getUniformCode(), point);
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            System.out.println("缓存所有测点发生异常");
+        }
+        System.out.println("测点缓存完毕");
+
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/domain/topic/TopicService.java

@@ -0,0 +1,74 @@
+package com.gyee.wisdom.dataadapter.domain.topic;
+
+import com.gyee.wisdom.common.data.timeseries.BasicTsPoint;
+import com.gyee.wisdom.common.data.timeseries.TsDataType;
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.common.data.topic.Topic;
+
+import com.gyee.wisdom.common.data.topic.TopicPoint;
+import com.gyee.wisdom.dao.topic.ITopicDao;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+
+@Service
+@Slf4j
+public class TopicService {
+
+    private HashMap<String, List<TsPoint>> topicPointsMap = new HashMap<>();
+
+    @Autowired
+    private ITopicDao topicDao;
+
+    public List<Topic> getAll() {
+        return topicDao.getAll();
+    }
+
+    public List<TsPoint> getTsPointListByTopic(String topic) {
+
+        ArrayList<TsPoint> tsPoints = new ArrayList<>();
+
+        if (topicPointsMap.containsKey(topic) == false) {
+            //todo: 加载topic关联的TsPoint
+            Topic topicData = topicDao.getByTopic(topic);
+
+            if (topicData != null) {
+                System.out.println(topicData.getId());
+                List<TopicPoint> pointList = topicData.getPointList();
+                pointList.forEach((k) -> {
+                    TsDataType tsDataType = TsDataType.DOUBLE;
+                    if (k.getDataType().equals("bool"))
+                        tsDataType = TsDataType.BOOLEAN;
+                    tsPoints.add(new BasicTsPoint(k.getId(), tsDataType));
+                });
+
+            }
+        }
+        return tsPoints;
+
+    }
+
+    public List<TsPoint> createTsPointsList() {
+        ArrayList<TsPoint> tsPoints = new ArrayList<>();
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0001", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0002", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0003", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0004", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0005", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0006", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0007", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0008", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0009", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0010", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0011", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0012", TsDataType.DOUBLE));
+        tsPoints.add(new BasicTsPoint("XSFJ.NX_GD_XSF_FJ_P1_L1_001_AI0013", TsDataType.DOUBLE));
+
+        return tsPoints;
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/help/Constant.java

@@ -0,0 +1,67 @@
+package com.gyee.wisdom.dataadapter.help;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * @descrition:全局变量或方法类
+ * @author:WXW
+ * @date:2020-05-06
+ */
+public class Constant
+{
+    public static SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//
+
+
+
+    public static void d(String text)
+    {
+        System.out.println(text);
+    }
+    public static void dOneLine(String text)
+    {
+        System.out.print(text);
+    }
+    /*** @description: 日志文件打印 */
+    public static void dd(String text)
+    {
+        SimpleDateFormat datef=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
+        Date date=new Date();
+        text=datef.format(date)+"\t"+text;
+        System.out.println(text);
+    }
+
+
+
+    static String logPath=System.getProperty("userDataSet.dir")+"\\log\\";
+    static String logName="log.txt";
+    /*** @description: 日志文件写入 */
+    public static void j( String message)
+    {
+        File testFile = new File(logPath);
+        if(!testFile .exists())
+        {
+            testFile.mkdirs();
+        }
+        try
+        {
+            BufferedWriter writer = new BufferedWriter(new FileWriter(new File(logPath+logName),true));
+            SimpleDateFormat datef=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
+            Date date=new Date();
+            message=datef.format(date)+"\t"+message;
+            writer.write("\n"+message);
+            writer.close();
+            System.out.println(message);
+        }
+        catch(IOException e)
+        {
+            System.out.println(message);
+        }
+
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/infrastructure/config/JsonConfig.java

@@ -0,0 +1,38 @@
+package com.gyee.wisdom.dataadapter.infrastructure.config;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.Version;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.PropertyNamingStrategy;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+
+/**
+ * Json 序列化和反序列化通用格式.*/
+
+
+@Configuration
+public class JsonConfig {
+    @Bean
+    @Primary
+    public ObjectMapper objectMapper() {
+        return new ObjectMapper()
+                .registerModule(new Jdk8Module())
+                .setPropertyNamingStrategy(PropertyNamingStrategy.LOWER_CAMEL_CASE)            // Json 字段下划线分割
+                .setDateFormat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ"))       // 时间戳格式
+                .disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES)
+                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+                .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
+                .setSerializationInclusion(JsonInclude.Include.NON_NULL)                 // 忽略 null 字段
+                .setTimeZone(TimeZone.getTimeZone("GMT+8"));                             // 默认时区
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/runner/SpringStartAfter.java

@@ -0,0 +1,166 @@
+package com.gyee.wisdom.dataadapter.runner;
+
+import com.gyee.wisdom.common.data.timeseries.GeneralTsData;
+import com.gyee.wisdom.common.data.timeseries.TsDataType;
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.common.data.timeseries.TsPointData;
+import com.gyee.wisdom.common.data.windturbine.Windturbine;
+import com.gyee.wisdom.dao.things.IThingsPointDao;
+import com.gyee.wisdom.dao.timeseries.ILatestDao;
+import com.gyee.wisdom.dataadapter.domain.thing.WindturbineService;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.boot.SpringApplication;
+import org.springframework.stereotype.Component;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Component
+@Slf4j
+public class SpringStartAfter implements ApplicationRunner {
+
+    @Value("${taoscz.server_ip:192.168.1.60}")
+    private String serverIp;
+
+    @Value("${taoscz.server_port:6030}")
+    private int serverPort;
+
+    @Value("${taoscz.db_name:power_test}")
+    private String dbName;
+
+    @Value("${taoscz.user_name:root}")
+    private String userName;
+
+    @Value("${taoscz.password:taosdata}")
+    private String password;
+
+    @Autowired
+    private ILatestDao latestDao;
+
+    @Autowired
+    private WindturbineService windturbineService;
+    @Autowired
+    private IThingsPointDao thingsPointDao;
+
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+
+     // initDatabase("HNJ_FDC");
+
+//        Random r = new Random();
+//        Long ts = new Date().getTime();
+//        final List<TsPoint> allTsPoint = thingsPointDao.getAllTsPoint().stream().filter(s -> !s.getThingId().equals("BY_FDC")).collect(Collectors.toList());
+//        List<TsPointData> dataList = new ArrayList<>();
+//        for (TsPoint point :
+//                allTsPoint) {
+//            TsPointData tsPointData = new TsPointData();
+//            tsPointData.setTagName(point.getId());
+//            GeneralTsData generalTsData = new GeneralTsData();
+//            Double speed = r.nextDouble() * 6 + 3;
+//            generalTsData.setDoubleValue(java.util.Optional.of(speed));
+//            ts = ts + 1000;
+//            generalTsData.setTs(ts);
+//            tsPointData.setTsData(generalTsData);
+//            dataList.add(tsPointData);
+//        }
+//
+//
+//
+//
+//        while (true) {
+//            Thread.sleep(999);
+//            writeThread(dataList).run();
+//
+//        }
+
+
+    }
+
+    private Thread writeThread(List<TsPointData> list) {
+        Thread t = new Thread() {
+
+            @SneakyThrows
+            @Override
+            public void run() {
+                Random r = new Random();
+                Long ts = new Date().getTime();
+                for (TsPointData tsPointData :
+                        list) {
+                    GeneralTsData generalTsData = new GeneralTsData();
+                    Double speed = r.nextDouble() * 6 + 3;
+                    generalTsData.setDoubleValue(java.util.Optional.of(speed));
+
+                    generalTsData.setTs(ts);
+                    tsPointData.setTsData(generalTsData);
+                }
+                boolean b = latestDao.writeLatest(list);
+            }
+        };
+        return t;
+
+    }
+
+    private void initDatabase(String stationName) throws ClassNotFoundException {
+        log.error("开始执行创建taos库");
+        try {
+            final List<Windturbine> windturbines = windturbineService.queryWindturbine(stationName, "MY-1500");
+
+            log.error("查询风机完毕" + windturbines.size());
+           // Class.forName("com.taosdata.jdbc.TSDBDriver");
+           // String jdbcUrl = "jdbc:TAOS://" + serverIp + ":" + serverPort + "/" + dbName + "?user=" + userName + "&password=" + password;
+
+           Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+           String jdbcUrl = "jdbc:TAOS-RS://" + serverIp + ":" + serverPort + "/" + dbName + "?user=" + userName + "&password=" + password;
+
+            Properties connProps = new Properties();
+            connProps.setProperty("charset", "UTF-8");
+            connProps.setProperty("locale", "en_US.UTF-8");
+            connProps.setProperty("timezone", "UTC-8");
+            final Connection connection = DriverManager.getConnection(jdbcUrl, connProps);
+
+
+            //String createDatabaseSql="create database if not exists "+stationName;
+            final Statement statement = connection.createStatement();
+            //statement.executeUpdate(createDatabaseSql);
+
+            String createSTableSql = "create stable if not exists " + stationName + ".windturbinedi(ts timestamp,value bool)tags(point binary(50));";
+            statement.executeUpdate(createSTableSql);
+
+
+            final List<TsPoint> allTsPoint = thingsPointDao.getAllTsPoint().stream().filter(s->s.getTsDataType()== TsDataType.BOOLEAN).collect(Collectors.toList());
+
+            Date st = new Date();
+            for (Windturbine data :
+                    windturbines) {
+
+                final List<TsPoint> collect = allTsPoint.stream().filter(s -> s.getThingId().equals(data.getCode())).collect(Collectors.toList());
+
+                for (TsPoint point :
+                        collect) {
+                    String createTableSql = "create table if not exists " + stationName + "." + point.getId() + " using windturbinedi tags(\"" + point.getId() + "\"" + ");";
+
+                    statement.executeUpdate(createTableSql);
+                }
+            }
+            Date et = new Date();
+            log.error("数据库创建完毕，耗时" + (et.getTime() - st.getTime()));
+        } catch (SQLException ex) {
+            log.error(ex.getMessage());
+            log.error("=============");
+            ex.printStackTrace();
+            log.error(ex.getStackTrace().toString());
+        }
+
+
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/PublishConfig.java

@@ -0,0 +1,26 @@
+package com.gyee.wisdom.dataadapter.websocket;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+
+@Configuration
+//@PropertySource("classpath:/publish.properties")
+public class PublishConfig {
+
+    @Value("${publish.rtdb_scan_interval:100}")
+    private int rtdbScanInterval;
+
+    @Value("${publish.publish_interval:500}")
+    private int publishInterval;
+
+    public int getRtdbScanInterval() {
+        return  rtdbScanInterval;
+    }
+
+    public int getPublishInterval() {
+        return  publishInterval;
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/PublishServer.java

@@ -0,0 +1,183 @@
+package com.gyee.wisdom.dataadapter.websocket;
+
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import com.gyee.wisdom.dao.timeseries.IDataChangeDao;
+import com.gyee.wisdom.dataadapter.help.Constant;
+import com.gyee.wisdom.dataadapter.websocket.backwork.PhotovoltaicInverterServer;
+import com.gyee.wisdom.dataadapter.websocket.backwork.WindturbineInfoCache;
+import com.gyee.wisdom.dataadapter.websocket.domain.MyConstant;
+import com.gyee.wisdom.dataadapter.websocket.session.StompSessionService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 数据发布服务
+ * 1、周期性扫描实时库，监听topic关联数据的变化
+ * 2、将变化的数据发布到对应的topic上
+ */
+@Slf4j
+@Component
+public class PublishServer {
+
+    private int rtdbScanInterval = 100;  // 实时库论询时间间隔(ms)
+    private int publishInterval = 500;   // 数据发布周期(ms)
+    private boolean serverStarted = false;
+    private boolean scanThreadFlag = false;
+    private boolean publishThreadFlag = false;
+
+    private final SimpMessagingTemplate messagingTemplate;
+
+    private ConcurrentLinkedQueue<TopicMessage> dataQueue = new ConcurrentLinkedQueue<>();
+
+    @Autowired
+    private StompSessionService stompSessionService;
+
+    @Autowired
+    private IDataChangeDao dataChangeDao;
+
+    @Autowired
+    public PublishServer(SimpMessagingTemplate messagingTemplate) {
+        this.messagingTemplate = messagingTemplate;
+    }
+
+    @Autowired
+    private WebSocketTsDataController webSocketTsDataController;
+
+    @Autowired
+    private WindturbineInfoCache windturbineInfoCache;
+
+    @Autowired
+    private PhotovoltaicInverterServer PVServer;
+
+    public void init(int scanInterval, int pubInterval) {
+        rtdbScanInterval = scanInterval;
+        publishInterval = pubInterval;
+        Constant.d("===========[发布服务  init]===========");
+    }
+
+    public boolean start()
+    {
+        if (serverStarted)
+        {
+            return true;
+        }
+
+        Constant.d("===========[发布服务  Start]===========");
+        try
+        {
+           /* scanThreadFlag = true;
+            getScanRtdbThread().start();
+            publishThreadFlag = true;
+            getPublishThread().start();*/
+            WindturbineInfoThread().start();
+            InverterDataThread().start();
+
+        }
+        catch (Exception ex)
+        {
+            log.error(ex.getMessage());
+        }
+        return true;
+    }
+
+    public void stop() {
+        scanThreadFlag = false;
+        publishThreadFlag = false;
+        PVServer.allowUpdatePVData=false;
+        try {
+            Thread.sleep(1000);
+        } catch (Exception ex) {
+        }
+    }
+
+    Thread getScanRtdbThread() {
+        return new Thread(new Runnable() {
+            public void run() {
+                while (scanThreadFlag) {
+                    try {
+                        //log.info("rtdb scan task executing......");
+                        Set<String> topics = stompSessionService.getSessionTopics();
+                        for (String topic : topics) {
+                            Map<String, TsData> dataMap = dataChangeDao.getTopicDataChange(topic);
+                            if (dataQueue.offer(new TopicMessage(topic, dataMap)) == false) {
+                                log.error("dataQueue.offer failed!");
+                            }
+                        }
+                    } catch (Exception ex) {
+                        log.error(ex.getMessage());
+                    }
+                    sleep(rtdbScanInterval);
+                }
+            }
+        });
+    }
+
+    Thread getPublishThread() {
+        return new Thread(new Runnable() {
+            public void run() {
+                while (publishThreadFlag) {
+                    try {
+                        //log.info("publish task executing......");
+                        int cnt = dataQueue.size() < 10 ? dataQueue.size() : 10;
+                        while (cnt-- > 0) {
+                            TopicMessage topicData = dataQueue.poll();
+                            if (topicData != null && topicData.getTsDataMap() != null && topicData.getTsDataMap().size() > 0) {
+                                messagingTemplate.convertAndSend(topicData.getTopic(), topicData.getTsDataMap());
+                                log.info("public message: topic=" + topicData.getTopic());
+                            }
+                        }
+                    } catch (Exception ex) {
+                        log.info(ex.getMessage());
+                    }
+                    sleep(publishInterval);
+                }
+            }
+        });
+    }
+
+    //风机基本信息推荐线程
+    Thread WindturbineInfoThread() {
+        return new Thread(new Runnable() {
+            @Override
+            public void run() {
+                Constant.d("-------    [风机 光伏] 数据推送开始     --------");
+                while (true) {
+
+                    try {
+                        webSocketTsDataController.SendWindToAll(MyConstant.WINDTURBINE_INFO, windturbineInfoCache.getWindturbineDataMap());
+                        webSocketTsDataController.SendPVToAll(MyConstant.Photovoltaic_INFO,PVServer.getInverterMap());
+
+
+                        Thread .sleep(1500);
+                    } catch (Exception ex) {
+                        log.info(ex.getMessage());
+                    }
+                }
+            }
+        });
+    }
+
+    Thread InverterDataThread()
+    {
+        return new Thread(PVServer);
+    }
+
+
+
+
+    private void sleep(int milliseconds) {
+        try {
+            TimeUnit.MILLISECONDS.sleep(milliseconds);
+        } catch (Exception ex) {
+            log.info(ex.getMessage());
+        }
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/TopicMessage.java

@@ -0,0 +1,16 @@
+package com.gyee.wisdom.dataadapter.websocket;
+
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.Map;
+
+@Data
+@AllArgsConstructor
+public class TopicMessage {
+
+    private String topic;
+
+    private Map<String, TsData> tsDataMap;
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/WebSocketConfig.java

@@ -0,0 +1,66 @@
+package com.gyee.wisdom.dataadapter.websocket;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.converter.MessageConverter;
+import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
+import org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler;
+import org.springframework.messaging.simp.config.ChannelRegistration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
+import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
+import org.springframework.web.socket.config.annotation.WebSocketTransportRegistration;
+
+import java.util.List;
+
+@Configuration
+@EnableWebSocketMessageBroker
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry config) {
+        config.enableSimpleBroker("/topic");
+        config.setApplicationDestinationPrefixes("/app");
+    }
+
+    @Override
+    public void registerStompEndpoints(StompEndpointRegistry registry) {
+        registry.addEndpoint("/wisdom").setAllowedOrigins("*")
+                ;
+                //.withSockJS();
+    }
+
+    @Override
+    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
+        registration.setMessageSizeLimit(999 * 1024); // default : 64 * 1024
+        registration.setSendTimeLimit(999 * 10000); // default : 10 * 10000
+        registration.setSendBufferSizeLimit(300*1024);
+    }
+
+    @Override
+    public void configureClientInboundChannel(ChannelRegistration registration) {
+
+    }
+
+    @Override
+    public void configureClientOutboundChannel(ChannelRegistration registration) {
+
+    }
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
+
+    }
+
+    @Override
+    public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
+
+    }
+
+    @Override
+    public boolean configureMessageConverters(List<MessageConverter> messageConverters) {
+        return false;
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/WebSocketTsDataController.java

@@ -0,0 +1,303 @@
+package com.gyee.wisdom.dataadapter.websocket;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.gyee.wisdom.common.data.photovoltaic.InverterBasicData;
+import com.gyee.wisdom.common.data.timeseries.*;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsDataService;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsPointService;
+import com.gyee.wisdom.dataadapter.help.Constant;
+import com.gyee.wisdom.dataadapter.websocket.domain.WindturbineData;
+import com.gyee.wisdom.dataadapter.websocket.session.StompSessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.messaging.simp.annotation.SubscribeMapping;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+
+
+@Controller
+public class WebSocketTsDataController {
+
+    @Autowired
+    protected TsDataService tsDataService;
+
+    @Autowired
+    protected TsPointService tsPointService;
+
+    @Autowired
+    private StompSessionService stompSessionService;
+
+    @Autowired
+    private SimpMessagingTemplate simpMessagingTemplate;
+
+    @SubscribeMapping("/subscribe")
+    public boolean subscribeTopic(SimpMessageHeaderAccessor headerAccessor) {
+        List<String> topic = headerAccessor.getNativeHeader("topic");
+        String sessionId = headerAccessor.getSessionId();
+        stompSessionService.subscribeTopic(sessionId, topic.get(0));
+        return true;
+    }
+
+    @SubscribeMapping("/unsubscribe")
+    public boolean unSubscribeTopic(SimpMessageHeaderAccessor headerAccessor) {
+        List<String> topic = headerAccessor.getNativeHeader("topic");
+        String sessionId = headerAccessor.getSessionId();
+        stompSessionService.unSubscribeTopic(sessionId, topic.get(0));
+        return true;
+    }
+
+    @SubscribeMapping("/test")
+    public List<GeneralTsData> listTest(SimpMessageHeaderAccessor headerAccessor) {
+        List<String> jsonList = headerAccessor.getNativeHeader("json");
+        //json转集合
+        JSONArray jsonArray = JSON.parseArray(jsonList.get(0));
+        List<TsPointData> list = JSONObject.parseArray(jsonArray.toJSONString(), TsPointData.class);
+
+        //json转对象
+        JSONObject obj = JSONObject.parseObject("{'ts':1529658448797,'status':1}");
+        GeneralTsData tsData = JSONObject.toJavaObject(obj, GeneralTsData.class);
+
+        List<GeneralTsData> list1 = new ArrayList<>();
+        GeneralTsData data1 = new GeneralTsData();
+        GeneralTsData data2 = new GeneralTsData();
+
+        data1.setTs(new Date().getTime());
+        data2.setTs(new Date().getTime());
+
+        data1.setStatus((short) 1);
+        data2.setStatus((short) 1);
+        list1.add(data1);
+        list1.add(data2);
+        list1.add(data1);
+        list1.add(data2);
+
+        return list1;
+
+    }
+
+    @SubscribeMapping("/latest")
+    public Map<String, TsData> getLatest(SimpMessageHeaderAccessor headerAccessor) {
+
+        List<String> keyList = headerAccessor.getNativeHeader("keyStr");
+        List<String> thingTypeList = headerAccessor.getNativeHeader("thingType");
+        List<String> thingIdList = headerAccessor.getNativeHeader("thingId");
+        List<String> uniformCodesList = headerAccessor.getNativeHeader("uniformCodes");
+
+        if (keyList.size() > 0) {
+            String[] tagNames = keyList.get(0).split(",");
+            Map<String, TsData> data = tsDataService.getLatest(tagNames);
+            if (data == null) {
+                Map<String, TsData> nullData = new HashMap<>();
+                return nullData;
+            } else {
+                return data;
+            }
+        } else if (thingTypeList.size() > 0 && thingIdList.size() > 0 && uniformCodesList.size() > 0) {
+            String[] uCodes = uniformCodesList.get(0).split(",");
+            return tsDataService.getLatestByUniformCodes(thingTypeList.get(0), thingIdList.get(0), uCodes);
+        } else {
+            Map<String, TsData> nullData = new HashMap<>();
+            return nullData;
+        }
+    }
+
+
+    @SubscribeMapping("/history/raw")
+    public List<TsData> getHistoryRaw(SimpMessageHeaderAccessor headerAccessor) {
+
+        List<String> tagNameList = headerAccessor.getNativeHeader("tagName");
+        List<String> thingTypeList = headerAccessor.getNativeHeader("thingType");
+        List<String> thingIdList = headerAccessor.getNativeHeader("thingId");
+        List<String> uniformCodesList = headerAccessor.getNativeHeader("uniformCode");
+        List<String> startTsList = headerAccessor.getNativeHeader("startTs");
+        List<String> endTsList = headerAccessor.getNativeHeader("endTs");
+
+        if (tagNameList.size() > 0 && startTsList.size() > 0 && endTsList.size() > 0)
+            return tsDataService.getHistoryRaw(tagNameList.get(0), Long.valueOf(startTsList.get(0)), Long.valueOf(endTsList.get(0)));
+
+        if (thingTypeList.size() > 0 && thingIdList.size() > 0 && uniformCodesList.size() > 0 && startTsList.size() > 0 && endTsList.size() > 0) {
+            return tsDataService.getHistoryRaw(thingTypeList.get(0), thingIdList.get(0), uniformCodesList.get(0), Long.valueOf(startTsList.get(0)), Long.valueOf(endTsList.get(0)));
+        } else
+            return null;
+    }
+
+    @SubscribeMapping("/history/snap")
+    public List<TsData> getHistorySnap(SimpMessageHeaderAccessor headerAccessor) {
+
+        List<String> tagNameList = headerAccessor.getNativeHeader("tagName");
+        List<String> thingTypeList = headerAccessor.getNativeHeader("thingType");
+        List<String> thingIdList = headerAccessor.getNativeHeader("thingId");
+        List<String> uniformCodesList = headerAccessor.getNativeHeader("uniformCode");
+        List<String> startTsList = headerAccessor.getNativeHeader("startTs");
+        List<String> endTsList = headerAccessor.getNativeHeader("endTs");
+        List<String> intervalList = headerAccessor.getNativeHeader("interval");
+
+        if (tagNameList.size() > 0 && startTsList.size() > 0 && endTsList.size() > 0 && intervalList.size() > 0)
+            return tsDataService.getHistorySnap(tagNameList.get(0), Long.valueOf(startTsList.get(0)), Long.valueOf(endTsList.get(0)), Integer.valueOf(intervalList.get(0)));
+        if (thingIdList.size() > 0 && thingTypeList.size() > 0 && uniformCodesList.size() > 0 && startTsList.size() > 0 && endTsList.size() > 0 && intervalList.size() > 0) {
+            return tsDataService.getHistorySnap(thingTypeList.get(0), thingIdList.get(0), uniformCodesList.get(0), Long.valueOf(startTsList.get(0)), Long.valueOf(endTsList.get(0)), Integer.valueOf(intervalList.get(0)));
+        } else
+            return null;
+
+    }
+
+    @SubscribeMapping("/history/stat")
+    public List<DoubleStatData> getHistoryStat(SimpMessageHeaderAccessor headerAccessor) {
+
+        List<String> tagNameList = headerAccessor.getNativeHeader("tagName");
+        List<String> thingTypeList = headerAccessor.getNativeHeader("thingType");
+        List<String> thingIdList = headerAccessor.getNativeHeader("thingId");
+        List<String> uniformCodesList = headerAccessor.getNativeHeader("uniformCode");
+        List<String> startTsList = headerAccessor.getNativeHeader("startTs");
+        List<String> endTsList = headerAccessor.getNativeHeader("endTs");
+        List<String> intervalList = headerAccessor.getNativeHeader("interval");
+
+        if (tagNameList.size() > 0 && startTsList.size() > 0 && endTsList.size() > 0 && intervalList.size() > 0)
+            return tsDataService.getHistoryStat(tagNameList.get(0), Long.valueOf(startTsList.get(0)), Long.valueOf(endTsList.get(0)), Integer.valueOf(intervalList.get(0)));
+        if (thingIdList.size() > 0 && thingTypeList.size() > 0 && uniformCodesList.size() > 0 && startTsList.size() > 0 && endTsList.size() > 0 && intervalList.size() > 0) {
+            return tsDataService.getHistoryStat(thingTypeList.get(0), thingIdList.get(0), uniformCodesList.get(0), Long.valueOf(startTsList.get(0)), Long.valueOf(endTsList.get(0)), Integer.valueOf(intervalList.get(0)));
+        } else
+            return null;
+
+    }
+
+    @SubscribeMapping("/history/section")
+    public Map<String, TsData> getHistorySection(SimpMessageHeaderAccessor headerAccessor) throws Exception {
+        List<String> tagNameList = headerAccessor.getNativeHeader("tagNames");
+        List<String> tsList = headerAccessor.getNativeHeader("ts");
+        try {
+            if (tagNameList.size() > 0 && tsList.size() > 0) {
+                String[] tagNameArr = tagNameList.get(0).split(",");
+                return tsDataService.getHistorySection(Long.valueOf(tsList.get(0)), tagNameArr);
+            } else
+                return null;
+
+        } catch (Exception e) {
+            return null;
+        }
+
+    }
+
+    @SubscribeMapping("/write/history/batch")
+    public boolean writeHistoryBatch(SimpMessageHeaderAccessor headerAccessor) {
+        List<String> jsonList = headerAccessor.getNativeHeader("tsDataList");
+        if (jsonList.size() > 0) {
+            JSONArray jsonArray = JSON.parseArray(jsonList.get(0));
+            List<TsPointData> list = JSONObject.parseArray(jsonArray.toJSONString(), TsPointData.class);
+            try {
+                tsDataService.writeHistory(list);
+                return true;
+            } catch (Exception e) {
+                return false;
+            }
+        } else
+            return false;
+
+
+    }
+
+    @PostMapping("/write/history")
+    @ResponseBody
+    public boolean writeHistory(SimpMessageHeaderAccessor headerAccessor) {
+        List<String> jsonList = headerAccessor.getNativeHeader("tsData");
+        if (jsonList.size() > 0) {
+            JSONObject obj = JSONObject.parseObject(jsonList.get(0));
+            TsPointData tsData = JSONObject.toJavaObject(obj, TsPointData.class);
+            try {
+                List<TsPointData> list = new ArrayList<>();
+                list.add(tsData);
+                tsDataService.writeHistory(list);
+                return true;
+            } catch (Exception e) {
+                return false;
+            }
+        } else
+            return false;
+
+    }
+
+    @PostMapping("/write/history/list")
+    @ResponseBody
+    public boolean writeHistoryList(SimpMessageHeaderAccessor headerAccessor) {
+        List<String> jsonList = headerAccessor.getNativeHeader("tsData");
+        if (jsonList.size() > 0) {
+            JSONObject obj = JSONObject.parseObject(jsonList.get(0));
+            TsPointDataList tsData = JSONObject.toJavaObject(obj, TsPointDataList.class);
+            try {
+                List<TsPointData> tsDataList = new ArrayList<>();
+                if (tsData != null) {
+                    for (int i = 0; i < tsData.getTsDataList().size(); i++) {
+                        TsPointData data = new TsPointData();
+                        data.setTagName(tsData.getTagName());
+                        data.setTsData(tsData.getTsDataList().get(i));
+                        tsDataList.add(data);
+                    }
+                    tsDataService.writeHistory(tsDataList);
+                    return true;
+                } else {
+                    return false;
+                }
+            } catch (Exception e) {
+                return false;
+            }
+        } else
+            return false;
+
+    }
+
+
+    @PostMapping("/write/latest/batch")
+    @ResponseBody
+    public boolean writeLatestBatch(SimpMessageHeaderAccessor headerAccessor) throws Exception {
+
+        List<String> jsonList = headerAccessor.getNativeHeader("tsDataList");
+        if (jsonList.size() > 0) {
+            JSONArray jsonArray = JSON.parseArray(jsonList.get(0));
+            List<TsPointData> list = JSONObject.parseArray(jsonArray.toJSONString(), TsPointData.class);
+
+            return tsDataService.writeLatest(list);
+        } else
+            return false;
+    }
+
+    @PostMapping("/write/latest")
+    @ResponseBody
+    public boolean writeLatest(SimpMessageHeaderAccessor headerAccessor) throws Exception {
+        List<String> jsonList = headerAccessor.getNativeHeader("tsData");
+        if (jsonList.size() > 0) {
+            JSONObject obj = JSONObject.parseObject(jsonList.get(0));
+            TsPointData tsData = JSONObject.toJavaObject(obj, TsPointData.class);
+
+            List<TsPointData> tsDataList = new ArrayList<>();
+            tsDataList.add(tsData);
+            return tsDataService.writeLatest(tsDataList);
+        } else
+            return false;
+
+    }
+
+    /**
+     * @description websocket广播方法
+     * @author wanghs
+     * @date 2019-09-23
+     * @param distination 广播地址
+     * @param sendMap 消息体
+     * @return void
+     */
+    public void SendWindToAll(String destination, Map<String, WindturbineData> sendMap){
+        simpMessagingTemplate.convertAndSend(destination,sendMap);
+        Constant.dOneLine(" 风 ");
+    }
+
+    public void SendPVToAll(String destination, Map<String,InverterBasicData> pvDataMap)
+    {
+        simpMessagingTemplate.convertAndSend(destination,pvDataMap);
+        Constant.dOneLine(" 光 ");
+    }
+}
+

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/backwork/BackWorkStart.java

@@ -0,0 +1,49 @@
+package com.gyee.wisdom.dataadapter.websocket.backwork;
+
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsPointService;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+/**
+ * @descrition:风机信息更新线程
+ * @author:Wanghs
+ * @date:2019-09-23
+ */
+@Component
+public class BackWorkStart implements ApplicationRunner {
+    @Value("${websocket_start:false}")
+    private String websocketIsStart;
+
+    @Value("${isLoadAllTag:false}")
+    private String isLoadAllWindturbineTag;
+
+    @Autowired
+    private WindturbineInfoCache windturbineInfoCache;
+
+    @Autowired
+    private TsPointService tsPointService;
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+
+        //一次性加载所有测点至缓存
+        if(Boolean.valueOf(isLoadAllWindturbineTag)){
+            tsPointService.getAllTsPointToCache();
+        }
+
+        if (Boolean.valueOf(websocketIsStart)) {
+            boolean initSuccess = windturbineInfoCache.init();
+            if (initSuccess) {
+                //数据更新线程启动
+                windturbineInfoCache.start();
+            }
+        }
+
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/backwork/PhotovoltaicInverterServer.java

@@ -0,0 +1,237 @@
+package com.gyee.wisdom.dataadapter.websocket.backwork;
+
+import com.gyee.wisdom.common.data.photovoltaic.Inverter;
+import com.gyee.wisdom.common.data.photovoltaic.InverterBasicData;
+import com.gyee.wisdom.common.data.timeseries.DoubleTsData;
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.dao.pv_inverter.IInverterDao;
+import com.gyee.wisdom.dao.things.IThingsPointDao;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsDataService;
+import com.gyee.wisdom.dataadapter.help.Constant;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+
+/**
+ * @descrition:光伏逆变器信息
+ * @author:WXW
+ * @date:2020-04-28
+ */
+@Component
+@Slf4j
+public class PhotovoltaicInverterServer implements Runnable
+{
+
+    @Autowired
+    private IInverterDao iInverterDao;
+    @Autowired
+    private IThingsPointDao thingsPointDao;
+    @Autowired
+    private TsDataService tsDataService;
+
+    private Map<String, InverterBasicData> inverterMap = new HashMap<>();
+    private Map<String, InverterBasicData> pvIMap = new HashMap<>();
+    private Map<String, InverterBasicData> pvUMap = new HashMap<>();
+    private Map<String, InverterBasicData> pvWMap = new HashMap<>();
+    private Map<String, InverterBasicData> pvSMap = new HashMap<>();
+
+    @Value("${uniformcode.pv_I:AIG060}")
+    private String pv_I;
+    @Value("${uniformcode.pv_U:AIG061}")
+    private String pv_U;
+    @Value("${uniformcode.pv_P:AI130}")
+    private String pv_P;
+    @Value("${uniformcode.pv_statue:FJZT}")
+    private String pv_S;
+
+    private String[] pv_uniformCode;
+
+    public boolean allowUpdatePVData=true;
+
+    public Map<String,InverterBasicData> getInverterMap()
+    {
+        return inverterMap;
+    }
+
+    public boolean init()
+    {
+        try
+        {
+            pv_uniformCode = new String[]{pv_I, pv_U, pv_P, pv_S};
+            // 查询所有光伏逆变器基本信息
+            List<Inverter> inverterList = iInverterDao.findAllInverter();
+            //
+            inverterList.forEach(i ->
+                    {
+                        // 变为光伏逆变器数据信息
+                        InverterBasicData pvIVT = new InverterBasicData(i);
+                        List<TsPoint> pointList = thingsPointDao.findTsPointByUnformCodes("windturbine", i.getId(), pv_uniformCode);
+                        pointList.forEach(p -> // 按照标签点存放到对应类型的Map中
+                                {
+                                    if (pv_I.equals(p.getUniformCode()) && !pvIMap.containsKey(p.getId()))//电流
+                                    {
+                                        pvIMap.put(p.getId(), pvIVT);
+                                    }
+                                    else if (pv_U.equals(p.getUniformCode()) && !pvUMap.containsKey(p.getId()))//电压
+                                    {
+                                        pvUMap.put(p.getId(), pvIVT);
+                                    }
+                                    else if (pv_P.equals(p.getUniformCode()) && !pvWMap.containsKey(p.getId()))//功率
+                                    {
+                                        pvWMap.put(p.getId(), pvIVT);
+                                    }
+                                    else if (pv_S.equals(p.getUniformCode()) && !pvSMap.containsKey(p.getId()))//状态
+                                    {
+                                        pvSMap.put(p.getId(), pvIVT);
+                                    }
+                                }
+                        );
+
+                        if (!inverterMap.containsKey(i.getId())) // 所有光伏的数据表
+                        {
+                            inverterMap.put(i.getId(), pvIVT);
+                        }
+                    }
+            );
+            Constant.d("[光伏]信息缓存              [OK]! \n");
+            return true;
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+            Constant.d("[光伏]信息缓存              [Error]!\n" + ex.getMessage());
+            return false;
+        }
+    }
+
+    private void updatePVData()
+    {
+        updateMapOf(PVDataType.I);
+        updateMapOf(PVDataType.U);
+        updateMapOf(PVDataType.P);
+        updateMapOf(PVDataType.S);
+        //Constant.dOneLine(Constant.dateFormat.format(new Date()));
+//        Constant.dOneLine((updateMapOf(PVDataType.I) ? " 光伏I " : " 光伏I[Error]! "));
+//        Constant.dOneLine((updateMapOf(PVDataType.U) ? " 光伏U " : " 光伏U[Error]! "));
+//        Constant.dOneLine((updateMapOf(PVDataType.P) ? " 光伏P " : " 光伏P[Error]! "));
+//        Constant.dOneLine((updateMapOf(PVDataType.S) ? " 光伏S " : " 光伏S[Error]! "));
+        //Constant.d(Constant.dateFormat.format(new Date()));
+    }
+
+    private boolean updateMapOf(PVDataType pvT)
+    {
+        try
+        {
+            Map<String, InverterBasicData> refPointMap;
+            switch (pvT)
+            {
+                case I:
+                {
+                    refPointMap = pvIMap;
+                }
+                break;
+                case U:
+                {
+                    refPointMap = pvUMap;
+                }
+                break;
+                case P:
+                {
+                    refPointMap = pvWMap;
+                }
+                break;
+                case S:
+                {
+                    refPointMap = pvSMap;
+                }
+                break;
+                default:
+                {
+                    return false;
+                }
+            }
+            //String [] piontIDKeys=refPointMap.keySet().toArray(new String[0]);
+            Map<String, TsData> tsDataMap = tsDataService.getLatest(refPointMap.keySet().toArray(new String[0]));
+            if (tsDataMap != null)
+            {
+                tsDataMap.entrySet().forEach(
+                        kv ->
+                        {
+                            if (kv.getValue() instanceof DoubleTsData && refPointMap.containsKey(kv.getKey())) // 数值类型
+                            {
+                                switch (pvT)
+                                {
+                                    case I:
+                                    {
+                                        refPointMap.get(kv.getKey()).setI(((DoubleTsData) kv.getValue()).getDoubleValue());
+                                    }
+                                    break;
+                                    case U:
+                                    {
+                                        refPointMap.get(kv.getKey()).setU(((DoubleTsData) kv.getValue()).getDoubleValue());
+                                    }
+                                    break;
+                                    case P:
+                                    {
+                                        refPointMap.get(kv.getKey()).setP(((DoubleTsData) kv.getValue()).getDoubleValue());
+                                    }
+                                    break;
+                                    case S:
+                                    {
+                                        refPointMap.get(kv.getKey()).setStatue(((DoubleTsData) kv.getValue()).getDoubleValue());
+                                        refPointMap.get(kv.getKey()).setTs(kv.getValue().getTs());
+                                    }
+                                    break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                );
+            }
+            return true;
+        }
+        catch (Exception e)
+        {
+            Constant.d(pvT.toString()+"  \n");
+            e.printStackTrace();
+            return false;
+        }
+
+    }
+
+    @Override
+    public void run()
+    {
+        Constant.d("-------    [光伏] 基本信息服务启动    --------");
+        if(init())
+        {
+            allowUpdatePVData=true;
+            while (allowUpdatePVData)
+            {
+                try
+                {
+                    updatePVData();
+                    Thread.sleep(1800);
+                }
+                catch(Exception ex)
+                {
+                    Constant.d("光伏逆变器数据更新:       "+Constant.dateFormat.format(new Date())+"\n");
+                    ex.printStackTrace();
+                }
+            }
+        }
+    }
+
+    enum PVDataType
+    {
+        I,
+        U,
+        P,
+        S
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/backwork/UniformCodeConfig.java

@@ -0,0 +1,51 @@
+package com.gyee.wisdom.dataadapter.websocket.backwork;
+
+import lombok.Data;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * @descrition:
+ * @author:Wanghs
+ * @date:2019-09-23
+ */
+@Configuration
+public class UniformCodeConfig {
+
+    @Value("${uniformcode.wind_speed_code:AI022}")
+    private String windSpeedCode;
+
+    @Value("${uniformcode.roll_speed_code:AI128}")
+    private String rollSpeedCode;
+
+    @Value("${uniformcode.power_code:AI130}")
+    private String powerCode;
+
+    @Value("${uniformcode.status_code:FJZT8}")
+    private String statusCode;
+
+    @Value("${uniformcode.lock_code:XDSL}")
+    private String lockCode;
+
+    public String getWindSpeedCode() {
+        return windSpeedCode;
+    }
+
+    public String getRollSpeedCode() {
+        return rollSpeedCode;
+    }
+
+    public String getPowerCode() {
+        return powerCode;
+    }
+
+    public String getStatusCode() {
+        return statusCode;
+    }
+
+    public String getLockCode() {
+        return lockCode;
+    }
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/backwork/WindturbineInfoCache.java

@@ -0,0 +1,243 @@
+package com.gyee.wisdom.dataadapter.websocket.backwork;
+
+import com.gyee.wisdom.common.data.timeseries.DoubleTsData;
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.common.data.windturbine.Windturbine;
+import com.gyee.wisdom.dao.things.IThingsPointDao;
+import com.gyee.wisdom.dao.windturbine.IWindturbineDao;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsDataService;
+import com.gyee.wisdom.dataadapter.domain.timeseries.TsPointService;
+import com.gyee.wisdom.dataadapter.websocket.domain.WindturbineData;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+
+import java.util.*;
+
+
+/**
+ * @descrition: 风机信息缓存类
+ * @author:Wanghs
+ * @date:2019-09-23
+ */
+@Component
+@Slf4j
+public class WindturbineInfoCache {
+
+
+    @Autowired
+    private IWindturbineDao windturbineDao;
+
+    @Autowired
+    private IThingsPointDao thingsPointDao;
+
+    @Autowired
+    private TsPointService tsPointService;
+
+    @Autowired
+    private TsDataService tsDataService;
+
+    @Autowired
+    private UniformCodeConfig uniformCodeConfig;
+
+
+    //key:风机编号,value风机信息
+    private Map<String, WindturbineData> windturbineDataMap = new HashMap<>();
+
+    //key:风速测点,value风机信息
+    private Map<String, WindturbineData> windSpeedMap = new HashMap<>();
+
+    //key:转速测点,value风机信息
+    private Map<String, WindturbineData> rollSpeedMap = new HashMap<>();
+
+    //key:功率测点,value风机信息
+    private Map<String, WindturbineData> powerMap = new HashMap<>();
+
+    //key:状态测点,value风机信息
+    private Map<String, WindturbineData> statusMap = new HashMap<>();
+
+    //key:挂牌测点,value风机信息
+    private Map<String, WindturbineData> lockTypeMap = new HashMap<>();
+
+
+    public Map<String, WindturbineData> getWindturbineDataMap() {
+        return windturbineDataMap;
+    }
+
+    /**
+     * @param
+     * @return boolean
+     * @description 风机信息初始化
+     * @author wanghs
+     * @date 2019-09-23
+     */
+    public boolean init() {
+
+        boolean result = false;
+        try {
+            List<Windturbine> wList = windturbineDao.find();
+            for (int i = 0; i < wList.size(); i++) {
+                Windturbine things = wList.get(i);
+
+                if (things.getWindPowerStationId().contains("FDC")) {
+
+                    WindturbineData wData = new WindturbineData();
+                    wData.setModelId(things.getModelId());
+                    wData.setWindturbineId(things.getId());
+                    wData.setStationId(things.getWindPowerStationId());
+                    wData.setProjectId(things.getProjectId());
+                    List<String> uniformcodeList = new ArrayList();
+
+                    uniformcodeList.add(uniformCodeConfig.getWindSpeedCode());
+                    uniformcodeList.add(uniformCodeConfig.getRollSpeedCode());
+                    uniformcodeList.add(uniformCodeConfig.getPowerCode());
+                    uniformcodeList.add(uniformCodeConfig.getStatusCode());
+                    uniformcodeList.add(uniformCodeConfig.getLockCode());
+
+                    String[] uniformcodeArray = new String[uniformcodeList.size()];
+                    uniformcodeList.toArray(uniformcodeArray);
+
+                   // List<TsPoint> pointList = thingsPointDao.findTsPointByUnformCodes("windturbine", things.getId(), uniformcodeArray);
+                    List<TsPoint> pointList=tsPointService.getTsPoint("windturbine", things.getId(), uniformcodeArray);
+                    for (int j = 0; j < pointList.size(); j++) {
+                        TsPoint point = pointList.get(j);
+                        if (point.getUniformCode().equals(uniformCodeConfig.getWindSpeedCode())) {
+                            if (!windSpeedMap.containsKey(point.getId()))
+                                windSpeedMap.put(point.getId(), wData);
+                        } else if (point.getUniformCode().equals(uniformCodeConfig.getRollSpeedCode())) {
+                            if (!rollSpeedMap.containsKey(point.getId()))
+                                rollSpeedMap.put(point.getId(), wData);
+                        } else if (point.getUniformCode().equals(uniformCodeConfig.getPowerCode())) {
+                            if (!powerMap.containsKey(point.getId()))
+                                powerMap.put(point.getId(), wData);
+                        } else if (point.getUniformCode().equals(uniformCodeConfig.getStatusCode())) {
+                            if (!statusMap.containsKey(point.getId()))
+                                statusMap.put(point.getId(), wData);
+                        } else if (point.getUniformCode().equals(uniformCodeConfig.getLockCode())) {
+                            if (!lockTypeMap.containsKey(point.getId()))
+                                lockTypeMap.put(point.getId(), wData);
+                        }
+                    }
+                    if (!windturbineDataMap.containsKey(things.getId())) {
+                        windturbineDataMap.put(things.getId(), wData);
+                    }
+                }
+            }
+
+            log.info("风机缓存初始化完毕");
+            result = true;
+        } catch (Exception ex) {
+            log.info("风机信息缓存初始化异常" + ex.getMessage());
+        } finally {
+            return result;
+        }
+
+    }
+
+    public void start() {
+
+        try {
+            getUpdateThread().start();
+
+        } catch (Exception ex) {
+
+        }
+    }
+
+    Thread getUpdateThread() {
+        return new Thread(new Runnable() {
+            public void run() {
+                System.out.println("实时风机启停计算线程启动");
+                while (true) {
+                    try {
+                        updateWinduturbineInfo();
+                        Thread.sleep(1000);
+
+                    } catch (Exception ex) {
+
+                    }
+                }
+            }
+        });
+    }
+
+    private void updateWinduturbineInfo() {
+
+        //Instant st = Instant.now();
+        boolean windSpeedUpdateSuccess = updateInfoByMap(windSpeedMap, "windSpeed");
+        if (!windSpeedUpdateSuccess)
+            log.info("风机风速更新失败");
+        boolean rollSpeedUpdateSuccess = updateInfoByMap(rollSpeedMap, "rollSpeed");
+        if (!rollSpeedUpdateSuccess)
+            log.info("风机转速更新失败");
+        boolean powerUpdateSuccess = updateInfoByMap(powerMap, "power");
+        if (!powerUpdateSuccess)
+            log.info("风机功率更新失败");
+        boolean statusUpdateSuccess = updateInfoByMap(statusMap, "status");
+        if (!statusUpdateSuccess)
+            log.info("风机状态更新失败");
+        boolean lockUpdateSuccess = updateInfoByMap(lockTypeMap, "lock");
+        if (!lockUpdateSuccess)
+            log.info("风机挂牌状态更新失败");
+    }
+
+    private boolean updateInfoByMap(Map<String, WindturbineData> updateMap, String type) {
+
+        boolean success = false;
+        try {
+            String[] pointArr = new String[updateMap.size()];
+            Object[] keyArr = updateMap.keySet().toArray();
+            for (int i = 0; i < keyArr.length; i++) {
+                pointArr[i] = keyArr[i].toString();
+            }
+            Map<String, TsData> mapResult = tsDataService.getLatest(pointArr);
+            if (mapResult != null) {
+                Iterator<Map.Entry<String, TsData>> entries = mapResult.entrySet().iterator();
+                if (entries != null) {
+                    while (entries.hasNext()) {
+                        Map.Entry<String, TsData> entry = entries.next();
+                        String key = entry.getKey();
+                        TsData tsData = entry.getValue();
+                        if (tsData instanceof DoubleTsData) {
+                            DoubleTsData doubleTsData = (DoubleTsData) tsData;
+                            if (updateMap.containsKey(key)) {
+                                WindturbineData wData = updateMap.get(key);
+                                switch (type) {
+                                    case "windSpeed":
+                                        wData.setWindSpeed(doubleTsData.getDoubleValue());
+                                        break;
+                                    case "rollSpeed":
+                                        wData.setRollSpeed(doubleTsData.getDoubleValue());
+                                        break;
+                                    case "power":
+                                        wData.setPower(doubleTsData.getDoubleValue());
+                                        break;
+                                    case "status":
+                                        wData.setStatus(doubleTsData.getDoubleValue());
+                                        wData.setTs(doubleTsData.getTs());
+                                        break;
+                                    case "lock":
+                                        wData.setLockValue(doubleTsData.getDoubleValue());
+                                        break;
+                                    default:
+                                        break;
+                                }
+
+                            }
+                        }
+                    }
+                }
+            }
+            success = true;
+            return success;
+        } catch (Exception ex) {
+            log.info("风机信息更新异常" + ex.getMessage());
+        } finally {
+            return success;
+        }
+
+
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/domain/MyConstant.java

@@ -0,0 +1,17 @@
+package com.gyee.wisdom.dataadapter.websocket.domain;
+
+/**
+ * @descrition: 常量类, 存放订阅地址等相关信息
+ * @author:Wanghs
+ * @date:2019-09-23
+ */
+public final class MyConstant {
+
+    public static int UnInitZero=0;
+
+    //风机基本信息订阅地址
+    public static final String WINDTURBINE_INFO = "/topic/windturbine";
+
+    public static final String Photovoltaic_INFO="/topic/pv";
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/domain/TopicMsg.java

@@ -0,0 +1,15 @@
+package com.gyee.wisdom.dataadapter.websocket.domain;
+
+import lombok.Data;
+
+/**
+ * @descrition:
+ * @author:Wanghs
+ * @date:2019-09-23
+ */
+@Data
+public class TopicMsg<T> {
+    private T body;
+
+    private String messageType;
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/domain/WindturbineData.java

@@ -0,0 +1,45 @@
+package com.gyee.wisdom.dataadapter.websocket.domain;
+
+import lombok.Data;
+
+import java.util.Map;
+
+/**
+ * @descrition: 风机信息
+ * @author:Wanghs
+ * @date:2019-09-23
+ */
+@Data
+public class WindturbineData {
+    /// 风机编号
+    private String windturbineId = "";
+
+    /// 风机型号
+    private String modelId = "";
+
+    /// 风场编号
+    private String stationId = "";
+
+    //项目编号
+    private String projectId = "";
+
+    /// 风速值
+    private double windSpeed = MyConstant.UnInitZero;
+
+    /// 功率值
+    private double power = MyConstant.UnInitZero;
+
+    /// 转速值
+    private double rollSpeed = MyConstant.UnInitZero;
+
+    /// 状态值
+    private double status = -1;
+
+    /// 挂牌状态
+    private double lockValue = MyConstant.UnInitZero;
+
+    /// 状态持续时长
+    private long ts = MyConstant.UnInitZero;
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/intercepter/InChannelInterceptor.java

@@ -0,0 +1,21 @@
+package com.gyee.wisdom.dataadapter.websocket.intercepter;
+
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.simp.stomp.StompCommand;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.messaging.support.ChannelInterceptor;
+import org.springframework.messaging.support.ChannelInterceptorAdapter;
+
+public class InChannelInterceptor implements ChannelInterceptor {
+    @Override
+    public Message<?> preSend(Message<?> message, MessageChannel channel) {
+//        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
+//        StompCommand command = accessor.getCommand();
+//        accessor.getSessionId();
+        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + message.toString());
+
+        // ...
+        return message;
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/intercepter/MyWebAppConfigurer.java

@@ -0,0 +1,36 @@
+package com.gyee.wisdom.dataadapter.websocket.intercepter;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.*;
+
+/**
+ * 拦截器
+* @ClassName: MyWebAppConfigurer
+* @author gyee
+* @date 2018年6月3日
+*
+ */
+@Configuration
+public class MyWebAppConfigurer  extends  WebMvcConfigurationSupport  {
+
+	/** 解决跨域问题 **/
+	@Override
+	public void addCorsMappings(CorsRegistry registry){
+
+
+        registry.addMapping("/**")
+			// 设置允许跨域请求的域名
+			.allowedOriginPatterns("*")
+			// 是否允许证书
+			.allowCredentials(true)
+			// 设置允许的方法
+			.allowedMethods("GET", "POST", "DELETE", "PUT")
+			// 设置允许的header属性
+			.allowedHeaders("*")
+				// 跨域允许时间
+			.maxAge(3600);
+			super.addCorsMappings(registry);
+
+	}
+	
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/intercepter/OutChannelInterceptor.java

@@ -0,0 +1,20 @@
+package com.gyee.wisdom.dataadapter.websocket.intercepter;
+
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.simp.stomp.StompCommand;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.messaging.support.ChannelInterceptor;
+import org.springframework.messaging.support.ChannelInterceptorAdapter;
+
+public class OutChannelInterceptor implements ChannelInterceptor {
+    @Override
+    public Message<?> preSend(Message<?> message, MessageChannel channel) {
+//        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
+//        StompCommand command = accessor.getCommand();
+//        accessor.getSessionId();
+        System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<" + message.toString());
+
+        return message;
+    }
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/listener/BrokerAvailabilityEventListener.java

@@ -0,0 +1,33 @@
+package com.gyee.wisdom.dataadapter.websocket.listener;
+
+import com.gyee.wisdom.dataadapter.websocket.PublishConfig;
+import com.gyee.wisdom.dataadapter.websocket.PublishServer;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.ApplicationListener;
+import org.springframework.messaging.simp.broker.BrokerAvailabilityEvent;
+import org.springframework.stereotype.Component;
+
+@Component
+public class BrokerAvailabilityEventListener implements
+        ApplicationListener<BrokerAvailabilityEvent> {
+    @Value("${websocket_start:false}")
+    private String websocketIsStart;
+    @Autowired
+    private PublishConfig publishConfig;
+
+    @Autowired
+    private PublishServer publishServer;
+
+    @Override
+    public void onApplicationEvent(BrokerAvailabilityEvent event) {
+        System.out.println("BrokerAvailabilityEvent  rised!");
+        System.out.println("listener: " + event.toString());
+        publishServer.init(publishConfig.getRtdbScanInterval(), publishConfig.getPublishInterval());
+        if (Boolean.valueOf(websocketIsStart)) {
+            publishServer.start();
+        }
+
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/listener/SessionConnectedEventListener.java

@@ -0,0 +1,34 @@
+package com.gyee.wisdom.dataadapter.websocket.listener;
+
+import com.gyee.wisdom.dataadapter.websocket.session.WisdomStompSession;
+import com.gyee.wisdom.dataadapter.websocket.session.StompSessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationListener;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.messaging.SessionConnectedEvent;
+
+import java.util.Date;
+
+@Component
+public class SessionConnectedEventListener implements
+        ApplicationListener<SessionConnectedEvent> {
+
+    @Autowired
+    private StompSessionService stompSessionService;
+
+    @Override
+    public void onApplicationEvent(SessionConnectedEvent event) {
+        //System.out.println("SessionConnectedEvent  rised!");
+        //System.out.println("message: " + event.getMessage());
+        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(event.getMessage());
+        WisdomStompSession session = new WisdomStompSession();
+        session.setSessionId(accessor.getSessionId());
+        session.setClientIp(accessor.getHost());
+        session.setCreateTime(new Date());
+
+        stompSessionService.addSession(session);
+        System.out.print("-[+]-");
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/listener/SessionDisconnectEventListener.java

@@ -0,0 +1,29 @@
+package com.gyee.wisdom.dataadapter.websocket.listener;
+
+import com.gyee.wisdom.dataadapter.websocket.session.StompSessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationListener;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.messaging.SessionDisconnectEvent;
+
+@Component
+public class SessionDisconnectEventListener implements
+        ApplicationListener<SessionDisconnectEvent> {
+
+    @Autowired
+    private StompSessionService stompSessionService;
+
+    @Override
+    public void onApplicationEvent(SessionDisconnectEvent event) {
+        System.out.println("SessionDisconnectEvent  rised!");
+        System.out.println("message: " + event.getMessage());
+
+        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(event.getMessage());
+        String sessionId = accessor.getSessionId();
+        stompSessionService.removeSession(sessionId);
+
+
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/listener/SessionSubscribeEventListener.java

@@ -0,0 +1,28 @@
+package com.gyee.wisdom.dataadapter.websocket.listener;
+
+import com.gyee.wisdom.dataadapter.websocket.session.StompSessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationListener;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.messaging.SessionSubscribeEvent;
+
+@Component
+public class SessionSubscribeEventListener implements
+        ApplicationListener<SessionSubscribeEvent> {
+
+//    @Autowired
+//    private StompSessionService stompSessionService;
+
+    @Override
+    public void onApplicationEvent(SessionSubscribeEvent event) {
+        System.out.println("SessionSubscribeEvent  rised!");
+        System.out.println("message: " + event.getMessage());
+
+//        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(event.getMessage());
+//        String sessionId = accessor.getSessionId();
+//        String topic = accessor.getDestination();
+//        stompSessionService.subscribeTopic(sessionId, topic);
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/listener/SessionUnsubscribeEventListener.java

@@ -0,0 +1,29 @@
+package com.gyee.wisdom.dataadapter.websocket.listener;
+
+import com.gyee.wisdom.dataadapter.websocket.session.StompSessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationListener;
+import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.messaging.SessionUnsubscribeEvent;
+
+@Component
+public class SessionUnsubscribeEventListener implements
+        ApplicationListener<SessionUnsubscribeEvent> {
+
+//    @Autowired
+//    private StompSessionService stompSessionService;
+
+    @Override
+    public void onApplicationEvent(SessionUnsubscribeEvent event) {
+        System.out.println("SessionUnsubscribeEvent  rised!");
+        System.out.println("message: " + event.getMessage());
+
+//        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(event.getMessage());
+//        String sessionId = accessor.getSessionId();
+//        String topic = accessor.getDestination();
+//        stompSessionService.unSubscribeTopic(sessionId, topic);
+
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/session/StompSessionService.java

@@ -0,0 +1,84 @@
+package com.gyee.wisdom.dataadapter.websocket.session;
+
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.dao.timeseries.IDataChangeDao;
+import com.gyee.wisdom.dataadapter.domain.topic.TopicService;
+import lombok.Data;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+@Data
+@Service
+public class StompSessionService {
+
+    private HashMap<String, WisdomStompSession> sessionMap = new HashMap<>();
+    private Set<String> sessionTopics = new HashSet<>();
+    //private boolean isDirtyTopics;
+
+    @Autowired
+    private TopicService topicService;
+
+    @Autowired
+    private IDataChangeDao dataChangeDao;
+
+    public WisdomStompSession getSession(String sessionId) {
+        if (sessionMap.containsKey(sessionId))
+            return sessionMap.get(sessionId);
+
+        return null;
+    }
+
+    public void addSession(WisdomStompSession session) {
+        if (sessionMap.containsKey(session.getSessionId()) == false) {
+            sessionMap.put(session.getSessionId(), session);
+        }
+    }
+
+    public void removeSession(String sessionId) {
+        if (sessionMap.containsKey(sessionId))
+            sessionMap.remove(sessionId);
+    }
+
+    public void subscribeTopic(String sessionId, String topicId) {
+        if (sessionMap.containsKey(sessionId)) {
+            sessionMap.get(sessionId).subscribeTopic(topicId);
+            if (sessionTopics.contains(topicId) == false) {
+                sessionTopics.add(topicId);
+                List<TsPoint> tsPoints = topicService.getTsPointListByTopic(topicId);
+                dataChangeDao.registerTopic(topicId, tsPoints);
+            }
+        }
+    }
+
+    public void unSubscribeTopic(String sessionId, String topic) {
+        if (sessionMap.containsKey(sessionId)) {
+            sessionMap.get(sessionId).unSubscribeTopic(topic);
+            boolean removeTopic = true;
+            for (WisdomStompSession session : sessionMap.values() ) {
+                if (session.getTopics() != null && session.getTopics().contains(topic)) {
+                    removeTopic = false;
+                    break;
+                }
+            }
+            if (removeTopic) {
+                dataChangeDao.unRegisterTopic(topic);
+            }
+        }
+    }
+
+    public Set<String> getSessionTopics() {
+//        if (isDirtyTopics) {
+//            refreshSessionTopics();
+//            //isDirtyTopics = false;
+//        }
+        return sessionTopics;
+    }
+
+
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/websocket/session/WisdomStompSession.java

@@ -0,0 +1,29 @@
+package com.gyee.wisdom.dataadapter.websocket.session;
+
+import lombok.Data;
+
+import java.util.*;
+
+@Data
+public class WisdomStompSession {
+    private String sessionId;
+    private String clientIp;
+    private Date createTime;
+    private String userName;
+    private Date loginTime;
+
+    private Set<String> topics;
+
+    public void subscribeTopic(String topic) {
+        if (topics == null)
+            topics = new HashSet<>();
+        if (topics.contains(topic) == false)
+            topics.add(topic);
+    }
+
+    public void unSubscribeTopic(String topic) {
+        if (topics != null && topics.contains(topic))
+            topics.remove(topic);
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/write/PointList.java

@@ -0,0 +1,253 @@
+package com.gyee.wisdom.dataadapter.write;
+
+import org.springframework.stereotype.Component;
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * @descrition:
+ * @author:Wanghs
+ * @date:2019-04-26
+ */
+@Component
+public class PointList {
+    public static List<String> pintList = new ArrayList();
+
+    public static Map<String,String> mapPoint=new HashMap<>();
+
+    //key为读取点，value为写入点
+    public static void MapInit(){
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0001","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0001");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0161","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0161");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0175","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0175");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0081","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0081");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0241","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0241");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0255","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0255");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2259","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI2259");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2273","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI2273");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2915","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI2948");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2995","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI3028");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3009","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI3042");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1227","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1222");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1355","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1350");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1163","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1158");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1035","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1030");
+        mapPoint.put("SBQXLDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0971","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI0966");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1675","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1670");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1611","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1606");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1483","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1478");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1419","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI1414");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2669","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI2697");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2605","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI2633");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2541","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI2569");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3469","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI3497");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3405","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI3433");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3341","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI3369");
+        mapPoint.put("SBQNWDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3277","NXDQDI.NX_GD_SBQF_DQ_P1_L1_001_DI3305");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0376","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI0376");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0194","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI0194");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0858","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI0858");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0192","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI0192");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0530","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI0530");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1554","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1554");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1508","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1508");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1462","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1462");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1646","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1646");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1600","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1600");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1416","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1416");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1370","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1370");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1324","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1324");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1692","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1692");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1278","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1278");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1232","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1232");
+        mapPoint.put("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1186","NXDQDI.NX_GD_QSF_DQ_P1_L1_001_DI1186");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0034","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0034");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0308","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0308");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0331","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0331");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0169","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0169");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0192","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0192");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1514","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI1514");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0914","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0914");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0849","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0849");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0979","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0979");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1629","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI1629");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1368","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI1368");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0333","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0333");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0194","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0194");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1501","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI1501");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0916","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0916");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0851","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0851");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0981","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI0981");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1631","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI1631");
+        mapPoint.put("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1369","NXDQDI.NX_GD_XSF_DQ_P1_L1_001_DI1369");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0003","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0003");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0011","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0011");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0019","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0019");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0025","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0025");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0034","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0034");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0040","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0040");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0049","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0049");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0055","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0055");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0070","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0070");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0076","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0076");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0082","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0082");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0088","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0088");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0093","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0093");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI1433","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI1433");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0098","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0098");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0104","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0104");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0110","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0110");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0116","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0116");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0121","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0121");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI1472","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI1472");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0126","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0126");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0132","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0132");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0138","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0138");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0144","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0144");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI0149","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI0149");
+        mapPoint.put("NSSDQN.NX_GD_NSSF_DQ_P1_L1_001_DI1511","NXDQDI.NX_GD_NSSF_DQ_P1_L1_001_DI1511");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0893","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0893");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0940","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0940");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0636","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0636");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0585","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0585");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0534","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0534");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0485","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0485");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0425","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0425");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0365","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0365");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI1029","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI1029");
+        mapPoint.put("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0985","NXDQDI.NX_GD_MHSF_DQ_P1_L1_001_DI0985");
+
+    }
+
+    public static void pointListInit() {
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0001");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0161");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0175");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0081");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0241");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0255");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2259");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2273");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2948");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3028");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3042");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1222");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1350");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1158");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1030");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI0966");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1670");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1606");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1478");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI1414");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2697");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2633");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI2569");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3497");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3433");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3369");
+        pintList.add("SBQDQ.NX_GD_SBQF_DQ_P1_L1_001_DI3305");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0376");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0194");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0858");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0192");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI0530");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1554");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1508");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1462");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1646");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1600");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1416");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1370");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1324");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1692");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1278");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1232");
+        pintList.add("QSDQ.NX_GD_QSF_DQ_P1_L1_001_DI1186");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0034");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0308");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0331");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0169");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0192");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1514");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0914");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0849");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0979");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1629");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1368");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0333");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0194");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1501");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0916");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0851");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI0981");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1631");
+        pintList.add("XSDQ.NX_GD_XSF_DQ_P1_L1_001_DI1369");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0003");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0011");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0019");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0025");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0034");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0040");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0049");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0055");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0070");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0076");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0082");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0088");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0093");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI1433");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0098");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0104");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0110");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0116");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0121");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI1472");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0126");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0132");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0138");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0144");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI0149");
+        pintList.add("NSSDQ.NX_GD_NSSF_DQ_P1_L1_001_DI1511");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0893");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0940");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0636");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0585");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0534");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0485");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0425");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0365");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI1029");
+        pintList.add("MHSDQ.NX_GD_MHSF_DQ_P1_L1_001_DI0985");
+    }
+
+    public static void readXml() throws IOException {
+        PointList l = new PointList();
+        String path = l.getClass().getResource("").getPath();
+
+        try {
+            String p = path + "/point.xml";
+          //  new File(p);
+            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            Document doc = builder.parse(p);
+            NodeList nl = doc.getElementsByTagName("point");
+
+            for(int i = 0; i < nl.getLength(); ++i) {
+                String pointString = nl.item(i).getFirstChild().getNodeValue();
+                pintList.add(pointString);
+            }
+
+            System.out.println(pintList.size());
+        } catch (Exception var10) {
+            System.out.println(var10.getMessage());
+        }
+
+    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/write/ReadAndWrite.java

@@ -0,0 +1,140 @@
+package com.gyee.wisdom.dataadapter.write;
+
+import com.gyee.wisdom.common.data.timeseries.BooleanTsData;
+import com.gyee.wisdom.common.data.timeseries.GeneralTsData;
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import com.gyee.wisdom.common.data.timeseries.TsPointData;
+//import com.rtdb.model.DoubleData;
+//import com.rtdb.model.Entity;
+//import com.rtdb.model.IntData;
+//import com.rtdb.model.MinPoint;
+//import com.rtdb.service.impl.BaseImpl;
+//import com.rtdb.service.impl.ServerImpl;
+//import com.rtdb.service.impl.SnapshotImpl;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Array;
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.ToIntFunction;
+
+/**
+ * @descrition:
+ * @author:Wanghs
+ * @date:2019-04-26
+ */
+@Component
+public class ReadAndWrite extends Thread {
+//    public void run() {
+//        try {
+//            ServerImpl readConnect = this.getConnect();
+//            ServerImpl writeConnect = this.getConnect();
+//            PointList.pointListInit();
+//
+//            while (true) {
+//                Thread.sleep(5000);
+//                //获取所有key
+//                Set<String> keys = PointList.mapPoint.keySet();
+//
+//                String tagNames[] = new String[keys.size()];
+//                int countIndx = 0;
+//                for (String getKey : PointList.mapPoint.keySet()) {
+//                    tagNames[countIndx] = getKey;
+//                    countIndx++;
+//                }
+//
+//                Map<String, TsData> readMap = this.read(readConnect, tagNames);
+//                List<TsPointData> writeList = new ArrayList();
+//                Iterator iter = readMap.keySet().iterator();
+//
+//                while (iter.hasNext()) {
+//                    String resultMapKey = (String) iter.next();
+//                    BooleanTsData data = (BooleanTsData) readMap.get(resultMapKey);
+//                    TsPointData writeData = new TsPointData();
+//
+//                    GeneralTsData gData = new GeneralTsData();
+//                    gData.setTs((new Date()).getTime());
+//                    if (data.getBooleanValue()) {
+//                        gData.setDoubleValue(Optional.ofNullable(1.0));
+//                    } else {
+//                        gData.setDoubleValue(Optional.ofNullable(0.0));
+//                    }
+//
+//                    //String tagName = key.replace("SBQDQ", "NXDQDI").replace("XSDQ", "NXDQDI").replace("QSDQ", "NXDQDI").replace("NSSDQ", "NXDQDI").replace("MHSDQ", "NXDQDI");
+//                 //如果MapPoint中包含查询结果的点，则通过map找要写入的点(value)
+//                   if(PointList.mapPoint.containsKey(resultMapKey)){
+//                       String writeTagName=PointList.mapPoint.get(resultMapKey);
+//                       writeData.setTagName(writeTagName);
+//                       writeData.setTsData(gData);
+//                       writeList.add(writeData);
+//                   }
+//
+//                }
+//
+//                System.out.println(writeList.size() + "查询完毕");
+//               int count = this.write(writeConnect, writeList);
+//               System.out.println("写入数量" + count);
+//            }
+//        } catch (Exception ex) {
+//            System.out.println(ex.getMessage());
+//        }
+//    }
+//
+//    public Map<String, TsData> read(ServerImpl connect, String... tagNames) throws Exception {
+//        HashMap tsDataMap = new HashMap();
+//
+//        try {
+//            SnapshotImpl snap = new SnapshotImpl(connect);
+//            BaseImpl base = new BaseImpl(connect);
+//            List<MinPoint> lstPoint = base.findPoints(tagNames);
+//            int[] ids = lstPoint.stream().mapToInt(MinPoint::getId).toArray();
+//            Entity<IntData> entityD = snap.getIntSnapshots(ids);
+//
+//            for (int i = 0; i < tagNames.length; ++i) {
+//                tsDataMap.put(tagNames[i], new BooleanTsData(((IntData) entityD.getList().get(i)).getDateTime().getTime(), ((IntData) entityD.getList().get(i)).getQuality(), ((IntData) entityD.getList().get(i)).getValue() != 0.0D));
+//            }
+//
+//            return tsDataMap;
+//        } catch (Exception var13) {
+//            return tsDataMap;
+//        } finally {
+//            ;
+//        }
+//    }
+//
+//    public int write(ServerImpl connect, List<TsPointData> list) throws Exception {
+//        try {
+//            SnapshotImpl snap = new SnapshotImpl(connect);
+//            BaseImpl base = new BaseImpl(connect);
+//            String[] tagNames = (String[]) list.stream().map(TsPointData::getTagName).toArray((x$0) -> {
+//                return new String[x$0];
+//            });
+//            List<MinPoint> pointList = base.findPoints(tagNames);
+//            List<DoubleData> doubleList = new ArrayList();
+//
+//            int count;
+//            for (count = 0; count < list.size(); ++count) {
+//                Date time = new Date();
+//                time.setTime(((TsPointData) list.get(0)).getTsData().getTs());
+//                DoubleData data = new DoubleData(((MinPoint) pointList.get(count)).getId(), time, (Double) ((TsPointData) list.get(count)).getTsData().getDoubleValue().get(), (short) 0, 0);
+//                doubleList.add(data);
+//            }
+//
+//            count = snap.putDoubleSnapshots(doubleList);
+//            return count;
+//        } catch (Exception var11) {
+//            return -1;
+//        }
+//    }
+//
+//    private ServerImpl getConnect() throws Exception {
+//        String serverIp = "192.168.1.100";
+//        short serverPort = 6327;
+//        String userName = "sa";
+//        String password = "golden";
+//        ServerImpl conn = new ServerImpl(serverIp, serverPort, userName, password);
+//        return conn;
+//    }
+
+}

data-adapter/src/main/java/com/gyee/wisdom/dataadapter/write/WriteRedis.java

@@ -0,0 +1,53 @@
+package com.gyee.wisdom.dataadapter.write;
+
+import com.gyee.wisdom.common.data.timeseries.BasicTsPoint;
+import com.gyee.wisdom.common.data.timeseries.TsPoint;
+import com.gyee.wisdom.dao.things.IThingsPointDao;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+public class WriteRedis extends Thread {
+   /* public IThingsPointDao getThingsPointDao() {
+        return thingsPointDao;
+    }
+
+    public void setThingsPointDao(IThingsPointDao thingsPointDao) {
+        this.thingsPointDao = thingsPointDao;
+    }
+
+    public RedisLatestDao getRedisLatestDao() {
+        return redisLatestDao;
+    }
+
+    public void setRedisLatestDao(RedisLatestDao redisLatestDao) {
+        this.redisLatestDao = redisLatestDao;
+    }
+
+    private IThingsPointDao thingsPointDao;
+    private RedisLatestDao redisLatestDao;
+    public void run() {
+        try {
+            while (true) {
+                Thread.sleep(1000);
+                //获取所有key
+                List<TsPoint> tsPoints = new ArrayList<>();
+                List<TsPoint> lst = thingsPointDao.getAllTsPoint();
+                for (TsPoint tsPoint:lst){
+                    if (tsPoint.getTag().equals("3")){
+                        tsPoints.add(tsPoint);
+                    }
+                }
+                redisLatestDao.setTsDataLatest(tsPoints);
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }*/
+
+}

data-adapter/src/main/java/com/gyee/wisdom/traceforbidden/UndertowWebServerCustomizer.java

@@ -0,0 +1,33 @@
+package com.gyee.wisdom.traceforbidden;
+
+/**
+ * @descrition:
+ * @author:Wanghs
+ * @date:2020-06-30
+ */
+import io.undertow.server.HandlerWrapper;
+import io.undertow.server.HttpHandler;
+import io.undertow.server.handlers.DisallowedMethodsHandler;
+import io.undertow.util.HttpString;
+import org.springframework.boot.web.embedded.undertow.UndertowServletWebServerFactory;
+import org.springframework.boot.web.server.WebServerFactoryCustomizer;
+import org.springframework.stereotype.Component;
+
+@Component
+public class UndertowWebServerCustomizer  implements WebServerFactoryCustomizer<UndertowServletWebServerFactory> {
+
+    @Override
+    public void customize(UndertowServletWebServerFactory factory) {
+
+        factory.addDeploymentInfoCustomizers(deploymentInfo -> {
+            deploymentInfo.addInitialHandlerChainWrapper(new HandlerWrapper() {
+                @Override
+                public HttpHandler wrap(HttpHandler handler) {
+                    HttpString[] disallowedHttpMethods = { HttpString.tryFromString("TRACE"),
+                            HttpString.tryFromString("TRACK") };
+                    return new DisallowedMethodsHandler(handler, disallowedHttpMethods);
+                }
+            });
+        });
+    }
+}

data-adapter/src/main/lib/eDosProxyApi.h

@@ -0,0 +1,488 @@
+#ifndef __EDOS_PROXY_API__
+#define __EDOS_PROXY_API__
+
+#define EDOSPROXYAPI_EXPORTS
+
+#ifdef EDOSPROXYAPI_EXPORTS
+#define EDOSPROXYAPI_API __declspec(dllexport) 
+#else
+#define EDOSPROXYAPI_API __declspec(dllimport)
+#endif
+
+#pragma pack(push, __EDOS_PROXY__)
+#pragma pack(1)
+
+#define ERROR_LOGIN_FAILED				 -2000
+#define ERROR_USER_ALREADY_EXIST  -2001
+#define ERROR_USER_NOT_EXIST  -2002
+#define ERROR_USER_ACCOUNT_ALREADY_EXIST  -2003
+#define ERROR_IDENTITY_ALREADY_EXIST  -2004
+#define ERROR_IDENTITY_NOT_EXIST  -2005
+#define ERROR_SERVICE_ALREADY_EXIST  -2006
+#define ERROR_SERVICE_NOT_EXIST  -2007
+#define ERROR_POINT_ALREADY_EXIST  -2008
+#define ERROR_POINT_NOT_EXIST  -2009
+#define ERROR_HISTORY_FULL  -2010
+#define ERROR_NO_LOGIN		  -2011
+#define ERROR_NO_PERMISSION  -2012
+#define ERROR_CHANGE_ADMIN_SETTING  -2013
+#define ERROR_CONNECT_TO_HISTORY  -2014
+#define ERROR_GET_CAPACITY_FAILED = -2015
+#define ERROR_NOT_EQUAL_CAPACITY = -2016
+#define ERROR_HISTORY_NAME  -2017
+#define ERROR_PARAM_EMPTY  -2018
+#define ERROR_PARAM_VALUE_ERROR  -2019
+#define ERROR_GET_POINT_INFO  -2020
+#define ERROR_DELETE_POINT  -2021
+#define ERROR_GET_POINT_INDEXES  -2022
+#define ERROR_PARAM_CONTAIN_DOT  -2023
+#define ERROR_HISTORY_NOT_RUNNING -2024
+#define ERROR_POINT_NAME = -2025
+#define ERROR_NOT_STRING_HISTORY -2026
+#define ERROR_NOT_DOUBLE_HISTORY -2027
+#define ERROR_INSTANCE_TYPE -2028
+#define ERROR_NOT_POINT_EXTEND_DATA -2029
+#define ERROR_NOT_INSTANCE_DESC -2030
+#define ERROR_NOT_IMAGE_HISTORY -2031
+
+#define SERVICE_BUSY									 -1
+#define PROXY_NOT_WORKING					-1001
+#define SEND_DATA_TO_BUF						-1002
+#define SOCKET_NOT_OPEN						-1003
+#define REQUEST_BUFFER_NOT_ENOUGH	-1004
+#define NO_COMMUNICATION_KEY			-1005
+#define ERROR_HIST_REQUEST_TIME -1006
+
+#define  INFO_LENGTH					200
+#define  IMAGE_SIZE						10000
+
+#define POINT_ALLOW_READ   1
+#define POINT_ALLOW_WRITE  2
+#define POINT_FULL_CONTROL 3
+
+#define FLOAT_ERROR -1.7E308
+
+typedef struct
+{
+	int dateUTC;
+	int bLowWarn;
+	double lowWarn;
+	int bLowAlarm;
+	double lowAlarm;
+	int bLowOutOfRange;
+	double lowOutOfRange;
+	int bHighWarn;
+	double highWarn;
+	int bHighAlarm;
+	double highAlarm;
+	int bHighOutOfRange;
+	double highOutOfRange;
+	char reservedField[INFO_LENGTH];
+	char reservedField2[INFO_LENGTH];
+	char reservedField3[INFO_LENGTH];
+	char reservedField4[INFO_LENGTH];
+	char reservedField5[INFO_LENGTH];
+	char reservedField6[INFO_LENGTH];
+	char reservedField7[INFO_LENGTH];
+	char reservedField8[INFO_LENGTH];
+	char reservedField9[INFO_LENGTH];
+	char reservedField10[INFO_LENGTH];
+	int bNoDataCheck;
+	int bForceDataToHistory;
+	int forcePeriod;
+} POINT_EXTEND_BACKUP_DATA;
+
+
+typedef struct
+{
+	int bLowWarn;
+	double lowWarn;
+	int bLowAlarm;
+	double lowAlarm;
+	int bLowOutOfRange;
+	double lowOutOfRange;
+	int bHighWarn;
+	double highWarn;
+	int bHighAlarm;
+	double highAlarm;
+	int bHighOutOfRange;
+	double highOutOfRange;
+	char reservedField[INFO_LENGTH];
+	char reservedField2[INFO_LENGTH];
+	char reservedField3[INFO_LENGTH];
+	char reservedField4[INFO_LENGTH];
+	char reservedField5[INFO_LENGTH];
+	char reservedField6[INFO_LENGTH];
+	char reservedField7[INFO_LENGTH];
+	char reservedField8[INFO_LENGTH];
+	char reservedField9[INFO_LENGTH];
+	char reservedField10[INFO_LENGTH];
+	int bNoDataCheck;
+	int bForceDataToHistory;
+	int forcePeriod;
+} POINT_EXTEND_DATA;
+
+typedef struct  
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+	char ip[50];
+	unsigned short port;
+	int capacity;
+}	HISTORY;
+
+typedef struct  
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+} IDENTITY;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+} PERMISSION;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+	char account[INFO_LENGTH];
+	char password[INFO_LENGTH];
+} USER;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	int  count;
+	int  stringCount;
+	char description[INFO_LENGTH];
+	char system[INFO_LENGTH];
+	char subSystem[INFO_LENGTH];
+} POINT_INSTANCE_INFO;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+	char system[INFO_LENGTH];
+	char subSystem[INFO_LENGTH];
+} POINT_INSTANCE_DESC;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+	unsigned short nPrecision;
+	double deadBand;
+	int expireDays;
+	unsigned short pointType;
+	char units[50];
+	char instance[INFO_LENGTH];
+	char instanceAttribute[INFO_LENGTH];
+	char instanceAttributeDescription[INFO_LENGTH];
+	char type[INFO_LENGTH];
+	int minimumUpdateFreq;
+	double dValue;
+	int tTime;
+	unsigned short status;
+} HISTORY_POINT;
+
+typedef struct
+{
+	HISTORY_POINT point;
+	POINT_EXTEND_DATA data;
+} HISTORY_POINT_EX;
+
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+	int expireDays;
+	char units[50];
+	char instance[INFO_LENGTH];
+	char instanceAttribute[INFO_LENGTH];
+	char instanceAttributeDescription[INFO_LENGTH];
+	char type[INFO_LENGTH];
+	int minimumUpdateFreq;
+	char sValue[INFO_LENGTH];
+	int tTime;
+	unsigned short status;
+} HISTORY_STRING_POINT;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	char description[INFO_LENGTH];
+	int expireDays;
+	char units[50];
+	char instance[INFO_LENGTH];
+	char instanceAttribute[INFO_LENGTH];
+	char instanceAttributeDescription[INFO_LENGTH];
+	char type[INFO_LENGTH];
+	int minimumUpdateFreq;
+	char image[IMAGE_SIZE];
+	int tTime;
+	unsigned short status;
+} HISTORY_IMAGE_POINT;
+
+typedef struct
+{
+	int tTime;
+	double dValue;
+	unsigned short status;
+} HISTORY_VALUE;
+
+typedef struct
+{
+	int tTime;
+	char sValue[INFO_LENGTH];
+	unsigned short status;
+} HISTORY_STRING_VALUE;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	HISTORY_VALUE rec;
+} POINT_VALUE;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	HISTORY_STRING_VALUE rec;
+} POINT_STRING_VALUE;
+
+typedef struct
+{
+	int tTime;
+	char image[IMAGE_SIZE];
+	unsigned short status;
+} HISTORY_IMAGE_VALUE;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	HISTORY_IMAGE_VALUE rec;
+} POINT_IMAGE_VALUE;
+
+
+typedef struct
+{
+	HISTORY_VALUE maxValue;
+	HISTORY_VALUE minValue;
+	HISTORY_VALUE avgValue;
+} HIST_STAT_VALUE;
+
+typedef struct
+{
+	char name[INFO_LENGTH];
+	int instanceCount;
+} TYPE_INSTANCE_INFO;
+
+typedef struct
+{
+	unsigned short n_days;      /* number of days until data expires */
+	long           earliest;    /* time of earliest entry for this point */
+	long           latest;      /* time of last entry for this point */
+	long           n_entries;   /* how many entries available for point */
+} POINT_INFO;
+
+
+extern "C" EDOSPROXYAPI_API int InitCommunicationKey(unsigned long *key,bool cacheEnable,char *cacheFolder,int maxCacheSizeInMB);
+
+extern "C" EDOSPROXYAPI_API int ConnectToServer(unsigned long key,char *serverIP,unsigned short serverPort);
+
+extern "C" EDOSPROXYAPI_API int Login(unsigned long key,char *account,char *password);
+
+extern "C" EDOSPROXYAPI_API int CreateServ(unsigned long key,HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int UpdateServ(unsigned long key,HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int DeleteServ(unsigned long key,HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int LoadAllServices(unsigned long key,HISTORY *service,unsigned short nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int LoadHistoryInfo(unsigned long key,HISTORY service,int *pointCount,int *capacity);
+
+extern "C" EDOSPROXYAPI_API int CreateIdentity(unsigned long key,IDENTITY identity,PERMISSION *permission,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int UpdateIdentity(unsigned long key,IDENTITY identity,PERMISSION *permission,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int DeleteIdentity(unsigned long key,IDENTITY identity);
+
+extern "C" EDOSPROXYAPI_API int LoadAllIdentity(unsigned long key,IDENTITY *identities,unsigned short nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int LoadIdentityPermission(unsigned long key,IDENTITY identity,PERMISSION *permission,unsigned short nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int LoadAllPermission(unsigned long key,PERMISSION *permission,unsigned short nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int CreateUser(unsigned long key,USER user,IDENTITY identity);
+
+extern "C" EDOSPROXYAPI_API int UpdateUser(unsigned long key,USER user,IDENTITY identity);
+
+extern "C" EDOSPROXYAPI_API int DeleteUser(unsigned long key,USER user);
+
+extern "C" EDOSPROXYAPI_API int GetCurrentLoginIdentity(unsigned long key,IDENTITY *identity);
+
+extern "C" EDOSPROXYAPI_API int LoadAllUsers(unsigned long key,USER *user,IDENTITY *identities,unsigned short nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int CreatePoint(unsigned long key,HISTORY_POINT point,IDENTITY *identities,unsigned short *usMode,unsigned short nCount); // usMode can be POINT_ALLOW_READ,POINT_ALLOW_WRITE,POINT_FULL_CONTROL
+
+extern "C" EDOSPROXYAPI_API int UpdatePoint(unsigned long key,HISTORY_POINT point,IDENTITY *identities,unsigned short *usMode,unsigned short nCount); // usMode can be POINT_ALLOW_READ,POINT_ALLOW_WRITE,POINT_FULL_CONTROL
+
+extern "C" EDOSPROXYAPI_API int DeletePoint(unsigned long key,HISTORY_POINT point);
+
+extern "C" EDOSPROXYAPI_API int GetHistoryPoints(unsigned long key,HISTORY service,char *filterName,char *filterDesc,char *filterInstance,char * filterInstanceAttribute,char * filterInstanceAttributeDescription,char *type,HISTORY_POINT *point,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetHistoryPointsEX(unsigned long key, HISTORY service, char *filterName, char *filterDesc, char *filterInstance, char * filterInstanceAttribute, char * filterInstanceAttributeDescription, char *type, HISTORY_POINT_EX *point, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int SendMultiPoint(unsigned long key,POINT_VALUE *recs,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int SendMultiPointBigData(unsigned long key, POINT_VALUE *recs,int nCount);
+
+extern "C" EDOSPROXYAPI_API int InitMultiPoint(unsigned long key, POINT_VALUE *recs, unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int InitMultiPointBigData(unsigned long key, POINT_VALUE *recs, int nCount);
+
+extern "C" EDOSPROXYAPI_API int SendSinglePoint(unsigned long key,char *name,HISTORY_VALUE *recs,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int GetRTValue(unsigned long key,char *name,HISTORY_VALUE *rec);
+
+extern "C" EDOSPROXYAPI_API int GetPointID(unsigned long key, char *name, int *id);
+
+extern "C" EDOSPROXYAPI_API int GetRTValueList(unsigned long key,char **nameList,HISTORY_VALUE *rec,int nCount);
+
+extern "C" EDOSPROXYAPI_API int GetHistSnap(unsigned long key,char *name,int tStart,int tEnd,int period,HISTORY_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetHistStat(unsigned long key,char *name,int tStart,int tEnd,int period,HIST_STAT_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetHistRaw(unsigned long key,char *name,int tStart,int tEnd,HISTORY_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetHistMatrix(unsigned long key,char **nameList,int tTime,HISTORY_VALUE *rec,int nCount);
+
+extern "C" EDOSPROXYAPI_API int UpdatePointData(unsigned long key,char *name,HISTORY_VALUE *rec,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int UpdateBigPointData(unsigned long key, char *name, HISTORY_VALUE *rec, int nCount);
+
+extern "C" EDOSPROXYAPI_API int GetPointIdentities(unsigned long key,char *name,IDENTITY *identities,unsigned short *usModes,unsigned short nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetPointInstances(unsigned long key,POINT_INSTANCE_INFO *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetInstancePoints(unsigned long key,char *instance,int start,int count,HISTORY_POINT *point,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetPointsUnderHistory(unsigned long key,char *history,int start,int count,HISTORY_POINT *point,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetPointInfo(unsigned long key,char *name,HISTORY_POINT *point);
+
+extern "C" EDOSPROXYAPI_API int SendData(unsigned long key,unsigned char *data,unsigned long len);
+
+extern "C" EDOSPROXYAPI_API int CreateStringPoint(unsigned long key,HISTORY_STRING_POINT point);
+
+extern "C" EDOSPROXYAPI_API int UpdateStringPoint(unsigned long key,HISTORY_STRING_POINT point);
+
+extern "C" EDOSPROXYAPI_API int DeleteStringPoint(unsigned long key,HISTORY_STRING_POINT point);
+
+extern "C" EDOSPROXYAPI_API int SendMultiStringPoint(unsigned long key,POINT_STRING_VALUE *recs,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int SendSingleStringPoint(unsigned long key,char *name,HISTORY_STRING_VALUE *recs,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int GetPointsUnderStringHistory(unsigned long key,char *history,int start,int count,HISTORY_STRING_POINT *point,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetStringRTValue(unsigned long key,char *name,HISTORY_STRING_VALUE *rec);
+
+extern "C" EDOSPROXYAPI_API int GetStringRTValueList(unsigned long key,char **nameList,HISTORY_STRING_VALUE *rec,int nCount);
+
+extern "C" EDOSPROXYAPI_API int GetStringHistoryPoints(unsigned long key,HISTORY service,char *filterName,char *filterDesc,char *filterInstance,char * filterInstanceAttribute,char * filterInstanceAttributeDescription,char *type,HISTORY_STRING_POINT *point,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetStringHistSnap(unsigned long key,char *name,int tStart,int tEnd,int period,HISTORY_STRING_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetStringHistRaw(unsigned long key,char *name,int tStart,int tEnd,HISTORY_STRING_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetStringHistMatrix(unsigned long key,char **nameList,int tTime,HISTORY_STRING_VALUE *rec,int nCount);
+
+extern "C" EDOSPROXYAPI_API int UpdateStringPointData(unsigned long key,char *name,HISTORY_STRING_VALUE *rec,unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int GetInstanceStringPoints(unsigned long key,char *instance,int start,int count,HISTORY_STRING_POINT *point,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int CreateStringService(unsigned long key,HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int UpdateStringService(unsigned long key,HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int DeleteStringService(unsigned long key,HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int GetStringPointInfo(unsigned long key,char *name,HISTORY_STRING_POINT *point);
+
+extern "C" EDOSPROXYAPI_API int LoadAllTypes(unsigned long key,TYPE_INSTANCE_INFO *types,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetPointInstancesUnderType(unsigned long key,char* type,POINT_INSTANCE_INFO *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int DeletePointData(unsigned long key,char *name,int tStart,int tEnd);
+
+extern "C" EDOSPROXYAPI_API int GetPointStat(unsigned long key,char *name,POINT_INFO* info);
+
+extern "C" EDOSPROXYAPI_API bool IsConnected(unsigned long key);
+
+extern "C" EDOSPROXYAPI_API int DisposeKey(unsigned long key);
+
+extern "C" EDOSPROXYAPI_API int CreateOrUpdatePointExtendData(unsigned long key,char *name,POINT_EXTEND_DATA data);
+
+extern "C" EDOSPROXYAPI_API int SearchPointExtendData(unsigned long key,char *name,POINT_EXTEND_DATA *data);
+
+extern "C" EDOSPROXYAPI_API int DeletePointExtendData(unsigned long key,char *name);
+
+extern "C" EDOSPROXYAPI_API int SearchPointExtendBackUpData(unsigned long key,char *name,int tStart,int tEnd,POINT_EXTEND_BACKUP_DATA *data,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetStringHistSnapRaw(unsigned long key,char *name,int tStart,int tEnd,int period,HISTORY_STRING_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetHistSnapRaw(unsigned long key,char *name,int tStart,int tEnd,int period,HISTORY_VALUE *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int CreateOrUpdateInstanceDesc(unsigned long key,POINT_INSTANCE_DESC desc);
+
+extern "C" EDOSPROXYAPI_API int RemoveInstanceDesc(unsigned long key,char *instanceName);
+
+extern "C" EDOSPROXYAPI_API int SearchInstance(unsigned long key,char *type,char *description,char *system,char *subSystem,POINT_INSTANCE_INFO *rec,int nCount,int *retsize);
+
+extern "C" EDOSPROXYAPI_API int CreateImageService(unsigned long key, HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int UpdateImageService(unsigned long key, HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int DeleteImageService(unsigned long key, HISTORY service);
+
+extern "C" EDOSPROXYAPI_API int CreateImagePoint(unsigned long key, HISTORY_IMAGE_POINT point);
+
+extern "C" EDOSPROXYAPI_API int UpdateImagePoint(unsigned long key, HISTORY_IMAGE_POINT point);
+
+extern "C" EDOSPROXYAPI_API int DeleteImagePoint(unsigned long key, HISTORY_IMAGE_POINT point);
+
+extern "C" EDOSPROXYAPI_API int SendMultiImagePoint(unsigned long key, POINT_IMAGE_VALUE *recs, unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int SendSingleImagePoint(unsigned long key, char *name, HISTORY_IMAGE_VALUE *recs, unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int GetPointsUnderImageHistory(unsigned long key, char *history, int start, int count, HISTORY_IMAGE_POINT *point, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetImageRTValue(unsigned long key, char *name, HISTORY_IMAGE_VALUE *rec);
+
+extern "C" EDOSPROXYAPI_API int GetImageRTValueList(unsigned long key, char **nameList, HISTORY_IMAGE_VALUE *rec, int nCount);
+
+extern "C" EDOSPROXYAPI_API int GetImageHistoryPoints(unsigned long key, HISTORY service, char *filterName, char *filterDesc, char *filterInstance, char * filterInstanceAttribute, char * filterInstanceAttributeDescription, char *type, HISTORY_IMAGE_POINT *point, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetImageHistSnap(unsigned long key, char *name, int tStart, int tEnd, int period, HISTORY_IMAGE_VALUE *rec, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetImageHistSnapRaw(unsigned long key, char *name, int tStart, int tEnd, int period, HISTORY_IMAGE_VALUE *rec, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetImageHistRaw(unsigned long key, char *name, int tStart, int tEnd, HISTORY_IMAGE_VALUE *rec, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetImageHistMatrix(unsigned long key, char **nameList, int tTime, HISTORY_IMAGE_VALUE *rec, int nCount);
+
+extern "C" EDOSPROXYAPI_API int GetInstanceImagePoints(unsigned long key, char *instance, int start, int count, HISTORY_IMAGE_POINT *point, int nCount, int *retsize);
+
+extern "C" EDOSPROXYAPI_API int GetImagePointInfo(unsigned long key, char *name, HISTORY_IMAGE_POINT *point);
+
+extern "C" EDOSPROXYAPI_API int UpdateImagePointData(unsigned long key, char *name, HISTORY_IMAGE_VALUE *rec, unsigned short nCount);
+
+extern "C" EDOSPROXYAPI_API int TracePoint(unsigned long key, char *name);
+
+#pragma pack(pop, __EDOS_PROXY__)
+
+#endif

data-adapter/src/main/resources/application.yaml

@@ -0,0 +1,147 @@
+server:
+  port: 8012
+  connection-timeout: 3000
+
+spring:
+  application:
+    name: data-adapter
+  jpa:
+    show-sql: false
+  cache:
+    type: SIMPLE
+  datasource:
+    # -------------------------1区mysql/2区oracle---------------------------------------
+#    driver-class-name: oracle.jdbc.OracleDriver
+#    url: jdbc:oracle:thin:@123.60.213.70:1521:gdnxfd
+#    username: nxfdprod
+#    password: gdnxfd123
+    # ----------------------------------------------------------------
+    driver-class-name: com.mysql.jdbc.Driver
+    url: jdbc:mysql://123.60.219.66/wisdom_cs?useUnicode=true&characterEncoding=UTF-8
+    username: root
+    password: gyeepd@123
+    # ----------------------------------------------------------------
+    type: com.alibaba.druid.pool.DruidDataSource
+    druid:
+          max-active: 20
+          initial-size: 1
+          min-idle: 3
+          max-wait: 60000
+          time-between-eviction-runs-millis: 60000
+          min-evictable-idle-time-millis: 300000
+          test-while-idle: true
+          test-on-borrow: false
+          test-on-return: false
+#  redis:
+#    database: 2
+#    host: 192.168.2.5
+#    password:
+#    port: 6379
+#    timeout: 60000
+#    jedis:
+#      pool:
+#        maxTotal: 20
+#        maxIdle: 20
+#        maxwait: 60000
+#        minIdle: 10
+# 此处Key不可改变
+knife4j:
+  redis:
+    # 是否采用json序列化方式，若不采用jackson序列化
+    jsonSerialType: 'Fastjson'
+    host: 192.168.1.252
+    password: gyee123
+    port: 6379
+    databases: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18] # 要使用的库，会根据此处填写的库生成redisTemplate
+    timeout: 60s
+    lettuce: # lettuce基于netty，线程安全，支持并发
+      pool:
+        max-active: 50
+        max-wait: -1ms
+        max-idle: 8
+        min-idle: 0
+  cache:
+    type: Simple
+
+timeseries:
+  db-type: taoscz #"${DATABASE_TYPE:sql}" # cassandra/kairosDB/hbase/opentsDB/influxDB/TiDB
+  #db-type: hadoop #"${DATABASE_TYPE:sql}" # cassandra/kairosDB/hbase/opentsDB/influxDB/TiDB
+#golden 数据库信息
+golden:
+  server_ip: 123.60.213.70
+  #server_ip: 172.168.1.3
+  server_port: 6327
+  user_name: sa
+  password: golden
+  pool_size: 10
+  max_pool_size: 100
+  #单次查询历史原始数据的数量上限
+  query_history_limit: 100000
+
+#hadoop数据库信息
+hadoop:
+#查询上一个值的最多访问次数  2的8次方,增加步长为60分钟,如:t0-60,t0-120,t0-240....
+ lastValueSearch: 8
+ urlMap:
+   DJL: http://192.168.1.61:4242/api/
+   DQ: http://192.168.1.62:4242/api/
+   GF: http://192.168.1.63:4242/api/
+   GGL: http://192.168.1.64:4242/api/
+   FGL: http://192.168.1.66:4242/api/
+   FJ: http://192.168.1.69:4243/api/
+   JSFW: http://192.168.1.67:4242/api/
+   #仅限于查询NSSDQN,NXDQDI,SBQNWDQ,SBQXLDQ
+   DQ2: http://192.168.1.62:10001/api/
+
+#taos数据库
+taos:
+  server_ip: 192.168.2.252
+  server_port: 6030
+  user_name: root
+  password: taosdata
+  pool_size: 10
+  max_pool_size: 100
+
+taoscz:
+  server_ip: 192.168.1.252
+  server_port: 6030
+  db_name: hnj_fdc
+  user_name: root
+  password: taosdata
+  pool_size: 10
+  max_pool_size: 100
+  driver_type: com.taosdata.jdbc.TSDBDriver
+
+#EDOS 数据库信息
+edos:
+  server_ip: 192.168.1.100
+  server_port: 10010
+  default_connections: 1
+  incremental_connections: 1
+  max_connections: 10
+# Publish 发布服务配置
+publish:
+  rtdb_scan_interval: 1000
+  publish_interval: 5000
+
+#是否缓存所有风机测点
+isLoadAllTag: true
+#是否启动websocket推送
+websocket_start: false
+#websocket推送风机基本信息统一编码
+uniformcode:
+ wind_speed_code: AI022
+ roll_speed_code: AI128
+ power_code: AI130
+ status_code: FJZT8
+ lock_code: XDSL
+ pv_I: AIG060     #电流-A相
+ pv_U: AIG061     #电压-A相
+ pv_P: AI130      #功率-有功功率
+ pv_statue: FJZT  #状态
+
+
+
+
+
+

data-adapter/src/main/resources/banner.txt

@@ -0,0 +1,6 @@
+#####    ##   #####   ##           ##   #####    ##   #####  ##### ###### #####
+#    #  #  #    #    #  #         #  #  #    #  #  #  #    #   #   #      #    #
+#    # #    #   #   #    # ##### #    # #    # #    # #    #   #   #####  #    #
+#    # ######   #   ######       ###### #    # ###### #####    #   #      #####
+#    # #    #   #   #    #       #    # #    # #    # #        #   #      #   #
+#####  #    #   #   #    #       #    # #####  #    # #        #   ###### #    #

data-adapter/src/main/resources/log4j2.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+    <Properties>
+        <Property name="Pattern">%d{yyyy-MM-dd HH:mm:ss.SSS} %5p %t %M(%F:%L) %m%n</Property>
+    </Properties>
+    <Filter type="ThresholdFilter" level="INFO"/>
+
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="${Pattern}"/>
+        </Console>
+        <RollingFile name="RollingFileInfo" fileName="logs/info.log"
+                     filePattern="logs/%d{yyyy-MM}/info-%d{yyyy-MM-dd}.%i.log">
+            <PatternLayout pattern="${Pattern}"/>
+            <ThresholdFilter level="INFO" onMatch="ACCEPT" onMismatch="DENY"/>
+            <Policies>
+                <TimeBasedTriggeringPolicy/>
+                <SizeBasedTriggeringPolicy size="100 MB"/>
+            </Policies>
+        </RollingFile>
+        <RollingFile name="RollingFileWarn" fileName="logs/warn.log"
+                     filePattern="logs/%d{yyyy-MM}/warn-%d{yyyy-MM-dd}.%i.log">
+            <PatternLayout pattern="${Pattern}"/>
+            <ThresholdFilter level="WARN" onMatch="ACCEPT" onMismatch="DENY"/>
+            <Policies>
+                <TimeBasedTriggeringPolicy/>
+                <SizeBasedTriggeringPolicy size="100 MB"/>
+            </Policies>
+        </RollingFile>
+        <RollingFile name="RollingFileError" fileName="logs/error.log"
+                     filePattern="logs/%d{yyyy-MM}/error-%d{yyyy-MM-dd}.%i.log">
+            <PatternLayout pattern="${Pattern}"/>
+            <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY"/>
+            <Policies>
+                <TimeBasedTriggeringPolicy/>
+                <SizeBasedTriggeringPolicy size="100 MB"/>
+            </Policies>
+        </RollingFile>
+    </Appenders>
+
+    <Loggers>
+        <Root level="INFO">
+            <AppenderRef ref="Console"/>
+            <!--<appender-ref ref="RollingFileInfo"/>-->
+            <appender-ref ref="RollingFileWarn"/>
+            <appender-ref ref="RollingFileError"/>
+        </Root>
+    </Loggers>
+</Configuration>

data-adapter/src/test/java/com/gyee/wisdom/test/ClientStompFrameHandler.java

@@ -0,0 +1,26 @@
+package com.gyee.wisdom.test;
+
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import org.springframework.messaging.simp.stomp.StompFrameHandler;
+import org.springframework.messaging.simp.stomp.StompHeaders;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class ClientStompFrameHandler implements StompFrameHandler {
+
+    public Type getPayloadType(StompHeaders headers) {
+        Map<String, TsData> map = new HashMap<>();
+        return map.getClass();
+    }
+
+
+    public void handleFrame(StompHeaders headers, Object payload) {
+        System.out.println("回调数据");
+        Map<String, TsData> map = (Map<String, TsData>) payload;
+        System.out.println(payload.toString());
+
+    }
+}

data-adapter/src/test/java/com/gyee/wisdom/test/ClientStompSessionHandler.java

@@ -0,0 +1,44 @@
+package com.gyee.wisdom.test;
+
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.messaging.simp.stomp.*;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class ClientStompSessionHandler extends StompSessionHandlerAdapter {
+
+    public boolean connect = false;
+
+    @Override
+    public void handleFrame(StompHeaders headers, Object payload) {
+
+        System.out.println("测试返回数据");
+        Map<String, TsData> map = (Map<String, TsData>) payload;
+        System.out.println(payload.toString());
+        System.out.println(map);
+    }
+
+    @Override
+    public void handleException(StompSession s, StompCommand c, StompHeaders h, byte[] p, Throwable ex) {
+        System.out.println(ex.getMessage());
+    }
+
+    @Override
+    public void handleTransportError(StompSession session, Throwable ex) {
+        System.out.println(ex.getMessage());
+    }
+
+    @Override
+    public void afterConnected(final StompSession session, StompHeaders connectedHeaders) {
+        System.out.println("websocket连接成功");
+        connect = true;
+        session.subscribe("/topic/test", new ClientStompFrameHandler());
+
+    }
+
+
+}

data-adapter/src/test/java/com/gyee/wisdom/test/StompClient.java

@@ -0,0 +1,102 @@
+package com.gyee.wisdom.test;
+
+import com.gyee.wisdom.common.data.timeseries.TsData;
+import org.springframework.messaging.converter.MappingJackson2MessageConverter;
+import org.springframework.messaging.simp.stomp.StompHeaders;
+import org.springframework.messaging.simp.stomp.StompSession;
+import org.springframework.messaging.simp.stomp.StompSessionHandler;
+import org.springframework.web.socket.WebSocketHttpHeaders;
+import org.springframework.web.socket.client.standard.StandardWebSocketClient;
+import org.springframework.web.socket.messaging.WebSocketStompClient;
+import org.springframework.web.socket.sockjs.client.SockJsClient;
+import org.springframework.web.socket.sockjs.client.Transport;
+import org.springframework.web.socket.sockjs.client.WebSocketTransport;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+public class StompClient {
+
+    private SockJsClient sockJsClient;
+
+    private WebSocketStompClient stompClient;
+
+    private StompSession stompSession;
+
+    private final WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
+
+    public StompClient() {
+        List<Transport> transports = new ArrayList<>();
+        transports.add(new WebSocketTransport(new StandardWebSocketClient()));
+        this.sockJsClient = new SockJsClient(transports);
+
+        this.stompClient = new WebSocketStompClient(sockJsClient);
+        this.stompClient.setMessageConverter(new MappingJackson2MessageConverter());
+    }
+
+    public Map<String, TsData> getLatest(String keys) {
+        return null;
+    }
+
+    public void connect(StompSessionHandler handler) {
+        try {
+            stompSession = stompClient.connect("ws://localhost:8011/wisdom", headers, handler).get();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void sendRequest(StompSessionHandler handler) {
+        if (stompSession != null) {
+            StompHeaders headers = new StompHeaders();
+            headers.setDestination("/app/latest");
+            headers.add("keyStr", "MHSFJ.NX_GD_MHSF_FJ_P1_L1_001_AI0001,MHSFJ.NX_GD_MHSF_FJ_P1_L1_001_AI0005");
+            stompSession.subscribe(headers, handler);
+        }
+    }
+
+    public void sendSubscribe(StompSessionHandler handler) {
+        if (stompSession != null) {
+            StompHeaders headers = new StompHeaders();
+            headers.setDestination("/app/subscribe");
+            headers.add("topic", "/topic/test");
+            stompSession.subscribe(headers, handler);
+
+        }
+    }
+
+    public static void main2(String[] args) throws InterruptedException {
+
+        System.out.println("11111");
+        ClientStompSessionHandler handler = new ClientStompSessionHandler();
+        System.out.println("22222");
+
+        StompClient sc = new StompClient();
+        sc.connect(handler);
+
+        boolean isToConnect = true;
+        while (isToConnect) {
+            Thread.sleep(10);
+            System.out.println("循环等待握手成功");
+            if (handler.connect) {
+                sc.sendSubscribe(handler);
+                isToConnect = false;
+            }
+        }
+
+        //sc.sendRequest(handler);
+        try {
+            System.in.read();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+
+}