网路分组前端完成

后端通用化改造完成

.gitignore

@@ -0,0 +1,33 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

pom.xml

@@ -0,0 +1,149 @@
+<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.dc</groupId>
+    <artifactId>dataChange</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>dataChange</name>
+    <description>dataChange</description>
+    <properties>
+        <java.version>1.8</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <mybatisplus.version>3.3.1</mybatisplus.version>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <!--httpStatus-->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.13</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <!--            <version>${lombok.version}</version>-->
+        </dependency>
+
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-boot-starter</artifactId>
+            <version>${mybatisplus.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.baomidou</groupId>
+                    <artifactId>mybatis-plus-generator</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <!--            <version>5.1.45</version>-->
+            <version>8.0.19</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.junit.vintage</groupId>
+                    <artifactId>junit-vintage-engine</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.10.1</version> <!-- 确保使用最新版本 -->
+        </dependency>
+<!--        本地lib依赖-->
+        <dependency>
+            <groupId>opendds</groupId>
+            <artifactId>i2jrt</artifactId>
+            <version>3.16</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/lib/i2jrt.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>opendds</groupId>
+            <artifactId>messenger_idl_test</artifactId>
+            <version>3.16</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/lib/messenger_idl_test.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>opendds</groupId>
+            <artifactId>OpenDDS_DCPS</artifactId>
+            <version>3.16</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/lib/OpenDDS_DCPS.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>opendds</groupId>
+            <artifactId>tao_java</artifactId>
+            <version>3.16</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/lib/tao_java.jar</systemPath>
+        </dependency>
+    </dependencies>
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-dependencies</artifactId>
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <encoding>UTF-8</encoding>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring-boot.version}</version>
+                <configuration>
+                    <mainClass>com.dc.datachange.DataChangeApplication</mainClass>
+                    <includeSystemScope>true</includeSystemScope>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>repackage</id>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

src/main/java/com/dc/datachange/DataChangeApplication.java

@@ -0,0 +1,17 @@
+package com.dc.datachange;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+@SpringBootApplication
+@EnableAsync
+@EnableScheduling
+public class DataChangeApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DataChangeApplication.class, args);
+    }
+
+}

src/main/java/com/dc/datachange/communityQuality/controller/CommunityQualityController.java

@@ -0,0 +1,61 @@
+package com.dc.datachange.communityQuality.controller;
+
+import com.dc.datachange.utils.R;
+import com.dc.datachange.communityQuality.entity.LinkParam;
+import com.dc.datachange.communityQuality.entity.Message;
+import org.springframework.web.bind.annotation.*;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/community")
+public class CommunityQualityController {
+
+    private final List<Map<String, Object>> nodeList = new ArrayList<>();
+    private final LinkParam linkParam = new LinkParam();
+    private final List<Message> messageArrayList = new ArrayList<>();
+    private final List<Message> receivedMessageArrayList = new ArrayList<>();
+
+    @GetMapping("listLinkParam")
+    public R listLinkParam() {
+        System.out.printf(linkParam.toString());
+        return R.ok().put("linkParam", linkParam);
+    }
+
+    @PostMapping("updateLink")
+    public R updateLink(@RequestParam Map<String, Object> params) {
+        int id = Integer.parseInt(params.get("PlatformID").toString());
+        int isValid = Integer.parseInt(params.get("isValid").toString());
+        int isSilence = Integer.parseInt(params.get("isSilence").toString());
+        String linkSpeed = params.get("linkSpeed").toString();
+        String linkQuality = params.get("linkQuality").toString();
+        String nodeName = params.get("nodeName").toString();
+
+        linkParam.setPlatformID(id);
+        linkParam.setLinkSwitch(isValid);
+        linkParam.setLinkQuality(linkQuality);
+        linkParam.setLinkSpeed(linkSpeed);
+        linkParam.setLinkSilent(isSilence);
+        linkParam.setSelectedNode(nodeName);
+        return R.ok();
+    }
+
+    @PostMapping("sendMessage")
+    public R sendMessage(@RequestBody List<Message> messageList) {
+        messageArrayList.addAll(messageList);
+        return R.ok();
+    }
+
+    @GetMapping("listReceivedMessage")
+    public R listReceivedMessage() {
+        for (Message message : messageArrayList) {
+            if (message.getStatus().equals("成功")){
+                receivedMessageArrayList.add(message);
+            }
+        }
+        return R.ok().put("receivedMessage", receivedMessageArrayList);
+    }
+}

src/main/java/com/dc/datachange/communityQuality/entity/LinkParam.java

@@ -0,0 +1,19 @@
+package com.dc.datachange.communityQuality.entity;
+
+import lombok.Data;
+
+@Data
+public class LinkParam {
+
+    private int platformID;
+
+    private int linkSwitch;
+
+    private int linkSilent;
+
+    private String selectedNode;
+
+    private String linkSpeed;
+
+    private String linkQuality;
+}

src/main/java/com/dc/datachange/communityQuality/entity/Message.java

@@ -0,0 +1,17 @@
+package com.dc.datachange.communityQuality.entity;
+
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+public class Message {
+
+    private String time;
+
+    private String domain;
+
+    private String topic;
+
+    private String status;
+}

src/main/java/com/dc/datachange/core/common/ConnectionParams.java

@@ -0,0 +1,33 @@
+package com.dc.datachange.core.common;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@Configuration
+@ConfigurationProperties(prefix = "dds.connection")
+public class ConnectionParams {
+    private String DCPSBit;
+    private String DCPSConfigFile;
+    private boolean isReliable;
+    private boolean isWaitForAcks;
+
+    public String[] toArgs(){
+        List<String> args=new ArrayList<>();
+        args.add("-DCPSBit");
+        args.add(getDCPSBit());
+        args.add("-DCPSConfigFile");
+        args.add(getDCPSConfigFile());
+        if(isReliable()){
+            args.add("-r");
+        }
+        if (isWaitForAcks()){
+            args.add("-w");
+        }
+        return args.toArray(new String[0]);
+    }
+}

src/main/java/com/dc/datachange/core/common/ControlConstans.java

@@ -0,0 +1,8 @@
+package com.dc.datachange.core.common;
+
+public class ControlConstans {
+    public static final String CTRL_START="1";
+    public static final String CTRL_PAUSE="2";
+    public static final String CTRL_CONTINUE="3";
+    public static final String CTRL_FINISH="4";
+}

src/main/java/com/dc/datachange/core/common/MsgConstants.java

@@ -0,0 +1,28 @@
+package com.dc.datachange.core.common;
+
+import java.util.HashMap;
+
+public class MsgConstants {
+
+    public static final String ERROR_MSG="0";
+    public static final String INITIAL_MSG="1";
+    public static final String INITIAL_ANS="11";
+    public static final String INITIAL_REQ="12";
+    public static final String DAOTIAO_MSG="2";
+    public static final String DAOTIAO_REQ="21";
+    public static final String PLATFORM_POSITION="3";
+    public static final String NETWORK_GROUP="4";
+    public static final String RADAR_PULSE="5";
+    public static final String ELECTRIC_INTERFERE="6";
+    public static final String COMPREHEN_INTELL="7";
+    public static final String HEART_BEAT="8";
+
+
+
+    public static final HashMap<String,String > PLAT_MAP= new HashMap<String,String>(){{
+        put("1","支撑平台");
+        put("2","任务系统");
+        put("3","数据交换平台");
+        put("4","算法平台");
+    }};
+}

src/main/java/com/dc/datachange/core/common/PlatConstants.java

@@ -0,0 +1,8 @@
+package com.dc.datachange.core.common;
+
+public class PlatConstants {
+    public static final String ALGORITHM_PLATFORM="4";
+    public static final String SUPPORT_PLATFORM = "1";
+    public static final String TASK_SYSTEM="2";
+    public static final String EXCHANGE_PLATFORM="3";
+}

src/main/java/com/dc/datachange/core/common/State.java

@@ -0,0 +1,14 @@
+package com.dc.datachange.core.common;
+
+public enum State {
+    /**
+     * 一开始为INITIALING
+     * 程序启动完成后切换为INITIALED，发送初始化请求信息，只接收初始化应答数据
+     * 接收到开始消息后，切换为RUNNING，接收和发送所有数据,初始化应答等效开始消息
+     * 接受到暂停消息时，切换为PAUSED，只接收继续请求和结束请求
+     * 接收到继续请求后，切换为RUNNING，接收和发送所有数据
+     * 接收到结束请求后，清空所有数据，切换为INITIALED
+     */
+    INITIALING, INITIALED, RUNNING, PAUSED
+
+}

src/main/java/com/dc/datachange/core/connection/DDSInitializer.java

@@ -0,0 +1,22 @@
+package com.dc.datachange.core.connection;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class DDSInitializer implements ApplicationRunner {
+    private final DDSStateManger ddsStateManger;
+
+    public DDSInitializer(DDSStateManger ddsStateManger){
+        this.ddsStateManger=ddsStateManger;
+    }
+
+    @Override
+    public void run(ApplicationArguments args) {
+        ddsStateManger.initialed();
+        log.info("State changed to initialed");
+    }
+}

src/main/java/com/dc/datachange/core/connection/DDSPublisher.java

