提交数据服务模块

tsddcs-datacacheservice/pom.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>tsddcs</artifactId>
+        <groupId>org.ts.ddcs</groupId>
+        <version>1.0.0.RELEASE</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.ts.ddcs</groupId>
+    <artifactId>datacacheservice</artifactId>
+    <name>${project.artifactId}</name>
+    <version>1.0.0.RELEASE</version>
+    <packaging>jar</packaging>
+    <description>数据平台-缓存服务</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.ts.ddcs</groupId>
+            <artifactId>tsddcs-commonservice</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <!--redis 缓存-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <!--KAFKA-->
+        <dependency>
+            <groupId>org.springframework.kafka</groupId>
+            <artifactId>spring-kafka</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.kafka</groupId>
+            <artifactId>kafka-streams</artifactId>
+            <version>3.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.kafka</groupId>
+            <artifactId>kafka-clients</artifactId>
+            <version>3.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.kafka</groupId>
+            <artifactId>kafka-streams-scala_2.13</artifactId>
+            <version>3.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jdbc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-common</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.paho</groupId>
+            <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
+        </dependency>
+    </dependencies>
+</project>

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/CacheServerApplication.java

@@ -0,0 +1,18 @@
+package org.ts.ddcs;
+
+import org.ts.ddcs.log.LogHelper;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import javax.annotation.PostConstruct;
+import java.io.*;
+import java.util.Base64;
+
+@SpringBootApplication
+@EnableScheduling
+public class CacheServerApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(CacheServerApplication.class, args);
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/config/Config.java

@@ -0,0 +1,25 @@
+package org.ts.ddcs.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+
+@Component
+public class Config {
+    @Autowired
+    public ServerConfig serverConfig;
+
+    private static class ServerConfigInstanceHolder {
+        private static Config instance = new Config();
+    }
+
+    public static Config newInstance() {
+        return Config.ServerConfigInstanceHolder.instance;
+    }
+
+    @PostConstruct
+    void init() {
+        Config.newInstance().serverConfig = serverConfig;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/config/ServerConfig.java

@@ -0,0 +1,18 @@
+package org.ts.ddcs.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author dylan
+ */
+@Component
+@Configuration
+@ConfigurationProperties(prefix = "run-config.server", ignoreUnknownFields = false)
+@Data
+public class ServerConfig {
+    private String serverId;
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/controller/test/TestController.java

@@ -0,0 +1,190 @@
+package org.ts.ddcs.controller.test;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.worker.DataProcessHolder;
+
+import org.springframework.beans.factory.annotation.Autowired;
+
+import org.springframework.data.redis.core.HashOperations;
+import org.springframework.data.redis.core.ListOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.*;
+
+import org.ts.ddcs.tool.GBConstants;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+@RestController
+@RequestMapping("/test/")
+public class TestController {
+
+    @Autowired
+    private KafkaTemplate<String, String> kafkaTemplate;
+//
+//    @GetMapping("clear")
+//    @ResponseBody
+//    public Object clear() {
+//        JSONObject res = new JSONObject();
+//        try {
+//            RedisTemplate redisTemplate = DataProcessHolder.newInstance().dataProcess.redisTemplate;
+//
+//            HashOperations<String, String, String> opsHash = redisTemplate.opsForHash();
+//
+//          Set<String> keys= redisTemplate.keys("*:"+ GBConstants.REDIS_KEY_COMMAND_QUERY);
+//
+//       //     Set<String> keys = opsHash.keys("rtu_online");
+//            if (null != keys && keys.size() > 0) {
+//                for (String rtuCode : keys) {
+//
+//                    if(opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY)){
+//                      //  opsHash.delete(rtuCode, "command");
+//                        redisTemplate.delete(rtuCode);
+//                        //ListOperations<String, String> opsList = redisTemplate.opsForList();
+//                    }
+//
+//
+//
+//                }
+//            }
+//            res.put("code", 0);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            res.put("code", 1);
+//        }
+//        return res;
+//    }
+
+//    @GetMapping("clear")
+//    @ResponseBody
+//    public Object clear() {
+//        JSONObject res = new JSONObject();
+//        try {
+//            RedisTemplate redisTemplate = DataProcessHolder.newInstance().dataProcess.redisTemplate;
+//
+//            HashOperations<String, String, String> opsHash = redisTemplate.opsForHash();
+//
+//            Set<String> keys= redisTemplate.keys("*:"+ GBConstants.REDIS_KEY_COMMAND_QUERY);
+//
+//            //     Set<String> keys = opsHash.keys("rtu_online");
+//            if (null != keys && keys.size() > 0) {
+//                for (String rtuCode : keys) {
+//
+//                    if(opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY)){
+//                        //  opsHash.delete(rtuCode, "command");
+//                        redisTemplate.delete(rtuCode);
+//                        //ListOperations<String, String> opsList = redisTemplate.opsForList();
+//                    }
+//
+//
+//
+//                }
+//            }
+//            res.put("code", 0);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            res.put("code", 1);
+//        }
+//        return res;
+//    }
+
+    @GetMapping("image/list")
+    @ResponseBody
+    public Object imageList(@RequestParam(name = "name") String name, @RequestParam(name = "age") String age) {
+        JSONObject res = new JSONObject();
+        try {
+            JSONObject data = new JSONObject();
+
+
+            JSONArray list = new JSONArray();
+
+            JSONObject d = new JSONObject();
+
+            d.put("id","1");
+            d.put("bt","1001");
+            d.put("tm","2021-03-21 12:00:00");
+            d.put("company","大恒");
+            d.put("check","0");
+            d.put("product","玻璃");
+            d.put("productCod","CK10000");
+            list.add(d);
+
+             d = new JSONObject();
+
+            d.put("id","2");
+            d.put("bt","1002");
+            d.put("tm","2021-03-22 12:00:00");
+            d.put("company","大恒");
+            d.put("check","0");
+            d.put("product","玻璃2");
+            d.put("productCod","CK10001");
+            list.add(d);
+
+
+
+            data.put("list", list);
+            data.put("count",2);
+            data.put("curPage", 1);
+            data.put("pageSize", 1);
+
+            res.put("data", data);
+            res.put("code", 0);
+        } catch (Exception e) {
+            e.printStackTrace();
+            res.put("code", 1);
+        }
+        return res;
+    }
+
+
+    @GetMapping("hdfs/test")
+    @ResponseBody
+    public Object hdfs() {
+        JSONObject res = new JSONObject();
+        try {
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            String tm = timeFormat.format(new Date());
+           // DataProcessHolder.newInstance().dataProcess.SubmitFdfsTask(tm);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return res;
+    }
+
+
+    @GetMapping("kafka/send")
+    @ResponseBody
+    public Object send() {
+        JSONObject res = new JSONObject();
+        try {
+            JSONObject data = new JSONObject();
+            String batchId = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+            data.put("id", batchId);
+            data.put("kind", "50");
+            data.put("stcd", "0012345678");
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            SimpleDateFormat timeFormat2 = new SimpleDateFormat("yyyyMMdd");
+            data.put("tm", timeFormat.format(new Date()));
+            data.put("dt", timeFormat.format(new Date()));
+            data.put("drp", "20.2");
+            data.put("intv", "1");
+            data.put("wth", "0");
+            data.put("pdr", "0");
+            data.put("dyp", "0");
+            data.put("disp_date", timeFormat2.format(new Date()));
+
+            kafkaTemplate.send("fencer1", data.toJSONString());
+            //kafkaTemplate.send("xqh", data.toJSONString());
+
+            System.out.println("消息发送成功...");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return res;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/db/DatabaseService.java

@@ -0,0 +1,14 @@
+package org.ts.ddcs.db;
+
+import java.util.Date;
+
+/**
+ * @author dylan
+ */
+public interface DatabaseService {
+    void saveRtu(String rtuCode);
+    void saveDatagram(String rtuCode, Date logTime, String datagram);
+    long datagramCount(Date startTime,Date endTime);
+
+    void updateLastTime(String rtuCode,Date time);
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/db/impl/DatabaseServiceImpl.java

@@ -0,0 +1,101 @@
+package org.ts.ddcs.db.impl;
+
+import org.ts.ddcs.db.DatabaseService;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.PreparedStatementSetter;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author dylan
+ */
+@Service("DatabaseService")
+@Transactional
+public class DatabaseServiceImpl implements DatabaseService {
+
+    @Autowired
+    JdbcTemplate jdbcTemplate;
+
+    @Override
+    public void saveRtu(String rtuCode) {
+//        String sql ="SELECT * FROM t_base_rtu_info WHERE RTU_CD='"+rtuCode+"'";
+//        List<Map<String,Object>> list =jdbcTemplate.queryForList(sql);
+//        if (null != list && list.size()>0){
+//
+//        }else{
+//           sql ="INSERT INTO `t_base_rtu_info`(`RTU_CD`) VALUES ('"+rtuCode+"')";
+//           jdbcTemplate.update(sql);
+//        }
+    }
+
+    @Override
+    public void saveDatagram(String rtuCode, Date logTime, String datagram) {
+        String sql = "INSERT INTO `t_data_datagram`(`RTU_CODE`,`DATAGRAM`,`LOG_TIME`) VALUES (?,?,?)";
+        jdbcTemplate.update(sql, new PreparedStatementSetter() {
+            @Override
+            public void setValues(PreparedStatement preparedStatement) throws SQLException {
+                int index = 0;
+                preparedStatement.setString(++index, rtuCode);
+                preparedStatement.setString(++index, datagram);
+                preparedStatement.setTimestamp(++index, new Timestamp(logTime.getTime()));
+            }
+        });
+    }
+
+    @Override
+    public long datagramCount(Date startTime, Date endTime) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        String sql = "SELECT count(d.ID) num FROM t_data_datagram d  ";
+        sql += " WHERE 1=1 ";
+        sql += " AND ( d.LOG_TIME >= '" + sdf.format(startTime) + "' AND  d.LOG_TIME < '" + sdf.format(endTime) + "')";
+        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
+        if (null != list && list.size() > 0) {
+            Map<String, Object> m = list.get(0);
+            return (long) m.get("num");
+        }
+        return 0;
+    }
+
+    @Override
+    public void updateLastTime(String rtuCode, Date time) {
+        //更新实时状态表
+        String sql = "select rtu_code from  rtu_realtime_status where rtu_code = '" + rtuCode + "' ";
+        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
+        if (list.size() > 0) {
+            sql = "UPDATE  rtu_realtime_status  ";
+            sql += " SET last_up_time=?,update_time=? ";
+            sql += " WHERE rtu_code=? ";
+            jdbcTemplate.update(sql, new PreparedStatementSetter() {
+                @Override
+                public void setValues(PreparedStatement preparedStatement) throws SQLException {
+                    int index = 0;
+                    preparedStatement.setTimestamp(++index, new Timestamp(time.getTime()));
+                    preparedStatement.setTimestamp(++index, new Timestamp(System.currentTimeMillis()));
+                    preparedStatement.setString(++index, rtuCode);
+                }
+            });
+        } else {
+            sql = "INSERT INTO rtu_realtime_status  (rtu_code,last_up_time) VALUES (?,?)";
+            jdbcTemplate.update(sql, new PreparedStatementSetter() {
+                @Override
+                public void setValues(PreparedStatement preparedStatement) throws SQLException {
+                    int index = 0;
+                    preparedStatement.setString(++index, rtuCode);
+                    preparedStatement.setTimestamp(++index, new Timestamp(time.getTime()));
+                }
+            });
+        }
+    }
+
+
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/hadoop/HadoopUtils.java

@@ -0,0 +1,23 @@
+package org.ts.ddcs.hadoop;
+
+
+
+public class HadoopUtils {
+//    public static Configuration hadoopConf() {
+//        Configuration conf = new Configuration();
+//        // 配置跨平台提交任务
+//        //conf.setBoolean("mapreduce.app-submission.cross-platform", true);
+//        // 指定NameNode
+//        conf.set("fs.defaultFS", "hdfs://172.9.0.190:9000");
+//
+//        // 指定Yarn
+//     //   conf.set("mapreduce.framework.name", "yarn");
+//        // 指定resourcemanager
+//       // conf.set("yarn.resourcemanager.address", "master:8032");
+//        // 指定资源分配器
+//      //  conf.set("yarn.resourcemanager.scheduler.address", "master:8030");
+//        // 指定historyserver
+//      //  conf.set("mapreduce.jobhistory.address", "slave01:10020");
+//        return conf;
+//    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/hadoop/HdfsHelp.java

@@ -0,0 +1,4 @@
+package org.ts.ddcs.hadoop;
+
+public class HdfsHelp {
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/hbase/HBaseConfig.java

@@ -0,0 +1,42 @@
+package org.ts.ddcs.hbase;
+
+
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+
+@Configuration
+@EnableConfigurationProperties(HBaseProperties.class)
+public class HBaseConfig {
+    private final HBaseProperties properties;
+
+    public HBaseConfig(HBaseProperties properties) {
+        this.properties = properties;
+    }
+
+//    @Bean
+//    public HbaseTemplate hbaseTemplate() {
+//        HbaseTemplate hbaseTemplate = new HbaseTemplate();
+//        hbaseTemplate.setConfiguration(configuration());
+//        hbaseTemplate.setAutoFlush(false);
+//        return hbaseTemplate;
+//    }
+
+//    public org.apache.hadoop.conf.Configuration configuration() {
+//        org.apache.hadoop.conf.Configuration configuration = HBaseConfiguration.create();
+////        Map<String, String> config = properties.getConfig();
+////        Set<String> keySet = config.keySet();
+////        for (String key : keySet) {
+////            configuration.set(key, config.get(key));
+////        }
+//        configuration.set("hbase.zookeeper.quorum", "hbase140");
+//        configuration.set("hbase.zookeeper.property.clientPort", "2181");
+//        //   configuration.set("hbase.master", "fdfsnode3:16000");
+////        configuration.set("zookeeper.znode.parent", "/hbase");
+////        configuration.setInt("hbase.rpc.timeout", 6000);
+////        configuration.setInt("hbase.client.operation.timeout", 6000);
+////        configuration.setInt("hbase.client.scanner.timeout.period", 6000);
+//        return configuration;
+//    }
+
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/hbase/HBaseProperties.java

@@ -0,0 +1,20 @@
+package org.ts.ddcs.hbase;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.Map;
+
+@ConfigurationProperties(prefix = "hbase")
+public class HBaseProperties {
+
+    private Map<String, String> config;
+
+    public Map<String, String> getConfig() {
+        return config;
+    }
+
+    public void setConfig(Map<String, String> config) {
+        this.config = config;
+    }
+
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/kafka/KafkaConfig.java

@@ -0,0 +1,78 @@
+package org.ts.ddcs.kafka;
+
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.common.serialization.StringDeserializer;
+import org.apache.kafka.common.serialization.StringSerializer;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.annotation.EnableKafka;
+import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
+import org.springframework.kafka.core.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+@EnableKafka
+public class KafkaConfig {
+
+    @Value("${spring.data.kafka.servers}")
+    private String servers;
+
+    @Bean
+    ConcurrentKafkaListenerContainerFactory<Integer, String> kafkaListenerContainerFactory() {
+        ConcurrentKafkaListenerContainerFactory<Integer, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
+        factory.setConsumerFactory(consumerFactory());
+        factory.setBatchListener(true);
+        return factory;
+    }
+
+    @Bean
+    public ConsumerFactory<Integer, String> consumerFactory() {
+        return new DefaultKafkaConsumerFactory<>(consumerConfigs());
+    }
+
+    @Bean
+    public Map<String, Object> consumerConfigs() {
+        Map<String, Object> props = new HashMap<>();
+        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
+        props.put(ConsumerConfig.GROUP_ID_CONFIG, "collect");
+        //props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, true);
+        //props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "100");
+        //props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "15000");
+        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 10);
+        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
+        return props;
+    }
+
+
+    @Bean
+    public ProducerFactory<String, String> producerFactory() {
+        return new DefaultKafkaProducerFactory<>(producerConfigs());
+    }
+
+
+    @Bean
+    public Map<String, Object> producerConfigs() {
+        Map<String, Object> props = new HashMap<>();
+        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
+        props.put(ProducerConfig.RETRIES_CONFIG, 3);
+        props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 1000);
+        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 1024);
+        props.put(ProducerConfig.LINGER_MS_CONFIG, 500);
+        // props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
+        props.put(ProducerConfig.ACKS_CONFIG, "1");
+        // props.put(ProducerConfig.RECONNECT_BACKOFF_MS_CONFIG, 1000);
+        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+        return props;
+    }
+
+    @Bean
+    public KafkaTemplate<String, String> kafkaTemplate() {
+        return new KafkaTemplate<String, String>(producerFactory());
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/kafka/KafkaMessageListener.java

@@ -0,0 +1,29 @@
+package org.ts.ddcs.kafka;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.worker.DataProcessHolder;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * @author dylan
+ */
+@Component
+public class KafkaMessageListener {
+//    @KafkaListener(topics = "${rabbit.config.queue.logMessage}")
+    public void listen(List<ConsumerRecord<String, String>> records) throws Exception {
+        try {
+            for (ConsumerRecord<String, String> cr : records) {
+                LogHelper.info("kafka " + cr.topic() + " " + cr.partition() + " " + cr.value());
+                JSONObject body = JSONObject.parseObject(cr.value());
+                DataProcessHolder.newInstance().dataProcess.submitMapTask(body);
+            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/kafka/RabbitQueueConfig.java

@@ -0,0 +1,20 @@
+package org.ts.ddcs.kafka;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix = "run-config.mq", ignoreUnknownFields = false)
+@Data
+public class RabbitQueueConfig {
+
+    private String waitingToProcessDatagram;
+    private String toRtuDatagram;
+    private String serverSelfCheckingMessage;
+    private String warningMessage;
+    private String checkStateQueue;
+    private String logMessage;
+
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/log/LogHelper.java

@@ -0,0 +1,48 @@
+package org.ts.ddcs.log;
+
+import org.ts.ddcs.worker.DataProcess;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Random;
+
+public class LogHelper {
+
+    public static Logger logger= LoggerFactory.getLogger(LogHelper.class);
+    public static void error(Exception e){
+        logger.error("[ERROR]",e.fillInStackTrace());
+    }
+    public static void error(String logid,Exception e){
+        logger.error(logid+" [ERROR] ",e.fillInStackTrace());
+    }
+    public static void error(String error){
+        logger.error(error);
+    }
+
+    public static void info(String info, Object... objects){
+        logger.info(info, objects);
+    }
+
+    public static void debug(String debug){
+        logger.debug(debug);
+    }
+    public static String createLogId(String prefix){
+        try {
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            String time = timeFormat.format(new Date());
+            Random rm = new Random();
+            // 获得随机数
+            double pross = (1 + rm.nextDouble()) * Math.pow(10, 5);
+            // 将获得的获得随机数转化为字符串
+            String fixLengthString = String.valueOf(pross);
+            // 返回固定的长度的随机数
+            String ranom = fixLengthString.substring(1, 6);
+            return DataProcess.config().getServerId()+" "+prefix + "_" + time + "_" + ranom;
+        }catch (Exception e){
+            LogHelper.error(e);
+            return prefix;
+        }
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/mqtt/Mqtt.java

@@ -0,0 +1,107 @@
+package org.ts.ddcs.mqtt;
+
+
+import org.ts.ddcs.log.LogHelper;
+import org.eclipse.paho.client.mqttv3.MqttClient;
+import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
+import org.eclipse.paho.client.mqttv3.MqttException;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * @author dylan
+ */
+@Component
+public class Mqtt {
+    @Value("${run-config.mqtt.mqttSubTopic}")
+    public String subTopic;
+
+    @Value("${run-config.mqtt.mqttPubTopic}")
+    public String pubTopic;
+
+    @Value("${run-config.mqtt.mqttBroker}")
+    public String mqttBroker;
+
+    @Value("${run-config.server.serverId}")
+    public String clientId;
+
+    public void send(String jsonStr) {
+        try {
+            int qos = 0;
+            MemoryPersistence persistence = new MemoryPersistence();
+            MqttClient client = new MqttClient(mqttBroker, clientId, persistence);
+            // MQTT 连接选项
+            MqttConnectOptions connOpts = new MqttConnectOptions();
+            connOpts.setUserName("collect");
+            connOpts.setPassword("123".toCharArray());
+            // 保留会话
+            connOpts.setCleanSession(true);
+            // 设置回调
+            client.setCallback(new OnMessageCallback());
+            // 建立连接
+            client.connect(connOpts);
+            // 订阅
+            //client.subscribe(subTopic);
+            // 消息发布所需参数
+            MqttMessage message = new MqttMessage(jsonStr.getBytes());
+            message.setQos(qos);
+            client.publish(pubTopic, message);
+            Thread.sleep(100);
+            client.disconnect();
+            client.close();
+        } catch (MqttException me) {
+            LogHelper.error("reason " + me.getReasonCode());
+            LogHelper.error("msg " + me.getMessage());
+            LogHelper.error("loc " + me.getLocalizedMessage());
+            LogHelper.error("cause " + me.getCause());
+            LogHelper.error("excep " + me);
+            LogHelper.error(me);
+        } catch (InterruptedException e) {
+            LogHelper.error(e);
+        }
+    }
+
+    public void send(List<String> jsonStrList) {
+        try {
+            int qos = 0;
+            MemoryPersistence persistence = new MemoryPersistence();
+            MqttClient client = new MqttClient(mqttBroker, clientId, persistence);
+            // MQTT 连接选项
+            MqttConnectOptions connOpts = new MqttConnectOptions();
+            connOpts.setUserName("collect");
+            connOpts.setPassword("123".toCharArray());
+            // 保留会话
+            connOpts.setCleanSession(true);
+            // 设置回调
+            client.setCallback(new OnMessageCallback());
+            // 建立连接
+            client.connect(connOpts);
+            // 订阅
+            //client.subscribe(subTopic);
+            // 消息发布所需参数
+            for (String jsonStr : jsonStrList) {
+                MqttMessage message = new MqttMessage(jsonStr.getBytes());
+                message.setQos(qos);
+                client.publish(pubTopic, message);
+                Thread.sleep(200);
+            }
+
+            Thread.sleep(100);
+            client.disconnect();
+            client.close();
+        } catch (MqttException me) {
+            LogHelper.error("reason " + me.getReasonCode());
+            LogHelper.error("msg " + me.getMessage());
+            LogHelper.error("loc " + me.getLocalizedMessage());
+            LogHelper.error("cause " + me.getCause());
+            LogHelper.error("excep " + me);
+            LogHelper.error(me);
+        } catch (InterruptedException e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/mqtt/OnMessageCallback.java

@@ -0,0 +1,27 @@
+package org.ts.ddcs.mqtt;
+
+import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
+import org.eclipse.paho.client.mqttv3.MqttCallback;
+import org.eclipse.paho.client.mqttv3.MqttMessage;
+
+/**
+ * @author dylan
+ */
+public class OnMessageCallback implements MqttCallback {
+    @Override
+    public void connectionLost(Throwable cause) {
+        System.out.println("连接断开，可以做重连");
+    }
+
+    @Override
+    public void messageArrived(String topic, MqttMessage message) throws Exception {
+        System.out.println("接收消息主题:" + topic);
+        System.out.println("接收消息Qos:" + message.getQos());
+        System.out.println("接收消息内容:" + new String(message.getPayload()));
+    }
+
+    @Override
+    public void deliveryComplete(IMqttDeliveryToken token) {
+        System.out.println("deliveryComplete---------" + token.isComplete());
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/tool/BytesHelp.java

@@ -0,0 +1,777 @@
+package org.ts.ddcs.tool;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.security.MessageDigest;
+import java.util.Calendar;
+
+public class BytesHelp {
+
+    /**
+     * bcd码转int
+     *
+     * @param bs  cbcd16进制数组
+     * @param off 起始位置
+     * @param len 长度
+     * @return int
+     */
+    public static int cbcd2int(byte[] bs, int off, int len) {
+        int v = 0;
+        for (int i = off; i < (off + len); i++) {
+            v = (v * 100) + (((bs[i] & 0xFF) >> 4) * 10) + (bs[i] & 0x0F);
+        }
+        return v;
+    }
+
+    /**
+     * int转bcd码
+     *
+     * @param i   int数值
+     * @param len (bcd长度)
+     * @return byte[] cbcd16进制数组
+     */
+    public static byte[] int2cbcd(int i, int len) {
+        byte[] bs = new byte[len];
+        int temp;
+        for (int j = len - 1; j >= 0; j--) {
+            temp = i % 100;
+            bs[j] = (byte) (((temp / 10) << 4) + ((temp % 10) & 0x0F));
+            i /= 100;
+        }
+        return bs;
+    }
+
+    /**
+     * 数值类型转byte数组(long(8),int(4),short(2))
+     *
+     * @param num (long,int,short)
+     * @param len (8, 4, 2)
+     * @return
+     */
+    public static byte[] number2bytes(long num, int len) {
+        byte[] bs = new byte[len];
+        for (int j = 0; j < len; j++) {
+            bs[len - j - 1] = (byte) (num >> (j * 8));
+        }
+        return bs;
+    }
+
+    /**
+     * byte数组转short
+     *
+     * @param bs
+     * @return
+     */
+    public static short bytes2short(byte[] bs) {
+        short s = (short) (bs[1] & 0xFF);
+        s |= (bs[0] << 8) & 0xFF00;
+        return s;
+    }
+
+    /**
+     * short转byte数组
+     *
+     * @param s
+     * @return
+     */
+    public static byte[] short2bytes(short s) {
+        byte[] bs = new byte[2];
+        for (int i = 1; i >= 0; i--) {
+            bs[i] = (byte) (s % 256);
+            s >>= 8;
+        }
+        return bs;
+    }
+
+    /**
+     * String转bcd byte数组
+     *
+     * @param s
+     * @return
+     */
+    public static byte[] string2cbcd(String s) {
+        if (s.length() % 2 != 0) {
+            s = "0" + s;
+        }
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        char[] cs = s.toCharArray();
+        for (int i = 0; i < cs.length; i += 2) {
+            int high = cs[i] - 48;
+            int low = cs[i + 1] - 48;
+            baos.write(high << 4 | low);
+        }
+        return baos.toByteArray();
+    }
+
+    /**
+     * 转数据为字符串
+     * @param bs
+     * @param off
+     * @param len
+     * @return
+     */
+    public static String getHexString(byte[] bs, int off, int len) {
+        StringBuffer sb = new StringBuffer();
+        for (int i = off; i < (off + len); i++) {
+            String hex = Integer.toHexString(bs[i] & 0xFF);
+            if (hex.length() == 1) {
+                sb.append('0').append(hex);
+            } else {
+                sb.append(hex);
+            }
+            // sb.append(' ');
+        }
+        return sb.toString();
+    }
+
+    /**
+     * byte数组转String
+     *
+     * @param bs
+     * @param off
+     * @param len
+     * @return
+     */
+    public static String bytes2String(byte[] bs, int off, int len) {
+        return new String(bs, off, len).trim();
+    }
+
+    /**
+     * String 转 byte[]
+     *
+     * @param str
+     * @param len
+     * @return
+     */
+    public static byte[] string2bytes(String str, int len) {
+        byte[] bs;
+        if (str != null) {
+            bs = str.getBytes();
+        } else {
+            bs = new byte[len];
+        }
+        return bs;
+    }
+
+    /**
+     * int 转 byte数组
+     *
+     * @param i
+     * @return
+     */
+    public static byte[] int2Bytes(int i) {
+        return int2Bytes(i, 4);
+    }
+
+    /**
+     * int 转 byte数组
+     *
+     * @param i
+     * @return
+     */
+    public static byte[] intToBytes(int i,int length) {
+        return int2Bytes(i, length);
+    }
+    /**
+     * int 转 byte数组
+     *
+     * @param i
+     * @param len
+     * @return
+     */
+    public static byte[] int2Bytes(int i, int len) {
+        byte[] bs = new byte[len];
+        for (int j = 0; j < len; j++) {
+            bs[len - j - 1] = (byte) (i >> (j * 8));
+        }
+        return bs;
+    }
+
+
+    public static int byteslowbitToInt(byte[] bytes,int off){
+
+        byte[] tmpbuf = new byte[4];
+        tmpbuf[2] = (byte) (bytes[off] & 0x0f);
+        tmpbuf[3] = bytes[off+1];
+        int v = 0;
+        for (int ii = 0; ii < 4; ii++) {
+            int shi = (4 - 1 - ii) * 8;
+            v += (tmpbuf[ii] & 0x000000FF) << shi;
+        }
+        return v;
+    }
+
+    /**
+     * byte数组转int(命令字专用)
+     *
+     * @param bytes
+     * @return
+     */
+    public static int bytes2Int(byte[] bytes, int off, int len) {
+        int v = 0;
+        int pos = off + len - 1;
+        if (pos >= 0) {
+            v |= (bytes[pos] & 0xFF);
+        }
+        pos--;
+        if (pos >= 0) {
+            v |= ((bytes[pos] << 8) & 0xFF00);
+        }
+        pos--;
+        if (pos >= 0) {
+            v |= ((bytes[pos] << 16) & 0xFF0000);
+        }
+        pos--;
+        if (pos >= 0) {
+            v |= ((bytes[pos] << 24) & 0xFF000000);
+        }
+        return v;
+    }
+
+    // bytes补位用
+    public static byte[] string2Bytes(String src, int len, int max) {
+        byte[] dest = new byte[max];
+
+        if (src == null) {
+            return dest;
+        }
+        while (src.length() < len) {
+            src += " ";
+        }
+        byte[] temp = src.getBytes();
+
+        System.arraycopy(temp, 0, dest, 0, temp.length >= len ? len
+                : temp.length);
+
+        return dest;
+    }
+
+    public static byte[] getBytesFromFile(File file) {
+        byte[] ret = null;
+        try {
+            if (file == null) {
+                return null;
+            }
+            FileInputStream in = new FileInputStream(file);
+            ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
+            byte[] b = new byte[4096];
+            int n;
+            while ((n = in.read(b)) != -1) {
+                out.write(b, 0, n);
+            }
+            in.close();
+            out.close();
+            ret = out.toByteArray();
+        } catch (Exception e) {
+            return null;
+        }
+        return ret;
+    }
+
+    public static String getMD5Digest(String str) {
+        return getMD5Digest(str.getBytes());
+    }
+
+    public static String getMD5Digest(byte[] bytes) {
+        MessageDigest messageDigest = null;
+        try {
+            messageDigest = MessageDigest.getInstance("MD5");
+            messageDigest.reset();
+            messageDigest.update(bytes);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        byte[] byteArray = messageDigest.digest();
+        StringBuffer md5StrBuff = new StringBuffer();
+
+        for (int i = 0; i < byteArray.length; i++) {
+            if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)
+                md5StrBuff.append("0").append(
+                        Integer.toHexString(0xFF & byteArray[i]));
+            else
+                md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));
+        }
+
+        return md5StrBuff.toString();
+    }
+
+    public static String leftFill(String src, int len, char fillChar) {
+
+        int length = src.length();
+        if (src == null || len < length)
+            return src;
+
+        String result = src;
+        for (int i = length; i < len; i++) {
+            result = String.valueOf(fillChar) + result;
+        }
+
+        return result;
+    }
+
+    /**
+     * 将字符串拼接成指定长度的字符串,不足的补空格
+     *
+     * @param str    字符串
+     * @param length
+     * @return
+     */
+    public static String spliceSpaces(String str, int length) {
+        int strLen = str.length();
+        if (strLen > length) {
+            str = "";
+            for (int i = 0; i < length; i++) {
+                str += " ";
+            }
+        } else {
+            for (int i = 0; i < (length - strLen); i++) {
+                str += " ";
+            }
+        }
+        return str;
+    }
+
+    /**
+     * 将字符串拼接成指定长度的字符串,不足的补0
+     *
+     * @param str    字符串
+     * @param length
+     * @return
+     */
+    public static String spliceZero(String str, int length) {
+        int strLen = str.length();
+        if (strLen > length) {
+            str = "";
+            for (int i = 0; i < length; i++) {
+                str += "0";
+            }
+        } else {
+            for (int i = 0; i < (length - strLen); i++) {
+                str = "0" + str;
+            }
+        }
+        return str;
+    }
+
+    public static byte[] arrayApend(byte[] a, byte[] b) {
+        int a_len = (a == null ? 0 : a.length);
+        int b_len = (b == null ? 0 : b.length);
+        byte[] c = new byte[a_len + b_len];
+        if (a_len == 0 && b_len == 0) {
+            return null;
+        } else if (a_len == 0) {
+            System.arraycopy(b, 0, c, 0, b.length);
+        } else if (b_len == 0) {
+            System.arraycopy(a, 0, c, 0, a.length);
+        } else {
+            System.arraycopy(a, 0, c, 0, a.length);
+            System.arraycopy(b, 0, c, a.length, b.length);
+        }
+        return c;
+    }
+
+
+    public static byte[] arrayApendbyte(byte[] a, byte b) {
+        int a_len = (a == null ? 0 : a.length);
+
+        byte[] c = new byte[a_len + 1];
+        if (a_len == 0) {
+            return null;
+        } else {
+            System.arraycopy(a, 0, c, 0, a.length);
+            System.arraycopy(b, 0, c, a.length, 1);
+        }
+        return c;
+    }
+
+
+    /**
+     * 获取字符Ascii值
+     *
+     * @param str
+     * @return
+     */
+    public static int getAsciiValue(String str) {
+        if (str.length() != 1) {
+            return 0;
+        }
+        char[] ch = str.toCharArray();
+
+        return ch[0];
+    }
+
+    /**
+     * 获取字符Ascii值 16
+     *
+     * @param str
+     * @return
+     */
+    public static String getAsciiHexValueS(String str) {
+        char[] ch = str.toCharArray();
+        StringBuffer retStr = new StringBuffer();
+        for (int i = 0; i < ch.length; i++) {
+            retStr.append(Integer.toHexString(ch[i]));
+        }
+        return retStr.toString();
+    }
+
+    /**
+     * 获取字符Ascii值
+     *
+     * @param str
+     * @return
+     */
+    public static String getAsciiValueS(String str) {
+        char[] ch = str.toCharArray();
+        StringBuffer retStr = new StringBuffer();
+        for (int i = 0; i < ch.length; i++) {
+            retStr.append((int) ch[i]);
+        }
+        return retStr.toString();
+    }
+
+    public static String getAsciiStr(int d) {
+        char e = (char) d;
+        return e + "";
+    }
+
+
+    public static String byte2HexStr(byte[] b) {
+        String stmp = "";
+        StringBuilder sb = new StringBuilder("");
+        for (int n = 0; n < b.length; n++) {
+            stmp = Integer.toHexString(b[n] & 0xFF);
+            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
+            //sb.append(" ");
+        }
+        return sb.toString().toUpperCase().trim();
+    }
+
+    public static String byte2HexStr(byte[] b, int pos, int length) {
+        String stmp = "";
+        StringBuilder sb = new StringBuilder("");
+        for (int n = 0; n < length; n++) {
+            stmp = Integer.toHexString(b[n + pos] & 0xFF);
+            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
+        }
+        return sb.toString().toUpperCase().trim();
+    }
+
+    public static byte[] hexStr2Bytes(String hexString) {
+        hexString = hexString.toLowerCase();
+        int remainder = hexString.length() % 2;
+        if(remainder>0){
+        	hexString ="0"+hexString;
+        }
+        final byte[] byteArray = new byte[hexString.length()/2];
+        int k = 0;
+        for (int i = 0; i < byteArray.length; i++) {
+            //因为是16进制，最多只会占用4位，转换成字节需要两个16进制的字符，高位在先
+            //将hex 转换成byte   "&" 操作为了防止负数的自动扩展
+            // hex转换成byte 其实只占用了4位，然后把高位进行右移四位
+            // 然后“|”操作  低四位 就能得到 两个 16进制数转换成一个byte.
+            //
+            byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
+            byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
+            byteArray[i] = (byte) (high << 4 | low);
+            k += 2;
+        }
+        return byteArray;
+    }
+
+    public static byte[] subBytes(byte[] src, int begin, int count) {
+        byte[] bs = new byte[count];
+        for (int i = begin; i < begin + count; i++) bs[i - begin] = src[i];
+        return bs;
+    }
+
+    //CRC校验运算
+    public static byte GetCRCByte(byte[] data) {
+        int crc = 0x0; // 初始值为0
+        for (byte bt : data) {
+            crc = crc ^ bt;
+            for (int j = 1; j <= 8; j++) {
+                if ((crc & 0x80) == 0x80)
+                    crc = (crc << 1) ^ 0xE5;// 多项式值为E5,被校验值左移
+                else
+                    crc = crc << 1;
+            }
+        }
+        return (byte) crc;
+    }
+
+    //将16进制字符串转换为16进制byte数组
+    public static byte[] HexString2Bytes(String src) {
+        byte[] ret = new byte[8];
+        byte[] tmp = src.getBytes();
+        for (int i = 0; i < 8; i++) {
+            ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
+        }
+        return ret;
+    }
+
+    public static byte uniteBytes(byte src0, byte src1) {
+        byte _b0 = Byte.decode("0x" + new String(new byte[]{src0})).byteValue();
+        _b0 = (byte) (_b0 << 4);
+        byte _b1 = Byte.decode("0x" + new String(new byte[]{src1})).byteValue();
+        byte ret = (byte) (_b0 ^ _b1);
+        return ret;
+    }
+
+
+    //16进制字符串转换为2进制字符串
+    public static String hexString2binaryString(String hexString) {
+        if (hexString == null || hexString.length() % 2 != 0)
+            return null;
+        String bString = "", tmp;
+        for (int i = 0; i < hexString.length(); i++) {
+            tmp = "0000"
+                    + Integer.toBinaryString(Integer.parseInt(
+                    hexString.substring(i, i + 1), 16));
+            bString += tmp.substring(tmp.length() - 4);
+        }
+        return bString;
+    }
+
+    /**
+     * 获取时间戳位
+     *
+     * @return
+     */
+    public static byte[] getTPByte() {
+
+
+        Calendar now = Calendar.getInstance();
+        //String year = now.get(Calendar.YEAR)+"";
+        String second = now.get(Calendar.SECOND) + "";
+        String minute = now.get(Calendar.MINUTE) + "";
+        String hour = now.get(Calendar.HOUR_OF_DAY) + "";
+        String day = now.get(Calendar.DATE) + "";
+        byte[] tpArea;
+
+        if (second.length() == 1) {
+            tpArea = BytesHelp.hexStr2Bytes("0" + second);
+        } else {
+            tpArea = BytesHelp.hexStr2Bytes(second);
+        }
+
+        if (minute.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + minute));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(minute));
+        }
+        if (hour.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + hour));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(hour));
+        }
+        if (day.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + day));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(day));
+        }
+
+        tpArea = BytesHelp.arrayApend(tpArea,
+                BytesHelp.hexStr2Bytes("00"));
+
+        return tpArea;
+
+    }
+
+
+    /**
+     * 单一字节中选择指定位bcd码转换为整数
+     *
+     * @param b
+     * @param highBit 高位,最大7
+     * @param lowBit  低位,从0开始
+     * @return
+     */
+    public static int bcdToInt(byte b, int highBit, int lowBit) {
+        int g = highBit - lowBit + 1;
+        int a = ((int) Math.pow(2, g) - 1) << lowBit;
+        int b2 = (b & a) >> lowBit;
+        return b2;
+    }
+
+    public static byte[] crcFun2014(byte[] packet, int pos, int length) {
+        int n = length;
+        int crc = 0xFFFF;
+        for (int b = 0; b < n; b++) {
+            crc = byteToInteger(packet[pos + b]) ^ crc;
+            for (int c = 0; c < 8; c++) {
+                int dd = crc & 0x0001;
+                if (dd == 1) {
+                    crc = crc >> 1;
+                    crc ^= 0xA001;
+                } else {
+                    crc = crc >> 1;
+                }
+            }
+        }
+        return BytesHelp.int2Bytes(crc, 2);
+    }
+
+    public static byte[] crcFun2014(byte[] packet) {
+        int n = packet.length;
+        int crc = 0xFFFF;
+        for (int b = 0; b < n; b++) {
+            crc = byteToInteger(packet[b]) ^ crc;
+            for (int c = 0; c < 8; c++) {
+                int dd = crc & 0x0001;
+                if (dd == 1) {
+                    crc = crc >> 1;
+                    crc ^= 0xA001;
+                } else {
+                    crc = crc >> 1;
+                }
+            }
+        }
+        return BytesHelp.int2Bytes(crc, 2);
+    }
+
+    public static int byteToInteger(byte b) {
+        int value;
+        value = b & 0xff;
+        return value;
+    }
+
+
+    /**
+     * 获取发报时间
+     *
+     * @return
+     */
+    public static byte[] getFBTm() {
+
+
+        Calendar now = Calendar.getInstance();
+        String year = now.get(Calendar.YEAR) + "";
+        String month = now.get(Calendar.MONTH) + 1 + "";
+        String day = now.get(Calendar.DATE) + "";
+        String hour = now.get(Calendar.HOUR_OF_DAY) + "";
+        String minute = now.get(Calendar.MINUTE) + "";
+        String second = now.get(Calendar.SECOND) + "";
+
+        byte[] tpArea;
+
+        tpArea = BytesHelp.hexStr2Bytes(year.substring(2, year.length()));
+
+        if (month.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + month));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(month));
+        }
+
+        if (day.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + day));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(day));
+        }
+        if (hour.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + hour));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(hour));
+        }
+        if (minute.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes("0" + minute));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea,
+                    BytesHelp.hexStr2Bytes(minute));
+        }
+
+        if (second.length() == 1) {
+            tpArea = BytesHelp.arrayApend(tpArea, BytesHelp.hexStr2Bytes("0" + second));
+        } else {
+            tpArea = BytesHelp.arrayApend(tpArea, BytesHelp.hexStr2Bytes(second));
+        }
+
+        return tpArea;
+
+    }
+
+
+    //将16进制RTU编码改成10进制
+    public static String byte2HexMpCdStr(byte[] b) {
+        String stmp = "";
+        StringBuilder sb = new StringBuilder("");
+        for (int n = 0; n < 3; n++) {
+            stmp = Integer.toHexString(b[n] & 0xFF);
+            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
+        }
+
+        int mpcd = 0;
+        if (sb.toString().startsWith("00")) {//00开头的站点编号按照10进制处理，99的按照16进制处理,为了满足威控的编码格式
+	    	String str4 = Integer.toHexString(b[4] & 0xFF);
+	    	String mpcdStr = Integer.toHexString(b[3] & 0xFF);
+	    	if(str4.length()==1){
+	    		mpcdStr += "0"+str4;
+	    	}else{
+	    		mpcdStr +=str4;
+	    	}
+	    	//String mpcdStr = Integer.toHexString(b[3] & 0xFF)+Integer.toHexString(b[4] & 0xFF);
+	    	mpcd =  Integer.parseInt(mpcdStr);
+	    } else {
+            mpcd = bytes2Int(BytesHelp.subBytes(b, 3, 2), 0, 2) % 10000;
+        }
+        sb.append(StringUtil.leftFill(mpcd + "", 4, '0'));
+        return sb.toString().toUpperCase().trim();
+    }
+
+
+    //将16进制RTU编码改成10进制（东深厂商专用），编号最后俩个字节颠倒
+    public static String byte2HexMpCdStrDS(byte[] b) {
+        String stmp = "";
+        StringBuilder sb = new StringBuilder("");
+        for (int n = 0; n < 3; n++) {
+            stmp = Integer.toHexString(b[n] & 0xFF);
+            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
+        }
+
+        int mpcd = 0;
+        if (sb.toString().startsWith("00")) {//00开头的站点编号按照10进制处理，99的按照16进制处理,为了满足威控的编码格式
+            String mpcdStr = Integer.toHexString(b[3] & 0xFF) + Integer.toHexString(b[4] & 0xFF);
+            mpcd = Integer.parseInt(mpcdStr);
+        } else {
+            byte[] mpCdTail = new byte[2];
+            mpCdTail[0] = b[4];
+            mpCdTail[1] = b[3];
+            //mpcd =  bytes2Int( BytesHelp.subBytes(b, 3, 2),0,2) %10000;
+            mpcd = bytes2Int(mpCdTail, 0, 2) % 10000;
+        }
+        sb.append(StringUtil.leftFill(mpcd + "", 4, '0'));
+        return sb.toString().toUpperCase().trim();
+    }
+
+    //bdcd十六进字符串转成字节数组
+    public static byte[] hstrToBytes(String str) {
+        char[] ca = str.toCharArray();
+        byte[] databuff = new byte[ca.length / 2];
+        for (int j = 0; j < ca.length; j += 2) {
+
+            byte bb = (byte) (charToByte(ca[j]) << 4 | charToByte(ca[j + 1]));
+            databuff[j == 0 ? 0 : (j / 2)] = bb;
+        }
+        return databuff;
+    }
+
+    public static byte charToByte(char c) {
+        return (byte) "0123456789ABCDEF".indexOf(c);
+    }
+
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/tool/GBConstants.java

@@ -0,0 +1,202 @@
+package org.ts.ddcs.tool;
+
+public class GBConstants {
+
+	public final static String VERSION_KEY_SZY_54 ="5.4";
+	public final static String  BASE_KEY_SERVER_MASTER ="server_master";
+	public final static String  BASE_KEY_COLLECT_SERVER ="collect_server_id";
+	public final static String  BASE_KEY_COLLECT_SERVER_GROUP ="collect_server_id_group";
+	public final static String  BASE_KEY_RTU ="rtuCode";
+	public final static String  BASE_KEY_AGREEMENT ="agreement";
+	public final static String  BASE_KEY_DATAGRAM ="datagram";
+	public final static String  BASE_KEY_VERSION ="version";
+	public final static String  BASE_KEY_SETTING ="setting_datagram";
+	public final static String  BASE_KEY_ORGID ="orgId";
+	public final static String  BASE_KEY_DATAGRAM_PICK_TM ="datagramPickTime";
+	public final static String  BASE_KEY_WARNING_INFO ="warningInfo";
+	public final static String  BASE_KEY_WARNING_KIND ="warningKind";
+	public final static String  BASE_KEY_WARNING_CHECK_TIME ="checkTime";
+
+
+	public final static String  RELAY_KEY_URL ="key_url";
+	public final static String  RELAY_KEY_CHANNEL ="key_channel";
+	public final static String  RELAY_KEY_MQ ="MQ";
+	public final static String  RELAY_KEY_HTTP ="HTTP";
+	public final static String  RELAY_KEY_QUEUE ="key_queue";
+	public final static String  HTTP_REQUEST_KEY_CODE ="code";
+	public final static String  HTTP_REQUEST_KEY_OK ="0";
+	public final static String  HTTP_REQUEST_KEY_ERROR ="1";
+
+
+	public final static String AGREEMENT_KIND_SW="sw2014";
+	public final static String AGREEMENT_KIND_SZY="szy2012";
+
+
+	public final static String REDIS_KEY ="redis_key";
+	public final static String REDIS_KEY_COMMAND_QUERY ="command:query";
+	public final static String REDIS_KEY_COMMAND_SETTING = "command:setting";
+	public final static String REDIS_KEY_COMMAND_FILE = "command:file";
+	public final static String REDIS_KEY_SERVER_MASTER ="server_master";
+	public final static String REDIS_KEY_COLLECT_SERVER ="collect_server_id";
+	public final static String REDIS_KEY_RTU_SPACE_TIME ="spaceTime";
+	public final static String REDIS_KEY_RTU_STATUS_DATAGRAM ="statusDatagram";
+	public final static String REDIS_KEY_PROJECT_PREFIX ="project_";
+	public final static String REDIS_KEY_PROJECT_ID ="projectId";
+	public final static String REDIS_KEY_AGREEMENT ="agreement";
+
+	public final static String WARNING_TYPE_UNDEFINE ="0";//未定义预警类型
+	public final static String WARNING_TYPE_OFFLINE ="1"; //RTU设备在线预警
+	public final static String WARNING_TYPE_DATAGRAM_DELAY ="2";//报文上报延时
+	public final static String WARNING_TYPE_RTU_FAULT_SE ="3";//水位计故障
+	public final static String WARNING_TYPE_RTU_FAULT_AC ="4";//交流电故障
+	public final static String WARNING_TYPE_RTU_FAULT_BV ="5";//电池电压故障
+	public final static String WARNING_TYPE_RTU_COLLECT_TIME_ERROR ="6";//采集时间错误
+	public final static String WARNING_TYPE_CRC_ERROR ="7";//CRC检验错误
+	public final static String WARNING_TYPE_OUTLIER_DATA ="8";//异常数据
+    public final static String WARNING_TYPE_SD_DAMAGE ="9";//SD卡损坏
+
+	public final static String RTU_STATUS_INFO_NAME_WSE ="waterLevelDeviceStatus";//水位计
+	public final static String RTU_STATUS_INFO_NAME_ACC ="alternatingCurrentCharging";//交流电
+	public final static String RTU_STATUS_INFO_NAME_BV ="batteryVoltage";//电池电压
+	public final static String RTU_STATUS_INFO_NAME_PV ="powerVoltage";//电源电压
+
+	public final static long BASE_RTU_FRESH_CONNECT_TIME = 90000;
+
+	public final static String RELAY_DATAGRAM_ACTIVE="1";
+	public final static String RELAY_DATAGRAM_ENABLE="0";
+	public final static String RELAY_DATAGRAM_REMOTE_IP_KEY="relayIp";
+	public final static String RELAY_DATAGRAM_KEY="relay";
+
+
+	public final static String SERVER_MESSAGE_KIND_RUNNING ="1";
+
+//	/**
+//	 * GPRS帧类型
+//	 */
+	public final static int GPRS_TYPE_LOGIN = 0x01; //登录帧
+	public final static int GPRS_TYPE_LOGIN_REPLY = 0x02; //登录应答帧
+	public final static int GPRS_TYPE_LOGOUT = 0x03; //注销帧
+	public final static int GPRS_TYPE_LOGOUT_REPLY = 0x04; //注销应答帧
+	public final static int GPRS_TYPE_DATA = 0x05; //数据帧
+	public final static int GPRS_TYPE_DATA_REPLY = 0x06; //数据应答帧，暂时不用
+	public final static int GPRS_TYPE_HEART = 0x07; //心跳帧
+	public final static int GPRS_TYPE_HEART_REPLY = 0x08; //心跳应答帧
+
+
+
+	/**
+	 * AFN
+	 */
+	// 链路检测
+	public final static int DATA_AFN_LOGIN = 0x02;
+	
+	// 参数设置及查询
+	public final static int DATA_AFN_RESET = 0x01; //复位命令
+	
+	
+	
+	public final static int DATA_AFN_SETWORKPATTERN = 0x07; //设置终端工作模式
+	public final static int DATA_AFN_QUERYWORKPATTERN = 0x08; //查询终端工作模式
+	public final static int DATA_AFN_SETTIMINGINTERVAL = 0x09; //设置终端自报时间间隔及时间起点
+	public final static int DATA_AFN_QUERYTIMINGINTERVAL = 0x0A; //查询终端自报时间间隔及时间起点
+	
+	public final static int DATA_AFN_SETALTITUDE = 0x14; //设置终端井口高程、水位下限及水位计量程
+	public final static int DATA_AFN_QUERYALTITUDE = 0x15; //查询终端井口高程、水位下限及水位计量程
+	
+	public final static int DATA_AFN_SETSIMID = 0x17; //设置终端SIM卡ID号
+	public final static int DATA_AFN_QUERYSIMID = 0x18; //查询终端SIM卡ID号
+	public final static int DATA_AFN_QUERYHISTIMEVALUE = 0x19; //查询终端某一天的历史记录
+	
+	public final static int DATA_AFN_CLEARHISDATA = 0x1B; //清空终端历史数据
+	
+//	public final static int DATA_AFN_QUERYREALTIMEVALUE = 0x16; //查询终端水位实时值
+//	public final static int DATA_AFN_QUERYREALTIMEWATERQUALITY = 0x26; //查询终端水质实时值
+	
+	//GZ设置终端地址
+	public final static int DATA_AFN_SETADDRESS = 0x10; 
+	//GZ查询终端地址
+	public final static int DATA_AFN_QUERYADDRESS = 0x50; 
+	
+	//GZ设置终端时钟
+	public final static int DATA_AFN_SETCLOCK = 0x11; //设置终端时钟
+	//GZ查询终端时钟
+	public final static int DATA_AFN_QUERYCLOCK = 0x51; 
+	//GZ定时自报数据
+	public final static int DATA_AFN_TIMINGDATA = 0xC0;
+	//GZ随机自报报警数据
+	public final static int DATA_AFN_WARNING = 0x81; 
+	//GZ查询终端实时值
+	public final static int DATA_AFN_QUERYREALTIMEVALUE = 0xB0; 
+	
+	//GZ查询终端报警状态和终端状态
+	public final static int DATA_AFN_QUERYWARNINGSTATUS = 0x5E; 
+	
+	
+	/*
+	 * zs20141025 用水计量 命令
+	 */
+	public final static int DATA_AFN_QUERY_WATER_INSTANTFLOW = 0x16; //查询用水瞬时流量
+	public final static int DATA_AFN_QUERY_WATER_TOTALFLOW = 0x26; //查询用水累计流量
+	public final static int DATA_AFN_WATERMEASURE_TIMINGDATA = 0x29;//zs20141025 定时自报数据
+	
+	public final static int DATA_AFN_SETRESPONSE = 0x00; //设置命令执行后返回的响应
+	
+	
+	
+	
+	
+	public final static int MAX_FCB = 3;
+	
+	// 控制域功能码
+	public final static int CONTROL_DIR0_FN_COMMAN_CONFIRM = 1;
+	public final static int CONTROL_DIR0_FN_QUERY_STATUS = 4;
+	
+	/*
+	 * GZ 功能码 水位参数
+	 */
+	public final static int CONTROL_DIR0_FN_QUERY_WATERLEVEL = 2;//5改为2 zs20151204 modify
+	
+	/*
+	 * GZ 功能码 水质参数
+	 */
+	public final static int CONTROL_DIR0_FN_QUERY_WATERQUALITY = 10;
+	
+	/*
+	 * GZ 报警和状态参数
+	 */
+	public final static int CONTROL_DIR0_FN_QUERY_RTUSTATUS = 13;
+	
+	/*
+	 * GZ 功能码 流量（水量）
+	 */
+	public final static int CONTROL_DIR0_FN_QUERY_WATERFLOW = 3;
+	
+	
+	
+	
+	public final static int CONTROL_DIR0_FN_QUERY_WARNPARAM = 6;
+	
+	
+	public final static int CONTROL_DIR1_FN_REPLY_CONFIRM = 1;
+	public final static int CONTROL_DIR1_FN_REPLY_NODATA = 2;
+	public final static int CONTROL_DIR1_FN_REPLY_STATUS = 4;
+	public final static int CONTROL_DIR0_FN_REPLY_WATERLEVEL = 5;
+	public final static int CONTROL_DIR0_FN_REPLY_WARNPARAM = 6;
+	
+	
+	/**
+	 * 报警种类
+	 */
+	public final static int WARN_AC_OFF = 0x0001; //工作用交流电停电
+	public final static int WARN_DC_OFF = 0x0002; //蓄电池电压低
+	public final static int WARN_EQUIP_ERR = 0x0020; //流量仪表故障
+	public final static int WARN_PUMP_ERR = 0x0040; //水泵故障
+	public final static int WARN_QUAN_LIMIT = 0x0080; //剩余水量下限报警
+	
+	public final static int WARN_TERM_IC = 0x0400; //终端IC卡功能报警
+	public final static int WARN_VAL_CON = 0x0800; //定值控制报警
+	public final static int WARN_TERM_STATE = 0x2000; //终端箱门状态报警
+	
+
+}
+

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/tool/RedisHelper.java

@@ -0,0 +1,59 @@
+package org.ts.ddcs.tool;
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+
+@SuppressWarnings("all")
+public class RedisHelper {
+    public  static  String queryValueBySimKey(String key, RedisTemplate redisTemplate){
+        if(null != key && null != redisTemplate){
+            Set<String> keys= redisTemplate.keys(key);
+            if(null != keys && keys.size()==1){
+                String keyJson = keys.iterator().next();
+                if (null != keyJson && keyJson.length() > 0) {
+                    ValueOperations<String,String> ops = redisTemplate.opsForValue();
+                    if(null != ops){
+                        String value=ops.get(keyJson);
+                        if(null != value){
+                            return value;
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public  static  boolean hasKey(String key, RedisTemplate redisTemplate){
+        if(null != key && null != redisTemplate){
+            return redisTemplate.hasKey(key);
+        }
+        return false;
+    }
+
+
+
+    public  static List<String> queryValueListBySimKey(String key, RedisTemplate redisTemplate){
+        List<String> valueList=new LinkedList<>();
+        if(null != key && null != redisTemplate){
+            Set<String> keys= redisTemplate.keys(key);
+            if(null != keys){
+                ValueOperations<String,String> ops = redisTemplate.opsForValue();
+                for(String kv:keys){
+                    if(null != ops){
+                        String value=ops.get(kv);
+                        if(null != value){
+                            valueList.add(value);
+                        }
+                    }
+                }
+            }
+        }
+        return valueList;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/tool/StringUtil.java

@@ -0,0 +1,552 @@
+package org.ts.ddcs.tool;
+
+
+
+
+
+import java.io.UnsupportedEncodingException;
+import java.math.BigDecimal;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+public class StringUtil {
+
+	private StringUtil() {
+
+	}
+
+	/**
+	 * @param str
+	 *            xxx,xxx,xxx
+	 * @return Collection - String
+	 */
+	public static Collection SimpleStringToCollection(String str) {
+
+		Collection list = new ArrayList();
+		StringTokenizer st = new StringTokenizer(str, ",");
+		while (st.hasMoreTokens()) {
+			list.add(st.nextToken());
+		}
+		return list;
+	}
+
+	public static Collection SimpleStringToCollection(String str,
+			String delimChar) {
+
+		Collection list = new ArrayList();
+		StringTokenizer sToken = new StringTokenizer(str, delimChar);
+		while (sToken.hasMoreTokens()) {
+			list.add(sToken.nextToken());
+		}
+		return list;
+	}
+
+	/**
+	 * @param str
+	 *            "xx|xx,xx|xx" or "x,x" or ...
+	 * @return Collection - Collection - String
+	 */
+	public static Collection StringToCollection(String str) {
+
+		Collection result = new ArrayList();
+		Collection colRecord = null;
+		StringTokenizer stFirst = new StringTokenizer(str, ",");
+		StringTokenizer stSecond = null;
+		String record = null;
+		String column = null;
+		while (stFirst.hasMoreTokens()) {
+			colRecord = new ArrayList();
+			record = stFirst.nextToken();
+			stSecond = new StringTokenizer(record, "|");
+			while (stSecond.hasMoreTokens()) {
+				column = stSecond.nextToken();
+				colRecord.add(column);
+			}
+			result.add(colRecord);
+		}
+
+		Iterator it = result.iterator();
+		while (it.hasNext()) {
+			colRecord = (Collection) it.next();
+			Iterator iter = colRecord.iterator();
+			while (iter.hasNext())
+				System.out.print(iter.next().toString() + " ");
+			System.out.println();
+		}
+		return result;
+	}
+
+	/**
+	 * @param str
+	 *            xxx,xxx,xxx
+	 * @return String[]
+	 */
+	public static String[] StringToArray(String str) {
+
+		if (str == null || str.equals(""))
+			return null;
+
+		Collection list = new ArrayList();
+		StringTokenizer st = new StringTokenizer(str, ",");
+		while (st.hasMoreTokens()) {
+			list.add(st.nextToken());
+		}
+
+		return (String[]) list.toArray(new String[list.size()]);
+	}
+
+	/**
+	 * @param str
+	 *            xxx,xxx,xxx
+	 * @return String[]
+	 */
+	public static String[] StringToArray(String str, String token) {
+
+		if (str == null || str.equals(""))
+			return null;
+
+		Collection list = new ArrayList();
+		StringTokenizer st = new StringTokenizer(str, token);
+		while (st.hasMoreTokens()) {
+			list.add(st.nextToken());
+		}
+
+		return (String[]) list.toArray(new String[list.size()]);
+	}
+
+	public static String leftFill(String src, int len, char fillChar) {
+
+		if (src == null || len < src.length())
+			return src;
+
+		String result = src;
+		for (int i = src.length(); i < len; i++) {
+			result = String.valueOf(fillChar) + result;
+		}
+
+		return result;
+	}
+
+	public static String rightFill(String src, String encoding, int len,
+			char fillChar) throws UnsupportedEncodingException {
+
+		int length = src.getBytes(encoding).length;
+		if (src == null || len < length)
+			return src;
+
+		String result = src;
+		for (int i = length; i < len; i++) {
+			result += String.valueOf(fillChar);
+		}
+
+		return result;
+	}
+
+	public static String rightFill(String src, int len, char fillChar) {
+
+		if (src == null || len < src.length())
+			return src;
+
+		String result = src;
+		for (int i = src.getBytes().length; i < len; i++) {
+			result += String.valueOf(fillChar);
+		}
+
+		return result;
+	}
+
+	public static String replace(String source, String oldString,
+			String newString) {
+
+		return replaceAll(source, oldString, newString);
+	}
+
+	public static String subString(String src, int index, int len,
+			String charset) {
+
+		if (src == null) {
+			return src;
+		}
+
+		String result = "";
+		try {
+			int subTotal = 0;
+
+			for (int i = 0; i < src.length(); i++) {
+				String subStr = src.substring(index, index + 1);
+				subTotal += subStr.getBytes(charset).length;
+				result += subStr;
+
+				if (subTotal >= len) {
+					if (index < src.length()) {
+						result += "...";
+					}
+					break;
+				}
+
+				index++;
+			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+		return result;
+	}
+
+	public static String replaceAll(String source, String from, String to) {
+
+		if (source == null || source.equals(""))
+			return source;
+		String remain = source;
+		String result = "";
+		while (remain.indexOf(from) != -1) {
+
+			result += remain.substring(0, remain.indexOf(from)) + to;
+			remain = remain.substring(remain.indexOf(from) + from.length(),
+					remain.length());
+		}
+		if (remain != null && !remain.equals(""))
+			result += remain;
+		return result;
+	}
+
+	public static int firstIndexOf(String src, char ch) {
+
+		int result = -1;
+		if (src == null) {
+			return result;
+		}
+
+		return src.indexOf(ch);
+	}
+
+	public static int lastIndexOf(String src, char ch) {
+
+		int result = -1;
+		if (src == null) {
+			return result;
+		}
+
+		for (int i = src.length() - 1; i >= 0; i--) {
+			if (src.charAt(i) == ch) {
+				return i;
+			}
+		}
+		return result;
+	}
+
+	public static String arrayToString(String[] arr) {
+
+		String result = "";
+		if (arr == null) {
+			return result;
+		}
+
+		for (int i = 0; i < arr.length; i++) {
+			if (i == 0) {
+				result = arr[i];
+			} else {
+				result += "," + arr[i];
+			}
+		}
+
+		return result;
+	}
+
+	public static String[] getDistinctArray(String[] oldArray) {
+
+		int cnt = 0;
+		for (int i = 0; i < oldArray.length; i++) {
+			if (oldArray[i] == null) {
+				continue;
+			}
+			if (oldArray[i].equals("")) {
+				oldArray[i] = null;
+				continue;
+			}
+			cnt++;
+			for (int j = i + 1; j < oldArray.length; j++) {
+				if (oldArray[j] == null) {
+					continue;
+				}
+				if (oldArray[j].equals("")) {
+					oldArray[j] = null;
+					continue;
+				}
+				if (oldArray[i].equals(oldArray[j])) {
+					oldArray[j] = null;
+				}
+			}
+		}
+
+		String[] newArray = new String[cnt];
+		if (cnt > 0) {
+			int index = 0;
+			for (int i = 0; i < oldArray.length; i++) {
+				if (oldArray[i] != null) {
+					newArray[index++] = oldArray[i];
+					// System.out.println("i=" +
+					// oldArray[i]);
+				}
+			}
+		}
+		return newArray;
+	}
+
+	public static String[] replaceArray(String[] oldArray, Map map) {
+
+		String[] result = new String[oldArray.length];
+		for (int i = 0; i < result.length; i++) {
+			String key = oldArray[i];
+			String value = (String) map.get(key);
+			result[i] = value == null ? key : value;
+		}
+
+		return result;
+	}
+
+	public static boolean isBlank(String str) {
+
+		if (str == null || str.trim().equals("")) {
+			return true;
+		}
+		return false;
+	}
+	
+	public static boolean isNotBlank(String str) {
+
+		if (null != str  && !str.trim().equals("")) {
+			return true;
+		}
+		return false;
+	}
+
+	public static String replace(String sourceStr, int start, int end,
+			String str) {
+
+		if (sourceStr == null || sourceStr.trim().equals("")) {
+			return sourceStr;
+		}
+
+		if (sourceStr.length() < end)
+			return sourceStr;
+
+		String s = sourceStr.substring(0, start) + str
+				+ sourceStr.substring(end);
+		return s;
+	}
+
+	public static int getSubstringCount(String src, String substr) {
+
+		if (src == null)
+			return 0;
+
+		int num = 0;
+		int index = 0;
+		while ((index = src.indexOf(substr, index)) != -1) {
+			num++;
+			index += substr.length();
+		}
+		return num;
+	}
+
+	/**
+	 * remove rest of string content if the string includes 2 bytes(0x81 0x40)
+	 * or 00
+	 * 
+	 * @param src
+	 * @return pure string
+	 * @throws UnsupportedEncodingException
+	 */
+	public static String trimRightZero(String src, String encoding)
+			throws UnsupportedEncodingException {
+
+		byte pattern[] = { (byte) 0x81, 0x40 };
+		String match = new String(pattern, encoding);
+		int i = src.indexOf((char) 0);
+		int j = src.indexOf(match);
+		// int k = src.indexOf("@");
+		if (i > 0) {
+			return src.substring(0, i);
+		} else if (j > 0) {
+			return src.substring(0, j);
+		} else {
+			return src;
+		}
+	}
+
+	public static String getLastlenStr(String source, int len) {
+
+		String str = "";
+		if (source != null && source.length() > 0) {
+			int strlen = source.length();
+			if (strlen > len) {
+				str = source.substring(strlen - len);
+			} else
+				str = source;
+		}
+		return str;
+	}
+
+	public static String trim(String src) {
+
+		if (src == null)
+			return null;
+
+		char halfSpace = ' ';
+		int headIndex = 0;
+		int tailIndex = 0;
+		int len = src.length();
+		for (int i = 0; i < len; i++) {
+			char tmp = src.charAt(i);
+			if (tmp == halfSpace) {
+				headIndex++;
+			} else {
+				break;
+			}
+		}
+
+		for (int i = (len - 1); i >= 0; i--) {
+			char tmp = src.charAt(i);
+			if (tmp == halfSpace) {
+				tailIndex++;
+			} else {
+				break;
+			}
+		}
+
+		if (headIndex == len)
+			return "";
+
+		String result = src.substring(headIndex, len - tailIndex);
+
+		return result;
+	}
+
+	public static String convertStringEnc(String strSource, String strEncoding)
+			throws UnsupportedEncodingException {
+
+		String strResult = new String(strSource.getBytes("ISO-8859-1"),
+				strEncoding);
+		return strResult;
+	}
+
+	public static String map2String(Map map) {
+
+		if (map == null) {
+			return "";
+		}
+
+		if (map.isEmpty()) {
+			return "";
+		}
+		String dataStr = "";
+		Object[] expKeys = map.keySet().toArray();
+		for (int i = 0; i < expKeys.length; i++) {
+			String code = expKeys[i].toString();
+			String value = (String) map.get(code);
+			dataStr += "".equals(dataStr) ? code + ":" + value : ", " + code
+					+ ":" + value;
+		}
+		return dataStr;
+	}
+
+
+
+	private static String getMD5Digest(String src)
+			throws NoSuchAlgorithmException {
+
+		char[] ha = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
+				'b', 'c', 'd', 'e', 'f' };
+		try {
+
+			MessageDigest md = MessageDigest.getInstance("MD5");
+
+			md.update(src.getBytes("UTF-8"));
+
+			byte[] ba = md.digest();
+
+			int j = ba.length;
+			char[] ca = new char[j * 2];
+			int k = 0;
+
+			for (int i = 0; i < j; i++) {
+				byte b = ba[i];
+				ca[k++] = ha[b >>> 4 & 0xf];
+				ca[k++] = ha[b & 0xf];
+			}
+
+			return new String(ca);
+		} catch (Exception e) {
+
+			return null;
+		}
+
+	}
+
+	
+	public static String getNotNullStr(String str){
+		return str!= null ? str.trim():"";
+	}
+	
+	//去掉多余的0, 000908.8900  变为908.89
+	public static String getPrettyNumber(String number) {
+		if(number.contains("F")){
+			return null;
+		}
+	    return BigDecimal.valueOf(Double.parseDouble(number))  
+	            .stripTrailingZeros().toPlainString();  
+	}
+	
+	/**
+	 * 判断当前日期是星期几<br>
+	 * <br>
+	 * 
+	 * @param pTime
+	 *            修要判断的时间<br>
+	 * @return dayForWeek 判断结果<br>
+	 * @Exception 发生异常<br>
+	 */
+	public static int dayForWeek(String pTime) throws Exception {
+		SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
+		Calendar c = Calendar.getInstance();
+		c.setTime(format.parse(pTime));
+		int dayForWeek = 0;
+		if (c.get(Calendar.DAY_OF_WEEK) == 1) {
+			dayForWeek = 7;
+		} else {
+			dayForWeek = c.get(Calendar.DAY_OF_WEEK) - 1;
+		}
+		return dayForWeek;
+	}
+	
+	
+	 /**
+     * 
+     * 提供精确的小数位四舍五入处理。
+     * @param v 需要四舍五入的数字
+     * @param scale  小数点后保留几位
+     * @return 四舍五入后的结果
+    * 
+     */
+	 public static String roundForNumber(String v,int scale){
+         if(scale<0){
+             throw new IllegalArgumentException("The scale must be a positive integer or zero");
+         }
+         BigDecimal b = new BigDecimal(v);
+         BigDecimal one = new BigDecimal("1");
+         double retV =  b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
+         return retV+"";
+     }
+	 
+	 public static String convertSecondToHourQ(String qStr){
+			if(null==qStr || "".equals(qStr)){
+				return null;
+			}
+			Double qSecond = Double.parseDouble(qStr);
+			Double qHour = qSecond*3600;
+			return qHour.toString();
+		}
+	
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/DataProcess.java

@@ -0,0 +1,175 @@
+package org.ts.ddcs.worker;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.config.ServerConfig;
+import org.ts.ddcs.db.DatabaseService;
+import org.ts.ddcs.log.LogHelper;
+
+
+//import org.springframework.amqp.core.AmqpTemplate;
+import org.ts.ddcs.mqtt.Mqtt;
+import org.glassfish.jersey.internal.guava.ThreadFactoryBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.*;
+
+@Component
+public class DataProcess {
+
+    //    private ExecutorService logSelectThreadPool = Executors.newFixedThreadPool(3);
+//    private ExecutorService logSplitThreadPool = Executors.newFixedThreadPool(1);
+  //  private ExecutorService logMapThreadPool = Executors.newFixedThreadPool(1);
+    // private ExecutorService logCollectErrorThreadPool = Executors.newFixedThreadPool(1);
+    //  private ExecutorService logDataCollectThreadPool = Executors.newFixedThreadPool(1);
+    // private ExecutorService fdfsThreadPool = Executors.newFixedThreadPool(2);
+
+
+    private static ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("data-process-pool-%d").build();
+    /**
+     * 公共线程池
+     **/
+    private static ExecutorService publicThreadPool = new ThreadPoolExecutor(1, 100,
+            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1024), threadFactory, new ThreadPoolExecutor.AbortPolicy());
+
+    @Autowired
+    public RedisTemplate redisTemplate;
+//
+//    @Autowired
+//    public JdbcTemplate jdbcTemplate;
+
+    @Autowired
+    public DatabaseService databaseService;
+
+//    @Autowired
+//    private HbaseTemplate hbaseTemplate;
+
+/*    @Autowired
+    public AmqpTemplate amqpTemplate;*/
+
+    @Autowired
+    public Mqtt mqttServer;
+
+    @Autowired
+    public ServerConfig config;
+
+    @Autowired
+    public KafkaTemplate kafkaTemplate;
+
+    public long msgNotifyTime=0;
+
+
+    public static ServerConfig config() {
+        return DataProcessHolder.newInstance().dataProcess.config;
+    }
+
+
+    @PostConstruct
+    public void init() {
+        DataProcessHolder.newInstance().dataProcess = this;
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setValueSerializer(new StringRedisSerializer());
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
+    }
+
+//    public void SubmitLogSelectTask(String log) {
+//        try {
+//            LogSelectWorker workertask = new LogSelectWorker(log);
+//            FutureTask<Integer> futureTask = new FutureTask<>(workertask);
+//            this.logSelectThreadPool.submit(futureTask);
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+//    }
+
+//    public void SubmitFdfsTask(String tm) {
+//        try {
+//            ReadFdfsFileWorker workertask = new ReadFdfsFileWorker(tm);
+//            FutureTask<Integer> futureTask = new FutureTask<>(workertask);
+//            this.fdfsThreadPool.submit(futureTask);
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+//    }
+
+//    public void test() {
+//        List<Map<String, Object>> list = hbaseTemplate.find("ts:pptn", "hour", new RowMapper<Map<String, Object>>() {
+//
+//            @Override
+//            public Map<String, Object> mapRow(Result result, int i) throws Exception {
+//                Map<String, Object> d = new HashMap<>();
+//                List<Cell> cells = result.listCells();
+//                for (Cell cell : cells) {
+//                    String field = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
+//                    String res = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
+//                    System.out.println(field + res);
+//                }
+//
+//                return d;
+//            }
+//        });
+//    }
+
+
+//    public void SubmitCollectDataTask(String log) {
+//        try {
+//            LogDataCollectWorker workertask = new LogDataCollectWorker(log);
+//            FutureTask<Integer> futureTask = new FutureTask<>(workertask);
+//            // this.logDataCollectThreadPool.submit(futureTask);
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+//    }
+
+
+//    public void SubmitSplitLogTask(String log) {
+//        try {
+//            LogSpliteWorker workertask = new LogSpliteWorker(log);
+//            FutureTask<Integer> futureTask = new FutureTask<>(workertask);
+//            this.logSplitThreadPool.submit(futureTask);
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+//    }
+
+//    public void SubmitSplitLzLogTask(String log) {
+//        try {
+//            LzLogSpliteWorker workertask = new LzLogSpliteWorker(log);
+//            FutureTask<Integer> futureTask = new FutureTask<>(workertask);
+//            this.logSplitThreadPool.submit(futureTask);
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+//    }
+
+    public void submitMapTask(JSONObject log) {
+        try {
+            LogMapWorker task = new LogMapWorker(log);
+            FutureTask<Integer> futureTask = new FutureTask<>(task);
+            publicThreadPool.submit(futureTask);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+
+//    public void SubmitCollectErrorTask(JSONObject log) {
+//        try {
+//            LogCollectErrorWorker workertask = new LogCollectErrorWorker(log);
+//            FutureTask<Integer> futureTask = new FutureTask<>(workertask);
+//            //  this.logCollectErrorThreadPool.submit(futureTask);
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+//    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/DataProcessHolder.java

@@ -0,0 +1,13 @@
+package org.ts.ddcs.worker;
+
+public class DataProcessHolder {
+    private static class InstanceHolder {
+        static DataProcessHolder instance = new DataProcessHolder();
+    }
+
+    public static DataProcessHolder newInstance() {
+        return DataProcessHolder.InstanceHolder.instance;
+    }
+
+    public DataProcess dataProcess;
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogCollectErrorWorker.java

@@ -0,0 +1,40 @@
+package org.ts.ddcs.worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.springframework.data.redis.core.HashOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.Callable;
+
+@SuppressWarnings("all")
+public class LogCollectErrorWorker implements Callable<Integer> {
+
+    private JSONObject log;
+
+    LogCollectErrorWorker(JSONObject log) {
+        this.log = log;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+
+//            String logTime = log.getString("logTime");
+//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+//            Date dt = sdf.parse(logTime);
+//            String rtu = log.getString("rtu");
+//            String datagram = log.getString("datagram");
+//            String agreement = log.getString("agreement");
+//            RedisTemplate redisTemplate = DataProcessHolder.newInstance().dataProcess.redisTemplate;
+//            HashOperations<String, String, String> opsHash = redisTemplate.opsForHash();
+//            if (agreement.equals("sw2014")) {
+//
+//            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogConnectAnalysisWorker.java

@@ -0,0 +1,119 @@
+package org.ts.ddcs.worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+@SuppressWarnings("all")
+public class LogConnectAnalysisWorker implements Callable<Integer> {
+
+    private String datagram;
+
+    public LogConnectAnalysisWorker(String datagram) {
+        this.datagram = datagram;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+            Thread.sleep(2000);
+            LogHelper.info("从日志中抽取数据");
+            String log_path = "D:\\logs\\ts\\";
+            File file = new File(log_path);
+            File[] files = file.listFiles();
+
+            String rtuCode=null;
+            String key =null;
+
+            Map<String ,String> keys = new HashMap<>();
+
+            for (File f : files) {
+                if (f.isFile()) {
+                    Thread.sleep(1000);
+                    System.out.println("file name " + f.getName());
+                    BufferedReader reader = null;
+                    try {
+                        System.out.println("以行为单位读取文件内容，一次读一整行：");
+                        reader = new BufferedReader(new FileReader(f));
+                        String tempString = null;
+                        while ((tempString = reader.readLine()) != null) {
+//                            if (tempString.contains("0533525433 down file datagram")){
+//                                LogHelper.info(tempString);
+//                            }
+                            if (tempString.contains("success pick datagram")) {
+                                int s = tempString.indexOf("success pick datagram");
+                                String datagram = tempString.substring(s + "success pick datagram".length());
+                             //   {"agreement":"szy2012","rtuCode":"1508001B00","datagram":"680768B01508001B00E1B616","datagramPickTime":"20201208183601"}
+                                JSONObject data = JSONObject.parseObject(datagram);
+                                 rtuCode = data.getString("rtuCode");
+                                if (rtuCode.equals("0533525433")){
+                                    key = tempString.substring("2020-12-08 18:36:01.531 ".length(),"2020-12-08 18:36:01.531 ".length()+"7f60b7e1221c49dea47a24670b985ba5".length());
+                                    if (!keys.containsKey(key)){
+                                        keys.put(key,key);
+                                    }
+                                }
+                            }
+                        }
+                        reader.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    } finally {
+                        if (reader != null) {
+                            try {
+                                reader.close();
+                            } catch (IOException e1) {
+                            }
+                        }
+                    }
+                }
+            }
+
+
+            Set<String>  key_list = keys.keySet();
+
+            for (File f : files) {
+                if (f.isFile()) {
+                    Thread.sleep(1000);
+                    System.out.println("file name " + f.getName());
+                    BufferedReader reader = null;
+                    try {
+                        System.out.println("以行为单位读取文件内容，一次读一整行：");
+                        reader = new BufferedReader(new FileReader(f));
+                        String tempString = null;
+                        while ((tempString = reader.readLine()) != null) {
+                            for(String k :key_list){
+                                if (tempString.indexOf(k)>=0){
+                                    LogHelper.info(tempString);
+                                    break;
+                                }
+                            }
+                        }
+                        reader.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    } finally {
+                        if (reader != null) {
+                            try {
+                                reader.close();
+                            } catch (IOException e1) {
+                            }
+                        }
+                    }
+                }
+            }
+
+
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogDataCollectDLWorker.java

@@ -0,0 +1,89 @@
+package org.ts.ddcs.worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+import org.springframework.web.client.RestTemplate;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URI;
+import java.util.concurrent.Callable;
+
+@SuppressWarnings("all")
+public class LogDataCollectDLWorker implements Callable<Integer> {
+
+    private String datagram;
+
+    public LogDataCollectDLWorker(String datagram) {
+        this.datagram = datagram;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+//            Thread.sleep(2000);
+//            LogHelper.info("从日志中抽取数据");
+//            String log_path = "D:\\logs\\dl\\";
+//            File file = new File(log_path);
+//            File[] files = file.listFiles();
+//            for (File f : files) {
+//                if (f.isFile()) {
+//                    Thread.sleep(1000);
+//                    System.out.println("file name " + f.getName());
+//                    BufferedReader reader = null;
+//                    try {
+//                        System.out.println("以行为单位读取文件内容，一次读一整行：");
+//                        reader = new BufferedReader(new FileReader(f));
+//                        String tempString = null;
+//                        while ((tempString = reader.readLine()) != null) {
+//                            if (tempString.contains("***Receive String 2014 Hex One:")) {
+//                                int s = tempString.indexOf("***Receive String 2014 Hex One:");
+//                                String datagram = tempString.substring(s + "***Receive String 2014 Hex One:".length());
+//
+//                                JSONObject data = new JSONObject();
+//
+//                                data.put("agreement","sw2014");
+//
+//                                String datagramPickTime = tempString.substring(1, 1+"2020-11-10 08:13:22".length());
+//
+//                                data.put("logTime", datagramPickTime );
+//
+//
+//
+//                                data.put("datagram",datagram);
+//
+//
+//                                String rtuCode = datagram.substring(6, 6+10);
+//
+//                                data.put("rtu",rtuCode);
+//
+//                                LogHelper.info(data.getString("agreement") + " " + data.getString("logTime") + " " + data.getString("rtu") + " " + data.getString("datagram"));
+//
+//                                if (rtuCode.equals("992016000D")){
+//                                    DataProcessHolder.newInstance().dataProcess.SubmitMapTask(data);
+//                                }
+//
+//
+//                            }
+//                        }
+//                        reader.close();
+//                    } catch (IOException e) {
+//                        e.printStackTrace();
+//                    } finally {
+//                        if (reader != null) {
+//                            try {
+//                                reader.close();
+//                            } catch (IOException e1) {
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogDataCollectWorker.java

@@ -0,0 +1,99 @@
+package org.ts.ddcs.worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+import org.springframework.web.client.RestTemplate;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URI;
+import java.util.concurrent.Callable;
+
+@SuppressWarnings("all")
+public class LogDataCollectWorker implements Callable<Integer> {
+
+    private String datagram;
+
+    public LogDataCollectWorker(String datagram) {
+        this.datagram = datagram;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+            Thread.sleep(1000);
+            LogHelper.info("从日志中抽取数据");
+            String log_path = "D:\\logs\\ts\\";
+            File file = new File(log_path);
+            File[] files = file.listFiles();
+            for (File f : files) {
+                if (f.isFile()) {
+                    Thread.sleep(1000);
+                    System.out.println("file name " + f.getName());
+                    BufferedReader reader = null;
+                    try {
+                        System.out.println("以行为单位读取文件内容，一次读一整行：");
+                        reader = new BufferedReader(new FileReader(f));
+                        String tempString = null;
+                        while ((tempString = reader.readLine()) != null) {
+                            if (tempString.contains("queue_datagram_process body:")) {
+                                int s = tempString.indexOf("queue_datagram_process body:");
+                                String body = tempString.substring(s + "queue_datagram_process body:".length());
+                                JSONObject data = JSONObject.parseObject(body);
+                                if (!data.containsKey("datagramPickTime")) {
+                                    String datagramPickTime = tempString.substring(0, "2020-11-10".length()) + "000000";
+                                    datagramPickTime = datagramPickTime.replace("-", "");
+                                    data.put("datagramPickTime", datagramPickTime);
+                                }
+                                String datagram = data.getString("datagram");
+                                if (datagram.indexOf("68") == 0) {
+                                    if (datagram.substring("682468B31522001600".length(), "682468B31522001600".length() + 2).equals("C0")) {
+                                        if (datagram.substring("682468".length(), "682468".length() + 2).equals("B3")) {
+                                            String relayhttp = "http://172.9.0.195:8804/DataCollectServer/Collect/Datagram/Supplement";
+                                            RestTemplate restTemplate = new RestTemplate();
+                                            JSONObject result = restTemplate.postForObject(new URI(relayhttp), data, JSONObject.class);
+                                        }
+                                    }
+                                }
+                            } else if (tempString.contains("datagramProcess queue message:")) {
+                                int s = tempString.indexOf("datagramProcess queue message:");
+                                String body = tempString.substring(s + "datagramProcess queue message:".length());
+                                JSONObject data = JSONObject.parseObject(body);
+                                if (!data.containsKey("datagramPickTime")) {
+                                    String datagramPickTime = tempString.substring(0, "2020-11-10".length()) + "000000";
+                                    datagramPickTime = datagramPickTime.replace("-", "");
+                                    data.put("datagramPickTime", datagramPickTime);
+                                }
+                                String datagram = data.getString("datagram");
+                                if (datagram.indexOf("68") == 0) {
+                                    if (datagram.substring("682468B31522001600".length(), "682468B31522001600".length() + 2).equals("C0")) {
+                                        if (datagram.substring("682468".length(), "682468".length() + 2).equals("B3")) {
+                                            String relayhttp = "http://172.9.0.195:8804/DataCollectServer/Collect/Datagram/Supplement";
+                                            RestTemplate restTemplate = new RestTemplate();
+                                            JSONObject result = restTemplate.postForObject(new URI(relayhttp), data, JSONObject.class);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        reader.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    } finally {
+                        if (reader != null) {
+                            try {
+                                reader.close();
+                            } catch (IOException e1) {
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogMapWorker.java

@@ -0,0 +1,214 @@
+package org.ts.ddcs.worker;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.tool.GBConstants;
+import org.ts.ddcs.tool.RedisHelper;
+import org.springframework.data.redis.core.HashOperations;
+import org.springframework.data.redis.core.ListOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.concurrent.Callable;
+
+public class LogMapWorker implements Callable<Integer> {
+
+    private JSONObject log;
+
+    LogMapWorker(JSONObject log) {
+        this.log = log;
+    }
+
+    @Override
+    public Integer call() {
+        String LogId = LogHelper.createLogId("LogMapWorker");
+        try {
+            RedisTemplate redisTemplate = DataProcessHolder.newInstance().dataProcess.redisTemplate;
+            if (null == redisTemplate) {
+                return 0;
+            }
+            LogHelper.info(LogId + " " + log.getString("agreement") + " " + log.getString("logTime") + " " + log.getString("rtu") + " " + log.getString("datagram"));
+            ListOperations<String, String> opsList = redisTemplate.opsForList();
+            HashOperations<String, String, String> opsHash = redisTemplate.opsForHash();
+            String logTime = log.getString("logTime");
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            Date dt = sdf.parse(logTime);
+            String agreement = log.getString("agreement");
+            String rtuCode = log.getString("rtu");
+            String datagram = log.getString("datagram");
+
+            DataProcessHolder.newInstance().dataProcess.databaseService.saveDatagram(rtuCode, dt, datagram);
+
+            //生成测站规约
+            if (agreement.equals(GBConstants.AGREEMENT_KIND_SW)) {
+
+            } else {
+                if (opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_PROJECT_ID)) {
+                    String project_key = GBConstants.REDIS_KEY_PROJECT_PREFIX + opsHash.get(rtuCode, GBConstants.REDIS_KEY_PROJECT_ID);
+                    if (opsHash.hasKey(project_key, GBConstants.REDIS_KEY_AGREEMENT)) {
+                        agreement = opsHash.get(project_key, GBConstants.REDIS_KEY_AGREEMENT);
+                    }
+                }
+            }
+            //更新最近一天的小时报文列表
+            String list_hour_key = rtuCode + ":List:Hour";
+            if (RedisHelper.hasKey(list_hour_key, redisTemplate)) {
+                String last = opsList.rightPop(list_hour_key);
+                if (last.substring(0, "yyyy-MM-dd HH".length()).equals(logTime.substring(0, "yyyy-MM-dd HH".length()))) {
+                    opsList.rightPush(list_hour_key, logTime);
+                } else {
+                    opsList.rightPush(list_hour_key, last);
+                    opsList.rightPush(list_hour_key, logTime);
+                }
+            } else {
+                opsList.rightPush(list_hour_key, logTime);
+            }
+            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyyMMddHH");
+            Long size = opsList.size(list_hour_key);
+            if (size > 24) {
+                String left = opsList.leftPop(list_hour_key);
+                Date deleteDt = sdf.parse(left);
+                String deletehour = sdf2.format(deleteDt.getTime());
+                String delete_key = rtuCode + ":List:Minute:" + deletehour;
+                redisTemplate.delete(delete_key);
+            }
+            //更新每小时的报文列表
+            String hourStr = sdf2.format(dt.getTime());
+            String list_minute_key = rtuCode + ":List:Minute:" + hourStr;
+            JSONObject info = new JSONObject();
+            info.put("datagram", datagram);
+            String dataOfMinute = logTime + "=" + info.toJSONString();
+            opsList.rightPush(list_minute_key, dataOfMinute);
+
+            //更新最近50条报文
+            SimpleDateFormat sdf3 = new SimpleDateFormat("yyyyMMddHHmmss");
+            opsList.rightPush(rtuCode + ":List", logTime);
+            String datagramTime = sdf3.format(dt.getTime());
+            opsHash.put(rtuCode + ":datagram", datagramTime, datagram);
+            size = opsList.size(rtuCode + ":List");
+            if (size > 50) {
+                String lefttime = opsList.leftPop(rtuCode + ":List");
+                Date tmpdt = sdf.parse(lefttime);
+                String tmpdatagramTime = sdf3.format(tmpdt.getTime());
+                opsHash.delete(rtuCode + ":datagram", tmpdatagramTime);
+            }
+
+            opsHash.put(rtuCode, "datagram", datagram);
+            opsHash.put(rtuCode, "agreement", agreement);
+
+            if (opsHash.hasKey(rtuCode, "lastTime")) {
+                String lastTime = opsHash.get(rtuCode, "lastTime");
+                Date lastdt = sdf.parse(lastTime);
+                long diff = dt.getTime() - lastdt.getTime();
+                opsHash.put(rtuCode, "spaceTime", Long.toString(diff));
+                opsHash.put(rtuCode, "lastTime", logTime);
+            } else {
+                opsHash.put(rtuCode, "spaceTime", "0");
+                opsHash.put(rtuCode, "lastTime", logTime);
+            }
+
+            DataProcessHolder.newInstance().dataProcess.databaseService.updateLastTime(rtuCode,dt);
+
+            //更新在线状态
+            opsHash.put("rtu_online", rtuCode, logTime);
+
+
+
+          //  List<String> msgList = new ArrayList();
+            //并发连接
+//            Calendar calendar = Calendar.getInstance();
+//            calendar.setTime(dt);
+//            int year = calendar.get(Calendar.YEAR);
+//            int month = calendar.get(Calendar.MONTH);
+//            int day = calendar.get(Calendar.DAY_OF_MONTH);
+//            int hour = calendar.get(Calendar.HOUR_OF_DAY);
+//            int mintue = calendar.get(Calendar.MINUTE);
+//            int onlineNum = 0;
+//            List<String> rtu_online = opsHash.values("rtu_online");
+//            for (String tm : rtu_online) {
+//                Date t = sdf.parse(tm);
+//                calendar.setTime(t);
+//                int year2 = calendar.get(Calendar.YEAR);
+//                int month2 = calendar.get(Calendar.MONTH);
+//                int day2 = calendar.get(Calendar.DAY_OF_MONTH);
+//                int hour2 = calendar.get(Calendar.HOUR_OF_DAY);
+//                int mintue2 = calendar.get(Calendar.MINUTE);
+//                if (year == year2 && month == month2 && day == day2 && hour == hour2 && mintue == mintue2) {
+//                    onlineNum += 1;
+//                }
+//            }
+//            JSONObject msg = new JSONObject();
+//            msg.put("msg_code", "online_rtu_num");
+//            msg.put("name", "在线数量");
+//            msg.put("value", String.format("%d", onlineNum));
+//            msgList.add(msg.toJSONString());
+//
+
+            //1小时累计
+//            calendar.setTime(dt);
+//            calendar.add(Calendar.HOUR_OF_DAY, -1);
+//            Date startTime = calendar.getTime();
+//            calendar.setTime(dt);
+//            Date endTime = calendar.getTime();
+//
+//            long datagramNum = DataProcessHolder.newInstance().dataProcess.databaseService.datagramCount(startTime, endTime);
+//            msg = new JSONObject();
+//            msg.put("msg_code", "datagram_up_num_in_hour");
+//            msg.put("name", "1小时报文上报数量");
+//            msg.put("value", String.format("%d", datagramNum));
+//            msgList.add(msg.toJSONString());
+//
+//            //峰值
+//            boolean nextPeakValue = false;
+//            calendar.setTime(dt);
+//            year = calendar.get(Calendar.YEAR);
+//            month = calendar.get(Calendar.MONTH);
+//            day = calendar.get(Calendar.DAY_OF_MONTH);
+//            hour = calendar.get(Calendar.HOUR_OF_DAY);
+//            mintue = calendar.get(Calendar.MINUTE);
+//            mintue = mintue < 5 ? 0 : mintue - (mintue % 5);
+//            if (redisTemplate.hasKey("datagram_real_peak_value")) {
+//                String peakvalue = opsList.rightPop("datagram_real_peak_value");
+//                String[] peakvalueList = peakvalue.split(":");
+//                if (peakvalueList[1].equals(String.format("%04d%02d%02d%02d%02d", year, month, day, hour, mintue))) {
+//                    opsList.rightPush("datagram_real_peak_value", String.format("%d", Integer.parseInt(peakvalueList[0]) + 1) + ":" + String.format("%04d%02d%02d%02d%02d", year, month, day, hour, mintue));
+//                } else {
+//                    opsList.rightPush("datagram_real_peak_value", peakvalue);
+//                    opsList.rightPush("datagram_real_peak_value", "1:" + String.format("%04d%02d%02d%02d%02d", year, month, day, hour, mintue));
+//                    nextPeakValue = true;
+//                }
+//            } else {
+//                opsList.rightPush("datagram_real_peak_value", "1:" + String.format("%04d%02d%02d%02d%02d", year, month, day, hour, mintue));
+//            }
+//            if (opsList.size("datagram_real_peak_value") > 12) {
+//                opsList.leftPop("datagram_real_peak_value");
+//            }
+//            if (nextPeakValue) {
+//                List<String> peakValue = opsList.range("datagram_real_peak_value", 0, 11);
+//                JSONArray peakValueMsg = new JSONArray();
+//                for (String peak : peakValue) {
+//                    String[] peakvalueList = peak.split(":");
+//                    JSONObject d = new JSONObject();
+//                    d.put("name", Integer.parseInt(peakvalueList[1].substring(10, 12)) + "分");
+//                    d.put("value", Integer.parseInt(peakvalueList[0]));
+//                    peakValueMsg.add(d);
+//                }
+//
+//                msg = new JSONObject();
+//                msg.put("msg_code", "datagram_up_peak_value_in_hour");
+//                msg.put("list", peakValueMsg);
+//                msgList.add(msg.toJSONString());
+//            }
+//            int goingSecond = (int) ((dt.getTime() - DataProcessHolder.newInstance().dataProcess.msgNotifyTime) / 1000);
+//            if (goingSecond >= 2) {
+//                DataProcessHolder.newInstance().dataProcess.mqttServer.send(msgList);
+//                DataProcessHolder.newInstance().dataProcess.msgNotifyTime = dt.getTime();
+//            }
+        } catch (Exception e) {
+            LogHelper.error(LogId + " " + e);
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogSelectWorker.java

@@ -0,0 +1,27 @@
+package org.ts.ddcs.worker;
+
+
+import java.util.concurrent.Callable;
+
+public class LogSelectWorker implements Callable<Integer> {
+    private String log;
+
+    LogSelectWorker(String log) {
+        this.log = log;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+//            if (log.contains("success pick datagram")) {
+//                DataProcessHolder.newInstance().dataProcess.SubmitSplitLogTask(log);
+//            }else if (log.contains("***Receive String Hex:")){
+//                DataProcessHolder.newInstance().dataProcess.SubmitSplitLzLogTask(log);
+//            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LogSpliteWorker.java

@@ -0,0 +1,43 @@
+package org.ts.ddcs.worker;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+
+import java.util.concurrent.Callable;
+
+
+public class LogSpliteWorker implements Callable<Integer> {
+
+    private String log;
+
+    LogSpliteWorker(String log) {
+        this.log = log;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+//            JSONObject jsonLog = new JSONObject();
+//            String tm = log.substring(0, "yyyy-mm-dd hh:MM:ss.mmm ".length());
+//            jsonLog.put("logTime", tm);
+//            String log_content = log.substring("yyyy-mm-dd hh:MM:ss.mmm ".length());
+//            int offest = log_content.indexOf("success pick datagram") + "success pick datagram".length();
+//            String jsonStr = log_content.substring(offest);
+//            JSONObject json = JSONObject.parseObject(jsonStr);
+//            jsonLog.put("datagram", json.getString("datagram"));
+//            if (json.containsKey("version")) {
+//                jsonLog.put("agreement", json.getString("version"));
+//            } else if (json.containsKey("agreement")) {
+//                jsonLog.put("agreement", json.getString("agreement"));
+//            } else {
+//                jsonLog.put("agreement", json.getString(""));
+//            }
+//            jsonLog.put("rtu", json.getString("rtuCode"));
+//            DataProcessHolder.newInstance().dataProcess.SubmitMapTask(jsonLog);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/LzLogSpliteWorker.java

@@ -0,0 +1,45 @@
+package org.ts.ddcs.worker;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.log.LogHelper;
+
+import java.util.concurrent.Callable;
+
+
+public class LzLogSpliteWorker implements Callable<Integer> {
+
+    private String log;
+
+    LzLogSpliteWorker(String log) {
+        this.log = log;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+            JSONObject jsonLog = new JSONObject();
+            int index = log.indexOf("***Receive String Hex:") + "***Receive String Hex:".length();
+            String hexStr = log.substring(index);
+            if (hexStr.substring(0,2).equals("68")) {
+                jsonLog.put("agreement", "szy2012");
+                jsonLog.put("rtu", hexStr.substring("682468B3".length(), "682468B3".length() + 10));
+                jsonLog.put("datagram", hexStr);
+                String tm = log.substring(0, "yyyymmdd hh:MM:ss".length());
+                String rePackTm = tm.substring(0,4)+"-"+tm.substring(4,6)+"-"+tm.substring(6,8)+" "+tm.substring("yyyymmdd ".length());
+                jsonLog.put("logTime", rePackTm);
+                DataProcessHolder.newInstance().dataProcess.submitMapTask(jsonLog);
+            }else{
+                String tm = log.substring(0, "yyyy-mm-dd hh:MM:ss.mmm ".length());
+                jsonLog.put("logTime", tm);
+                jsonLog.put("agreement", "sw2014");
+                jsonLog.put("rtu", hexStr.substring("7E7E01".length(), "7E7E01".length() + 10));
+                jsonLog.put("datagram", hexStr);
+                DataProcessHolder.newInstance().dataProcess.submitMapTask(jsonLog);
+            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/java/org/ts/ddcs/worker/ReadFdfsFileWorker.java

@@ -0,0 +1,78 @@
+package org.ts.ddcs.worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.hadoop.HadoopUtils;
+import org.ts.ddcs.log.LogHelper;
+
+
+import java.net.URI;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+@SuppressWarnings("all")
+public class ReadFdfsFileWorker implements Callable<Integer> {
+
+
+    private String tm;
+
+    ReadFdfsFileWorker(String tm) {
+        this.tm = tm;
+    }
+
+
+    @Override
+    public Integer call() throws Exception {
+        try {
+//            JSONObject data = new JSONObject();
+//            Configuration cnf = HadoopUtils.hadoopConf();
+//            FileSystem fs = FileSystem.get(new URI("hdfs://172.9.0.190:9000"), cnf);
+//            String dir = "/flume/logs/" + tm.substring(2, 2 + "yy-mm-dd".length());
+//            FileStatus[] statusArr = fs.listStatus(new Path(dir));        //listStatus方法用于列出目录下的所有文件
+//            Path[] listPaths = FileUtil.stat2Paths(statusArr);            //用FileUtil工具类将FileStatus类型的数组转换为Path类型的数组
+//            for (Path p : listPaths) {
+//                System.out.println(p);
+//
+//                HdfsDataInputStream hdis = (HdfsDataInputStream) fs.open(p);
+//                List<LocatedBlock> allBlocks = hdis.getAllBlocks();
+//                for (LocatedBlock block : allBlocks) {
+//                    ExtendedBlock eBlock = block.getBlock();
+//                    System.out.println("------------------------");
+//
+//                    System.out.println(eBlock.getBlockId());
+//                    System.out.println(eBlock.getBlockName());
+//                    System.out.println(block.getBlockSize());
+//                    System.out.println(block.getStartOffset());
+//                    // 获取当前的数据块所在的DataNode的信息
+//                    DatanodeInfo[] locations = block.getLocations();
+//                    for (DatanodeInfo info : locations) {
+//                        System.out.println(info.getIpAddr());
+//                        System.out.println(info.getHostName());
+//                    }
+//                }
+//
+//                // 获取文件状态
+//                FileStatus status = fs.getFileStatus(p);
+//                long tm = status.getModificationTime();
+//                short replicationFiles = status.getReplication();
+//                SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+//                LogHelper.info(timeFormat.format(new Date(tm)));
+//                SequenceFile.Reader reader = new SequenceFile.Reader(fs, p, cnf);
+//                Writable key = (Writable) ReflectionUtils.newInstance(reader.getKeyClass(), cnf);
+//                Writable value = (Writable) ReflectionUtils.newInstance(reader.getValueClass(), cnf);
+//                while (reader.next(key, value)) {
+//                    BytesWritable bw = (BytesWritable) value;
+//                    String s = new String(bw.getBytes(), "utf-8");
+//                    System.out.println(s);
+//                }
+//                IOUtils.closeStream(reader);
+//            }
+//            // 关闭文件操作对象
+//            fs.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return 0;
+    }
+}

tsddcs-datacacheservice/src/main/resources/application-dev.yml

@@ -0,0 +1,61 @@
+server:
+  port: 8821
+spring:
+  application:
+    name: LogProcessServer
+  #  rabbitmq:
+  #    host: 172.1.0.75
+  #    port: 5672
+  #    username: root
+  #    password: Dh82828800
+  redis:
+    database: 0
+    host: 172.1.0.75
+    port: 6379
+    password: Dh82828800
+  data:
+    kafka:
+      servers: 172.9.0.120:9092,172.9.0.121:9092,172.9.0.202:9092
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://172.1.0.63:3306/devicebox?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
+    username: root
+    password: Dh82828800
+run-config:
+  server:
+    serverId: 172-9-0-164
+  mqtt:
+    mqttSubTopic: topic-ts-notify/#
+    mqttPubTopic: topic-ts-notify/1
+    mqttBroker: tcp://172.9.0.206:1883
+  mq:
+    waitingToProcessDatagram: queue-waiting-process-datagram
+    toRtuDatagram: queue-to-rtu-datagram
+    serverSelfCheckingMessage: queue-server-self-checking-message
+    warningMessage: queue-warning-message
+    checkStateQueue: queue-datagram-check
+    logMessage: queue-log-message
+
+#  datasource:
+#    driver-class-name: com.kingbase8.Driver
+#    url: jdbc:kingbase8://172.9.0.100:54321/TEST
+#    username: SYSTEM
+#    password: Dh82828800
+
+
+#  mqtt:
+#    username: admin
+#    password: Dh82828800
+#    url: tcp://172.9.0.195:1883
+#    client:
+#      id: 'admin'
+#    default:
+#      topic: 'topicTest01'
+#    topics: topicTest01
+#    qosValues: 2,3
+
+#hbase:
+#  config:
+#    hbase.zookeeper.quorum: 172.9.0.204
+#    hbase.zookeeper.property.clientPort: 2181
+

tsddcs-datacacheservice/src/main/resources/application-prod.yml

@@ -0,0 +1,48 @@
+server:
+  port: 8821
+spring:
+  application:
+    name: LogProcessServer
+#  rabbitmq:
+#    host: 172.1.0.75
+#    port: 5672
+#    username: root
+#    password: Dh82828800
+  redis:
+    database: 0
+    host: 172.1.0.75
+    port: 6379
+    password: Dh82828800
+  data:
+    kafka:
+      servers: 172.9.0.120:9092,172.9.0.121:9092,172.9.0.202:9092
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://172.1.0.63:3306/devicebox?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
+    username: root
+    password: Dh82828800
+
+
+#  datasource:
+#    driver-class-name: com.kingbase8.Driver
+#    url: jdbc:kingbase8://172.9.0.100:54321/TEST
+#    username: SYSTEM
+#    password: Dh82828800
+
+
+#  mqtt:
+#    username: admin
+#    password: Dh82828800
+#    url: tcp://172.9.0.195:1883
+#    client:
+#      id: 'admin'
+#    default:
+#      topic: 'topicTest01'
+#    topics: topicTest01
+#    qosValues: 2,3
+
+#hbase:
+#  config:
+#    hbase.zookeeper.quorum: 172.9.0.204
+#    hbase.zookeeper.property.clientPort: 2181
+

tsddcs-datacacheservice/src/main/resources/application-test.yml

@@ -0,0 +1,48 @@
+server:
+  port: 8821
+spring:
+  application:
+    name: LogProcessServer
+#  rabbitmq:
+#    host: 172.1.0.75
+#    port: 5672
+#    username: root
+#    password: Dh82828800
+  redis:
+    database: 0
+    host: 172.1.0.75
+    port: 6379
+    password: Dh82828800
+  data:
+    kafka:
+      servers: 172.9.0.120:9092,172.9.0.121:9092,172.9.0.202:9092
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://172.1.0.63:3306/devicebox?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
+    username: root
+    password: Dh82828800
+
+
+#  datasource:
+#    driver-class-name: com.kingbase8.Driver
+#    url: jdbc:kingbase8://172.9.0.100:54321/TEST
+#    username: SYSTEM
+#    password: Dh82828800
+
+
+#  mqtt:
+#    username: admin
+#    password: Dh82828800
+#    url: tcp://172.9.0.195:1883
+#    client:
+#      id: 'admin'
+#    default:
+#      topic: 'topicTest01'
+#    topics: topicTest01
+#    qosValues: 2,3
+
+#hbase:
+#  config:
+#    hbase.zookeeper.quorum: 172.9.0.204
+#    hbase.zookeeper.property.clientPort: 2181
+

tsddcs-datacacheservice/src/main/resources/application.yml

@@ -0,0 +1,3 @@
+spring:
+  profiles:
+    active: dev

tsddcs-datacacheservice/src/main/resources/logback.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration debug="false">
+    <!--定义日志文件的存储地址和前缀名 -->
+    <property name="LOG_HOME" value="./logs" />
+
+    <!-- 一般信息按照每天生成日志文件 -->
+    <appender name="INFO_FILE"
+              class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <File>${LOG_HOME}/info.log</File>
+        <rollingPolicy
+                class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <!-- 每天一归档 -->
+            <fileNamePattern>${LOG_HOME}/info-%d{yyyyMMdd}.log.%i
+            </fileNamePattern>
+            <!-- 单个日志文件最多100MB, 30天的日志周期，最大不能超过10GB -->
+            <maxFileSize>100MB</maxFileSize>
+            <maxHistory>100</maxHistory>
+            <totalSizeCap>100GB</totalSizeCap>
+        </rollingPolicy>
+        <encoder>
+            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->
+            <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %msg%n</Pattern>
+        </encoder>
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>INFO</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+    <!--错误信息按照每天生成日志文件 -->
+    <appender name="ERROR_FILE"
+              class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>ERROR</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+        <File>${LOG_HOME}/error.log</File>
+        <rollingPolicy
+                class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <!-- 每天一归档 -->
+            <fileNamePattern>${LOG_HOME}/error-%d{yyyyMMdd}.log.%i
+            </fileNamePattern>
+            <!-- 单个日志文件最多100MB, 30天的日志周期，最大不能超过10GB -->
+            <maxFileSize>100MB</maxFileSize>
+            <maxHistory>100</maxHistory>
+            <totalSizeCap>100GB</totalSizeCap>
+        </rollingPolicy>
+        <encoder>
+            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->
+            <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %msg%n</Pattern>
+        </encoder>
+    </appender>
+    <appender name="DEBUG_FILE"
+              class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <File>${LOG_HOME}/dev.log</File>
+        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <fileNamePattern>${LOG_HOME}/dev-%d{yyyyMMdd}.log.%i</fileNamePattern>
+            <maxFileSize>10MB</maxFileSize>
+            <maxHistory>100</maxHistory>
+            <totalSizeCap>100GB</totalSizeCap>
+        </rollingPolicy>
+        <layout>
+            <pattern>[%date{yyyy-MM-dd HH:mm:ss}]  %msg%n</pattern>
+        </layout>
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <level>DEBUG</level>
+            <onMatch>ACCEPT</onMatch>
+            <onMismatch>DENY</onMismatch>
+        </filter>
+    </appender>
+
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->
+            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %msg%n</pattern>
+        </encoder>
+    </appender>
+    <!-- 日志输出级别 这样设置不打印日志 -->
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+        <appender-ref ref="INFO_FILE" />
+        <appender-ref ref="ERROR_FILE" />
+        <appender-ref ref="DEBUG_FILE" />
+    </root>
+
+</configuration>

tsddcs-datacollect-simple/src/main/java/org/ts/ddcs/DataCollectSimpleApplication.java

@@ -0,0 +1,21 @@
+package org.ts.ddcs;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+
+
+/**
+ * 主应用入口
+ *
+ * @author dylan
+ */
+@SpringBootApplication
+@EnableScheduling
+public class DataCollectSimpleApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DataCollectSimpleApplication.class, args);
+    }
+}

tsddcs-datacollect-simple/src/main/java/org/ts/ddcs/dataStream/sink/DataStreamSwRestSink.java

@@ -0,0 +1,98 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2023/8/28
+ */
+package org.ts.ddcs.dataStream.sink;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import lombok.extern.slf4j.Slf4j;
+import org.ts.ddcs.common.metadata.DatagramMetadataEnum;
+import org.ts.ddcs.common.metadata.TaishanV2JsonPackMetadataEnum;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataStream.DataStreamCache;
+import org.ts.ddcs.dataStream.DataStreamLineManager;
+import org.ts.ddcs.enums.SwElementCodeEnum;
+import org.ts.ddcs.main.DataProcessorHolder;
+import org.ts.ddcs.metadata.DataStreamCacheMetadata;
+import org.ts.ddcs.metadata.sw.jpz.SwJpzFlowRateMetadataEnum;
+import org.ts.ddcs.tools.CloumnHelp;
+import org.ts.ddcs.tools.KeyStoreHelp;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/***
+ * Date:2023/8/28
+ * Title:水文输出
+ * Description：对本文件的详细描述，原则上不能少于30字
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+@Slf4j
+public class DataStreamSwRestSink extends DataStreamSink {
+    private DataStreamCache dataStreamCache;
+
+    @Override
+    public void init(DataStreamLineManager context) {
+        this.setContext(context);
+        this.dataStreamCache = context.getCache();
+    }
+
+    @Override
+    public void sink(DataStreamAdapter dataStreamAdapter, List<Map<String, Object>> elementDatas) {
+        log.info("sink {} 接收时间 {}", dataStreamAdapter.getRtuCode(), this.dataStreamCache.getStringValue(DataStreamCacheMetadata.METADATA_PICK_TIME.getName()));
+        Date dt = Date.from(this.dataStreamCache.getPickPacketTime().atZone(ZoneId.systemDefault()).toInstant());
+        JSONObject jsonBody = new JSONObject();
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_RTU_CODE.getName(), this.dataStreamCache.getRtuCode());
+        String siteKind = this.dataStreamCache.getStringValue(DataStreamCacheMetadata.METADATA_SITE_KIND.getName());
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_SITE_TYPE.getName(), siteKind);
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_FROM_TIME.getName(), dt.getTime());
+
+        String datagramCode = this.dataStreamCache.getDatagramCode();
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_DATAGRAM_TYPE.getName(), datagramCode);
+
+        //观测时间
+        Map<String, Object> cloumn = KeyStoreHelp.getOne(elementDatas, SwElementCodeEnum.getCode("TT"));
+        if (null != cloumn) {
+            String tmText = CloumnHelp.getString(cloumn);
+            DateTimeFormatter timeFormat = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
+            LocalDateTime tm = LocalDateTime.parse(tmText, timeFormat);
+            jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_COLLECT_TIME.getName(), Date.from(tm.atZone(ZoneId.systemDefault()).toInstant()).getTime());
+        }
+        JSONArray items = new JSONArray();
+        for (Map<String, Object> data : elementDatas) {
+            JSONObject item = new JSONObject();
+            String codeValue = (String) data.get(DatagramMetadataEnum.CACHE_METADATA_ELEMENT_CODE.getName());
+            List<Map<String, Object>> keyStore = (List<Map<String, Object>>) data.get(DatagramMetadataEnum.CACHE_METADATA_DATA.getName());
+            JSONArray datas = new JSONArray();
+            if (null != keyStore && keyStore.size() > 0) {
+                for (Map<String, Object> v : keyStore) {
+                    JSONObject value = new JSONObject(v);
+//                    String keyText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_CODE.getName());
+//                    String nameText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_NAME.getName());
+//                    String subCodeText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_SUB_CODE.getName());
+//                    String valueText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_VALUE.getName());
+//                    String unitText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_UNIT.getName());
+//                    String descText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_DESC.getName());
+//                    String errorText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_ERROR.getName());
+                    datas.add(value);
+                }
+            }
+            item.put(DatagramMetadataEnum.CACHE_METADATA_ELEMENT_CODE.getName(), codeValue);
+            item.put(DatagramMetadataEnum.CACHE_METADATA_DATA.getName(), datas);
+            items.add(item);
+        }
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_DATA.getName(), items);
+
+        log.info("data item :{}", jsonBody.toJSONString());
+        DataProcessorHolder.newInstance().dataProcess.postSwData(jsonBody);
+    }
+}

tsddcs-datacollect-simple/src/main/java/org/ts/ddcs/dataStream/sink/DataStreamSzyRestSink.java

@@ -0,0 +1,87 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2023/8/28
+ */
+package org.ts.ddcs.dataStream.sink;
+
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import lombok.extern.slf4j.Slf4j;
+import org.ts.ddcs.common.metadata.DatagramMetadataEnum;
+import org.ts.ddcs.common.metadata.TaishanV2JsonPackMetadataEnum;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataStream.DataStreamCache;
+import org.ts.ddcs.dataStream.DataStreamLineManager;
+import org.ts.ddcs.main.DataProcessorHolder;
+import org.ts.ddcs.metadata.DataStreamCacheMetadata;
+import org.ts.ddcs.metadata.szy.SzyFlowRateMetadataEnum;
+
+import java.time.ZoneId;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/***
+ * Date:2023/8/28
+ * Title:水资源输出
+ * Description：对本文件的详细描述，原则上不能少于30字
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+@Slf4j
+public class DataStreamSzyRestSink extends DataStreamSink {
+    private DataStreamCache dataStreamCache;
+
+    @Override
+    public void init(DataStreamLineManager context) {
+        this.setContext(context);
+        this.dataStreamCache = context.getCache();
+    }
+
+    @Override
+    public void sink(DataStreamAdapter dataStreamAdapter, List<Map<String, Object>> elementDatas) {
+        log.info("sink {} 接收时间", dataStreamAdapter.getRtuCode(), this.dataStreamCache.getStringValue(DataStreamCacheMetadata.METADATA_PICK_TIME.getName()));
+        Date dt = Date.from(this.dataStreamCache.getPickPacketTime().atZone(ZoneId.systemDefault()).toInstant());
+        JSONObject jsonBody = new JSONObject();
+
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_FROM_TIME.getName(), this.dataStreamCache.getStringValue(DataStreamCacheMetadata.METADATA_PICK_TIME.getName()));
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_UP_TIME.getName(), this.dataStreamCache.getStringValue(DataStreamCacheMetadata.METADATA_UP_TIME.getName()));
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_COLLECT_TIME.getName(), this.dataStreamCache.getStringValue(DataStreamCacheMetadata.METADATA_COLLECT_TIME.getName()));
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_RTU_CODE.getName(), this.dataStreamCache.getRtuCode());
+
+        String datagramCode = this.dataStreamCache.getDatagramCode();
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_DATAGRAM_TYPE.getName(), datagramCode);
+
+        JSONArray items = new JSONArray();
+        for (Map<String, Object> data : elementDatas) {
+            JSONObject item = new JSONObject();
+            String codeValue = (String) data.get(DatagramMetadataEnum.CACHE_METADATA_ELEMENT_CODE.getName());
+            List<Map<String, Object>> keyStore = (List<Map<String, Object>>) data.get(DatagramMetadataEnum.CACHE_METADATA_DATA.getName());
+            JSONArray datas = new JSONArray();
+            if (null != keyStore && keyStore.size() > 0) {
+                for (Map<String, Object> v : keyStore) {
+                    JSONObject value = new JSONObject(v);
+//                    String keyText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_CODE.getName());
+//                    String nameText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_NAME.getName());
+//                    String subCodeText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_SUB_CODE.getName());
+//                    String valueText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_VALUE.getName());
+//                    String unitText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_UNIT.getName());
+//                    String descText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_DESC.getName());
+//                    String errorText = (String) v.get(ElementDataMetadataEnum.ELEMENT_METADATA_ERROR.getName());
+                    datas.add(value);
+                }
+            }
+            item.put(DatagramMetadataEnum.CACHE_METADATA_ELEMENT_CODE.getName(), codeValue);
+            item.put(DatagramMetadataEnum.CACHE_METADATA_DATA.getName(), datas);
+            items.add(item);
+        }
+        jsonBody.put(TaishanV2JsonPackMetadataEnum.PACK_METADATA_DATA.getName(), items);
+
+        log.info("data item :{}", jsonBody.toJSONString());
+        DataProcessorHolder.newInstance().dataProcess.postSzyData(jsonBody);
+    }
+}

tsddcs-datacollect-simple/src/main/java/org/ts/ddcs/rest/RestHttpClient.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2024/3/14
+ */
+package org.ts.ddcs.rest;
+
+import com.alibaba.fastjson.JSONObject;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestTemplate;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/***
+ * Date:2024/3/14
+ * Title:文件所属模块（必须填写）
+ * Description：对本文件的详细描述，原则上不能少于30字
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+@Slf4j
+@Component
+public class RestHttpClient {
+    public JSONObject post(String url, JSONObject data) {
+        RestTemplate restTemplate = new RestTemplate();
+        JSONObject result = null;
+        try {
+            result = restTemplate.postForObject(new URI(url), data, JSONObject.class);
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
+}

tsddcs-datacollect-stream/pom.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>tsddcs</artifactId>
+        <groupId>org.ts.ddcs</groupId>
+        <version>1.0.0.RELEASE</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.ts.ddcs</groupId>
+    <artifactId>tsddcs-datacollect-stream</artifactId>
+    <name>${project.artifactId}</name>
+    <version>1.0.0.RELEASE</version>
+    <packaging>jar</packaging>
+    <description>数据平台-设备数据采集服务</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <!--redis 缓存-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.ts.ddcs</groupId>
+            <artifactId>tsddcs-commonservice</artifactId>
+        </dependency>
+        <!--KAFKA-->
+        <dependency>
+            <groupId>org.springframework.kafka</groupId>
+            <artifactId>spring-kafka</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.kafka</groupId>
+            <artifactId>kafka-streams</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.kafka</groupId>
+            <artifactId>kafka-streams-scala_2.13</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.kafka</groupId>
+            <artifactId>kafka-clients</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+            <version>4.1.66.Final</version>
+        </dependency>
+        <!--<dependency>-->
+            <!--<groupId>com.infiniteautomation</groupId>-->
+            <!--<artifactId>modbus4j</artifactId>-->
+            <!--<version>3.0.3</version>-->
+        <!--</dependency>-->
+        <dependency>
+            <groupId>org.dom4j</groupId>
+            <artifactId>dom4j</artifactId>
+            <version>2.1.1</version>
+        </dependency>
+        <!--<dependency>-->
+            <!--<groupId>org.rocksdb</groupId>-->
+            <!--<artifactId>rocksdbjni</artifactId>-->
+            <!--<version>5.5.1</version>-->
+        <!--</dependency>-->
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-common</artifactId>
+        </dependency>
+
+
+        <!--<dependency>-->
+            <!--<groupId>com.github.tobato</groupId>-->
+            <!--<artifactId>fastdfs-client</artifactId>-->
+        <!--</dependency>-->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+    </dependencies>
+
+
+
+</project>

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/DataCollectStreamApplication.java

@@ -0,0 +1,23 @@
+package org.ts.ddcs;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+
+/**
+ * 主应用入口
+ *
+ * @author dylan
+ */
+@SpringBootApplication
+@EnableScheduling
+public class DataCollectStreamApplication {
+
+    public static ConfigurableApplicationContext configurableApplicationContext;
+
+    public static void main(String[] args) {
+        DataCollectStreamApplication.configurableApplicationContext = SpringApplication.run(DataCollectStreamApplication.class, args);
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/RabbitMQ/DatagramListener.java

@@ -0,0 +1,34 @@
+package  org.ts.ddcs.RabbitMQ;
+
+
+import org.springframework.beans.factory.annotation.Value;
+
+
+//@Component
+public class DatagramListener {
+    @Value("${rabbit.config.queue.toRtuDatagram}")
+    private String sendToRtuDatagram;
+
+   // @RabbitListener(queues = "${rabbit.config.queue.toRtuDatagram}")
+//    @RabbitListener(
+//            bindings = @QueueBinding(
+//                    value = @Queue(value = "${rabbit.config.queue.datagramDownToRtu}"),
+//                    exchange = @Exchange(value = "${rabbit.config.queue.exchange}"),
+//                    key = "${rabbit.config.queue.routingKey}"
+//            )
+//    )
+    public void process(String body) {
+//        try {
+//            if (null != body) {
+//                LogHelper.info("queue sendToRtuDatagram  body:" + body);
+//                JSONObject data = JSONObject.parseObject(body);
+//                String rtuCode = data.getString(GBConstants.BASE_KEY_RTU);
+//                if (null != rtuCode) {
+//                    DataProcessHolder.newInstance().dataProcess.SubmitDownloadDatagramTask(rtuCode);
+//                }
+//            }
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/Worker/DownloadDatagramTask.java

@@ -0,0 +1,256 @@
+package  org.ts.ddcs.Worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.springframework.data.redis.core.HashOperations;
+import org.springframework.data.redis.core.ListOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.kafka.KafkaClient;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.main.DataProcess;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.Callable;
+
+/**
+ * 下行报文到RTU
+ *
+ * @author dylan
+ */
+public class DownloadDatagramTask implements Callable<Integer> {
+
+    private String rtuCode;
+
+    public DownloadDatagramTask(String rtuCode) {
+        this.rtuCode = rtuCode;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        String logId = LogHelper.createLogId("DownloadDatagramTask");
+        try {
+            LogHelper.info(logId + " 下行报文到 " + rtuCode);
+            RedisTemplate redisTemplate = DataProcessHolder.newInstance().dataProcess.redisTemplate;
+            HashOperations<String, String, String> opsHash = redisTemplate.opsForHash();
+            ListOperations<String, String> opsList = redisTemplate.opsForList();
+            if (opsHash.hasKey(rtuCode, "last_connect_id")) {
+                String connectId = opsHash.get(rtuCode, "last_connect_id");
+                DataStreamAdapter dataStreamAdapter = DataChannelHolder.newInstance().dataChannel.getDataTemplateAdapterByKey(connectId);
+                if (null != dataStreamAdapter) {
+//                    String master = null;
+//
+//                    boolean isMaster = false;
+//                    if (opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_SERVER_MASTER)) {
+//                        master = opsHash.get(rtuCode, GBConstants.REDIS_KEY_SERVER_MASTER);
+//                        if (null != master && master.equals(DataProcess.config().getServerId())) {
+//                            isMaster = true;
+//                        }
+//                    }
+                    /**RTU主连接服务器**/
+                    // if (isMaster) {
+                    LogHelper.info(logId + " " + rtuCode  + " process!");
+                    /**升级或下发文件**/
+                    if (opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE)) {
+                        String commandJson = opsHash.get(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE);
+                        LogHelper.info(logId + " " + rtuCode + " down file datagram  " + commandJson);
+                        JSONObject command = JSONObject.parseObject(commandJson);
+                        Date now = new Date();
+                        long lastSendTime = command.getLong("lastSendTime");
+                        long tryCount = command.getLong("tryCount");
+                        String relaydatagram = command.getString(GBConstants.BASE_KEY_DATAGRAM);
+                        if (null != relaydatagram) {
+                            String outDatagram = "";
+                            if (relaydatagram.startsWith("7E7E")) {
+                                String p1 = relaydatagram.substring(0, 32);
+                                String p2 = BytesUtil.byte2HexStr(BytesUtil.getFBTm());
+                                String p3 = relaydatagram.substring(44, relaydatagram.length() - 4);
+                                String body = p1 + p2 + p3;
+                                byte[] bodyBuff = BytesUtil.hexStr2Bytes(body);
+                                byte[] crc16 = BytesUtil.crcFun2014(bodyBuff);
+                                bodyBuff = BytesUtil.arrayApend(bodyBuff, crc16);//CRC16
+                                outDatagram = BytesUtil.byte2HexStr(bodyBuff);
+                            } else {
+                                outDatagram = relaydatagram;
+                            }
+                            dataStreamAdapter.output(BytesUtil.hexStr2Bytes(outDatagram));
+                            LogHelper.info(logId + " " + " relay  to " + rtuCode + " " + relaydatagram);
+                        }
+                        command.put("tryCount", tryCount + 1);
+                        command.put("lastSendTime", now.getTime());
+                        opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE, command.toJSONString());
+                        return 0;
+                    }
+
+                    if (redisTemplate.hasKey(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_FILE)) {
+                        if (opsList.size(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_FILE) > 0) {
+                            if (opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE)) {
+                                opsHash.delete(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE);
+                            }
+                            String commandJson = opsList.leftPop(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_FILE);
+                            LogHelper.info(logId + " " + rtuCode + " down file datagram  " + commandJson);
+                            JSONObject command = JSONObject.parseObject(commandJson);
+                            Date now = new Date();
+                            String relaydatagram = command.getString(GBConstants.BASE_KEY_DATAGRAM);
+                            if (null != relaydatagram) {
+                                String outDatagram = "";
+                                if (relaydatagram.startsWith("7E7E")) {
+                                    String p1 = relaydatagram.substring(0, 32);
+                                    String p2 = BytesUtil.byte2HexStr(BytesUtil.getFBTm());
+                                    String p3 = relaydatagram.substring(44, relaydatagram.length() - 4);
+                                    String body = p1 + p2 + p3;
+                                    byte[] bodyBuff = BytesUtil.hexStr2Bytes(body);
+                                    byte[] crc16 = BytesUtil.crcFun2014(bodyBuff);
+                                    bodyBuff = BytesUtil.arrayApend(bodyBuff, crc16);//CRC16
+                                    outDatagram = BytesUtil.byte2HexStr(bodyBuff);
+                                } else {
+                                    outDatagram = relaydatagram;
+                                }
+                                dataStreamAdapter.output(BytesUtil.hexStr2Bytes(outDatagram));
+                                LogHelper.info(logId + " " + " relay  to " + rtuCode + " " + relaydatagram);
+                            }
+                            long tryCount = 1;
+                            command.put("try", true);
+                            command.put("tryCount", tryCount);
+                            command.put("lastSendTime", now.getTime());
+                            if (command.containsKey("waittingBack")) {
+                                boolean waittingBack = command.getBoolean("waittingBack");
+                                if (waittingBack) {
+                                    opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE, command.toJSONString());
+                                }
+                            } else {
+                                opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_FILE, command.toJSONString());
+                            }
+                            return 0;
+                        }
+                    }
+
+                    if (opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_COMMAND_SETTING)) {
+                        String commandJson = opsHash.get(rtuCode, GBConstants.REDIS_KEY_COMMAND_SETTING);
+                        LogHelper.info(logId + " " + rtuCode + " down setting datagram  " + commandJson);
+                        JSONObject command = JSONObject.parseObject(commandJson);
+                        long tryCount = command.getLong("tryCount");
+                        if (tryCount < 10) {
+                            Date now = new Date();
+                            long lastSendTime = command.getLong("lastSendTime");
+                            long currTime = now.getTime();
+                            String relaydatagram = command.getString(GBConstants.BASE_KEY_DATAGRAM);
+                            if (null != relaydatagram) {
+                                dataStreamAdapter.output(BytesUtil.hexStr2Bytes(relaydatagram));
+                                LogHelper.info(logId + " " + " relay  to " + rtuCode + " " + relaydatagram);
+                            }
+                            command.put("tryCount", tryCount + 1);
+                            command.put("lastSendTime", now.getTime());
+                            opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_SETTING, command.toJSONString());
+                            return 0;
+                        } else {
+                            opsHash.delete(rtuCode, GBConstants.REDIS_KEY_COMMAND_SETTING);
+                        }
+                    }
+
+                    if (redisTemplate.hasKey(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_SETTING)) {
+                        if (opsList.size(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_SETTING) > 0) {
+                            String commandJson = opsList.leftPop(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_SETTING);
+                            LogHelper.info(logId + " " + rtuCode + " down setting datagram  " + commandJson);
+                            JSONObject command = JSONObject.parseObject(commandJson);
+                            Date now = new Date();
+                            String relaydatagram = command.getString(GBConstants.BASE_KEY_DATAGRAM);
+                            if (null != relaydatagram) {
+                                dataStreamAdapter.output(BytesUtil.hexStr2Bytes(relaydatagram));
+                                LogHelper.info(logId + " " + " relay  to " + rtuCode + " " + relaydatagram);
+                            }
+                            long tryCount = 1;
+                            command.put("tryCount", tryCount);
+                            command.put("lastSendTime", now.getTime());
+                            command.put("try", true);
+                            if (command.containsKey("waittingBack")) {
+                                boolean waittingBack = command.getBoolean("waittingBack");
+                                if (waittingBack) {
+                                    opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_SETTING, command.toJSONString());
+                                }
+                            } else {
+                                opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_SETTING, command.toJSONString());
+                            }
+                            return 0;
+                        }
+                    }
+
+                    if (opsHash.hasKey(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY)) {
+                        String commandJson = opsHash.get(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY);
+                        LogHelper.info(logId + " " + rtuCode + " down query datagram  " + commandJson);
+                        JSONObject command = JSONObject.parseObject(commandJson);
+                        long tryCount = command.getLong("tryCount");
+                        if (tryCount < 10) {
+                            Date now = new Date();
+                            long lastSendTime = command.getLong("lastSendTime");
+                            long currTime = now.getTime();
+                            String relaydatagram = command.getString(GBConstants.BASE_KEY_DATAGRAM);
+                            if (null != relaydatagram) {
+                                dataStreamAdapter.output(BytesUtil.hexStr2Bytes(relaydatagram));
+                                LogHelper.info(logId + " " + " relay  to " + rtuCode + " " + relaydatagram);
+                            }
+                            command.put("tryCount", tryCount + 1);
+                            command.put("lastSendTime", now.getTime());
+                            opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY, command.toJSONString());
+                        } else {
+                            opsHash.delete(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY);
+                        }
+                        return 0;
+                    }
+
+                    if (redisTemplate.hasKey(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_QUERY)) {
+                        if (opsList.size(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_QUERY) > 0) {
+                            String commandJson = opsList.leftPop(rtuCode + ":" + GBConstants.REDIS_KEY_COMMAND_QUERY);
+                            LogHelper.info(logId + " " + rtuCode + " down query datagram  " + commandJson);
+                            JSONObject command = JSONObject.parseObject(commandJson);
+                            Date now = new Date();
+                            String relaydatagram = command.getString(GBConstants.BASE_KEY_DATAGRAM);
+                            if (null != relaydatagram) {
+                                dataStreamAdapter.output(BytesUtil.hexStr2Bytes(relaydatagram));
+                                LogHelper.info(logId + " " + " relay  to " + rtuCode + " " + relaydatagram);
+                            }
+                            long tryCount = 1;
+                            command.put("tryCount", tryCount);
+                            command.put("lastSendTime", now.getTime());
+                            command.put("try", true);
+                            if (command.containsKey("waittingBack")) {
+                                boolean waittingBack = command.getBoolean("waittingBack");
+                                if (waittingBack) {
+                                    opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY, command.toJSONString());
+                                }
+                            } else {
+                                opsHash.put(rtuCode, GBConstants.REDIS_KEY_COMMAND_QUERY, command.toJSONString());
+                            }
+                            return 0;
+                        }
+                    }
+                    // }
+                } else {
+                    LogHelper.info(logId + " rtuCode " + rtuCode + " offline");
+                    SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+                    String queue = DataProcess.queueConfig().getServerSelfCheckingMessage();
+                    JSONObject body = new JSONObject();
+                    body.put("messageKind", "2");
+                    JSONObject content = new JSONObject();
+                    content.put("time", timeFormat.format(new Date()));
+                    content.put("serverName", DataProcessHolder.newInstance().dataProcess.serverName);
+                 //   content.put("serverId", DataProcess.config().getServerId());
+                    content.put("rtuCode", rtuCode);
+                    content.put("rtuStatus", "offline");
+                    body.put("message", content.toJSONString());
+                    KafkaClient.messageSubmit(queue, body.toJSONString());
+                }
+            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        } finally {
+            LogHelper.info(logId + " 下行报文下发操作已完成");
+        }
+        return 0;
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/Worker/RelayDatagramTask.java

@@ -0,0 +1,38 @@
+package  org.ts.ddcs.Worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.kafka.KafkaClient;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.main.DataProcess;
+
+
+import java.util.concurrent.Callable;
+
+/**
+ * 转发报文到处理服务器
+ * @author dylan
+ */
+public class RelayDatagramTask implements Callable<Integer> {
+    private JSONObject body;
+
+    public RelayDatagramTask(JSONObject body) {
+        this.body = body;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        String logId = LogHelper.createLogId("RelayDatagramTask");
+        try {
+            LogHelper.info(logId + " 即将转发报文:" + body.toJSONString());
+         //   body.put(GBConstants.REDIS_KEY_COLLECT_SERVER, DataProcess.config().getServerId());
+            String queue = DataProcess.queueConfig().getWaitingToProcessDatagram();
+            KafkaClient.messageSubmit(queue, body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(logId,e);
+        } finally {
+            LogHelper.info(logId + " 已通过 MQ 成功转发报文");
+        }
+        return 0;
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/Worker/WarningInfoNotifyWorker.java

@@ -0,0 +1,62 @@
+package  org.ts.ddcs.Worker;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.kafka.KafkaClient;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.main.DataProcess;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.Callable;
+
+
+/**
+ * @author dylan
+ */
+public class WarningInfoNotifyWorker implements Callable<Integer> {
+    private String agreement;
+    private String rtuCode;
+    private String datagram;
+    private String warningKind;
+    private String warningInfo;
+    private Date checkTime;
+
+    public WarningInfoNotifyWorker(Date checkTime, String agreement, String rtuCode, String warningKind, String datagram, String warningInfo) {
+        this.checkTime = checkTime;
+        this.agreement = agreement;
+        this.rtuCode = rtuCode;
+        this.datagram = datagram;
+        this.warningKind = warningKind;
+        this.warningInfo = warningInfo;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        String logId = LogHelper.createLogId("WarningInfoNotifyWorker");
+        try {
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_WARNING_CHECK_TIME, timeFormat.format(this.checkTime));
+            if (null != this.agreement) {
+                body.put(GBConstants.BASE_KEY_AGREEMENT, this.agreement);
+            }
+            if (null != this.rtuCode) {
+                body.put(GBConstants.BASE_KEY_RTU, this.rtuCode);
+            }
+            body.put(GBConstants.BASE_KEY_DATAGRAM, this.datagram);
+            body.put(GBConstants.BASE_KEY_WARNING_KIND, this.warningKind);
+            if (null != this.warningInfo) {
+                body.put(GBConstants.BASE_KEY_WARNING_INFO, this.warningInfo);
+            }
+            body.put(GBConstants.BASE_KEY_WARNING_STATUS, GBConstants.WARNING_STATUS_HAPPEN);
+            String queue = DataProcess.queueConfig().getWarningMessage();
+            KafkaClient.messageSubmit(queue, body.toJSONString());
+            LogHelper.info(logId + " warning notify " + queue + " " + this.rtuCode + " " + this.datagram + " " + this.warningKind + " " + this.warningInfo);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+        return 0;
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/config/Config.java

@@ -0,0 +1,25 @@
+package  org.ts.ddcs.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+
+@Component
+public class Config {
+    @Autowired
+    public ServerConfig serverConfig;
+
+    private static class ServerConfigInstanceHolder {
+        private static Config instance = new Config();
+    }
+
+    public static Config newInstance() {
+        return Config.ServerConfigInstanceHolder.instance;
+    }
+
+    @PostConstruct
+    void init() {
+        Config.newInstance().serverConfig = serverConfig;
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/config/MqQueueConfig.java

@@ -0,0 +1,18 @@
+package  org.ts.ddcs.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author dylan
+ */
+@Component
+@ConfigurationProperties(prefix = "run-config.mq", ignoreUnknownFields = false)
+@Data
+public class MqQueueConfig {
+    private String waitingToProcessDatagram;
+    private String toRtuDatagram;
+    private String warningMessage;
+    private String serverSelfCheckingMessage;
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/config/ServerConfig.java

@@ -0,0 +1,21 @@
+package  org.ts.ddcs.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author dylan
+ */
+@Component
+@Configuration
+@ConfigurationProperties(prefix = "run-config.server", ignoreUnknownFields = false)
+@Data
+public class ServerConfig {
+    private String tcpPort;
+    private String udpPort;
+    private String templatesDir;
+    private String templates;
+    private String tmpDir;
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/constant/NetPortStatus.java

@@ -0,0 +1,6 @@
+package org.ts.ddcs.constant;
+
+public class NetPortStatus {
+  public final static String ON = "ON";
+  public final static String OFF = "OFF";
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/controller/TestController.java

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2022/10/27
+ */
+package org.ts.ddcs.controller;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+
+/***
+ * Date:2022/10/27
+ * Title:文件所属模块（必须填写）
+ * Description：对本文件的详细描述，原则上不能少于30字
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+@RestController
+public class TestController {
+    @GetMapping(value = "collect/test")
+    public String toTest() {
+        try {
+            // 1.定义服务器的地址、端口号、数据
+            InetAddress address = InetAddress.getByName("localhost");
+            // 2.定义服务器端口
+            int port = 8002;
+
+            // 3.创建发送端对象：发送端自带默认端口号
+            DatagramSocket socket = new DatagramSocket(2222);
+
+            // 4.客户端启动成功，输出提示信息
+            System.out.println("****客户端启动成功****");
+            String msg ="7E7E01005128290300002F20080230522230271439160396987E7E01005128290300002F0008023052221027144016034F497E7E01005128290300002F0008023052221027144116038F187E7E01005128290300002F0008023052221027144216038FE87E7E01005128290300002F0008023052221027144316034FB97E7E01005128290300002F0008023052221027144416038E087E7E01005128290300002F0008023052221027144516034E597E7E01005128290300002F0008023052221027144616034EA97E7E01005128290300002F0008023052221027144716038EF8";
+            byte[] buffer= BytesUtil.hexStr2Bytes(msg);
+
+            DatagramPacket packets = new DatagramPacket(buffer, buffer.length, address, port);
+            // 5.4 发送数据出去
+            socket.send(packets);
+
+            while (true) {
+                byte[] buf = new byte[1024 * 64];
+                DatagramPacket packet = new DatagramPacket(buf, buf.length);
+                // 6.2 接收服务器响应的数据
+                socket.receive(packet);
+                // 6.3 取出数据
+                int len = packet.getLength();
+                if (len >0) {
+                    String rs = new String(buf, 0, len);
+                    System.out.println("收到了ip为：" + packet.getAddress() + " 端口号为：" + packet.getPort() + "的消息：" + rs);
+                    break;
+                }
+            }
+            socket.close();
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+        return "ok";
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataItemTemplateCache.java

@@ -0,0 +1,87 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2022/12/27
+ */
+package org.ts.ddcs.dataStream;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/***
+ * Date:2022/12/27
+ * Title:文件所属模块（必须填写）
+ * Description：对本文件的详细描述，原则上不能少于30字
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+
+public class DataItemTemplateCache {
+    private byte[] dataBuff;
+    private int readSize;
+    private Map<String, Object> keyStore = new HashMap<>();
+
+    public void setDataBuff(byte[] data) {
+        this.dataBuff = data;
+    }
+
+    public int remainDataSize() {
+        if (null != this.dataBuff) {
+            if (this.readSize == this.dataBuff.length) {
+                return 0;
+            }
+            return this.dataBuff.length - this.readSize;
+        }
+        return 0;
+    }
+
+    public void readIndex(int readSize) {
+        this.readSize = readSize;
+    }
+
+    public void readSize(int readSize) {
+        this.readSize = this.readSize + readSize;
+    }
+
+    public void resetStore(){
+        this.keyStore.clear();
+    }
+
+    public byte getByte() throws NullPointerException, IndexOutOfBoundsException {
+        return this.dataBuff[this.readSize];
+    }
+
+    public byte[] getBytes(int length) throws NullPointerException, IndexOutOfBoundsException {
+        byte[] buf = new byte[length];
+        System.arraycopy(this.dataBuff, this.readSize, buf, 0, length);
+        return buf;
+    }
+
+    public byte getByte(int pos) throws NullPointerException, IndexOutOfBoundsException {
+        return this.dataBuff[pos];
+    }
+
+    public byte[] getBytes(int pos, int length) throws NullPointerException, IndexOutOfBoundsException {
+        byte[] buf = new byte[length];
+        System.arraycopy(this.dataBuff, pos, buf, 0, length);
+        return buf;
+    }
+
+    public void addValue(String key, Object value) {
+        this.keyStore.put(key, value);
+    }
+
+    public Set<String> keys() {
+        return this.keyStore.keySet();
+    }
+
+    public Object getValue(String key) {
+        return this.keyStore.get(key);
+    }
+    public boolean hasValue(String key){
+        return  this.keyStore.containsKey(key);
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataSteam.java

@@ -0,0 +1,61 @@
+package  org.ts.ddcs.dataStream;
+import org.ts.ddcs.datatemplate.Template;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 数据流
+ * @author dylan
+ */
+@Data
+public class DataSteam implements DataStreamInterface {
+    public byte[] dataBuff;
+    public DataTemplateInterface takecareTemplates;
+    public List<DataProcesserInterface> dataProcesser;
+    public Template template;
+
+    @Override
+    public int dataSize() {
+        if (null != dataBuff) {
+            return dataBuff.length;
+        }
+        return 0;
+    }
+
+    @Override
+    public byte getByte(int pos) {
+        if (dataBuff != null && pos < dataBuff.length) {
+            byte byteValue = dataBuff[pos];
+            return byteValue;
+        }
+        return 0x00;
+    }
+
+    @Override
+    public byte[] getBytes(int length) {
+        if (dataBuff != null && dataBuff.length >= length) {
+            byte[] buf = new byte[length];
+            System.arraycopy(dataBuff, 0, buf, 0, length);
+            return buf;
+        }
+        return null;
+    }
+
+    @Override
+    public byte[] getBytes(int pos, int length) {
+        if (dataBuff != null && dataBuff.length >= (pos + length)) {
+            byte[] buf = new byte[length];
+            System.arraycopy(dataBuff, pos, buf, 0, length);
+            return buf;
+        }
+        return null;
+    }
+
+    @Override
+    public DataTemplateInterface getDataTemplate() {
+        return this.takecareTemplates;
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamAdapter.java

@@ -0,0 +1,216 @@
+package  org.ts.ddcs.dataStream;
+
+import lombok.extern.slf4j.Slf4j;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.net.DataChannelHolder;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.socket.DatagramPacket;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+
+/**
+ * 适配器，用于连接网络接口与数据处理器
+ *
+ * @author dylan
+ */
+@Slf4j
+public abstract class DataStreamAdapter {
+
+    protected LinkedBlockingQueue<byte[]> blockQueue = new LinkedBlockingQueue<>();
+
+    private byte[] remainBuff = new byte[0];
+
+    protected ChannelHandlerContext ctx;
+
+
+    /**
+     * 连接创建时间
+     */
+    private Date createTime;
+
+ //   private String channelType;
+
+    public Map<String, Object> keyStore = new ConcurrentHashMap<>();
+
+    protected String remoteIp;
+    protected String rtuCode;
+    protected String adapterKey;
+    protected String dataStreamLineKey;
+    private boolean isClose = false;
+    private int waitingProcessBlocks = 0;
+
+    public DataStreamAdapter() {
+      //  this.channelType = dataChannelType;
+        this.adapterKey = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+    }
+
+    public void init(String remoteIp) {
+        log.info("{} 初始化连接 ip {}",this.adapterKey,remoteIp);
+        this.remoteIp = remoteIp;
+        this.createTime = new Date();
+        DataStreamManageHolder.newInstance().dataStreamManager.regConnect(this);
+         DataChannelHolder.newInstance().dataChannel.online(this);
+    }
+
+    public boolean isClose() {
+        return this.isClose;
+    }
+
+    public String getCode() {
+        return this.rtuCode;
+    }
+
+    public void setCode(String code) {
+        this.rtuCode = code;
+    }
+
+    public String getAdapterKey() {
+        return this.adapterKey;
+    }
+
+    boolean processComplete() {
+        if (remainBuff != null && remainBuff.length > 0) {
+            return false;
+        }
+        return true;
+    }
+
+    void setDataStreamLineKey(String dataStreamLineKey) {
+        this.dataStreamLineKey = dataStreamLineKey;
+    }
+
+    String getDataStreamLineKey() {
+        return this.dataStreamLineKey;
+    }
+
+    public byte[] getBlock() {
+        try {
+            if (null == blockQueue) {
+                return new byte[0];
+            }
+            byte[] blockBuff = new byte[0];
+            if (remainBuff.length > 0) {
+                blockBuff = new byte[remainBuff.length];
+                System.arraycopy(remainBuff, 0, blockBuff, 0, remainBuff.length);
+            }
+            if (!blockQueue.isEmpty()) {
+                byte[] block = blockQueue.poll();
+                if (blockBuff.length > 0) {
+                    byte[] tmpBuff = new byte[blockBuff.length + block.length];
+                    System.arraycopy(blockBuff, 0, tmpBuff, 0, blockBuff.length);
+                    System.arraycopy(block, 0, tmpBuff, blockBuff.length, block.length);
+                    blockBuff = tmpBuff;
+                } else {
+                    blockBuff = block;
+                }
+            }
+            remainBuff = new byte[blockBuff.length];
+            System.arraycopy(blockBuff, 0, remainBuff, 0, blockBuff.length);
+            return blockBuff;
+        } catch (Exception e) {
+            log.error(this.getClass().getName(),e);
+            return new byte[0];
+        }
+    }
+
+    public byte[] getBlock(int index) {
+        try {
+            if (null == remainBuff) {
+                return new byte[0];
+            }
+            byte[] blockBuff = new byte[0];
+            if (remainBuff.length >= index) {
+                blockBuff = new byte[index];
+                System.arraycopy(remainBuff, 0, blockBuff, 0, index);
+            }
+            return blockBuff;
+        } catch (Exception e) {
+            log.error(this.getClass().getName(),e);
+            return new byte[0];
+        }
+    }
+
+    void readIndex(int index) {
+        if (index >= remainBuff.length) {
+            remainBuff = new byte[0];
+        } else {
+            byte[] tmpBuff = new byte[remainBuff.length - index];
+            System.arraycopy(remainBuff, index, tmpBuff, 0, remainBuff.length - index);
+            remainBuff = tmpBuff;
+        }
+    }
+
+    public Date getCreateTime() {
+        return this.createTime;
+    }
+
+
+    public void close() {
+        log.info("{} 连接关闭",this.adapterKey );
+        DataChannelHolder.newInstance().dataChannel.offline(this);
+        this.ctx = null;
+        this.isClose = true;
+        if (null == this.remainBuff || this.remainBuff.length == 0) {
+            DataStreamManageHolder.newInstance().dataStreamManager.closeConnect(this);
+        }
+    }
+
+
+    int getWaitingProcessBlocksCount() {
+        return this.waitingProcessBlocks;
+    }
+
+    void resetWaitingProcessBlocksCount() {
+        this.waitingProcessBlocks = 0;
+    }
+
+    void addWaitingProcessBlocksCount() {
+        this.waitingProcessBlocks++;
+    }
+
+    int moveToNext(String agreement) {
+//        if (null != agreement && agreement.equals(GBConstants.AGREEMENT_KIND_SW)) {
+//            for (int i = 3; i < this.remainBuff.length; i++) {
+//                if (this.remainBuff[i - 1] == 0x7E && this.remainBuff[i] == 0x7E) {
+//                    return i - 1;
+//                }
+//            }
+//        } else if (null != agreement && agreement.equals(GBConstants.AGREEMENT_KIND_SZY)) {
+//            for (int i = 5; i < this.remainBuff.length; i++) {
+//                if (this.remainBuff[i - 2] == 0x68 && this.remainBuff[i] == 0x68) {
+//                    return i - 2;
+//                }
+//            }
+//        }
+        return 0;
+    }
+
+
+    /**
+     * 输出到数据连接通道
+     *
+     * @param respBody
+     */
+    public abstract void output(byte[] respBody);
+
+    /**
+     * UDP数据包
+     *
+     * @param buf
+     * @param cx
+     * @param datagramPacket
+     */
+    public abstract void pushData(ByteBuf buf, ChannelHandlerContext cx, DatagramPacket datagramPacket);
+
+    /**
+     * TCP数据包
+     *
+     * @param buf
+     * @param cx
+     */
+    public abstract void pushData(ByteBuf buf, ChannelHandlerContext cx);
+
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamCache.java

@@ -0,0 +1,119 @@
+
+package org.ts.ddcs.dataStream;
+
+import lombok.NoArgsConstructor;
+
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 数据缓存
+ *
+ * @author swp
+ */
+@NoArgsConstructor
+public abstract class DataStreamCache {
+    private TestState state = TestState.LOOK;
+    private byte[] dataBuff;
+    private int readSize;
+    private Map<String, Object> keyStore = new HashMap<>();
+
+    public byte[] getDataBuff() {
+        return this.dataBuff;
+    }
+
+    public void setDataBuff(byte[] dataBuff) {
+        this.dataBuff = dataBuff;
+    }
+
+    public void resetStore() {
+        this.keyStore.clear();
+    }
+
+    public TestState getState() {
+        return this.state;
+    }
+
+    public void setState(TestState testState) {
+        this.state = testState;
+    }
+
+    public int remainDataSize() {
+        if (null != this.dataBuff) {
+            if (this.readSize == this.dataBuff.length) {
+                return 0;
+            }
+            return this.dataBuff.length - this.readSize;
+        }
+        return 0;
+    }
+
+    public void readIndex(int readSize) {
+        this.readSize = readSize;
+    }
+
+    public void readSize(int readSize) {
+        this.readSize = this.readSize + readSize;
+    }
+
+    public byte getByte() throws NullPointerException, IndexOutOfBoundsException {
+        return this.dataBuff[this.readSize];
+    }
+
+    public byte[] getBytes(int length) throws NullPointerException, IndexOutOfBoundsException {
+        byte[] buf = new byte[length];
+        System.arraycopy(this.dataBuff, this.readSize, buf, 0, length);
+        return buf;
+    }
+
+    public byte getByte(int pos) throws NullPointerException, IndexOutOfBoundsException {
+        return this.dataBuff[pos];
+    }
+
+    public byte[] getBytes(int pos, int length) throws NullPointerException, IndexOutOfBoundsException {
+        byte[] buf = new byte[length];
+        System.arraycopy(this.dataBuff, pos, buf, 0, length);
+        return buf;
+    }
+
+    public void addValue(String key, Object value) {
+        this.keyStore.put(key, value);
+    }
+
+    public Set<String> keys() {
+        return this.keyStore.keySet();
+    }
+
+    public Object getValue(String key) {
+        return this.keyStore.get(key);
+    }
+
+    public Object getItemValue(String key) {
+//        Object itemTemplateCacheObj = this.keyStore.get(BusinessConstant.SW_DATA_STREAM_CACHE_VALUE);
+//        if (null != itemTemplateCacheObj) {
+//            if (itemTemplateCacheObj instanceof DataItemTemplateCache) {
+//                DataItemTemplateCache itemTemplateCache = (DataItemTemplateCache) itemTemplateCacheObj;
+//                return itemTemplateCache.getValue(key);
+//            }
+//        }
+        return null;
+    }
+
+    public abstract void setPacketBuff(byte[] buff);
+
+    public abstract byte[] getPacketBuff();
+
+    public abstract void setPacketLen(int len);
+
+    public abstract int getPacketLen();
+
+    public abstract void setBodyBuff(byte[] buff);
+
+    public abstract byte[] getBodyBuff();
+
+    public abstract int getBodyLen();
+
+    public abstract byte[] getDeviceCodeBuff();
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamCommonProcessor.java

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2021/12/16
+ */
+package  org.ts.ddcs.dataStream;
+
+
+
+/***
+ * Date:2021/12/16
+ * Title:数据匹配器模块
+ * Description：每个适配器处理器
+ * @author dylan
+ * @mender：（文件的修改者，文件创建者之外的人）
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+public class DataStreamCommonProcessor extends DataStreamProcessor {
+
+    @Override
+    public void process(DataStreamCache dataStreamCache) {
+//        LogHelper.info("process " + this.templateLineNode.dataTemplate.getName());
+//        DataSteam dataSteam = context.dataSteam();
+//        this.reset();
+//        templateLineNode.dataTemplate.ready();
+//        templateLineNode.dataTemplate.stream(dataSteam);
+//        if (templateLineNode.dataTemplate.state() == TestState.LOOK) {
+//            dataSteam.takecareTemplates = templateLineNode.dataTemplate;
+//            dataSteam.dataProcesser = templateLineNode.dataProcessor;
+//        } else if (templateLineNode.dataTemplate.state() == TestState.MATHCE) {
+//            dataSteam.takecareTemplates = templateLineNode.dataTemplate;
+//            dataSteam.dataProcesser = templateLineNode.dataProcessor;
+//        } else {
+//            dataSteam.takecareTemplates = templateLineNode.dataTemplate;
+//            dataSteam.dataProcesser = templateLineNode.dataProcessor;
+//            this.forward();
+//        }
+    }
+
+    @Override
+    public void batchComplete(DataStreamCache dataStreamCache) {
+      //  LogHelper.info("complete " + this.templateLineNode.dataTemplate.getName());
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamFileProcessor.java

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2021/12/16
+ */
+package  org.ts.ddcs.dataStream;
+
+
+
+/***
+ * Date:2021/12/16
+ * Title:数据匹配器模块
+ * Description：文件包处理器
+ * @author dylan
+ * @mender：（文件的修改者，文件创建者之外的人）
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+public class DataStreamFileProcessor extends DataStreamProcessor {
+
+    @Override
+    public void process(DataStreamCache dataStreamCache) {
+
+
+    }
+
+    @Override
+    public void batchComplete(DataStreamCache dataStreamCache) {
+
+
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamInterface.java

@@ -0,0 +1,18 @@
+package  org.ts.ddcs.dataStream;
+
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+
+/**
+ * created by swp on 2017/8/30
+ */
+public interface DataStreamInterface {
+    public abstract int dataSize();
+
+    public abstract byte getByte(int pos);
+
+    public abstract byte[] getBytes(int length);
+
+    public abstract byte[] getBytes(int pos, int length);
+
+    public abstract DataTemplateInterface getDataTemplate();
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamLineManager.java

@@ -0,0 +1,158 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2022/3/25
+ */
+package org.ts.ddcs.dataStream;
+
+import lombok.Data;
+
+import org.ts.ddcs.datatemplate.DataTemplate;
+import org.ts.ddcs.datatemplate.TestState;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.util.LinkedList;
+import java.util.List;
+
+
+/***
+ * Date:2022/3/25
+ * Title:数据流处理链
+ * Description：数据链处理管理器
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+@Data
+public class DataStreamLineManager {
+    /**
+     * 线程工厂
+     */
+    //  private static ThreadFactory streamLineThreadFactory = new ThreadFactoryBuilder().setNameFormat("stream-process-pool-%d").build();
+    /**
+     * 数据流线程池
+     */
+    //  private ExecutorService dataStreamThreadPool = new ThreadPoolExecutor(1, 1,
+    //         0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1024), streamLineThreadFactory, new ThreadPoolExecutor.AbortPolicy());
+
+
+    private int bindAgreeementCode;
+
+    public DataStreamLineManager(int agreementCode) {
+        this.bindAgreeementCode = agreementCode;
+//        if (this.bindAgreeementCode == AgreementEnum.getCode(GBConstants.AGREEMENT_KIND_SW)) {
+//            dataStreamCache = new SwDataStreamCache();
+//        } else if (this.bindAgreeementCode == AgreementEnum.getCode(GBConstants.AGREEMENT_KIND_SZY)) {
+//            dataStreamCache = new SzyDataStreamCache();
+//        }
+
+    }
+
+    private List<DataStreamProcessor> processors = new LinkedList<>();
+
+    //   private DataSteam dataSteam = new DataSteam();
+
+    // public DataSteam dataSteam() {
+    //  return this.dataSteam;
+    //'\  }
+
+    /**
+     * 添加处理器
+     *
+     * @param processor    处理器
+     * @param dataTemplate 模板
+     */
+    public void addProcessor(DataStreamProcessor processor, DataTemplate dataTemplate) {
+        if (processors.size() > 0) {
+            processor.setPreProcessor(processors.get(processors.size() - 1));
+            processors.get(processors.size() - 1).setNextProcessor(processor);
+        }
+        processors.add(processor);
+        processor.init(this, dataTemplate);
+    }
+
+
+//    public void source(DataStreamAdapter dataStreamAdapter) {
+//        dataStreamThreadPool.execute(new ProcessorTask(dataStreamAdapter));
+//    }
+
+    public void match(byte[] dataBuf) {
+        LogHelper.info("待处理数据包 " + BytesUtil.byte2HexStr(dataBuf));
+//        this.dataStreamCache.pushDataBuff(dataBuf);
+//        processors.get(0).stream(this.dataStreamCache);
+    }
+
+    /**
+     * 处理任务
+     */
+    private class ProcessorTask implements Runnable {
+
+        DataStreamAdapter dataStreamAdapter;
+
+        ProcessorTask(DataStreamAdapter dataStreamAdapter) {
+            this.dataStreamAdapter = dataStreamAdapter;
+        }
+
+        @Override
+        public void run() {
+//            int readIndex = 0;
+//            try {
+//                byte[] block = dataStreamAdapter.getBlock();
+//                if (block.length == 0) {
+//                    return;
+//                }
+//                LogHelper.info(dataStreamAdapter.getAdapterKey() + " 待处理数据包 " + BytesUtil.byte2HexStr(block));
+//                dataSteam.dataBuff = block;
+//                dataSteam.takecareTemplates = null;
+//                dataSteam.dataProcesser = null;
+//                processors.get(0).stream(dataStreamAdapter);
+//                if (dataSteam.takecareTemplates.state() == TestState.LOOK) {
+//                    //数据报文异常,需要抛弃当前包，定位到下一个报文
+//                    if (dataStreamAdapter.getWaitingProcessBlocksCount() >= 10) {
+//                        LogHelper.info(dataStreamAdapter.getAdapterKey() + " 数据异常 当前处理流程被卡住!!!");
+//                        readIndex = dataStreamAdapter.moveToNext(dataSteam.takecareTemplates.agreement());
+//                        if (readIndex == 0) {
+//                            //找不到下一个包，直接把当前包抛弃
+//                            readIndex = block.length;
+//                        }
+//                        dataStreamAdapter.resetWaitingProcessBlocksCount();
+//                        //记录解析异常的报文
+//                        byte[] errorDatagram = dataStreamAdapter.getBlock(readIndex);
+//                        LogHelper.info(dataStreamAdapter.getAdapterKey() + " 异常报文 " + BytesUtil.byte2HexStr(errorDatagram));
+//                    } else {
+//                        dataStreamAdapter.addWaitingProcessBlocksCount();
+//                    }
+//                } else if (dataSteam.takecareTemplates.state() == TestState.MATHCE) {
+//                    //匹配到一个模板
+//                    LogHelper.info(dataStreamAdapter.getAdapterKey() + " 匹配到一个模板：" + dataSteam.takecareTemplates.getName());
+//                    if (dataSteam.dataProcesser != null && dataSteam.dataProcesser.size() > 0) {
+//                        for (int i = 0; i < dataSteam.dataProcesser.size(); i++) {
+//                            dataSteam.takecareTemplates.bridgeDataProcessor(dataSteam.dataProcesser.get(i), dataStreamAdapter);
+//                        }
+//                    }
+//                    readIndex = dataSteam.takecareTemplates.length();
+//                    dataStreamAdapter.resetWaitingProcessBlocksCount();
+//                    //LogHelper.info("match ");
+//                } else if (dataSteam.takecareTemplates.state() == TestState.UNKNOWN) {
+//                    LogHelper.info(dataStreamAdapter.getAdapterKey() + " 未匹配到可用模板：" + dataSteam.takecareTemplates.getName());
+//                    readIndex = dataSteam.takecareTemplates.length();
+//                    dataStreamAdapter.resetWaitingProcessBlocksCount();
+//                } else {
+//                    LogHelper.info(dataStreamAdapter.getAdapterKey() + " *********************不可能出现的故障，没有任何模板匹配！*********************");
+//                }
+//                dataStreamAdapter.readIndex(readIndex);
+//                byte[] reminblock = dataStreamAdapter.getBlock();
+//                if (reminblock.length > 0) {
+//                    LogHelper.info(dataStreamAdapter.getAdapterKey() + " 未处理数据包 " + BytesUtil.byte2HexStr(reminblock));
+//                }
+//            } catch (Exception e) {
+//                e.printStackTrace();
+//                LogHelper.error(e);
+//            } finally {
+//                LogHelper.info(dataStreamAdapter.getAdapterKey() + " *********************任务结束！*********************");
+//            }
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamManageHolder.java

@@ -0,0 +1,19 @@
+package  org.ts.ddcs.dataStream;
+
+
+/**
+ * 数据流主模块实例
+ *
+ * @author dylan
+ */
+public class DataStreamManageHolder {
+    private static class InstanceHolder {
+        static DataStreamManageHolder instance = new DataStreamManageHolder();
+    }
+
+    public static DataStreamManageHolder newInstance() {
+        return DataStreamManageHolder.InstanceHolder.instance;
+    }
+
+    public DataStreamManager dataStreamManager;
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamManager.java

@@ -0,0 +1,255 @@
+package org.ts.ddcs.dataStream;
+
+
+import com.alibaba.fastjson.JSONObject;
+
+import org.ts.ddcs.common.enums.AgreementEnum;
+import org.ts.ddcs.datatemplate.DataTemplateManageHolder;
+import org.ts.ddcs.datatemplate.Template;
+import org.ts.ddcs.datatemplate.TemplateLineNode;
+import org.ts.ddcs.kafka.KafkaClient;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.*;
+
+
+/**
+ * 数据流主模块
+ *
+ * @author dylan
+ */
+public class DataStreamManager {
+
+    /**
+     * 数据流工作线程数量
+     */
+  //  private static final int STREAM_THREAD_NUM = 4;
+
+    /**
+     * 数据块队列
+     */
+ //   private LinkedBlockingQueue<Map<String, Object>> blockQueue = new LinkedBlockingQueue<Map<String, Object>>(1024);
+
+    /**
+     * 连接适配器
+     */
+    private Map<String, DataStreamAdapter> dataStreamAdapterCache = new ConcurrentHashMap<>(1024);
+
+    /**
+     * 数据链压力记录
+     */
+  //  private Map<String, Integer> dataStreamStreesCache = new ConcurrentHashMap<>(STREAM_THREAD_NUM);
+
+    /**
+     * 模板处理器链
+     */
+    private Map<Integer, DataStreamLineManager> streamLineCache = new ConcurrentHashMap<>();
+
+    /**
+     * 公共线程池
+     **/
+//    private static ThreadFactory batchThreadFactory = new ThreadFactoryBuilder().setNameFormat("batch-thread-pool-%d").build();
+//    private static ExecutorService batchThreadPool = new ThreadPoolExecutor(1, 1,
+//            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1024), batchThreadFactory, new ThreadPoolExecutor.AbortPolicy());
+
+
+    /**
+     * 任务定时器
+     */
+   // private ScheduledExecutorService scheduleExecutor = Executors.newSingleThreadScheduledExecutor(r -> new Thread(r, "batch-stream-task-" + r.hashCode()));
+
+
+    /**
+     * 数据流管理器初始化
+     */
+    public void init(String templates) {
+//        String[] list = templates.split(",");
+//        if (list.length > 0) {
+//            for (String t : list) {
+//                DataStreamLineManager lineManager = new DataStreamLineManager(AgreementEnum.getCode(t));
+//                List<TemplateLineNode> nodes = DataTemplateManageHolder.newInstance().dataTemplateManager.cloneTemplateLineNode(AgreementEnum.getCode(t));
+//                for (TemplateLineNode node : nodes
+//                ) {
+//                    lineManager.addProcessor(node.dataStreamProcessor, node);
+//                }
+//                streamLineCache.put(AgreementEnum.getCode(t), lineManager);
+//            }
+//        }
+
+
+
+
+
+
+//        try {
+            //this.initDataStream();
+//            this.scheduleExecutor.scheduleWithFixedDelay(() -> {
+//                try {
+//                    long tm = System.currentTimeMillis();
+//                    BatchDataStreamTask task = new BatchDataStreamTask(tm);
+//                    FutureTask<Integer> futureTask = new FutureTask<>(task);
+//                    batchThreadPool.execute(futureTask);
+//                } catch (Exception e) {
+//                    LogHelper.error(e);
+//                }
+//            }, 0, 100, TimeUnit.MILLISECONDS);
+
+
+//        } catch (Exception e) {
+//            LogHelper.error(e);
+//            throw e;
+//        }
+    }
+
+//    private class BatchDataStreamTask implements Callable<Integer> {
+//
+//        private long batchTm;
+//
+//        BatchDataStreamTask(long batchTm) {
+//            this.batchTm = batchTm;
+//        }
+//
+//        @Override
+//        public Integer call() {
+//            try {
+//                Map<String, String> streamMap = new HashMap<>();
+//                for (int i = 1; i <= STREAM_THREAD_NUM; i++) {
+//                    if (blockQueue.isEmpty()) {
+//                        break;
+//                    }
+//                    Map<String, Object> block = blockQueue.poll();
+//                    String adapterKey = (String) block.get("adapterKey");
+//                    String filterKey = (String) block.get("filterKey");
+//                    dataStreamStreesCache.put(filterKey, dataStreamStreesCache.get(filterKey) + 1);
+//                    DataStreamLineManager lineManager = streamLineCache.get(filterKey);
+//                    DataStreamAdapter dataStreamAdapter = dataStreamAdapterCache.get(adapterKey);
+//                    lineManager.source(dataStreamAdapter);
+//                    streamMap.put(dataStreamAdapter.getAdapterKey(), dataStreamAdapter.getAdapterKey());
+//                }
+//                Set<String> keySet = dataStreamAdapterCache.keySet();
+//
+//                for (String key : keySet) {
+//                    if (!streamMap.containsKey(key)) {
+//                        DataStreamAdapter dataStreamAdapter = dataStreamAdapterCache.get(key);
+//                        if (!dataStreamAdapter.processComplete()) {
+//                            String filterKey = dataStreamAdapter.getDataStreamLineKey();
+//                            dataStreamStreesCache.put(filterKey, dataStreamStreesCache.get(filterKey) + 1);
+//                            DataStreamLineManager lineManager = streamLineCache.get(filterKey);
+//                            lineManager.source(dataStreamAdapter);
+//                        }
+//                    }
+//                }
+//
+//
+//                long ut = System.currentTimeMillis() - batchTm;
+//                if (ut > 100) {
+//                    LogHelper.info("task time too long !!!!!!!!!!!!!!!");
+//                }
+//            } catch (Exception e) {
+//                LogHelper.error(e);
+//            }
+//            return 0;
+//        }
+//    }
+
+
+    /**
+     * 注册连接
+     *
+     * @param adapter
+     */
+    void regConnect(DataStreamAdapter adapter) {
+        try {
+//        String allocateFilterKey = "01";
+//        int minStreesValue = dataStreamStreesCache.get("01");
+//        for (int i = 2; i <= STREAM_THREAD_NUM; i++) {
+//            String filterKey = String.format("%02d", i);
+//            int tmpStreesValue = dataStreamStreesCache.get(filterKey);
+//            if (tmpStreesValue < minStreesValue) {
+//                minStreesValue = tmpStreesValue;
+//                allocateFilterKey = filterKey;
+//            }
+//        }
+//        adapter.setDataStreamLineKey(allocateFilterKey);
+            //if (!dataStreamAdapterCache.containsKey(adapter.getAdapterKey())) {
+            dataStreamAdapterCache.put(adapter.getAdapterKey(), adapter);
+            //}
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 关闭连接
+     *
+     * @param adapter
+     */
+    public void closeConnect(DataStreamAdapter adapter) {
+
+      //  try {
+       //     KafkaStream.clearKeyValue(adapter.getAdapterKey());
+            //if (dataStreamAdapterCache.containsKey(adapter.getAdapterKey())) {
+                // dataStreamAdapterCache.remove(adapter.getAdapterKey());
+                //  waittingCloseAdapterCache.put(adapter.getAdapterKey(), adapter);
+           // }
+//        } catch (RocksDBException e) {
+//            e.printStackTrace();
+//        }
+
+    }
+
+
+//    public void sourceEvent(String filterKey, String key) {
+//        Map<String, Object> block = new HashMap<>();
+//        block.put("filterKey", filterKey);
+//        block.put("adapterKey", key);
+//        block.put("tm", System.currentTimeMillis());
+//        blockQueue.offer(block);
+//    }
+
+    public void responseEvent(String key,byte[] respBlock) {
+        if (this.dataStreamAdapterCache.containsKey(key)){
+            DataStreamAdapter dataStreamAdapter= DataChannelHolder.newInstance().dataChannel.getDataTemplateAdapterByKey(key);
+            if (null != dataStreamAdapter){
+                dataStreamAdapter.output(respBlock);
+            }else{
+                LogHelper.info("运行错误,链接已经提前关闭:"+key);
+            }
+        }
+    }
+
+
+    public void sourceEvent(String adapterKey, byte[] byteBuff) {
+        JSONObject block = new JSONObject();
+        block.put("adapterKey", adapterKey);
+        block.put("block", byteBuff);
+        block.put("tm", System.currentTimeMillis());
+        KafkaClient.messageSubmit("kafka-data-stream-source-event", block.toJSONString());
+    }
+
+    /**
+     * 初始化数据流处理器
+     */
+    private void initDataStream() {
+        try {
+//            for (int i = 0; i < STREAM_THREAD_NUM; i++) {
+//                DataStreamLineManager lineManager = new DataStreamLineManager();
+//                List<TemplateLineNode> nodes = DataTemplateManageHolder.newInstance().dataTemplateManager.cloneTemplateLineNode();
+//                for (TemplateLineNode node : nodes
+//                ) {
+//                    lineManager.addProcessor(node.dataStreamProcessor, node);
+//                }
+//                String lineKey = String.format("%02d", (i + 1));
+//                streamLineCache.put(lineKey, lineManager);
+//                dataStreamStreesCache.put(lineKey, 1);
+//            }
+        } catch (Exception e) {
+            LogHelper.error("初始化数据流失败！");
+            throw e;
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamProcessor.java

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2021/12/16
+ */
+package org.ts.ddcs.dataStream;
+
+
+import lombok.Data;
+
+import org.ts.ddcs.datatemplate.DataTemplate;
+
+
+/***
+ * Date:2021/12/16
+ * Title:数据匹配器模块
+ * Description：每个适配器处理器
+ * @author dylan
+ * @mender：（文件的修改者，文件创建者之外的人）
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+@Data
+public abstract class DataStreamProcessor {
+    private DataStreamProcessor preProcessor;
+    private DataStreamProcessor nextProcessor;
+    private DataStreamLineManager context;
+    private DataTemplate dataTemplate;
+    private boolean isForward = false;
+
+    public void init(DataStreamLineManager context, DataTemplate dataTemplate) {
+        this.context = context;
+        this.dataTemplate = dataTemplate;
+    }
+
+    public void reset() {
+        this.isForward = false;
+    }
+
+    public void forward() {
+        this.isForward = true;
+    }
+
+    public void setPreProcessor(DataStreamProcessor processor) {
+        this.preProcessor = processor;
+    }
+
+    public void setNextProcessor(DataStreamProcessor processor) {
+        this.nextProcessor = processor;
+    }
+
+    public DataStreamProcessor getPreProcessor() {
+        return this.preProcessor;
+    }
+
+    public DataStreamProcessor getNextProcessor() {
+        return this.nextProcessor;
+    }
+
+    public abstract void process(DataStreamCache dataStreamCache);
+
+    public abstract void batchComplete(DataStreamCache dataStreamCache);
+
+    public void stream(DataStreamCache dataStreamCache) {
+        try {
+            this.process(dataStreamCache);
+            if (this.isForward) {
+                if (null != nextProcessor) {
+                    nextProcessor.stream(dataStreamCache);
+                }
+            } else {
+                this.backStream(dataStreamCache);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw e;
+        }
+    }
+
+    private void backStream(DataStreamCache dataStreamCache) {
+        this.batchComplete(dataStreamCache);
+        if (null != preProcessor) {
+            preProcessor.backStream(dataStreamCache);
+        }
+    }
+
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamStore.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2022/3/25
+ */
+package  org.ts.ddcs.dataStream;
+
+/*** 
+ * Date:2022/3/25
+ * Title:文件所属模块（必须填写）
+ * Description：对本文件的详细描述，原则上不能少于30字
+ * @author dylan
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+public class DataStreamStore {
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/DataStreamUnknownProcessor.java

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2019 DH
+ * All right reserved.
+ * 项目名称: 大恒泰山系统
+ * 创建日期:2021/12/16
+ */
+package  org.ts.ddcs.dataStream;
+
+
+
+/***
+ * Date:2021/12/16
+ * Title:数据匹配器模块
+ * Description：每个适配器处理器
+ * @author dylan
+ * @mender：（文件的修改者，文件创建者之外的人）
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ */
+public class DataStreamUnknownProcessor extends DataStreamProcessor {
+
+    @Override
+    public void process(DataStreamCache dataStreamCache) {
+//        LogHelper.info("process " + this.templateLineNode.dataTemplate.getName());
+//        this.reset();
+//        DataSteam dataSteam = context.dataSteam();
+//        templateLineNode.dataTemplate.ready();
+//        templateLineNode.dataTemplate.stream(dataSteam);
+//        dataSteam.takecareTemplates = templateLineNode.dataTemplate;
+//        dataSteam.dataProcesser = templateLineNode.dataProcessor;
+    }
+
+    @Override
+    public void batchComplete(DataStreamCache dataStreamCache) {
+        //LogHelper.info("complete " + this.templateLineNode.dataTemplate.getName());
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/TcpDataStreamAdapter.java

@@ -0,0 +1,77 @@
+package  org.ts.ddcs.dataStream;
+
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.socket.DatagramPacket;
+
+
+/**
+ * created by swp on 2017/8/21
+ * 适配器，用于连接网络通道与数据处理器
+ *
+ * @author dylan
+ */
+public class TcpDataStreamAdapter extends DataStreamAdapter {
+
+    public TcpDataStreamAdapter() {
+        super();
+    }
+
+    @Override
+    public void output(byte[] respBody) {
+        if (null != this.ctx) {
+            try {
+                ByteBuf buf = Unpooled.buffer(respBody.length);
+                buf.writeBytes(respBody);
+                ChannelFuture cf = this.ctx.writeAndFlush(buf);
+                cf.addListener(new ChannelFutureListener() {
+                    @Override
+                    public void operationComplete(ChannelFuture channelFuture) throws Exception {
+                        //写操作完成，并没有错误发生
+                        if (channelFuture.isSuccess()) {
+                            LogHelper.info(adapterKey+" TcpDataStreamAdapter  writeAndFlush is successful!!");
+                        } else {
+                            //记录错误
+                            LogHelper.info(adapterKey+" TcpDataStreamAdapter  writeAndFlush is error!!");
+                            LogHelper.error(channelFuture.cause().getMessage());
+                        }
+                    }
+                });
+            } catch (Exception e) {
+                LogHelper.error(e);
+            } finally {
+                LogHelper.info(this.adapterKey +" TcpDataStreamAdapter  writeAndFlush to rtuCode:" + rtuCode);
+            }
+        } else {
+            LogHelper.info(this.adapterKey+" TcpDataStreamAdapter  net channel close !!");
+        }
+    }
+
+    @Override
+    public void pushData(ByteBuf buf, ChannelHandlerContext cx, DatagramPacket datagramPacket) {
+
+    }
+
+    @Override
+    public void pushData(ByteBuf buf, ChannelHandlerContext cx) {
+        try {
+            this.ctx = cx;
+            int byteSize = buf.readableBytes();
+            if (byteSize > 0) {
+                byte[] block = new byte[byteSize];
+                buf.readBytes(block);
+               // this.blockQueue.offer(block);
+              //  DataStreamManageHolder.newInstance().dataStreamManager.sourceEvent(this.adapterKey,System.currentTimeMillis());
+               DataStreamManageHolder.newInstance().dataStreamManager.sourceEvent(this.adapterKey,block);
+               // LogHelper.info(this.adapterKey + " TcpDataStreamAdapter  接收到数据 "+ BytesUtil.byte2HexStr(block));
+            }
+        } catch (IndexOutOfBoundsException e) {
+            LogHelper.error(this.adapterKey, e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/TestState.java

@@ -0,0 +1,20 @@
+package org.ts.ddcs.dataStream;
+
+/**
+ * created by swp on 2017/8/22
+ */
+public enum TestState {
+    /**
+     * 未知
+     */
+    UNKNOWN,
+    /**
+     * 查找
+     */
+    LOOK,
+    /**
+     * 匹配
+     */
+    MATHCE,
+
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataStream/UdpDataStreamAdapter.java

@@ -0,0 +1,87 @@
+package  org.ts.ddcs.dataStream;
+
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.socket.DatagramPacket;
+
+import java.net.InetSocketAddress;
+
+
+/**
+ * created by swp on 2017/8/21
+ * 适配器，用于匹配数据模板与数据处理器
+ *
+ * @author dylan
+ */
+public class UdpDataStreamAdapter extends DataStreamAdapter {
+
+    private InetSocketAddress socketAddress = null;
+
+    public UdpDataStreamAdapter() {
+        super();
+    }
+
+    @Override
+    public void output(byte[] respBody) {
+        if (null != ctx) {
+            try {
+                ByteBuf buf = Unpooled.buffer(respBody.length);
+                buf.writeBytes(respBody);
+                if (null != socketAddress) {
+                    DatagramPacket datagram = new DatagramPacket(buf, socketAddress);
+                    ChannelFuture cf = this.ctx.writeAndFlush(datagram);
+                    cf.addListener(new ChannelFutureListener() {
+                        @Override
+                        public void operationComplete(ChannelFuture channelFuture) throws Exception {
+                            //写操作完成，并没有错误发生
+                            if (channelFuture.isSuccess()) {
+                                LogHelper.info(adapterKey + " UdpDataStreamAdapter  writeAndFlush is successful!!");
+                            } else {
+                                //记录错误
+                                LogHelper.info(adapterKey + " UdpDataStreamAdapter  writeAndFlush is error!!");
+                                LogHelper.error(channelFuture.cause().getMessage());
+                            }
+                        }
+                    });
+                }
+            } catch (Exception e) {
+                LogHelper.error(e);
+            } finally {
+                LogHelper.info(this.adapterKey + " UdpDataStreamAdapter output  write to rtuCode:" + rtuCode + " ip:" + socketAddress.getHostName() + " port:" + socketAddress.getPort());
+            }
+        } else {
+            LogHelper.info(this.adapterKey + " UdpDataStreamAdapter out is null");
+        }
+    }
+
+    @Override
+    public void pushData(ByteBuf buf, ChannelHandlerContext cx, DatagramPacket datagramPacket) {
+        try {
+            this.ctx = cx;
+            this.socketAddress = new InetSocketAddress(datagramPacket.sender().getAddress(), datagramPacket.sender().getPort());
+            int byteSize = buf.readableBytes();
+            if (byteSize > 0) {
+                byte[] block = new byte[byteSize];
+                buf.readBytes(block);
+               //this.blockQueue.offer(block);
+              //  DataStreamManageHolder.newInstance().dataStreamManager.sourceEvent(this.adapterKey,System.currentTimeMillis());
+                DataStreamManageHolder.newInstance().dataStreamManager.sourceEvent(this.adapterKey,block);
+               // LogHelper.info(this.adapterKey + " UdpDataStreamAdapter 接收到数据 " + " ip:" + socketAddress.getHostName() + " port:" + socketAddress.getPort() + " " + BytesUtil.byte2HexStr(block));
+            }
+        } catch (IndexOutOfBoundsException e) {
+            LogHelper.error(this.adapterKey, e);
+        }
+    }
+
+    @Override
+    public void pushData(ByteBuf buf, ChannelHandlerContext cx) {
+
+    }
+
+
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/DataProcesser.java

@@ -0,0 +1,18 @@
+package  org.ts.ddcs.dataprocesser;
+
+/**
+ * created by swp on 2017/8/28
+ *
+ * @author dylan
+ */
+public abstract class DataProcesser {
+    private String name = null;
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/DataProcesserInterface.java

@@ -0,0 +1,20 @@
+package  org.ts.ddcs.dataprocesser;
+
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+
+
+/**
+ * 数据解析器接口 ，接收报文数据包，所有数据解析器都需要实现此接口
+ *
+ * @author dylan
+ */
+
+public interface DataProcesserInterface {
+
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template);
+
+    public abstract String getName();
+
+    public abstract void setName(String name);
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/UnknownDataProcesser.java

@@ -0,0 +1,26 @@
+package  org.ts.ddcs.dataprocesser;
+
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+
+/**
+ * created by swp on 2017/8/28
+ *
+ * @author dylan
+ */
+
+public class UnknownDataProcesser extends DataProcesser implements DataProcesserInterface {
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId("UnknownDataProcesser");
+        try {
+//            byte[] datagramBuff = new byte[length];
+//            System.arraycopy(byteBuff, pos, datagramBuff, 0, length);
+//            String datagram = BytesUtil.byte2HexStr(datagramBuff);
+//            LogHelper.info(logId + " datagram :" + datagram);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/dtuDatagram/DtuDataProcesser.java

@@ -0,0 +1,56 @@
+package  org.ts.ddcs.dataprocesser.dtuDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * created by swp on 2017/8/28
+ *
+ * @author dylan
+ */
+
+public class DtuDataProcesser extends DataProcesser implements DataProcesserInterface {
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId("DtuDataProcesser");
+        try {
+            Date dt = new Date();
+            byte[] datagramBuff = new byte[length];
+            System.arraycopy(byteBuff, pos, datagramBuff, 0, length);
+            String datagram = BytesUtil.byte2HexStr(datagramBuff);
+            LogHelper.info(logId + " datagram :" + datagram);
+
+            String rtuCode = dataStreamAdapter.getCode();
+            if (null != rtuCode) {
+                SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+                byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+                String gram = BytesUtil.byte2HexStr(dataGram);
+                JSONObject body = new JSONObject();
+                body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+                body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+                body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+                body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+                body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+                DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+//                DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+                LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+            } else {
+                LogHelper.info(logId + " dtu dont send link datagram!!!!!!!!!");
+            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/dtuDatagram/DtuLinkDataProcesser.java

@@ -0,0 +1,53 @@
+package  org.ts.ddcs.dataprocesser.dtuDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * created by swp on 2017/8/28
+ *
+ * @author dylan
+ */
+
+public class DtuLinkDataProcesser extends DataProcesser implements DataProcesserInterface {
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId("DtuLinkDataProcesser");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] datagramBuff = new byte[length];
+            System.arraycopy(byteBuff, pos, datagramBuff, 0, length);
+            String datagram = BytesUtil.byte2HexStr(datagramBuff);
+            LogHelper.info(logId + " datagram :" + datagram);
+            String uuid = new String(template.rtuCode(), "UTF-8");
+            LogHelper.info(logId + " uuid: " + uuid);
+            dataStreamAdapter.setCode(uuid);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, uuid);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+          //  DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtAck.java

@@ -0,0 +1,35 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x0100
+ * 设备注册
+ */
+public class DataProcessorJtAck extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0001 终端通用应答" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtBatchLocation.java

@@ -0,0 +1,80 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x0100
+ * 设备注册
+ */
+public class DataProcessorJtBatchLocation extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0704 批量上报位置" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] funCode = new byte[2];
+            funCode[0] = (byte) 0x80;
+            funCode[1] = (byte) 0x01;
+            byte[] respPacket = funCode;
+            int len = 5;
+            //消息属性
+            byte[] lenBuf = BytesUtil.int2Bytes(len);
+            String bin = BytesUtil.bytesToBinStr(lenBuf);
+            String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+            lenBuf = BytesUtil.binStrToBytes(parameter);
+            respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+            //版本
+            byte[] ver = new byte[1];
+            ver[0] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, ver);
+            //手机号
+            respPacket = BytesUtil.arrayApend(respPacket, template.rtuCode());
+            //流水号
+            byte[] index = new byte[2];
+            index[0] = (byte) 0x00;
+            index[1] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, index);
+            //消息体流水
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 16, 2));
+            //消息ID
+            byte[] command=new byte[2];
+            command[0] = (byte) 0x07;
+            command[1] = (byte) 0x04;
+            respPacket = BytesUtil.arrayApend(respPacket, command);
+            //消息体状态
+            byte[] status = new byte[1];
+            status[0] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, status);
+            int crc = respPacket[0];
+            for (int i = 1; i < respPacket.length; i++) {
+                crc = crc ^ respPacket[i];
+            }
+            byte[] crcBuff = new byte[1];
+            crcBuff[0] = (byte) crc;
+            respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+            byte[] respBuff = BytesUtil.subBytes(packetContext, 0, 1);
+            respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+            respBuff = BytesUtil.arrayApend(respBuff, BytesUtil.subBytes(packetContext, 0, 1));
+            dataStreamAdapter.output(respBuff);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtHeartbeat.java

@@ -0,0 +1,35 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x0100
+ * 设备注册
+ */
+public class DataProcessorJtHeartbeat extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0002 心跳" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtLocation.java

@@ -0,0 +1,159 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x0100
+ * 设备注册
+ */
+public class DataProcessorJtLocation extends DataProcesser implements DataProcesserInterface {
+
+    private byte[] getTakePhotoDatagram(String phoneKey) {
+        byte[] funCode = new byte[2];
+        funCode[0] = (byte) 0x88;
+        funCode[1] = (byte) 0x01;
+        byte[] respPacket = funCode;
+        int len = 12;
+        //消息属性
+        byte[] lenBuf = BytesUtil.int2Bytes(len);
+        String bin = BytesUtil.bytesToBinStr(lenBuf);
+        String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+        lenBuf = BytesUtil.binStrToBytes(parameter);
+        respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+        //版本
+        byte[] ver = new byte[1];
+        ver[0] = (byte) 0x01;
+        respPacket = BytesUtil.arrayApend(respPacket, ver);
+        //手机号
+        respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes(phoneKey));
+        //流水号
+        byte[] index = new byte[2];
+        index[0] = (byte) 0x00;
+        index[1] = (byte) 0x01;
+        respPacket = BytesUtil.arrayApend(respPacket, index);
+        byte[] bodyBuff = new byte[12];
+        //通道ID
+        bodyBuff[0] = 0x01;
+        //拍摄命令
+        //   if (type.equals("0")) {
+        bodyBuff[1] = 0x00;
+        bodyBuff[2] = 0x01;
+        bodyBuff[3] = 0x00;
+//        } else {
+//            //  byte[] tmpBuff = BytesUtil.hexStr2Bytes("FF");
+//            bodyBuff[1] = (byte) 0xff;
+//            bodyBuff[2] = (byte) 0xff;
+//            bodyBuff[3] = 0x05;
+//        }
+        bodyBuff[4] = 0x78;
+        bodyBuff[5] = 0x00;
+        bodyBuff[6] = (byte) 0x00;
+        bodyBuff[7] = 0x01;
+        bodyBuff[8] = (byte) 0xfe;
+        bodyBuff[9] = 127;
+        bodyBuff[10] = 127;
+        bodyBuff[11] = (byte) 0xfe;
+        respPacket = BytesUtil.arrayApend(respPacket, bodyBuff);
+        int crc = respPacket[0];
+        for (int i = 1; i < respPacket.length; i++) {
+            crc = crc ^ respPacket[i];
+        }
+        byte[] crcBuff = new byte[1];
+        crcBuff[0] = (byte) crc;
+        respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+        byte[] flag = new byte[1];
+        flag[0] = 0x7e;
+        byte[] respBuff = flag;
+        respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+        respBuff = BytesUtil.arrayApend(respBuff, flag);
+        return respBuff;
+    }
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0200 上报位置" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] funCode = new byte[2];
+            funCode[0] = (byte) 0x80;
+            funCode[1] = (byte) 0x01;
+            byte[] respPacket = funCode;
+            int len = 5;
+            //消息属性
+            byte[] lenBuf = BytesUtil.int2Bytes(len);
+            String bin = BytesUtil.bytesToBinStr(lenBuf);
+            String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+            lenBuf = BytesUtil.binStrToBytes(parameter);
+            respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+            //版本
+            byte[] ver = new byte[1];
+            ver[0] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, ver);
+            //手机号
+            respPacket = BytesUtil.arrayApend(respPacket, template.rtuCode());
+            //流水号
+            byte[] index = new byte[2];
+            index[0] = (byte) 0x00;
+            index[1] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, index);
+            //消息体流水
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 16, 2));
+            //消息ID
+            byte[] command = new byte[2];
+            command[0] = (byte) 0x02;
+            command[1] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, command);
+            //消息体状态
+            byte[] status = new byte[1];
+            status[0] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, status);
+            int crc = respPacket[0];
+            for (int i = 1; i < respPacket.length; i++) {
+                crc = crc ^ respPacket[i];
+            }
+            byte[] crcBuff = new byte[1];
+            crcBuff[0] = (byte) crc;
+            respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+            byte[] respBuff = BytesUtil.subBytes(packetContext, 0, 1);
+            respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+            respBuff = BytesUtil.arrayApend(respBuff, BytesUtil.subBytes(packetContext, 0, 1));
+            dataStreamAdapter.output(respBuff);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);  //帧起始符
+            String gram = BytesUtil.byte2HexStr(dataGram);
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode.substring(4, 20));
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc", BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           // DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            //下发图片拍照指令
+            byte[] outBuff = getTakePhotoDatagram(rtuCode);
+            dataStreamAdapter.output(outBuff);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtLogin.java

@@ -0,0 +1,81 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x30
+ * 测试报
+ */
+
+public class DataProcessorJtLogin extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " "+this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0102 鉴权" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] funCode = new byte[2];
+            funCode[0] = (byte) 0x80;
+            funCode[1] = (byte) 0x01;
+            byte[] respPacket = funCode;
+            int len = 5;
+            //消息属性
+            byte[] lenBuf = BytesUtil.int2Bytes(len);
+            String bin = BytesUtil.bytesToBinStr(lenBuf);
+            String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+            lenBuf = BytesUtil.binStrToBytes(parameter);
+            respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+            //版本
+            byte[] ver = new byte[1];
+            ver[0] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, ver);
+            //手机号
+            respPacket = BytesUtil.arrayApend(respPacket, template.rtuCode());
+            //流水号
+            byte[] index = new byte[2];
+            index[0] = (byte) 0x00;
+            index[1] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, index);
+            //消息体流水
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 16, 2));
+            //鉴权消息ID
+            byte[] command=new byte[2];
+            command[0] = (byte) 0x01;
+            command[1] = (byte) 0x02;
+            respPacket = BytesUtil.arrayApend(respPacket, command);
+            //消息体状态
+            byte[] status = new byte[1];
+            status[0] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, status);
+            int crc = respPacket[0];
+            for (int i = 1; i < respPacket.length; i++) {
+                crc = crc ^ respPacket[i];
+            }
+            byte[] crcBuff = new byte[1];
+            crcBuff[0] = (byte) crc;
+            respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+            byte[] respBuff = BytesUtil.subBytes(packetContext, 0, 1);
+            respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+            respBuff = BytesUtil.arrayApend(respBuff, BytesUtil.subBytes(packetContext, 0, 1));
+            dataStreamAdapter.output(respBuff);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtMultimedia.java

@@ -0,0 +1,153 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+
+import java.io.*;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x30
+ * 测试报
+ */
+
+public class DataProcessorJtMultimedia extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0801 多媒体数据上报" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] funCode = new byte[2];
+            funCode[0] = (byte) 0x88;
+            funCode[1] = (byte) 0x00;
+            byte[] respPacket = funCode;
+            int len = 4;
+            if (template.packageIndex() < template.packageTotal()) {
+                len += 1;
+            }
+            //消息属性
+            byte[] lenBuf = BytesUtil.int2Bytes(len);
+            String bin = BytesUtil.bytesToBinStr(lenBuf);
+            String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+            lenBuf = BytesUtil.binStrToBytes(parameter);
+            respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+            //版本
+            byte[] ver = new byte[1];
+            ver[0] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, ver);
+            //手机号
+            respPacket = BytesUtil.arrayApend(respPacket, template.rtuCode());
+            //流水号
+            byte[] index = new byte[2];
+            index[0] = (byte) 0x00;
+            index[1] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, index);
+            byte[] body = template.body();
+            //多媒体ID
+            byte[] mid = new byte[4];
+            System.arraycopy(body, 0, mid, 0, 4);
+            respPacket = BytesUtil.arrayApend(respPacket, mid);
+            if (template.packageIndex() < template.packageTotal()) {
+                byte[] retryPackageNum = new byte[1];
+                retryPackageNum[0] = 0x00;
+                respPacket = BytesUtil.arrayApend(respPacket, retryPackageNum);
+            }
+            int crc = respPacket[0];
+            for (int i = 1; i < respPacket.length; i++) {
+                crc = crc ^ respPacket[i];
+            }
+            byte[] crcBuff = new byte[1];
+            crcBuff[0] = (byte) crc;
+            respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+            byte[] respBuff = BytesUtil.subBytes(packetContext, 0, 1);
+            respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+            respBuff = BytesUtil.arrayApend(respBuff, BytesUtil.subBytes(packetContext, 0, 1));
+            dataStreamAdapter.output(respBuff);
+            if (template.packageTotal() > 1) {
+                if (template.packageIndex() == 1) {
+                    dataStreamAdapter.keyStore.clear();
+                    dataStreamAdapter.keyStore.put("" + template.packageIndex(), BytesUtil.byte2HexStr(template.datagramContext()));
+                } else {
+                    dataStreamAdapter.keyStore.put("" + template.packageIndex(), template.body());
+                }
+                if (template.packageIndex() == template.packageTotal()) {
+                    byte[] mediaType = new byte[1];
+                    System.arraycopy(body, 4, mediaType, 0, 1);
+                    byte[] mediaTExt = new byte[1];
+                    System.arraycopy(body, 5, mediaTExt, 0, 1);
+                    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+                    int fileSize = 0;
+                    for (int i = 2; i <= template.packageTotal(); i++) {
+                        byte[] buffer = (byte[]) dataStreamAdapter.keyStore.get("" + i);
+                        byteArrayOutputStream.write(buffer, 0, buffer.length);
+                        fileSize += buffer.length;
+                    }
+                    byteArrayOutputStream.flush();
+                    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
+                    String fileName = "";
+                    String type = "";
+                    String ext = "";
+                    if (mediaType[0] == 0) {
+                        //图像
+                        fileName = rtuCode + "-" + timeFormat.format(dt) + ".jpg";
+                        ext = "jpg";
+                        type = "image/jpeg";
+                    } else if (mediaType[0] == 1) {
+                        //音频
+                    } else if (mediaType[0] == 2) {
+                        //视频
+                        if (mediaTExt[0] == 3) {
+                            //wav
+                            fileName = rtuCode + "-" + timeFormat.format(dt) + ".wav";
+                            type = "video/wav";
+                            ext = "wav";
+                        } else if (mediaTExt[0] == 4) {
+                            //wmv
+                            fileName = rtuCode + "-" + timeFormat.format(dt) + ".wmv";
+                            type = "video/wmv";
+                            ext = "wmv";
+                        }
+                    }
+//                    FastImageFile fastImageFile = new FastImageFile(byteArrayInputStream, fileSize, ext, null);
+//                    StorePath storePath = DataProcessHolder.newInstance().dataProcess.fastFileStorageClient.uploadImage(fastImageFile);
+//                    String photoUrlPath = storePath.getFullPath();
+//                    String gram = (String) dataStreamAdapter.keyStore.get("1");
+//                    JSONObject data = new JSONObject();
+//                    data.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+//                    data.put(GBConstants.BASE_KEY_RTU, rtuCode.substring(4, 20));
+//                    data.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+//                    data.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+//                    data.put("photoUrlPath", photoUrlPath);
+//                    data.put("fileName", fileName);
+//                    data.put("fileType", type);
+//                    data.put("fileExt", ext);
+//                    data.put("afc", BytesUtil.byte2HexStr(template.funcCode()));
+//                    DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+//                    DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(data);
+                }
+            }
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtMultimediaInfo.java

@@ -0,0 +1,81 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x30
+ * 测试报
+ */
+
+public class DataProcessorJtMultimediaInfo extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " "+this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0800 多媒体信息上报" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] funCode = new byte[2];
+            funCode[0] = (byte) 0x80;
+            funCode[1] = (byte) 0x01;
+            byte[] respPacket = funCode;
+            int len = 5;
+            //消息属性
+            byte[] lenBuf = BytesUtil.int2Bytes(len);
+            String bin = BytesUtil.bytesToBinStr(lenBuf);
+            String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+            lenBuf = BytesUtil.binStrToBytes(parameter);
+            respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+            //版本
+            byte[] ver = new byte[1];
+            ver[0] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, ver);
+            //手机号
+            respPacket = BytesUtil.arrayApend(respPacket, template.rtuCode());
+            //流水号
+            byte[] index = new byte[2];
+            index[0] = (byte) 0x00;
+            index[1] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, index);
+            //消息体流水
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 16, 2));
+            //鉴权消息ID
+            byte[] command=new byte[2];
+            command[0] = (byte) 0x08;
+            command[1] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, command);
+            //消息体状态
+            byte[] status = new byte[1];
+            status[0] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, status);
+            int crc = respPacket[0];
+            for (int i = 1; i < respPacket.length; i++) {
+                crc = crc ^ respPacket[i];
+            }
+            byte[] crcBuff = new byte[1];
+            crcBuff[0] = (byte) crc;
+            respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+            byte[] respBuff = BytesUtil.subBytes(packetContext, 0, 1);
+            respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+            respBuff = BytesUtil.arrayApend(respBuff, BytesUtil.subBytes(packetContext, 0, 1));
+            dataStreamAdapter.output(respBuff);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtReg.java

@@ -0,0 +1,81 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.nio.charset.Charset;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.UUID;
+
+
+/**
+ * 0x0100
+ * 设备注册
+ */
+public class DataProcessorJtReg extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0100 注册" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] funCode = new byte[2];
+            funCode[0] = (byte) 0x81;
+            funCode[1] = (byte) 0x00;
+            byte[] respPacket = funCode;
+            String batchId = UUID.randomUUID().toString().replace("-", "").toLowerCase();
+            byte[] uuidBuff = batchId.getBytes(Charset.forName("GBK"));
+            int len = 3 + uuidBuff.length;
+            //消息属性
+            byte[] lenBuf = BytesUtil.int2Bytes(len);
+            String bin = BytesUtil.bytesToBinStr(lenBuf);
+            String parameter = "010000" + bin.substring(bin.length() - 10, bin.length());
+            lenBuf = BytesUtil.binStrToBytes(parameter);
+            respPacket = BytesUtil.arrayApend(respPacket, lenBuf);
+            //版本
+            byte[] ver = new byte[1];
+            ver[0] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, ver);
+            //手机号
+            respPacket = BytesUtil.arrayApend(respPacket, template.rtuCode());
+            //流水号
+            byte[] index = new byte[2];
+            index[0] = (byte) 0x00;
+            index[1] = (byte) 0x01;
+            respPacket = BytesUtil.arrayApend(respPacket, index);
+            //消息体流水
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 16, 2));
+            //消息体状态
+            byte[] status = new byte[1];
+            status[0] = (byte) 0x00;
+            respPacket = BytesUtil.arrayApend(respPacket, status);
+            //消息体UUID
+            respPacket = BytesUtil.arrayApend(respPacket, uuidBuff);
+            int crc = respPacket[0];
+            for (int i = 1; i < respPacket.length; i++) {
+                crc = crc ^ respPacket[i];
+            }
+            byte[] crcBuff = new byte[1];
+            crcBuff[0] = (byte) crc;
+            respPacket = BytesUtil.arrayApend(respPacket, crcBuff);
+            byte[] respBuff = BytesUtil.subBytes(packetContext, 0, 1);
+            respBuff = BytesUtil.arrayApend(respBuff, respPacket);
+            respBuff = BytesUtil.arrayApend(respBuff, BytesUtil.subBytes(packetContext, 0, 1));
+            dataStreamAdapter.output(respBuff);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/jtDatagram/DataProcessorJtTakePicture.java

@@ -0,0 +1,35 @@
+package  org.ts.ddcs.dataprocesser.jtDatagram;
+
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x0100
+ * 设备注册
+ */
+public class DataProcessorJtTakePicture extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " " + this.getClass().getSimpleName());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " JT 808-功能码:0805 拍照指令应答" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014.java

@@ -0,0 +1,74 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+import org.ts.ddcs.util.Commands;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * 创建日期: 2017年8月18日<br/>
+ *
+ * @author SWP
+ * @version 1.0
+ * Remark：2014规约报文解析器
+ * @mender：（文件的修改者，文件创建者之外的人）
+ */
+
+public class DataProcesser2014 extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            dataStreamAdapter.setCode(rtuCode);
+
+            String funcCode = BytesUtil.byte2HexStr(template.funcCode());
+            LogHelper.info(logId + " 2014年规约-功能码:" + funcCode + "-RTU:" + rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 13, 1));//报文起始符
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 14, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            respPacket = BytesUtil.arrayApend(respPacket, Commands.PACKET_CONTROL_FLAG_ESC);//RTU2014年报文正文结束符
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);  //帧起始符
+            String gram = BytesUtil.byte2HexStr(dataGram);
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+          //  DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014P2F.java

@@ -0,0 +1,56 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * 创建日期: 2017年8月28日<br/>
+ * Title:  2014规约报文解析器 链路维持报文 功能码 2F<br/>
+ *
+ * @author swp
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ * @mender：（文件的修改者，文件创建者之外的人）
+ */
+
+public class DataProcesser2014P2F extends DataProcesser implements DataProcesserInterface {
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P2F");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            String code = BytesUtil.byte2HexStr(template.rtuCode());
+            LogHelper.info(logId + " 2014年规约-功能码:2F" + "-RTU:" + code);
+            dataStreamAdapter.setCode(code);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+            String rtuCode = code;
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, code);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+         //   DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014P30.java

@@ -0,0 +1,69 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+import org.ts.ddcs.util.Commands;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x30
+ * 测试报
+ */
+
+public class DataProcesser2014P30 extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P30");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:30" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 13, 1));//报文起始符
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 14, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            respPacket = BytesUtil.arrayApend(respPacket, Commands.PACKET_CONTROL_FLAG_ESC);//RTU2014年报文正文结束符
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);  //帧起始符
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           // DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014P31.java

@@ -0,0 +1,71 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+import org.ts.ddcs.util.Commands;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 2014规约报文解析器均匀时段水文信息报
+ *
+ * @author dylan
+ */
+public class DataProcesser2014P31 extends DataProcesser implements DataProcesserInterface {
+
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P31");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:31" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            byte[] packetContext = template.datagramContext();
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 13, 1));//报文起始符
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 14, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            respPacket = BytesUtil.arrayApend(respPacket, Commands.PACKET_CONTROL_FLAG_ESC);//RTU2014年报文正文结束符
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+          //  DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014P36.java

@@ -0,0 +1,84 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 2014规约报文解析器 遥测站图片上报
+ * @author dylan
+ */
+public class DataProcesser2014P36 extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P36");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] packetContext = template.datagramContext();
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:30" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            byte[] ps = new byte[1];
+            ps[0] = 0x02;
+            respPacket = BytesUtil.arrayApend(respPacket, ps);//报文起始符
+            byte[] packIndex = BytesUtil.subBytes(packetContext, 14, 3);
+            int indexValue = BytesUtil.bytes2Int(packIndex, 0, 3);
+            int total = (indexValue >> 12) & 0x0FFF;
+            int count = indexValue & 0x0FFF;
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 17, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            if (count == 1) {
+                ps[0] = 0x05;
+                respPacket = BytesUtil.arrayApend(respPacket, ps);
+            } else if (total == count) {
+                ps[0] = 0x05;
+                respPacket = BytesUtil.arrayApend(respPacket, ps);
+            } else {
+                ps[0] = 0x05;
+                respPacket = BytesUtil.arrayApend(respPacket, ps);
+            }
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           // DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014P41.java

@@ -0,0 +1,72 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+import org.ts.ddcs.util.Commands;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/*
+ * created by swp on 2017/8/15
+ * 2014规约报文解析器 发报IP设置报文处理
+ */
+
+public class DataProcesser2014P41 extends DataProcesser implements DataProcesserInterface {
+
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P41");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            String funccode = BytesUtil.byte2HexStr(template.funcCode());
+            dataStreamAdapter.setCode(rtuCode);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:" + funccode + "-RTU:" + rtuCode);
+            byte[] packetContext = template.datagramContext();
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 13, 1));//报文起始符
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 14, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            respPacket = BytesUtil.arrayApend(respPacket, Commands.PACKET_CONTROL_FLAG_ESC);//RTU2014年报文正文结束符
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);  //帧起始符
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           // DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014P43.java

@@ -0,0 +1,68 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+import org.ts.ddcs.util.Commands;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/*
+ * created by swp on 2017/8/15
+ * 2014规约报文解析器 设置自报 时间间隔
+ */
+@SuppressWarnings("all")
+public class DataProcesser2014P43 extends DataProcesser implements DataProcesserInterface {
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P43");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            String funccode = BytesUtil.byte2HexStr(template.funcCode());
+            dataStreamAdapter.setCode(rtuCode);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:" + funccode + "-RTU:" + rtuCode);
+            byte[] packetContext = template.datagramContext();
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 13, 1));//报文起始符
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 14, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            respPacket = BytesUtil.arrayApend(respPacket, Commands.PACKET_CONTROL_FLAG_ESC);//RTU2014年报文正文结束符
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);  //帧起始符
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+        //    DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014PF1.java

@@ -0,0 +1,54 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * 0xF1
+ * 多包发送
+ */
+
+public class DataProcesser2014PF1 extends DataProcesser implements DataProcesserInterface {
+
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014PF1");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:F1" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+          //  DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014PF3.java

@@ -0,0 +1,53 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * 0xF3
+ * RTU重启
+ */
+
+public class DataProcesser2014PF3 extends DataProcesser implements DataProcesserInterface {
+
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014PF3");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:F3" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           /// DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014PF4.java

@@ -0,0 +1,53 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * 0xF3
+ * 升级配置文件下发
+ */
+
+public class DataProcesser2014PF4 extends DataProcesser implements DataProcesserInterface {
+
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014PF4");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:F4" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+          //  DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014PF5.java

@@ -0,0 +1,58 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * 创建日期: 2020年6月30日<br/>
+ * Title:  2014规约报文解析器 遥测站上报状态信息 功能码 F5<br/>
+ *
+ * @author SWP
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ * @mender：（文件的修改者，文件创建者之外的人）
+ */
+
+public class DataProcesser2014PF5 extends DataProcesser implements DataProcesserInterface {
+
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014PF5");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            LogHelper.info(logId + " " + " 2014年规约-功能码:F5" + "-RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           // DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesser2014p32x33x34.java

@@ -0,0 +1,76 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+
+
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+import org.ts.ddcs.util.Commands;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 0x32 0x33 0x34
+ * 定时报
+ * @author dylan
+ */
+
+public class DataProcesser2014p32x33x34 extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    @SuppressWarnings("all")
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014p32x33x34");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            //回复报文
+            byte[] rtuCodeBuff = template.rtuCode();
+            String rtuCode = BytesUtil.byte2HexStr(rtuCodeBuff);
+            dataStreamAdapter.setCode(rtuCode);
+            String funccode = BytesUtil.byte2HexStr(template.funcCode());
+            LogHelper.info(logId + " " + " 2014年规约-功能码:" + funccode + "-RTU:" + rtuCode);
+
+            byte[] packetContext = template.datagramContext();
+            //拼装回复报文，先回复再解析入库
+            byte[] respPacket = BytesUtil.subBytes(packetContext, 0, 2);  //帧起始符
+            respPacket = BytesUtil.arrayApend(respPacket, rtuCodeBuff);//遥测站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 2, 1));//中心站地址
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 8, 2));//密码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 10, 1));//功能码
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.hexStr2Bytes("8008")); //报文下行标识及长度
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 13, 1));//报文起始符
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.subBytes(packetContext, 14, 2));//流水号
+            respPacket = BytesUtil.arrayApend(respPacket, BytesUtil.getFBTm());//发报时间
+            respPacket = BytesUtil.arrayApend(respPacket, Commands.PACKET_CONTROL_FLAG_ESC);//RTU2014年报文正文结束符
+            byte[] crc16 = BytesUtil.crcFun2014(respPacket);
+            respPacket = BytesUtil.arrayApend(respPacket, crc16);//CRC16
+            dataStreamAdapter.output(respPacket);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+//            DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+//            LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesserSw2014Ack.java

@@ -0,0 +1,38 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 创建日期: 2017年8月28日<br/>
+ * Title:  2014规约报文解析器 默认应答器 <br/>
+ *
+ * @author swp
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ * @mender：（文件的修改者，文件创建者之外的人）
+ */
+
+public class DataProcesserSw2014Ack extends DataProcesser implements DataProcesserInterface {
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() );
+        try {
+
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/swDatagram/DataProcesserSw2014Sink.java

@@ -0,0 +1,52 @@
+package  org.ts.ddcs.dataprocesser.swDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 创建日期: 2017年8月28日<br/>
+ * Title:  2014规约报文输出<br/>
+ *
+ * @author swp
+ * @version 1.0
+ * Remark：认为有必要的其他信息
+ * @mender：（文件的修改者，文件创建者之外的人）
+ */
+
+public class DataProcesserSw2014Sink extends DataProcesser implements DataProcesserInterface {
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey());
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            String code = BytesUtil.byte2HexStr(template.rtuCode());
+            LogHelper.info(logId + " 2014年规约-功能码:" +BytesUtil.byte2HexStr(template.funcCode())+  "-RTU:" + code);
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String datagramText = BytesUtil.byte2HexStr(dataGram);
+            LogHelper.info(logId + " 报文:" +datagramText);
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, datagramText);
+            body.put(GBConstants.BASE_KEY_RTU, code);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+//            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+           // DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+        } catch (Exception e) {
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/dataprocesser/szyDatagram/DataProcesser2012.java

@@ -0,0 +1,135 @@
+package  org.ts.ddcs.dataprocesser.szyDatagram;
+
+import com.alibaba.fastjson.JSONObject;
+import org.ts.ddcs.main.DataProcessHolder;
+import org.ts.ddcs.common.constant.GBConstants;
+import org.ts.ddcs.dataprocesser.DataProcesser;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.datatemplate.DataTemplateInterface;
+import org.ts.ddcs.log.LogHelper;
+import org.ts.ddcs.net.DataChannelHolder;
+import org.ts.ddcs.util.BytesUtil;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+/**
+ * 2012规约报文解析器
+ * @author dylan
+ */
+public class DataProcesser2012 extends DataProcesser implements DataProcesserInterface {
+
+    @Override
+    public void packetReadly(byte[] byteBuff, int pos, int length, DataStreamAdapter dataStreamAdapter, DataTemplateInterface template) {
+        String logId = LogHelper.createLogId(dataStreamAdapter.getAdapterKey() + " DataProcesser2014P2F");
+        try {
+            Date dt = new Date();
+            SimpleDateFormat timeFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+            byte[] afnBuff = template.funcCode();
+            String afn = BytesUtil.byte2HexStr(afnBuff);
+            String rtuCode = BytesUtil.byte2HexStr(template.rtuCode());
+            LogHelper.info(logId + " 2012年水资源规约 AFN:" + afn + " RTU:" + rtuCode);
+            dataStreamAdapter.setCode(rtuCode);
+            DataChannelHolder.newInstance().dataChannel.online(dataStreamAdapter);
+            byte[] ca = new byte[1];
+            ca[0] = byteBuff[3];
+            ca[0] = (byte) (ca[0] & 0x7F);
+            if ((byte) 0xC0 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 自报报文");
+                String content = BytesUtil.byte2HexStr(ca) + rtuCode + "C0";
+                content += "00";
+                byte[] contenbuff = BytesUtil.hexStr2Bytes(content);
+                byte[] crc = new byte[1]; //系统计算的校验码
+                crc[0] = BytesUtil.GetCRCByte(contenbuff);
+                int datagramLen = 1 + 1 + 1 + contenbuff.length + 1 + 1;
+                byte[] datagram = new byte[datagramLen];
+                int count = 0;
+                datagram[count] = 0x68;
+                count += 1;
+                datagram[count] = (byte) contenbuff.length;
+                count += 1;
+                datagram[count] = 0x68;
+                count += 1;
+                System.arraycopy(contenbuff, 0, datagram, count, contenbuff.length);
+                count += contenbuff.length;
+                datagram[count] = crc[0];
+                count += 1;
+                datagram[count] = 0x16;
+                String datagramStr = BytesUtil.byte2HexStr(datagram);
+                LogHelper.info(logId + " " + rtuCode + " 回复 " + datagramStr);
+                dataStreamAdapter.output(datagram);
+            } else if ((byte) 0x02 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 链路检测");
+            } else if ((byte) 0x10 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 设置终端编号10H ,设置遥测终端,中继站地址");
+            } else if ((byte) 0x11 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 接收设置遥测终端,中继站时钟 开始***");
+            } else if ((byte) 0x12 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 设置终端工作模式12H");
+            } else if ((byte) 0xA1 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 接收设置终端自报种类及时间间隔 开始***");
+            } else if ((byte) 0x50 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 查询终端编号50H");
+            } else if ((byte) 0x51 == afnBuff[0]) {
+                LogHelper.info(rtuCode + " 查询终端时钟 51H");
+            } else if ((byte) 0x52 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 查询终端工作模式52H");
+            } else if ((byte) 0x53 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 查询终端自报种类及时间间隔53H");
+            } else if ((byte) 0x81 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 随机自报报警数据");
+                String content = BytesUtil.byte2HexStr(ca) + rtuCode + "81";
+                content += "00";
+                byte[] contenbuff = BytesUtil.hexStr2Bytes(content);
+                byte[] crc = new byte[1]; //系统计算的校验码
+                crc[0] = BytesUtil.GetCRCByte(contenbuff);
+                int datagramLen = 1 + 1 + 1 + contenbuff.length + 1 + 1;
+                byte[] datagram = new byte[datagramLen];
+                int count = 0;
+                datagram[count] = 0x68;
+                count += 1;
+                datagram[count] = (byte) contenbuff.length;
+                count += 1;
+                datagram[count] = 0x68;
+                count += 1;
+                System.arraycopy(contenbuff, 0, datagram, count, contenbuff.length);
+                count += contenbuff.length;
+                datagram[count] = crc[0];
+                count += 1;
+                datagram[count] = 0x16;
+                String datagramStr = BytesUtil.byte2HexStr(datagram);
+                LogHelper.info(logId + " " + rtuCode + " 回复 " + datagramStr);
+                dataStreamAdapter.output(datagram);
+            } else if ((byte) 0x82 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 人工置数82H");
+            } else if ((byte) 0x90 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 复位终端参数及状态90H");
+            } else if ((byte) 0x91 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 清空终端历史数据单元91H");
+            } else if ((byte) 0x87 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 接收设置终端发报IP 开始***");
+            } else if ((byte) 0xB0 == afnBuff[0]) {
+                LogHelper.info(logId + " " + rtuCode + " 升级 开始***");
+            } else if ((byte) 0xF5 == afnBuff[0]) {
+
+            }
+
+            byte[] dataGram = BytesUtil.subBytes(byteBuff, pos, length);
+            String gram = BytesUtil.byte2HexStr(dataGram);
+            JSONObject body = new JSONObject();
+            body.put(GBConstants.BASE_KEY_DATAGRAM, gram);
+            body.put(GBConstants.BASE_KEY_RTU, rtuCode);
+            body.put(GBConstants.BASE_KEY_AGREEMENT, template.agreement());
+            body.put(GBConstants.BASE_KEY_DATAGRAM_PICK_TM, timeFormat.format(dt));
+            body.put("afc",BytesUtil.byte2HexStr(template.funcCode()));
+            //DataProcessHolder.newInstance().dataProcess.submitRelayDatagramTask(body);
+            //LogHelper.info(logId + " " + "success pick datagram" + body.toJSONString());
+        } catch (Exception e) {
+            e.printStackTrace();
+            LogHelper.error(e);
+        }
+    }
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/datatemplate/DataTemplate.java

@@ -0,0 +1,28 @@
+package  org.ts.ddcs.datatemplate;
+
+
+/**
+ * 数据模板抽象类
+ *
+ * @author dylan
+ */
+public abstract class DataTemplate {
+    protected TestState state = TestState.LOOK;
+    protected int length = 0;
+    protected int featureWeight = 0;
+    protected String templateName;
+    protected byte[] featureKey;
+    protected byte[] featureIndex;
+    protected String agreement;
+
+    public void setFeature(byte[] featureKey, byte[] featureIndex) {
+        if (null != featureKey && null != featureIndex) {
+            this.featureKey = new byte[featureKey.length];
+            System.arraycopy(featureKey, 0, this.featureKey, 0, featureKey.length);
+            this.featureIndex = new byte[featureIndex.length];
+            System.arraycopy(featureIndex, 0, this.featureIndex, 0, featureIndex.length);
+        }
+    }
+
+    public abstract boolean checkFeature(byte[] check, int pos, int length);
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/datatemplate/DataTemplateInterface.java

@@ -0,0 +1,147 @@
+package  org.ts.ddcs.datatemplate;
+
+
+import org.ts.ddcs.dataStream.DataStreamAdapter;
+import org.ts.ddcs.dataStream.DataStreamInterface;
+import org.ts.ddcs.dataprocesser.DataProcesserInterface;
+import org.ts.ddcs.filter.DataFilter;
+
+
+/**
+ * 数据模板接口
+ *
+ * @author dylan
+ */
+public abstract interface DataTemplateInterface {
+    /**
+     * 重置
+     */
+    public abstract void ready();
+
+    /**
+     * 流处理
+     *
+     * @param s
+     */
+    public abstract void stream(DataStreamInterface s);
+
+    /**
+     * 数据长度
+     *
+     * @return
+     */
+    public abstract int length();
+
+    /**
+     * 取匹配状态
+     *
+     * @return
+     */
+    public abstract TestState state();
+
+    /**
+     * 取特性权重
+     *
+     * @return
+     */
+    public abstract int featureWeight();
+
+    /**
+     * 设置特性权重
+     *
+     * @param weight
+     */
+    public abstract void setFeatureWeight(int weight);
+
+    /**
+     * 取模板名称
+     *
+     * @return
+     */
+    public abstract String getName();
+
+    /**
+     * 设置模板名称
+     *
+     * @param name
+     */
+    public abstract void setName(String name);
+
+    /**
+     * 设置特性
+     *
+     * @param fetureKey
+     * @param fetureIndex
+     */
+    public abstract void setFeature(byte[] fetureKey, byte[] fetureIndex);
+
+    /**
+     * 连接到数据处理器
+     *
+     * @param processer
+     * @param dataStreamAdapter
+     */
+    public abstract void bridgeDataProcessor(DataProcesserInterface processer, DataStreamAdapter dataStreamAdapter);
+
+    /**
+     * 连接到过滤器
+     *
+     * @param filter
+     * @param dataStreamAdapter
+     * @return
+     */
+    public abstract boolean bridgeDataFilter(DataFilter filter, DataStreamAdapter dataStreamAdapter);
+
+    /**
+     * 功能码
+     *
+     * @return
+     */
+    public abstract byte[] funcCode();
+
+    /**
+     * 测站编码
+     *
+     * @return
+     */
+    public abstract byte[] rtuCode();
+
+    /**
+     * 报文内容
+     *
+     * @return
+     */
+    public abstract byte[] datagramContext();
+
+    /**
+     * 规约
+     *
+     * @return
+     */
+    public abstract String agreement();
+
+    /**
+     * 分包
+     *
+     * @return
+     */
+    public abstract boolean hasNext();
+
+    /**
+     * 分包总数
+     * @return
+     */
+    public abstract int packageTotal();
+
+    /**
+     * 分包序号
+     * @return
+     */
+    public abstract int packageIndex();
+
+    /**
+     * 消息正文
+     * @return
+     */
+    public abstract byte[] body();
+}

tsddcs-datacollect-stream/src/main/java/org/ts/ddcs/datatemplate/DataTemplateManageHolder.java

@@ -0,0 +1,18 @@
+package  org.ts.ddcs.datatemplate;
+
+/**
+ * 数据模板实例
+ *
+ * @author dylan
+ */
+public class DataTemplateManageHolder {
+    private static class InstanceHolder {
+        static DataTemplateManageHolder instance = new DataTemplateManageHolder();
+    }
+
+    public static DataTemplateManageHolder newInstance() {
+        return DataTemplateManageHolder.InstanceHolder.instance;
+    }
+
+    public DataTemplateManager dataTemplateManager;
+}