@@ -0,0 +1,224 @@
+package com.dc.datachange.core.connection;
+
+import DDS.*;
+import Messenger.Message;
+import Messenger.MessageDataWriter;
+import Messenger.MessageDataWriterHelper;
+import Messenger.MessageTypeSupportImpl;
+import OpenDDS.DCPS.DEFAULT_STATUS_MASK;
+import OpenDDS.DCPS.TheParticipantFactory;
+import com.dc.datachange.core.common.ConnectionParams;
+import lombok.extern.slf4j.Slf4j;
+import org.omg.CORBA.StringSeqHolder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.util.concurrent.*;
+
+@Component
+@Slf4j
+public class DDSPublisher {
+    @Autowired
+    private ConnectionParams params;
+    private int count = 0;
+    private final BlockingQueue<Message> messageQueue = new LinkedBlockingQueue<>();
+    private volatile boolean isInitialized = false;
+    private volatile boolean running = true;
+    private int instanceHandle;
+    private MessageDataWriter mdw;
+    private final ExecutorService matchService = Executors.newSingleThreadExecutor();
+
+    @PostConstruct
+    private void initialize(){
+        try {
+            // ... 原有初始化代码到创建DataWriter为止...
+            log.info("Start Publisher");
+
+            DomainParticipantFactory dpf = TheParticipantFactory.WithArgs(new StringSeqHolder(params.toArgs()));
+            if (dpf == null) {
+                log.error("ERROR: Domain Participant Factory not found");
+                return;
+            }
+            DomainParticipant dp = dpf.create_participant(4,
+                    PARTICIPANT_QOS_DEFAULT.get(), null, DEFAULT_STATUS_MASK.value);
+            if (dp == null) {
+                log.error("ERROR: Domain Participant creation failed");
+                return;
+            }
+
+            MessageTypeSupportImpl servant = new MessageTypeSupportImpl();
+            if (servant.register_type(dp, "") != RETCODE_OK.value) {
+                log.error("ERROR: register_type failed");
+                return;
+            }
+
+            Topic top = dp.create_topic("Movie Discussion List",
+                    servant.get_type_name(),
+                    TOPIC_QOS_DEFAULT.get(),
+                    null,
+                    DEFAULT_STATUS_MASK.value);
+            if (top == null) {
+                log.error("ERROR: Topic creation failed");
+                return;
+            }
+
+            Publisher pub = dp.create_publisher(PUBLISHER_QOS_DEFAULT.get(), null,
+                    DEFAULT_STATUS_MASK.value);
+            if (pub == null) {
+                log.error("ERROR: Publisher creation failed");
+                return;
+            }
+
+            // Use the default transport configuration (do nothing)
+
+            DataWriterQos dw_qos = new DataWriterQos();
+            dw_qos.durability = new DurabilityQosPolicy();
+            dw_qos.durability.kind = DurabilityQosPolicyKind.from_int(0);
+            dw_qos.durability_service = new DurabilityServiceQosPolicy();
+            dw_qos.durability_service.history_kind = HistoryQosPolicyKind.from_int(0);
+            dw_qos.durability_service.service_cleanup_delay = new Duration_t();
+            dw_qos.deadline = new DeadlineQosPolicy();
+            dw_qos.deadline.period = new Duration_t();
+            dw_qos.latency_budget = new LatencyBudgetQosPolicy();
+            dw_qos.latency_budget.duration = new Duration_t();
+            dw_qos.liveliness = new LivelinessQosPolicy();
+            dw_qos.liveliness.kind = LivelinessQosPolicyKind.from_int(0);
+            dw_qos.liveliness.lease_duration = new Duration_t();
+            dw_qos.reliability = new ReliabilityQosPolicy();
+            dw_qos.reliability.kind = ReliabilityQosPolicyKind.from_int(0);
+            dw_qos.reliability.max_blocking_time = new Duration_t();
+            dw_qos.destination_order = new DestinationOrderQosPolicy();
+            dw_qos.destination_order.kind = DestinationOrderQosPolicyKind.from_int(0);
+            dw_qos.history = new HistoryQosPolicy();
+            dw_qos.history.kind = HistoryQosPolicyKind.from_int(0);
+            dw_qos.resource_limits = new ResourceLimitsQosPolicy();
+            dw_qos.transport_priority = new TransportPriorityQosPolicy();
+            dw_qos.lifespan = new LifespanQosPolicy();
+            dw_qos.lifespan.duration = new Duration_t();
+            dw_qos.user_data = new UserDataQosPolicy();
+            dw_qos.user_data.value = new byte[0];
+            dw_qos.ownership = new OwnershipQosPolicy();
+            dw_qos.ownership.kind = OwnershipQosPolicyKind.from_int(0);
+            dw_qos.ownership_strength = new OwnershipStrengthQosPolicy();
+            dw_qos.writer_data_lifecycle = new WriterDataLifecycleQosPolicy();
+            dw_qos.representation = new DataRepresentationQosPolicy();
+            dw_qos.representation.value = new short[0];
+
+            DataWriterQosHolder qosh = new DataWriterQosHolder(dw_qos);
+            pub.get_default_datawriter_qos(qosh);
+            qosh.value.history.kind = HistoryQosPolicyKind.KEEP_ALL_HISTORY_QOS;
+            if (params.isReliable()) {
+                qosh.value.reliability.kind =
+                        ReliabilityQosPolicyKind.RELIABLE_RELIABILITY_QOS;
+            }
+            DataWriter dw = pub.create_datawriter(top,
+                    qosh.value,
+                    null,
+                    DEFAULT_STATUS_MASK.value);
+            if (dw == null) {
+                log.error("ERROR: DataWriter creation failed");
+                return;
+            }
+            log.info("Publisher Created DataWriter");
+
+            StatusCondition sc = dw.get_statuscondition();
+            sc.set_enabled_statuses(PUBLICATION_MATCHED_STATUS.value);
+            WaitSet ws = new WaitSet();
+            ws.attach_condition(sc);
+
+            PublicationMatchedStatusHolder matched =
+                    new PublicationMatchedStatusHolder(new PublicationMatchedStatus());
+            ws.detach_condition(sc);
+            mdw = MessageDataWriterHelper.narrow(dw);
+
+            matchService.submit(()->waitMatch(dw,ws,matched));
+
+            Message template = new Message();
+            template.subject_id = 99;
+            instanceHandle = mdw.register_instance(template);
+//            executorService.submit(this::processMessageQueue);
+            isInitialized = true;
+
+        } catch (Exception e) {
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    private void waitMatch(DataWriter dw, WaitSet ws, PublicationMatchedStatusHolder matched) {
+        Duration_t timeout;
+        while (running) {
+            log.info("Publisher等待match中");
+            final int result = dw.get_publication_matched_status(matched);
+            if (result != RETCODE_OK.value) {
+                log.error("ERROR: get_publication_matched_status()" +
+                        "failed.");
+                return ;
+            }
+            // 原有匹配等待逻辑...
+            if (matched.value.current_count >= 1) {
+                log.info("Publisher Matched");
+                break;
+            }
+            // 修改等待时间为有限等待
+            timeout = new Duration_t(1, 0);
+            ConditionSeqHolder cond = new ConditionSeqHolder(new Condition[]{});
+            ws.wait(cond, timeout);
+        }
+        matchService.shutdown();
+    }
+
+    public <T1,T2,T3> void publishMessage(T1 from, T2 subject, T3 text) {
+        if (!isInitialized) {
+            throw new IllegalStateException("Publisher not initialized");
+        }
+
+        Message msg = new Message();
+        msg.subject_id = 99;
+        msg.from = String.valueOf(from);
+        msg.subject = String.valueOf(subject);
+        msg.text = String.valueOf(text);
+        msg.count = count++; // 根据需求调整
+
+        messageQueue.offer(msg); // 非阻塞式添加
+    }
+
+    public <T1,T2> void publishMessage(T1 from, T2 subject) {
+        publishMessage(from,subject,"");
+    }
+
+    @PreDestroy
+    public void preDestroy(){
+        isInitialized=false;
+        running=false;
+        log.info("终止publisher运行");
+//        disconnection();
+        log.info("关闭publisher连接完成");
+    }
+
+    @Bean
+    @Async
+    public void processMessageQueue() {
+        try {
+            while (running) {
+                Message msg = messageQueue.poll(1, TimeUnit.SECONDS); // 带超时的获取
+                if (msg != null) {
+                    int ret;
+                    do {
+                        ret = mdw.write(msg, instanceHandle);
+                        if (ret != RETCODE_OK.value) {
+                            Thread.sleep(100); // 失败时短暂等待
+                        }
+                    } while (running && ret == RETCODE_TIMEOUT.value);
+                }
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+}

src/main/java/com/dc/datachange/core/connection/DDSStateManger.java

@@ -0,0 +1,79 @@
+package com.dc.datachange.core.connection;
+
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.common.PlatConstants;
+import com.dc.datachange.core.common.State;
+import com.dc.datachange.core.entity.*;
+import com.dc.datachange.core.entity.speicMsg.DaoTiaoMsg;
+import com.dc.datachange.core.entity.speicMsg.InitialMessage;
+import com.dc.datachange.core.exchange.DataManager;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.DependsOn;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+@DependsOn("DDSSubscriber")
+public class DDSStateManger {
+    @Autowired
+    private DDSPublisher publisher;
+    @Autowired
+    private DataManager dataManager;
+    private volatile State state=State.INITIALING;
+
+    @Async
+    @Scheduled(fixedDelay = 6000)
+    public void initializer(){
+        if(state==State.INITIALED)
+            publisher.publishMessage(PlatConstants.EXCHANGE_PLATFORM, MsgConstants.INITIAL_REQ);
+    }
+
+    @Async
+    @Scheduled(fixedDelay = 6000)
+    public void heartBeat(){
+        publisher.publishMessage(PlatConstants.EXCHANGE_PLATFORM, MsgConstants.HEART_BEAT);
+    }
+    public boolean isInitialed(){
+        return state.equals(State.INITIALED);
+    }
+    public boolean isRunning(){
+        return state.equals(State.RUNNING);
+    }
+    public boolean isPaused(){
+        return state.equals(State.PAUSED);
+    }
+
+    public void initialed(){
+        this.state=State.INITIALED;
+    }
+    public void pause(){
+        this.state=State.PAUSED;
+    }
+    public void running(){
+        this.state=State.RUNNING;
+    }
+    public void stop(){
+        //理论上结束后还需要手动开始，但是目前省略这一步，结束后自动开始
+        initialed();
+        dataManager.clean();
+        running();
+    }
+
+    public boolean stateChecker(VoMessage message){
+        if (InitialMessage.class.equals(message.getClass())) {
+            return isInitialed();
+        } else if (message.isNormalMsg()) {
+            return isRunning();
+        } else if (message.getClass().equals(DaoTiaoMsg.class)){
+            return isRunning() || isPaused() || isInitialed();
+        }
+        return false;
+    }
+
+    public String getState(){
+        return state.name();
+    }
+}

src/main/java/com/dc/datachange/core/connection/DDSSubscriber.java

@@ -0,0 +1,160 @@
+package com.dc.datachange.core.connection;
+
+import DDS.*;
+import Messenger.MessageTypeSupportImpl;
+import OpenDDS.DCPS.DEFAULT_STATUS_MASK;
+import OpenDDS.DCPS.TheParticipantFactory;
+import com.dc.datachange.core.common.ConnectionParams;
+import com.dc.datachange.core.exchange.DDSListener;
+import lombok.extern.slf4j.Slf4j;
+import org.omg.CORBA.StringSeqHolder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.DependsOn;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+
+@Component
+@Slf4j
+@DependsOn("DDSPublisher")
+public class DDSSubscriber {
+    @Autowired
+    private ConnectionParams params;
+    @Autowired
+    private DDSListener listener;
+    private volatile boolean running = true;
+
+    @PostConstruct
+    public void initialized(){
+        try {
+            // ... 保持原有初始化代码到创建DataReader为止...
+
+            log.info("Start Subscriber");
+
+            DomainParticipantFactory dpf = TheParticipantFactory.WithArgs(new StringSeqHolder(params.toArgs()));
+            if (dpf == null) {
+                System.err.println("ERROR: Domain Participant Factory not found");
+                return;
+            }
+            DomainParticipant dp = dpf.create_participant(4,
+                    PARTICIPANT_QOS_DEFAULT.get(), null, DEFAULT_STATUS_MASK.value);
+            if (dp == null) {
+                System.err.println("ERROR: Domain Participant creation failed");
+                return;
+            }
+
+            MessageTypeSupportImpl servant = new MessageTypeSupportImpl();
+            if (servant.register_type(dp, "") != RETCODE_OK.value) {
+                System.err.println("ERROR: register_type failed");
+                return;
+            }
+            Topic top = dp.create_topic("Movie Discussion List",
+                    servant.get_type_name(),
+                    TOPIC_QOS_DEFAULT.get(),
+                    null,
+                    DEFAULT_STATUS_MASK.value);
+            if (top == null) {
+                System.err.println("ERROR: Topic creation failed");
+                return;
+            }
+
+            Subscriber sub = dp.create_subscriber(SUBSCRIBER_QOS_DEFAULT.get(),
+                    null, DEFAULT_STATUS_MASK.value);
+            if (sub == null) {
+                System.err.println("ERROR: Subscriber creation failed");
+                return;
+            }
+
+            // Use the default transport (do nothing)
+
+            DataReaderQos dr_qos = new DataReaderQos();
+            dr_qos.durability = new DurabilityQosPolicy();
+            dr_qos.durability.kind = DurabilityQosPolicyKind.from_int(0);
+            dr_qos.deadline = new DeadlineQosPolicy();
+            dr_qos.deadline.period = new Duration_t();
+            dr_qos.latency_budget = new LatencyBudgetQosPolicy();
+            dr_qos.latency_budget.duration = new Duration_t();
+            dr_qos.liveliness = new LivelinessQosPolicy();
+            dr_qos.liveliness.kind = LivelinessQosPolicyKind.from_int(0);
+            dr_qos.liveliness.lease_duration = new Duration_t();
+            dr_qos.reliability = new ReliabilityQosPolicy();
+            dr_qos.reliability.kind = ReliabilityQosPolicyKind.from_int(0);
+            dr_qos.reliability.max_blocking_time = new Duration_t();
+            dr_qos.destination_order = new DestinationOrderQosPolicy();
+            dr_qos.destination_order.kind = DestinationOrderQosPolicyKind.from_int(0);
+            dr_qos.history = new HistoryQosPolicy();
+            dr_qos.history.kind = HistoryQosPolicyKind.from_int(0);
+            dr_qos.resource_limits = new ResourceLimitsQosPolicy();
+            dr_qos.user_data = new UserDataQosPolicy();
+            dr_qos.user_data.value = new byte[0];
+            dr_qos.ownership = new OwnershipQosPolicy();
+            dr_qos.ownership.kind = OwnershipQosPolicyKind.from_int(0);
+            dr_qos.time_based_filter = new TimeBasedFilterQosPolicy();
+            dr_qos.time_based_filter.minimum_separation = new Duration_t();
+            dr_qos.reader_data_lifecycle = new ReaderDataLifecycleQosPolicy();
+            dr_qos.reader_data_lifecycle.autopurge_nowriter_samples_delay = new Duration_t();
+            dr_qos.reader_data_lifecycle.autopurge_disposed_samples_delay = new Duration_t();
+            dr_qos.representation = new DataRepresentationQosPolicy();
+            dr_qos.representation.value = new short[0];
+
+            DataReaderQosHolder qosh = new DataReaderQosHolder(dr_qos);
+            sub.get_default_datareader_qos(qosh);
+            if (params.isReliable()) {
+                qosh.value.reliability.kind =
+                        ReliabilityQosPolicyKind.RELIABLE_RELIABILITY_QOS;
+            }
+            qosh.value.history.kind = HistoryQosPolicyKind.KEEP_ALL_HISTORY_QOS;
+
+            DataReader dr = sub.create_datareader(top,
+                    qosh.value,
+                    listener,
+                    DEFAULT_STATUS_MASK.value);
+            if (dr == null) {
+                log.error("ERROR: DataReader creation failed");
+                return;
+            }
+
+            StatusCondition sc = dr.get_statuscondition();
+            sc.set_enabled_statuses(SUBSCRIPTION_MATCHED_STATUS.value);
+            WaitSet ws = new WaitSet();
+            ws.attach_condition(sc);
+            SubscriptionMatchedStatusHolder matched =
+                    new SubscriptionMatchedStatusHolder(new SubscriptionMatchedStatus());
+
+            Duration_t timeout = new Duration_t(1, 0); // 1秒超时
+
+            while (running) {
+                final int result = dr.get_subscription_matched_status(matched);
+                if (result != RETCODE_OK.value) {
+                    log.error("ERROR: get_subscription_matched_status() failed");
+                    break;
+                }
+
+                if (matched.value.current_count > 0) {
+                    log.info("Subscriber Matched");
+                    break;
+                }
+
+                ConditionSeqHolder cond = new ConditionSeqHolder(new Condition[]{});
+                if (ws.wait(cond, timeout) != RETCODE_OK.value && running) {
+                    log.error("ERROR: wait() failed");
+                    break;
+                }
+            }
+
+            log.info("Subscriber initialization completed");
+
+        } catch (Exception e) {
+            if (running) {
+                e.printStackTrace();
+            }
+        }
+    }
+    @PreDestroy
+    public void preDestroy(){
+        running=false;
+        log.info("终止subscriber运行");
+        log.info("关闭subscriber连接完成");
+    }
+}

src/main/java/com/dc/datachange/core/entity/NormalMsg.java

@@ -0,0 +1,4 @@
+package com.dc.datachange.core.entity;
+
+public abstract class NormalMsg extends VoMessage{
+}

src/main/java/com/dc/datachange/core/entity/VoMessage.java

@@ -0,0 +1,18 @@
+package com.dc.datachange.core.entity;
+
+import Messenger.Message;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+
+@Data
+abstract public class VoMessage {
+    @JsonIgnore
+    protected Message DDSMessage;
+    protected String from;
+    protected String to;
+    public abstract String getMsgType();
+
+    public boolean isNormalMsg(){
+        return this.getClass().isAssignableFrom(NormalMsg.class);
+    }
+}

src/main/java/com/dc/datachange/core/entity/platformInfo/InterferPlatform.java

@@ -0,0 +1,81 @@
+package com.dc.datachange.core.entity.platformInfo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Slf4j
+public class InterferPlatform extends Platform {
+    /**
+     * 干扰平台id
+     * 1-9999
+     */
+    private Integer id;
+    /**
+     * 协同编号
+     * 1-9999
+     */
+    private String collaborationNumber;
+    /**
+     * 干扰策略
+     * 1-9999
+     */
+    private String strategy;
+    /**
+     * 是否实物
+     * 1：非实物
+     * 2：实物
+     */
+    private String isPhysical;
+    /**
+     * 起始纬度
+     * 0-90
+     */
+    private String latitude;
+    /**
+     * 起始经度
+     * 0-360
+     */
+    private String longitude;
+    /**
+     * 起始高度
+     */
+    private String height;
+
+    /**
+     * 组别信息
+     */
+    private Integer groupId;
+
+    @Override
+    public String getMsgType() {
+        return null;
+    }
+
+    public InterferPlatform(String line){
+        try {
+            String[] value= line.split(" ");
+            this.id = Integer.valueOf(value[0]);
+            this.collaborationNumber = value[1];
+            this.strategy = value[2];
+            this.isPhysical = value[3];
+            this.latitude = value[4];
+            this.longitude = value[5];
+            this.height = value[6];
+            this.groupId=null;
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    public boolean isGrouped(){
+        return groupId!=null;
+    }
+    public void grouped(Integer groupId){
+        this.groupId=groupId;
+    }
+}

src/main/java/com/dc/datachange/core/entity/platformInfo/Platform.java

@@ -0,0 +1,9 @@
+package com.dc.datachange.core.entity.platformInfo;
+
+import com.dc.datachange.core.entity.VoMessage;
+
+public abstract class Platform extends VoMessage {
+    public abstract Integer getId();
+    public abstract boolean isGrouped();
+    public abstract void grouped(Integer groupId);
+}

src/main/java/com/dc/datachange/core/entity/platformInfo/RadarPlatform.java

@@ -0,0 +1,81 @@
+package com.dc.datachange.core.entity.platformInfo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Slf4j
+public class RadarPlatform extends Platform {
+    /**
+     * 雷达平台id
+     * 1-9999
+     */
+    private Integer id;
+    /**
+     * 协同编号
+     * 1-9999
+     */
+    private String collaborationNumber;
+    /**
+     * 干扰策略
+     * 1-9999
+     */
+    private String strategy;
+    /**
+     * 是否实物
+     * 1：非实物
+     * 2：实物
+     */
+    private String isPhysical;
+    /**
+     * 起始纬度
+     * 0-90
+     */
+    private String latitude;
+    /**
+     * 起始经度
+     * 0-360
+     */
+    private String longitude;
+    /**
+     * 起始高度
+     */
+    private String height;
+
+    /**
+     * 组别信息
+     */
+    private Integer groupId;
+
+    public RadarPlatform(String line) {
+        try {
+            String[] value= line.split(" ");
+            this.id = Integer.valueOf(value[0]);
+            this.collaborationNumber = value[1];
+            this.strategy = value[2];
+            this.isPhysical = value[3];
+            this.latitude = value[4];
+            this.longitude = value[5];
+            this.height = value[6];
+            this.groupId = null;
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public String getMsgType() {
+        return null;
+    }
+    public boolean isGrouped(){
+        return groupId!=null;
+    }
+    public void grouped(Integer groupId){
+        this.groupId=groupId;
+    }
+}

src/main/java/com/dc/datachange/core/entity/speicMsg/CompIntelMsg.java

@@ -0,0 +1,67 @@
+package com.dc.datachange.core.entity.speicMsg;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.entity.NormalMsg;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * 综合情报
+ */
+@NoArgsConstructor
+@AllArgsConstructor
+@Slf4j
+@Data
+public class CompIntelMsg extends NormalMsg {
+    private static final String msgType= MsgConstants.COMPREHEN_INTELL;
+    private boolean validate=false;
+    /**
+     * 消息类型
+     * 综合 战术 自由
+     */
+    private String type;
+    /**
+     * 优先级
+     * 0-4
+     */
+    private String priority;
+    /**
+     * 是否广播
+     * 是 否
+     */
+    private String isBroadcast;
+    /**
+     * 消息内容
+     * 具体消息内容
+     */
+    private String message;
+
+    public CompIntelMsg(Message message){
+        try {
+            super.setDDSMessage(message);
+
+            String[] value = message.text.split(" ");
+            this.type = value[0];
+            this.priority = value[1];
+            this.isBroadcast = value[2];
+            this.message = value[3];
+
+            String[] parts = message.from.split(" ");
+            super.from = parts[0];
+            super.to = parts[1];
+            if(parts.length==2)
+                validate=true;
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public String getMsgType() {
+        return msgType;
+    }
+}

src/main/java/com/dc/datachange/core/entity/speicMsg/DaoTiaoMsg.java

@@ -0,0 +1,40 @@
+package com.dc.datachange.core.entity.speicMsg;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.entity.VoMessage;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+
+@Data
+@Slf4j
+@AllArgsConstructor
+public class DaoTiaoMsg extends VoMessage {
+    private static final String msgType= MsgConstants.DAOTIAO_MSG;
+    private boolean validate=false;
+    private String msg;
+
+    public DaoTiaoMsg(Message message) {
+        try {
+            super.setDDSMessage(message);
+
+            msg =message.text;
+
+            String[] parts = message.from.split(" ");
+            super.from = parts[0];
+            super.to = parts[1];
+
+            if(parts.length==2){
+                validate=true;
+            }
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public String getMsgType() {
+        return msgType;
+    }
+}

src/main/java/com/dc/datachange/core/entity/speicMsg/EleInterMsg.java

@@ -0,0 +1,83 @@
+package com.dc.datachange.core.entity.speicMsg;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.entity.NormalMsg;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Slf4j
+@Data
+public class EleInterMsg extends NormalMsg {
+    private static final String msgType= MsgConstants.ELECTRIC_INTERFERE;
+    private boolean validate=false;
+    /**
+     * 干扰类型
+     * 各种干扰决策类型
+     */
+    private String type;
+    /**
+     * 环境
+     * 水面 地面 空中
+     */
+    private String environment;
+    /**
+     * 区域
+     */
+    private String area;
+    /**
+     * 干扰策略
+     * 具体干扰策略
+     */
+    private String strategy;
+    /**
+     * 干扰目标
+     * 要干扰的目标
+     */
+    private String target;
+    /**
+     * 是否协同干扰
+     * 是 否
+     */
+    private String isCollaborated;
+    /**
+     * PRI
+     * 0-10000000
+     */
+    private String PRI;
+
+    public EleInterMsg(Message message){
+        try{
+            super.setDDSMessage(message);
+
+            String[] value = message.text.split(" ");
+            this.type = value[0];
+            this.environment = value[1];
+            this.area = value[2];
+            this.strategy = value[3];
+            this.target = value[4];
+            this.isCollaborated = value[5];
+            this.PRI = value[6];
+
+            String[] parts = message.from.split(" ");
+            super.from = parts[0];
+            super.to = parts[1];
+
+            if(parts.length==2 && value.length==7)
+                validate=true;
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public String getMsgType() {
+        return msgType;
+    }
+}

src/main/java/com/dc/datachange/core/entity/speicMsg/ErrorMessage.java

@@ -0,0 +1,15 @@
+package com.dc.datachange.core.entity.speicMsg;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.entity.VoMessage;
+
+public class ErrorMessage extends VoMessage {
+    public ErrorMessage(Message message){
+        super.setDDSMessage(message);
+    }
+    @Override
+    public String getMsgType() {
+        return MsgConstants.ERROR_MSG;
+    }
+}

src/main/java/com/dc/datachange/core/entity/speicMsg/InitialMessage.java

@@ -0,0 +1,59 @@
+package com.dc.datachange.core.entity.speicMsg;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.entity.VoMessage;
+import com.dc.datachange.core.entity.platformInfo.InterferPlatform;
+import com.dc.datachange.core.entity.platformInfo.RadarPlatform;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Slf4j
+@Data
+public class InitialMessage extends VoMessage {
+    private static final String msgType= MsgConstants.INITIAL_MSG;
+    private boolean validate=false;
+    private List<InterferPlatform> interPlats=new ArrayList<>();
+    private List<RadarPlatform> radarPlats=new ArrayList<>();
+
+    public InitialMessage(Message message){
+        this.setDDSMessage(message);
+        try {
+            String[] line = message.text.split("\n");
+            String[] nums = line[0].split(" ");
+            int interNums=Integer.parseInt(nums[0]);
+            int radarNums=Integer.parseInt(nums[1]);
+            int i=1;
+            for(;i<interNums+1;i++){
+                interPlats.add(new InterferPlatform(line[i]));
+            }
+            for(;i<interNums+radarNums+1;i++){
+                radarPlats.add(new RadarPlatform(line[i]));
+            }
+
+            String[] parts = message.from.split(" ");
+            super.from = parts[0];
+            super.to = parts[1];
+
+            if(parts.length==2)
+                validate=true;
+
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public String getMsgType() {
+        return msgType;
+    }
+
+}

src/main/java/com/dc/datachange/core/entity/speicMsg/RadarPulseMsg.java

@@ -0,0 +1,82 @@
+package com.dc.datachange.core.entity.speicMsg;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.entity.NormalMsg;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@NoArgsConstructor
+@AllArgsConstructor
+@Slf4j
+@Data
+public class RadarPulseMsg extends NormalMsg {
+    private static final String msgType= MsgConstants.RADAR_PULSE;
+    private boolean validate=false;
+    /**
+     * 类型
+     * 雷达、通信
+     */
+    public String type;
+    /**
+     * 环境
+     * 水面 地面 空中
+     */
+    public String environment;
+    /**
+     * 纬度
+     * 0-90
+     */
+    private String latitude;
+    /**
+     * 经度
+     * 0-360
+     */
+    private String longitude;
+    /**
+     * 高度
+     */
+    private String height;
+    /**
+     * 频率
+     * 0-10000000
+     */
+    private String frequency;
+    /**
+     * PRI
+     * 0-10000000
+     */
+    private String PRI;
+
+    //不考虑报错
+    public RadarPulseMsg(Message message){
+        try {
+            super.setDDSMessage(message);
+
+            String[] value = message.text.split(" ");
+            this.type = value[0];
+            this.environment = value[1];
+            this.latitude = value[2];
+            this.longitude = value[3];
+            this.height = value[4];
+            this.frequency = value[5];
+            this.PRI = value[6];
+
+            String[] parts = message.from.split(" ");
+            super.from = parts[0];
+            super.to = parts[1];
+            if(parts.length==2)
+                validate=true;
+        }catch (Exception e){
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public String getMsgType() {
+        return msgType;
+    }
+}

src/main/java/com/dc/datachange/core/exchange/DDSListener.java

@@ -0,0 +1,99 @@
+package com.dc.datachange.core.exchange;
+
+import DDS.*;
+import Messenger.Message;
+import Messenger.MessageDataReader;
+import Messenger.MessageDataReaderHelper;
+import Messenger.MessageHolder;
+import com.dc.datachange.core.entity.VoMessage;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+public class DDSListener extends DDS._DataReaderListenerLocalBase{
+    @Autowired
+    private InvokeExecutor executor;
+    @Value("${dds.config.enablePrint}")
+    private Boolean enablePrint;
+
+    public synchronized void on_data_available(DataReader reader) {
+
+        MessageDataReader mdr = MessageDataReaderHelper.narrow(reader);
+        if (mdr == null) {
+            log.error("ERROR: read: narrow failed.");
+            return;
+        }
+
+        MessageHolder mh = new MessageHolder(new Message());
+        SampleInfoHolder sih = new SampleInfoHolder(new SampleInfo(0, 0, 0,
+                new Time_t(), 0, 0, 0, 0, 0, 0, 0, false, 0));
+        int status = mdr.take_next_sample(mh, sih);
+
+        if (status == RETCODE_OK.value) {
+            if (sih.value.valid_data) {
+                //核心处理逻辑
+
+                VoMessage voMessage = executor.getSpecMsg(mh.value);
+                executor.invoke(voMessage);
+
+                if(enablePrint){
+                    System.out.println("==============================================");
+                    System.out.println("Message: subject    = " + mh.value.subject);
+                    System.out.println("         subject_id = "
+                            + mh.value.subject_id);
+                    System.out.println("         from       = " + mh.value.from);
+                    System.out.println("         count      = " + mh.value.count);
+                    System.out.println("         text       = " + mh.value.text);
+                    System.out.println("==============================================");
+                }
+
+            }
+            else if (sih.value.instance_state ==
+                    NOT_ALIVE_DISPOSED_INSTANCE_STATE.value) {
+                log.error("instance is disposed");
+            }
+            else if (sih.value.instance_state ==
+                    NOT_ALIVE_NO_WRITERS_INSTANCE_STATE.value) {
+                log.error("instance is unregistered");
+            }
+            else {
+                log.error("DataReaderListenerImpl::on_data_available: "
+                        + "ERROR: received unknown instance state "
+                        + sih.value.instance_state);
+            }
+
+        } else if (status == RETCODE_NO_DATA.value) {
+            log.error("ERROR: reader received DDS::RETCODE_NO_DATA!");
+        } else {
+            log.error("ERROR: read Message: Error: " + status);
+        }
+    }
+
+    public void on_requested_deadline_missed(DataReader reader, RequestedDeadlineMissedStatus status) {
+        log.error("DataReaderListenerImpl.on_requested_deadline_missed");
+    }
+
+    public void on_requested_incompatible_qos(DataReader reader, RequestedIncompatibleQosStatus status) {
+        log.error("DataReaderListenerImpl.on_requested_incompatible_qos");
+    }
+
+    public void on_sample_rejected(DataReader reader, SampleRejectedStatus status) {
+        log.error("DataReaderListenerImpl.on_sample_rejected");
+    }
+
+    public void on_liveliness_changed(DataReader reader, LivelinessChangedStatus status) {
+        log.info("DataReaderListenerImpl.on_liveliness_changed");
+    }
+
+    public void on_subscription_matched(DataReader reader, SubscriptionMatchedStatus status) {
+        log.info("DataReaderListenerImpl.on_subscription_matched");
+    }
+
+    public void on_sample_lost(DataReader reader, SampleLostStatus status) {
+        log.error("DataReaderListenerImpl.on_sample_lost");
+    }
+
+}

src/main/java/com/dc/datachange/core/exchange/DataManager.java

@@ -0,0 +1,133 @@
+package com.dc.datachange.core.exchange;
+
+import com.dc.datachange.core.entity.platformInfo.InterferPlatform;
+import com.dc.datachange.core.entity.platformInfo.RadarPlatform;
+import com.dc.datachange.core.entity.speicMsg.*;
+import com.dc.datachange.networkGroup.entity.NetworkGroup;
+import com.dc.datachange.utils.ConcurrentIndexedMap;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Component
+@Data
+@Slf4j
+public class DataManager {
+    private final ConcurrentHashMap<Class<?>, ConcurrentIndexedMap<?>> listMap =new ConcurrentHashMap<>();
+    private final ConcurrentIndexedMap<InterferPlatform> interferPlatforms = new ConcurrentIndexedMap<>(Map.class);
+    private final ConcurrentIndexedMap<RadarPlatform> radarPlatforms = new ConcurrentIndexedMap<>(Map.class);
+    private final ConcurrentIndexedMap<RadarPulseMsg> radarPulseMsgs = new ConcurrentIndexedMap<>(List.class);
+    private final ConcurrentIndexedMap<EleInterMsg> eleInterMsgs = new ConcurrentIndexedMap<>(List.class);
+    private final ConcurrentIndexedMap<CompIntelMsg> compIntelMsgs = new ConcurrentIndexedMap<>(List.class);
+    private final ConcurrentIndexedMap<NetworkGroup> networkGroups = new ConcurrentIndexedMap<>(Map.class);
+
+    /**
+     * 有自动的写法，但是太复杂了，手动一个个加算了
+     */
+    @PostConstruct
+    private void initialMap(){
+        listMap.put(InterferPlatform.class,interferPlatforms);
+        listMap.put(RadarPlatform.class,radarPlatforms);
+        listMap.put(RadarPulseMsg.class,radarPulseMsgs);
+        listMap.put(EleInterMsg.class,eleInterMsgs);
+        listMap.put(CompIntelMsg.class,compIntelMsgs);
+        listMap.put(NetworkGroup.class,networkGroups);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> void addData(T data){
+        if(data!=null){
+            Class<?> aClass = data.getClass();
+            ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(aClass);
+            if(list != null){
+                list.add(data);
+            }
+        }
+    }
+    @SuppressWarnings("unchecked")
+    public <T> void addData(List<T> data){
+        if(!data.isEmpty()){
+            Class<?> aClass = data.get(0).getClass();
+            ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(aClass);
+            if(list != null){
+                list.addAll(data);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> void addData(Integer index,T data){
+        if(data!=null){
+            Class<?> aClass = data.getClass();
+            ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(aClass);
+            if(list!=null){
+                list.put(index,data);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> List<T> getList(Class<T> tClass,int page,int size){
+        ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(tClass);
+        if(list !=null){
+            int start = Math.min((page - 1) * size, list.size());
+            int end = Math.min(start + size, list.size());
+            return list.subList(start, end);
+        }
+        return new ArrayList<>();
+    }
+
+    public <T> int getCount(Class<T> tClass){
+        ConcurrentIndexedMap<?> list = listMap.get(tClass);
+        if (list!=null){
+            return list.size();
+        }
+        return 0;
+    }
+    @SuppressWarnings("unchecked")
+    public <T> List<T> getAllData(Class<T> tClass){
+        ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(tClass);
+        if(list!=null){
+            return list.getList();
+        }
+        return new ArrayList<>();
+    }
+    @SuppressWarnings("unchecked")
+    public <T> T getData(Class<T> tClass,Integer keyOrIndex){
+        ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(tClass);
+        if(list!=null){
+            return list.getData(keyOrIndex);
+        }
+        return null;
+    }
+    @SuppressWarnings("unchecked")
+    public <T> boolean deleteData(Class<T> tClass,Object keyOrValue){
+        ConcurrentIndexedMap<T> list = (ConcurrentIndexedMap<T>) listMap.get(tClass);
+        if(list!=null){
+            try{
+                return list.remove(keyOrValue);
+            } catch (ClassCastException e){
+                log.error("输入类型{}转换错误,输入值为{},类型为{}",list.getType(),keyOrValue,keyOrValue.getClass());
+                return false;
+            }
+        }
+        return false;
+    }
+
+    public void clean(){
+        this.interferPlatforms.clear();
+        this.radarPlatforms.clear();
+        this.radarPulseMsgs.clear();
+        this.eleInterMsgs.clear();
+        this.compIntelMsgs.clear();
+        this.networkGroups.clear();
+    }
+
+
+}

src/main/java/com/dc/datachange/core/exchange/InvokeExecutor.java

@@ -0,0 +1,171 @@
+package com.dc.datachange.core.exchange;
+
+import Messenger.Message;
+import com.dc.datachange.core.common.ControlConstans;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.common.PlatConstants;
+import com.dc.datachange.core.connection.DDSStateManger;
+import com.dc.datachange.core.connection.DDSPublisher;
+import com.dc.datachange.core.entity.*;
+import com.dc.datachange.core.entity.speicMsg.*;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class InvokeExecutor {
+    @Autowired
+    private DDSStateManger stateManger;
+    @Autowired
+    private DDSPublisher publisher;
+    @Autowired
+    private DataManager dataManager;
+
+    public VoMessage getSpecMsg(Message message) {
+        switch (message.subject) {
+            case MsgConstants.INITIAL_MSG:
+                return new InitialMessage(message);
+            case MsgConstants.DAOTIAO_MSG:
+                return new DaoTiaoMsg(message);
+            case MsgConstants.RADAR_PULSE:
+                return new RadarPulseMsg(message);
+            case MsgConstants.ELECTRIC_INTERFERE:
+                return new EleInterMsg(message);
+            case MsgConstants.COMPREHEN_INTELL:
+                return new CompIntelMsg(message);
+            default:
+                return new ErrorMessage(message);
+        }
+    }
+
+    public void invoke(VoMessage message) {
+        try {
+            switch (message.getMsgType()) {
+                case MsgConstants.INITIAL_MSG:
+                    if (initialValidate(message)) {
+                        initialMsgInvoke(message);
+                    }
+                    break;
+                case MsgConstants.DAOTIAO_MSG:
+                    if (DaoTiaoValidate(message)) {
+                        DaoTiaoMsgInvoke(message);
+                    }
+                    break;
+                case MsgConstants.RADAR_PULSE:
+                    if (radarPulseValidate(message)) {
+                        radarPulseInvoke(message);
+                    }
+                    break;
+                case MsgConstants.ELECTRIC_INTERFERE:
+                    if(eleInterValidate(message)){
+                        eleInterInvoke(message);
+                    }
+                    break;
+                case MsgConstants.COMPREHEN_INTELL:
+                    if(compIntValidate(message)){
+                        compIntInvoke(message);
+                    }
+            }
+        } catch (Exception e) {
+            log.error(e.getMessage());
+            e.printStackTrace();
+        }
+
+    }
+
+    private boolean initialValidate(VoMessage message) {
+        InitialMessage initialMessage = (InitialMessage) message;
+        if (stateManger.stateChecker(initialMessage)) {
+            return initialMessage.isValidate()
+                    && initialMessage.getFrom().equals(PlatConstants.SUPPORT_PLATFORM)
+                    && initialMessage.getTo().equals(PlatConstants.EXCHANGE_PLATFORM);
+        }
+        return false;
+    }
+    private void initialMsgInvoke(VoMessage message) {
+        stateManger.running();
+        publisher.publishMessage(PlatConstants.EXCHANGE_PLATFORM, MsgConstants.INITIAL_ANS);
+
+        InitialMessage initialMessage = (InitialMessage) message;
+        initialMessage.getRadarPlats().forEach(x->dataManager.addData(x.getId(),x));
+        initialMessage.getInterPlats().forEach(x->dataManager.addData(x.getId(),x));
+    }
+    private boolean DaoTiaoValidate(VoMessage message) {
+        DaoTiaoMsg daoTiaoMsg = (DaoTiaoMsg) message;
+        if (stateManger.stateChecker(daoTiaoMsg)) {
+            return daoTiaoMsg.isValidate()
+                    && daoTiaoMsg.getFrom().equals(PlatConstants.SUPPORT_PLATFORM)
+                    && daoTiaoMsg.getTo().equals(PlatConstants.EXCHANGE_PLATFORM);
+        }
+        return false;
+    }
+    private void DaoTiaoMsgInvoke(VoMessage message) {
+        DaoTiaoMsg daoTiaoMsg = (DaoTiaoMsg) message;
+        switch (daoTiaoMsg.getMsg()){
+            case ControlConstans.CTRL_START:
+                if(stateManger.isInitialed())
+                    stateManger.running();
+                else log.error("当前状态{}无法处理开始请求",stateManger.getState());
+                break;
+            case ControlConstans.CTRL_PAUSE:
+                if(stateManger.isRunning())
+                    stateManger.pause();
+                else log.error("当前状态{}无法处理暂停请求",stateManger.getState());
+                break;
+            case ControlConstans.CTRL_CONTINUE:
+                if(stateManger.isPaused())
+                    stateManger.running();
+                else log.error("当前状态{}无法处理继续请求",stateManger.getState());
+                break;
+            case ControlConstans.CTRL_FINISH:
+                //理论上结束后还需要手动制定开始，但是目前省略这一步，结束后自动开始
+                stateManger.stop();
+                break;
+        }
+    }
+    private boolean radarPulseValidate(VoMessage message) {
+        RadarPulseMsg radarPulseMsg = (RadarPulseMsg) message;
+        if (stateManger.stateChecker(radarPulseMsg)) {
+            /*
+             * todo:根据分组判断message中的两个id是否在同一组中;
+             */
+        }
+        return true;
+    }
+
+    private void radarPulseInvoke(VoMessage message) {
+        RadarPulseMsg radarPulseMsg = (RadarPulseMsg) message;
+        dataManager.addData(radarPulseMsg);
+    }
+
+    private boolean eleInterValidate(VoMessage message) {
+        EleInterMsg eleInterMsg = (EleInterMsg) message;
+        if(stateManger.stateChecker(eleInterMsg)){
+            /*
+             * todo:根据分组判断message中的两个id是否在同一组中;
+             */
+        }
+        return true;
+    }
+
+    private void eleInterInvoke(VoMessage message) {
+        EleInterMsg eleInterMsg = (EleInterMsg) message;
+        dataManager.addData(eleInterMsg);
+    }
+
+    private boolean compIntValidate(VoMessage message) {
+        CompIntelMsg compIntelMsg = (CompIntelMsg) message;
+        if(stateManger.stateChecker(compIntelMsg)) {
+            /*
+             * todo:根据分组判断message中的两个id是否在同一组中;
+             */
+        }
+        return true;
+    }
+
+    private void compIntInvoke(VoMessage message) {
+        CompIntelMsg compIntelMsg = (CompIntelMsg) message;
+        dataManager.addData(compIntelMsg);
+    }
+}

src/main/java/com/dc/datachange/exception/IllegalTypeException.java

@@ -0,0 +1,7 @@
+package com.dc.datachange.exception;
+
+public class IllegalTypeException extends RuntimeException{
+    public IllegalTypeException(){
+        super("当前的列表模式不允许该方法");
+    }
+}

src/main/java/com/dc/datachange/exception/NameDuplicatedException.java

@@ -0,0 +1,7 @@
+package com.dc.datachange.exception;
+
+public class NameDuplicatedException extends NetworkCreateException{
+    public NameDuplicatedException(){
+        super("名称已存在");
+    }
+}

src/main/java/com/dc/datachange/exception/NetworkCreateException.java

@@ -0,0 +1,7 @@
+package com.dc.datachange.exception;
+
+public class NetworkCreateException extends RuntimeException{
+    public NetworkCreateException(String s) {
+        super(s);
+    }
+}

src/main/java/com/dc/datachange/exception/PlatChangeException.java

@@ -0,0 +1,7 @@
+package com.dc.datachange.exception;
+
+public class PlatChangeException extends NetworkCreateException{
+    public PlatChangeException() {
+        super("网路组内存在平台但平台类型发生变更");
+    }
+}

src/main/java/com/dc/datachange/exception/PlatUsedException.java

@@ -0,0 +1,7 @@
+package com.dc.datachange.exception;
+
+public class PlatUsedException extends RuntimeException{
+    public PlatUsedException(){
+        super("存在已被分组的平台被再次分组");
+    }
+}

src/main/java/com/dc/datachange/messageManager/controller/MessageController.java

@@ -0,0 +1,40 @@
+package com.dc.datachange.messageManager.controller;
+
+import com.dc.datachange.utils.PageUtils;
+import com.dc.datachange.utils.R;
+import com.dc.datachange.core.entity.speicMsg.CompIntelMsg;
+import com.dc.datachange.core.entity.speicMsg.EleInterMsg;
+import com.dc.datachange.core.entity.speicMsg.RadarPulseMsg;
+import com.dc.datachange.core.exchange.DataManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+
+@RestController
+@RequestMapping("/message")
+public class MessageController {
+    @Autowired
+    private DataManager dataManager;
+
+    @GetMapping("/listRadarPulses")
+    public R listRadarPulses(int page, int limit) {
+        List<RadarPulseMsg> list = dataManager.getList(RadarPulseMsg.class, page, limit);
+        PageUtils pageUtils = new PageUtils(list, dataManager.getCount(RadarPulseMsg.class), limit, page);
+        return R.ok().put("page", pageUtils);
+    }
+
+    @GetMapping("/listEleInters")
+    public R listEleInters(int page, int limit) {
+        List<EleInterMsg> list = dataManager.getList(EleInterMsg.class, page, limit);
+        PageUtils pageUtils = new PageUtils(list, dataManager.getCount(EleInterMsg.class), limit, page);
+        return R.ok().put("page", pageUtils);
+    }
+
+    @GetMapping("/listComInts")
+    public R listComInts(int page, int limit) {
+        List<CompIntelMsg> list = dataManager.getList(CompIntelMsg.class, page, limit);
+        PageUtils pageUtils = new PageUtils(list, dataManager.getCount(CompIntelMsg.class), limit, page);
+        return R.ok().put("page", pageUtils);
+    }
+}

src/main/java/com/dc/datachange/networkGroup/controller/NetworkController.java

@@ -0,0 +1,322 @@
+package com.dc.datachange.networkGroup.controller;
+
+import com.dc.datachange.core.entity.platformInfo.InterferPlatform;
+import com.dc.datachange.core.entity.platformInfo.Platform;
+import com.dc.datachange.core.entity.platformInfo.RadarPlatform;
+import com.dc.datachange.core.exchange.DataManager;
+import com.dc.datachange.exception.IllegalTypeException;
+import com.dc.datachange.exception.NameDuplicatedException;
+import com.dc.datachange.exception.NetworkCreateException;
+import com.dc.datachange.exception.PlatUsedException;
+import com.dc.datachange.networkGroup.entity.*;
+import com.dc.datachange.utils.PageUtils;
+import com.dc.datachange.utils.R;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@RestController
+@Slf4j
+@RequestMapping("/network")
+public class NetworkController {
+    @Autowired
+    private DataManager dataManager;
+
+    @GetMapping("allGroup")
+    public R getAllGroup() {
+        return R.ok().put("data", dataManager.getAllData(NetworkGroup.class));
+    }
+
+    @GetMapping("list")
+    public R getList(@RequestParam(defaultValue = "1") int page,
+                     @RequestParam(defaultValue = "10") int limit) {
+
+        // 计算总记录数
+        int totalCount = dataManager.getCount(NetworkGroup.class);
+        // 计算分页数据
+        List<NetworkGroup> paginatedList = dataManager.getList(NetworkGroup.class, page, limit);
+        // 创建 PageUtils 实例
+        PageUtils pageUtils = new PageUtils(paginatedList, totalCount, limit, page);
+
+        return R.ok().put("page", pageUtils);
+    }
+
+    @PostMapping("add")
+    public R addNetworkGroup(@RequestBody RawGroup rawGroup) {
+        try {
+            NetworkGroup group = new NetworkGroup(rawGroup);
+            dataManager.addData(group.getId(), group);
+            return R.ok();
+        } catch (NameDuplicatedException e) {
+            return R.error(e.getMessage());
+        }
+    }
+
+    @PostMapping("update")
+    public R updateNetworkGroup(@RequestBody NetworkGroup group) {
+        NetworkGroup oldGroup = dataManager.getData(group.getClass(), group.getId());
+        if (oldGroup != null) {
+            try {
+                oldGroup.update(group);
+                return R.ok();
+            } catch (NetworkCreateException e) {
+                return R.error(e.getMessage());
+            }
+        } else {
+            return R.error("原有平台不存在");
+        }
+    }
+
+    @GetMapping("delete")
+    public R deleteNetworkGroup(@RequestParam Integer id) {
+        if (dataManager.deleteData(NetworkGroup.class, id)) {
+            return R.ok();
+        } else {
+            return R.error();
+        }
+    }
+
+    @GetMapping("/listParams")
+    public R getParamsList(@RequestParam(defaultValue = "1") int page,
+                           @RequestParam(defaultValue = "10") int limit) {
+        // 计算总记录数
+        int totalCount = dataManager.getCount(NetworkGroup.class);
+        // 计算分页数据
+        List<NetworkParams> paramsList = dataManager.getList(NetworkGroup.class, page, limit).stream()
+                .map(NetworkParams::new).collect(Collectors.toList());
+        // 创建 PageUtils 实例
+        PageUtils pageUtils = new PageUtils(paramsList, totalCount, limit, page);
+
+        return R.ok().put("page", pageUtils);
+    }
+
+    @PostMapping("/updateParam")
+    public R updateNetworkParams(@RequestBody NetworkParams networkParams) {
+        NetworkGroup networkGroup = dataManager.getData(NetworkGroup.class, networkParams.getId());
+        if (networkGroup != null) {
+            String oldParams = networkGroup.getParams();
+            networkGroup.setParams(networkParams.getParams());
+            if (networkParams.getPlatformSet() != null) {
+                try {
+                    Set<Platform> collect = networkParams.getPlatformSet().stream()
+                            .map(x -> dataManager.getData(networkGroup.getTypeClass(), x))
+                            .peek(x ->{
+                                if(x.isGrouped() && !networkGroup.inSet(x.getId())){
+                                    throw new PlatUsedException();
+                                }
+                            })
+                            .collect(Collectors.toSet());
+                    if(collect.size()==networkParams.getPlatformSet().size() && !collect.contains(null)) {
+                        networkGroup.getPlatformSet().forEach(x->x.grouped(null));
+                        networkGroup.setPlatformSet(collect);
+                        collect.forEach(x->x.grouped(networkGroup.getId()));
+                        return R.ok();
+                    }
+                    else{
+                        networkGroup.setParams(oldParams);
+                        return R.error("存在错误类型的平台，修改已取消");
+                    }
+                } catch (IllegalTypeException e) {
+                    e.printStackTrace();
+                    return R.error(e.getMessage());
+                } catch (PlatUsedException e){
+                    return R.error(e.getMessage());
+                }
+            }
+            return R.ok();
+        } else return R.error("目标网络组不存在");
+    }
+
+    @GetMapping("/deleteParam")
+    public R deleteNetworkParams(@RequestParam Integer id){
+        NetworkGroup networkGroup = dataManager.getData(NetworkGroup.class, id);
+        networkGroup.setParams(null);
+        networkGroup.getPlatformSet().forEach(x->x.grouped(null));
+        networkGroup.setPlatformSet(new HashSet<>());
+        return R.ok();
+    }
+
+    //其实这两个方法应该合并为一个，然后在Controller层根据输入的Type判断用哪一个，在Service层进行具体实现
+    //但是没有Service，就懒得多写方法了
+    @GetMapping("/getRadarStations")
+    public R getRadarStations(){
+        return R.ok().put("data",dataManager.getAllData(RadarPlatform.class).stream()
+                .map(x-> new StationVo(x.getId(),x.isGrouped()))
+                .collect(Collectors.toList()));
+    }
+    @GetMapping("/getInterferStations")
+    public R getInterperStations(){
+        return R.ok().put("data",dataManager.getAllData(InterferPlatform.class).stream()
+                .map(x-> new StationVo(x.getId(),x.isGrouped()))
+                .collect(Collectors.toList()));
+    }
+    @GetMapping("/getInterferChartInfo")
+    public R getInterferChartInfo(){
+        List<NodeVo> nodes = dataManager.getInterferPlatforms().stream()
+                .map(x -> new NodeVo(x.getId(), x.getId()))
+                .collect(Collectors.toList());
+
+        List<EdgeVo> edgeList =new ArrayList<>();
+        for(NetworkGroup networkGroup: dataManager.getNetworkGroups()){
+            if(networkGroup.getType().equals("interference")) {
+                getEdgesFromGroup(edgeList, networkGroup);
+            }
+        }
+        return R.ok().put("nodes",nodes).put("edges",edgeList);
+    }
+    @GetMapping("/getRadarChartInfo")
+    public R getRadarChartInfo(){
+        List<NodeVo> nodes = dataManager.getRadarPlatforms().stream()
+                .map(x -> new NodeVo(x.getId(), x.getId()))
+                .collect(Collectors.toList());
+
+        List<EdgeVo> edgeList =new ArrayList<>();
+        for(NetworkGroup networkGroup: dataManager.getNetworkGroups()){
+            if(networkGroup.getType().equals("radar")) {
+                getEdgesFromGroup(edgeList, networkGroup);
+            }
+        }
+        return R.ok().put("nodes",nodes).put("edges",edgeList);
+    }
+
+    private void getEdgesFromGroup(List<EdgeVo> edgeList, NetworkGroup networkGroup) {
+        List<Platform> list = new ArrayList<>(networkGroup.getPlatformSet());
+        int size = list.size();
+        for(int i=0;i<size-1;i++){
+            for(int j=i+1;j<size;j++){
+                edgeList.add(new EdgeVo(list.get(i).getId(),list.get(j).getId()));
+            }
+        }
+    }
+//
+//    @PostMapping("update")
+//    public R updateNetworkGroup(@RequestParam Map<String, Object> params){
+//        String name = params.get("name").toString();
+//        String type = params.get("type").toString();
+//        String mainStation = params.get("mainStation").toString();
+//        String communication = params.get("communication").toString();
+//        // 修改列表中的对象
+//        for (NetworkGroup networkGroup: networkGroupList){
+//            if(networkGroup.getName().equals(name) && networkGroup.getType().equals(type)){
+//                networkGroup.setMainStation(mainStation);
+//                networkGroup.setCommunication(communication);
+//                //获取station数组，用于配置参数的链路设置,如果更新为enable，就加入list中
+//                addStation(type, communication, mainStation, name);
+//            }
+//        }
+//        return R.ok();
+//    }
+//
+//    @PostMapping("delete")
+//    public R deleteNetworkGroup(@RequestBody NetworkGroup networkGroup){
+//        networkGroupList.removeIf(group -> group.getId() == networkGroup.getId());
+//        idList.removeIf(map -> map.get("value").equals(networkGroup.getId()));
+//        radarStationList.removeIf(sourceStation -> sourceStation.get("name").equals(networkGroup.getMainStation()));
+//        interferenceStationList.removeIf(targetStation -> targetStation.get("name").equals(networkGroup.getMainStation()));
+//        return R.ok();
+//    }
+//
+//    @GetMapping("paramsList")
+//    public R paramsList(@RequestParam(defaultValue = "1") int page,
+//                  @RequestParam(defaultValue = "10") int limit){
+//
+//        System.out.println("networkParamsList" + networkParamsList);
+//        // 计算总记录数
+//        int totalCount = networkParamsList.size();
+//
+//        // 计算分页数据
+//        int fromIndex = (page - 1) * limit;
+//        int toIndex = Math.min(fromIndex + limit, totalCount);
+//        List<NetworkParams> paginatedList = networkParamsList.subList(fromIndex, toIndex);
+//
+//        // 创建 PageUtils 实例
+//        PageUtils page1 = new PageUtils(paginatedList, totalCount, limit, page);
+//
+//        return R.ok().put("page", page1);
+//    }
+//    @PostMapping("addParam")
+//    public R addNetworkParam(@RequestParam Map<String, Object> params){
+//        String link = params.get("link").toString();
+//        int groupId = Integer.parseInt(params.get("groupId").toString());
+//        String parameter = params.get("parameter").toString();
+//        String sourceStation = params.get("sourceStation").toString();
+//        String targetStation = params.get("targetStation").toString();
+//        for (NetworkParams networkParam: networkParamsList){
+//            if(networkParam.getLink().equals(link) && networkParam.getGroupId() == groupId){
+//                return R.error("链路已存在");
+//            }
+//        }
+//
+//        NetworkParams networkParam = new NetworkParams();
+//        networkParam.setGroupId(groupId);
+//        networkParam.setLink(link);
+//        networkParam.setParameter(parameter);
+//        networkParam.setSourceStation(sourceStation);
+//        networkParam.setTargetStation(targetStation);
+//        networkParamsList.add(networkParam);
+//        return R.ok();
+//    }
+//
+//    @PostMapping("updateParam")
+//    public R updateNetworkParam(@RequestParam Map<String, Object> params){
+//        String link = params.get("link").toString();
+//        int groupId = Integer.parseInt(params.get("groupId").toString());
+//        String parameter = params.get("parameter").toString();
+//        String sourceStation = params.get("sourceStation").toString();
+//        String targetStation = params.get("targetStation").toString();
+//        // 修改列表中的对象
+//        for (NetworkParams networkParam: networkParamsList){
+//            if(networkParam.getLink().equals(link) && networkParam.getGroupId() == groupId){
+//                return R.error("链路已存在");
+//            }
+//            if(networkParam.getGroupId() == groupId){
+//                networkParam.setLink(link);
+//                networkParam.setParameter(parameter);
+//                networkParam.setSourceStation(sourceStation);
+//                networkParam.setTargetStation(targetStation);
+//            }
+//        }
+//        return R.ok();
+//    }
+//
+//    @PostMapping("deleteParam")
+//    public R deleteNetworkParam(@RequestBody int id){
+//        networkParamsList.removeIf(networkParams -> networkParams.getId() == id);
+//        return R.ok();
+//    }
+//
+//    //添加主站
+//    private void addStation(String type, String communication, String mainStation, String groupName) {
+//        // 检查 communication 是否为 "enabled"
+//        if ("enabled".equals(communication)) {
+//            Map<String, Object> stationMap = new HashMap<>();
+//            stationMap.put("name", mainStation);
+//            stationMap.put("groupName", groupName);
+//
+//            // 根据 type 将 stationMap 添加到相应的列表中
+//            if ("radar".equals(type)) {
+//                // 检查是否已存在于 radarStationList 中
+//                if (!isStationExists(radarStationList, mainStation)) {
+//                    radarStationList.add(stationMap);
+//                }
+//            } else if ("interference".equals(type)) {
+//                // 检查是否已存在于 interferenceStationList 中
+//                if (!isStationExists(interferenceStationList, mainStation)) {
+//                    interferenceStationList.add(stationMap);
+//                }
+//            }
+//        }
+//    }
+//
+//    // 辅助方法：检查站点是否已存在
+//    private boolean isStationExists(List<Map<String, Object>> stationList, String mainStation) {
+//        return stationList.stream()
+//                .anyMatch(station -> mainStation.equals(station.get("name")));
+//    }
+}

src/main/java/com/dc/datachange/networkGroup/entity/EdgeVo.java

@@ -0,0 +1,16 @@
+package com.dc.datachange.networkGroup.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class EdgeVo {
+    private String source;
+    private String target;
+
+    public EdgeVo(Integer source, Integer target) {
+        this.source=source.toString();
+        this.target=target.toString();
+    }
+}

src/main/java/com/dc/datachange/networkGroup/entity/NetworkGroup.java

@@ -0,0 +1,85 @@
+package com.dc.datachange.networkGroup.entity;
+
+import com.dc.datachange.core.entity.platformInfo.Platform;
+import com.dc.datachange.core.entity.platformInfo.InterferPlatform;
+import com.dc.datachange.core.entity.platformInfo.RadarPlatform;
+import com.dc.datachange.exception.IllegalTypeException;
+import com.dc.datachange.exception.NameDuplicatedException;
+import com.dc.datachange.exception.PlatChangeException;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.HashSet;
+import java.util.Set;
+
+@Data
+@NoArgsConstructor
+public class NetworkGroup {
+
+    private static volatile int idCounter = 0; // 静态计数器
+    private static final HashSet<String> nameSet =new HashSet<>();
+
+    private int id;
+
+    private String type;
+
+    private String name;
+
+    private String mainStation;
+
+    private boolean communication;
+
+    private Set<Platform> platformSet;
+
+    private String params;
+
+    public NetworkGroup(RawGroup rawGroup) {
+        synchronized (NetworkGroup.class){
+            if(nameSet.contains(rawGroup.getName())){
+                throw new NameDuplicatedException();
+            }
+            nameSet.add(rawGroup.getName());
+            this.id=++idCounter;
+            this.type = rawGroup.getType();
+            this.name = rawGroup.getName();
+            this.mainStation = rawGroup.getMainStation();
+            this.communication = rawGroup.isCommunication();
+            this.platformSet = new HashSet<>();
+        }
+    }
+
+    public synchronized void update(NetworkGroup group) {
+        if(!platformSet.isEmpty() && !group.getType().equals(this.getType())){
+            throw new PlatChangeException();
+        }
+        if(nameSet.contains(group.getName()) && !group.getName().equals(this.getName())){
+            throw new NameDuplicatedException();
+        }
+        this.name=group.name;
+        this.type=group.type;
+        this.communication=group.communication;
+        this.mainStation=group.mainStation;
+    }
+
+    public boolean equals(Object o){
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        return ((NetworkGroup) o).getId()==this.id;
+    }
+
+    public Class<? extends Platform> getTypeClass(){
+        if(this.type.equals("radar")){
+            return RadarPlatform.class;
+        }else if(this.type.equals("interference")){
+            return InterferPlatform.class;
+        }else throw new IllegalTypeException();
+    }
+
+    public boolean inSet(Integer id){
+        return platformSet.stream().anyMatch(x->x.getId().equals(id));
+    }
+}

src/main/java/com/dc/datachange/networkGroup/entity/NetworkParams.java

@@ -0,0 +1,33 @@
+package com.dc.datachange.networkGroup.entity;
+
+import com.dc.datachange.core.entity.platformInfo.Platform;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Data
+@NoArgsConstructor
+public class NetworkParams {
+    private int id;
+    private String name;
+
+    private String params;
+
+    private Set<Integer> platformSet;
+    private String type;
+
+    public NetworkParams(NetworkGroup group){
+        if(group!=null){
+            this.type=group.getType();
+            this.name=group.getName();
+            this.id = group.getId();
+            this.params= group.getParams();
+            this.platformSet = group.getPlatformSet()
+                    .stream()
+                    .map(Platform::getId)
+                    .collect(Collectors.toSet());
+        }
+    }
+}

src/main/java/com/dc/datachange/networkGroup/entity/NodeVo.java

@@ -0,0 +1,16 @@
+package com.dc.datachange.networkGroup.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class NodeVo {
+    private String id;
+    private String name;
+
+    public NodeVo(Integer id, Integer name) {
+        this.id=id.toString();
+        this.name=name.toString();
+    }
+}

src/main/java/com/dc/datachange/networkGroup/entity/RawGroup.java

@@ -0,0 +1,21 @@
+package com.dc.datachange.networkGroup.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+/*
+ * 用于接收从前端发过来的没有id的分组信息
+ */
+public class RawGroup {
+    private String type;
+
+    private String name;
+
+    private String mainStation;
+
+    private boolean communication;
+}

src/main/java/com/dc/datachange/networkGroup/entity/StationVo.java

@@ -0,0 +1,14 @@
+package com.dc.datachange.networkGroup.entity;
+
+import lombok.Data;
+
+@Data
+public class StationVo {
+    private Integer id;
+    private boolean disabled;
+
+    public StationVo(Integer id, boolean grouped) {
+        this.id=id;
+        this.disabled=grouped;
+    }
+}

src/main/java/com/dc/datachange/utils/ConcurrentIndexedMap.java

@@ -0,0 +1,189 @@
+package com.dc.datachange.utils;
+
+import com.dc.datachange.exception.IllegalTypeException;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class ConcurrentIndexedMap<V> implements Collection<V> {
+    private final ConcurrentHashMap<Integer, V> keyMap;
+    private final CopyOnWriteArrayList<V> valueList;
+    private Type type = Type.UNKNOWN;
+
+    public ConcurrentIndexedMap(Class<?> t) {
+        if(Map.class.isAssignableFrom(t)){
+            type=Type.MAP;
+        }
+        else if (List.class.isAssignableFrom(t)){
+            type=Type.LIST;
+        }
+        this.keyMap = new ConcurrentHashMap<>();
+        this.valueList=new CopyOnWriteArrayList<>();
+    }
+
+    public String getType() {
+        return type.toString();
+    }
+
+    // 添加、修改元素，Map模式
+    public synchronized V put(Integer key, V value) {
+        checkMapType();
+//        新数据直接新增
+        if (!keyMap.containsKey(key)) {
+            valueList.add(value);
+            keyMap.put(key, value);
+        }else {
+//            旧数据修改Map数据与list数据
+//            没用上，代码中实际上是根据新元素修改旧元素，而不是进行替换
+            V oldValue=keyMap.get(key);
+            valueList.add(valueList.indexOf(oldValue),value);
+            keyMap.put(key,value);
+        }
+        return value;
+    }
+    // 添加元素，List模式
+    public boolean add(V v) {
+        checkListType();
+        return valueList.add(v);
+    }
+    // 添加元素，List模式
+    public boolean addAll(Collection<? extends V> c){
+        checkListType();
+        return valueList.addAll(c);
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        for(Object x: c){
+            if(this.remove(x)){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return this.valueList.retainAll(c);
+    }
+
+    // 修改元素，List模式
+    public V updateData(int index,V value){
+        return valueList.set(index, value);
+    }
+    // List一定有值，因此采用List
+    public int size(){
+        return valueList.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.valueList.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return this.valueList.contains(o);
+    }
+
+    @Override
+    public Iterator<V> iterator() {
+        return this.valueList.iterator();
+    }
+
+    @Override
+    public Object[] toArray() {
+        return this.valueList.toArray();
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        return this.valueList.toArray(a);
+    }
+
+    // 根据模式进行删除
+    public synchronized boolean remove(Object v) {
+        if(type.equals(Type.MAP)){
+            return removeByKey((Integer) v);
+        }else if(type.equals(Type.LIST)){
+            return removeByValue(v);
+        }
+        else throw new IllegalTypeException();
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        return new HashSet<>(this.valueList).containsAll(c);
+    }
+
+    public synchronized boolean removeByKey(Integer key) {
+        checkMapType();
+        if (keyMap.containsKey(key)) {
+            // 移除当前元素
+            V oldValue = keyMap.get(key);
+            valueList.remove(oldValue);
+            keyMap.remove(key);
+            return true;
+        }
+        return false;
+    }
+    public synchronized boolean removeByValue(Object value) {
+        checkListType();
+        if(value != null){
+            return valueList.remove(value);
+        }
+        return false;
+    }
+    public List<V> subList(int fromIndex, int toIndex) {
+        return valueList.subList(fromIndex, toIndex);
+    }
+
+    public V getData(Integer v){
+        if(type.equals(Type.MAP)){
+            return getByKey(v);
+        } else if (type.equals(Type.LIST)) {
+            return getByIndex(v);
+        }else
+            throw new IllegalTypeException();
+    }
+
+    // 根据键查找元素
+    private V getByKey(Integer key) {
+        return keyMap.get(key);
+    }
+    //根据index查找元素
+    private V getByIndex(int index){
+        return valueList.get(index);
+    }
+
+    // 清空数据
+    public synchronized void clear() {
+        keyMap.clear();
+        valueList.clear();
+    }
+
+    public List<V> getList(){
+        return this.valueList;
+    }
+
+    public enum Type{
+        UNKNOWN,LIST,MAP
+    }
+    private void checkListType() {
+        if(type.equals(Type.UNKNOWN)){
+            type=Type.LIST;
+        }else if(type.equals(Type.MAP)){
+            throw new IllegalTypeException();
+        }
+    }
+    private void checkMapType() {
+        if(type.equals(Type.UNKNOWN)){
+            type=Type.MAP;
+        }else if(type.equals(Type.LIST)){
+            throw new IllegalTypeException();
+        }
+    }
+
+
+}

src/main/java/com/dc/datachange/utils/PageUtils.java

@@ -0,0 +1,99 @@
+package com.dc.datachange.utils;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 分页工具类
+ *
+ * @author Mark sunlightcs@gmail.com
+ */
+public class PageUtils implements Serializable {
+	private static final long serialVersionUID = 4544626247724123447L;
+	/**
+	 * 总记录数
+	 */
+	private int totalCount;
+	/**
+	 * 每页记录数
+	 */
+	private int pageSize;
+	/**
+	 * 总页数
+	 */
+	private int totalPage;
+	/**
+	 * 当前页数
+	 */
+	private int currPage;
+	/**
+	 * 列表数据
+	 */
+	private List<?> list;
+
+	/**
+	 * 分页
+	 * @param list        列表数据
+	 * @param totalCount  总记录数
+	 * @param pageSize    每页记录数
+	 * @param currPage    当前页数
+	 */
+	public PageUtils(List<?> list, int totalCount, int pageSize, int currPage) {
+		this.list = list;
+		this.totalCount = totalCount;
+		this.pageSize = pageSize;
+		this.currPage = currPage;
+		this.totalPage = (int)Math.ceil((double)totalCount/pageSize);
+	}
+
+	/**
+	 * 分页
+	 */
+//	public PageUtils(IPage<?> page) {
+//		this.list = page.getRecords();
+//		this.totalCount = (int)page.getTotal();
+//		this.pageSize = (int)page.getSize();
+//		this.currPage = (int)page.getCurrent();
+//		this.totalPage = (int)page.getPages();
+//	}
+
+	public int getTotalCount() {
+		return totalCount;
+	}
+
+	public void setTotalCount(int totalCount) {
+		this.totalCount = totalCount;
+	}
+
+	public int getPageSize() {
+		return pageSize;
+	}
+
+	public void setPageSize(int pageSize) {
+		this.pageSize = pageSize;
+	}
+
+	public int getTotalPage() {
+		return totalPage;
+	}
+
+	public void setTotalPage(int totalPage) {
+		this.totalPage = totalPage;
+	}
+
+	public int getCurrPage() {
+		return currPage;
+	}
+
+	public void setCurrPage(int currPage) {
+		this.currPage = currPage;
+	}
+
+	public List<?> getList() {
+		return list;
+	}
+
+	public void setList(List<?> list) {
+		this.list = list;
+	}
+
+}

src/main/java/com/dc/datachange/utils/R.java

@@ -0,0 +1,56 @@
+package com.dc.datachange.utils;
+
+import org.apache.http.HttpStatus;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 返回数据
+ *
+ * @author Mark sunlightcs@gmail.com
+ */
+public class R extends HashMap<String, Object> {
+	private static final long serialVersionUID = 6554609311594029801L;
+
+	public R() {
+		put("code", 0);
+		put("msg", "success");
+	}
+
+	public static R error() {
+		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
+	}
+
+	public static R error(String msg) {
+		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
+	}
+
+	public static R error(int code, String msg) {
+		R r = new R();
+		r.put("code", code);
+		r.put("msg", msg);
+		return r;
+	}
+
+	public static R ok(String msg) {
+		R r = new R();
+		r.put("msg", msg);
+		return r;
+	}
+
+	public static R ok(Map<String, Object> map) {
+		R r = new R();
+		r.putAll(map);
+		return r;
+	}
+
+	public static R ok() {
+		return new R();
+	}
+
+	public R put(String key, Object value) {
+		super.put(key, value);
+		return this;
+	}
+}

src/main/java/com/dc/datachange/utils/Simulator.java

@@ -0,0 +1,155 @@
+package com.dc.datachange.utils;
+
+import com.dc.datachange.core.common.ControlConstans;
+import com.dc.datachange.core.common.MsgConstants;
+import com.dc.datachange.core.common.PlatConstants;
+import com.dc.datachange.core.connection.DDSPublisher;
+import com.dc.datachange.core.entity.platformInfo.InterferPlatform;
+import com.dc.datachange.core.entity.platformInfo.RadarPlatform;
+import com.dc.datachange.core.exchange.DataManager;
+import com.dc.datachange.networkGroup.controller.NetworkController;
+import com.dc.datachange.networkGroup.entity.NetworkGroup;
+import com.dc.datachange.networkGroup.entity.NetworkParams;
+import com.dc.datachange.networkGroup.entity.RawGroup;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+@RestController
+@RequestMapping("/test")
+public class Simulator {
+    @Autowired
+    private DDSPublisher publisher;
+    @Autowired
+    private DataManager dataManager;
+    @Autowired
+    private NetworkController networkController;
+    private static Integer count=0;
+
+    @GetMapping("/add1")
+    public R addRadarPulse(){
+        count++;
+        publisher.publishMessage(PlatConstants.TASK_SYSTEM+" "+PlatConstants.EXCHANGE_PLATFORM,
+                MsgConstants.RADAR_PULSE,"雷达 空中 21 127 10000 5000 "+count);
+        return R.ok();
+    }
+    @GetMapping("/add2")
+    public R addEleInter(){
+        count++;
+        publisher.publishMessage(PlatConstants.TASK_SYSTEM+" "+PlatConstants.EXCHANGE_PLATFORM,
+                MsgConstants.ELECTRIC_INTERFERE,"宽带干扰 空中 区域A 宽带干扰 未知 否 "+count);
+        return R.ok();
+    }
+    @GetMapping("/add3")
+    public R addComprehen(){
+        count++;
+        publisher.publishMessage(PlatConstants.TASK_SYSTEM+" "+PlatConstants.EXCHANGE_PLATFORM,
+                MsgConstants.COMPREHEN_INTELL,"综合 "+count+" 否 在侦察完成后立刻启动干扰");
+        return R.ok();
+    }
+    @GetMapping("/init")
+    public R init() throws InterruptedException {
+        publisher.publishMessage(PlatConstants.SUPPORT_PLATFORM+" "+PlatConstants.EXCHANGE_PLATFORM,
+                MsgConstants.INITIAL_MSG,
+                "6 4\n" +
+                        "104 1 0 1 -1502143.7779720642 5459654.14635412 2925524.054455928\n" +
+                        "105 1 0 1 -1119974.522455073 5202530.972695272 3503886.1094705067\n" +
+                        "103 1 0 1 -1569497.379037304 4803025.549234323 3879026.548666874\n" +
+                        "106 1 0 1 -2853706.7751482297 3559878.3551225117 4441990.145821915\n" +
+                        "101 1 0 1 -2437977.331981979 5037635.193417693 3049012.3329436616\n" +
+                        "102 1 0 1 -2088875.7919909689 4487613.197114771 4008771.869184186\n" +
+                        "201 2 1 1 -2288875.7919909689 4187613.197114771 4058771.869184186\n" +
+                        "202 2 1 1 -2388875.7919909689 4287613.197114771 4108771.869184186\n" +
+                        "203 2 1 1 -2188875.7919909689 4387613.197114771 4208771.869184186\n" +
+                        "204 2 1 1 -2588875.7919909689 4487613.197114771 4078771.869184186");
+        this.addNet1();
+        this.addNet2();
+        this.addNet1();
+        this.addNet2();
+        Thread.sleep(1000);
+        R r = addParams(1, new ArrayList<Integer>() {{
+            add(104);
+            add(105);
+        }});
+        System.out.println(r.toString());
+        R r1 = addParams(2, new ArrayList<Integer>() {{
+            add(201);
+            add(202);
+            add(203);
+        }});
+        System.out.println(r1.toString());
+        return R.ok();
+    }
+    @GetMapping("/initError1")
+    public R initError1(){
+        return addParams(2,new ArrayList<Integer>(){{add(104);add(202);}});
+    }
+    @GetMapping("/initError2")
+    public R initError2(){
+        return addParams(2,new ArrayList<Integer>(){{add(104);add(1111);}});
+    }
+    @GetMapping("/init2")
+    public R init2(){
+        publisher.publishMessage(PlatConstants.SUPPORT_PLATFORM+" "+PlatConstants.TASK_SYSTEM,
+                MsgConstants.INITIAL_MSG,
+                "6 4\n" +
+                        "104 1 0 1 -1502143.7779720642 5459654.14635412 2925524.054455928\n" +
+                        "105 1 0 1 -1119974.522455073 5202530.972695272 3503886.1094705067\n" +
+                        "103 1 0 1 -1569497.379037304 4803025.549234323 3879026.548666874\n" +
+                        "106 1 0 1 -2853706.7751482297 3559878.3551225117 4441990.145821915\n" +
+                        "101 1 0 1 -2437977.331981979 5037635.193417693 3049012.3329436616\n" +
+                        "102 1 0 1 -2088875.7919909689 4487613.197114771 4008771.869184186\n" +
+                        "201 2 1 1 -2288875.7919909689 4187613.197114771 4058771.869184186\n" +
+                        "202 2 1 1 -2388875.7919909689 4287613.197114771 4108771.869184186\n" +
+                        "203 2 1 1 -2188875.7919909689 4387613.197114771 4208771.869184186\n" +
+                        "204 2 1 1 -2588875.7919909689 4487613.197114771 4078771.869184186");
+        return R.ok();
+    }
+    @GetMapping("/listInter")
+    public R listInter(){
+        return R.ok().put("data", dataManager.getList(InterferPlatform.class,1,100));
+    }
+
+    @GetMapping("/listRadar")
+    public R listRadar(){
+        return R.ok().put("data", dataManager.getList(RadarPlatform.class,1,100));
+    }
+    @GetMapping("/stop")
+    public R stop(){
+        publisher.publishMessage(PlatConstants.SUPPORT_PLATFORM+" "+PlatConstants.EXCHANGE_PLATFORM,
+                MsgConstants.DAOTIAO_MSG, ControlConstans.CTRL_FINISH);
+        return R.ok();
+    }
+    @GetMapping("/addNet1")
+    public R addNet1(){
+        count++;
+        NetworkGroup interference =new NetworkGroup(new RawGroup("interference", count.toString(), count.toString(), true));
+        dataManager.addData(interference.getId(),interference);
+        return R.ok();
+    }
+    @GetMapping("/addNet2")
+    public R addNet2(){
+        count++;
+        NetworkGroup radar = new NetworkGroup(new RawGroup("radar", count.toString(), count.toString(), true));
+        dataManager.addData(radar.getId(),radar);
+        return R.ok();
+    }
+    @GetMapping("/listNet")
+    public R listNet(){
+        return R.ok().put("data",dataManager.getList(NetworkGroup.class,1,100));
+    }
+    @GetMapping("/addParams")
+    public R addParams(Integer id, List<Integer> ids){
+        count++;
+        NetworkParams data = new NetworkParams();
+        data.setId(id);
+        data.setParams(count.toString());
+        data.setPlatformSet(new HashSet<>(ids));
+        return networkController.updateNetworkParams(data);
+    }
+}

src/main/resources/application.yml

@@ -0,0 +1,58 @@
+# 应用名称
+spring:
+  application:
+    name: dataChange
+
+  #远程登录时使用的信息
+  omm:
+    ip: localhost
+    port: 8081
+    clientId: testapp
+    clientSecret: 123123
+
+  datasource:
+    url: jdbc:mysql://localhost:3306/dataChange
+    username: root
+    password: 123456
+    driver-class-name: com.mysql.cj.jdbc.Driver
+
+# 应用服务 WEB 访问端口
+server:
+  port: 8081
+  #  定时组件的配置，一般不改动
+  quartz:
+    properties:
+      org:
+        quartz:
+          scheduler:
+            instanceName: clusteredScheduler
+            instanceId: AUTO
+          jobStore:
+            class: org.quartz.impl.jdbcjobstore.JobStoreTX
+            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
+            tablePrefix: QRTZ_
+            isClustered: true
+            clusterCheckinInterval: 10000
+            useProperties: false
+          threadPool:
+            class: org.quartz.simpl.SimpleThreadPool
+            threadCount: 10
+            threadPriority: 5
+            threadsInheritContextClassLoaderOfInitializingThread: true
+
+#日志信息显示等级,默认为info
+logging:
+  level:
+    com.dmd.bigdata.mapper: debug
+    com.dmd.bigdata.levelManage.dao: debug
+
+dds:
+  connection:
+  #  不知道
+    DCPSBit: 0
+  #  DDS实例位置
+    DCPSConfigFile: D:\rocket\OpenDDS-3.16\java\tests\messenger\tcp.ini
+    isReliable: false
+    isWaitForAcks: false
+  config:
+    enablePrint: true

src/main/resources/static/index.html

@@ -0,0 +1,6 @@
+<html>
+<body>
+<h1>hello word!!!</h1>
+<p>this is a html page</p>
+</body>
+</html>