添加redis的支持

src/main/java/com/tuoheng/machine/statemachine/MachineStateManager.java

@@ -1,6 +1,7 @@
 package com.tuoheng.machine.statemachine;
 
 import com.tuoheng.machine.state.*;
+import com.tuoheng.machine.statemachine.store.MachineStateStore;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
@@ -9,26 +10,31 @@ import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * 设备状态管理器
+ * 负责状态的业务逻辑处理和变化通知，底层存储由 MachineStateStore 实现
  */
 @Slf4j
 @Component
 public class MachineStateManager {
 
     /**
-     * SN -> 设备状态
+     * 状态存储层（支持内存、Redis等多种实现）
      */
-    private final Map<String, MachineStates> stateMap = new ConcurrentHashMap<>();
+    private final MachineStateStore stateStore;
 
     /**
      * 状态变化监听器
      */
     private final Map<String, StateChangeListener> stateChangeListeners = new ConcurrentHashMap<>();
+    public MachineStateManager(MachineStateStore stateStore) {
+        this.stateStore = stateStore;
+        log.info("设备状态管理器初始化完成，使用存储实现: {}", stateStore.getClass().getSimpleName());
+    }
 
     /**
      * 获取设备状态
      */
     public MachineStates getStates(String sn) {
-        return stateMap.computeIfAbsent(sn, k -> new MachineStates());
+        return stateStore.getStates(sn);
     }
 
     /**
@@ -40,6 +46,7 @@ public class MachineStateManager {
 
         if (oldState != newState) {
             states.setDroneState(newState);
+            stateStore.saveStates(sn, states); // 保存到存储层
             log.info("无人机状态变化: sn={}, {} -> {}", sn, oldState, newState);
             notifyStateChange(sn, states.copy());
         }
@@ -54,6 +61,7 @@ public class MachineStateManager {
 
         if (oldState != newState) {
             states.setAirportState(newState);
+            stateStore.saveStates(sn, states); // 保存到存储层
             log.info("机巢状态变化: sn={}, {} -> {}", sn, oldState, newState);
             notifyStateChange(sn, states.copy());
         }
@@ -68,6 +76,7 @@ public class MachineStateManager {
 
         if (oldState != newState) {
             states.setCoverState(newState);
+            stateStore.saveStates(sn, states); // 保存到存储层
             log.info("舱门状态变化: sn={}, {} -> {}", sn, oldState, newState);
             notifyStateChange(sn, states.copy());
         }
@@ -82,6 +91,7 @@ public class MachineStateManager {
 
         if (oldState != newState) {
             states.setDrcState(newState);
+            stateStore.saveStates(sn, states); // 保存到存储层
             log.info("DRC状态变化: sn={}, {} -> {}", sn, oldState, newState);
             notifyStateChange(sn, states.copy());
         }
@@ -139,6 +149,7 @@ public class MachineStateManager {
         }
 
         if (changed) {
+            stateStore.saveStates(sn, currentStates); // 保存到存储层
             log.info("设备状态批量更新: sn={}, states={}", sn, currentStates);
             notifyStateChange(sn, currentStates.copy());
         }
@@ -177,7 +188,7 @@ public class MachineStateManager {
      * 移除设备状态（设备下线时调用）
      */
     public void removeStates(String sn) {
-        stateMap.remove(sn);
+        stateStore.removeStates(sn);
         log.info("移除设备状态: sn={}", sn);
     }
 }

src/main/java/com/tuoheng/machine/statemachine/store/InMemoryMachineStateStore.java

@@ -0,0 +1,49 @@
+package com.tuoheng.machine.statemachine.store;
+
+import com.tuoheng.machine.state.MachineStates;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 基于内存的设备状态存储实现
+ * 适用于单节点部署或开发测试环境
+ */
+@Slf4j
+@Component
+@ConditionalOnProperty(name = "machine.state.store.type", havingValue = "memory", matchIfMissing = true)
+public class InMemoryMachineStateStore implements MachineStateStore {
+
+    /**
+     * SN -> 设备状态
+     */
+    private final Map<String, MachineStates> stateMap = new ConcurrentHashMap<>();
+
+    @Override
+    public MachineStates getStates(String sn) {
+        return stateMap.computeIfAbsent(sn, k -> {
+            log.debug("创建新的设备状态: sn={}", sn);
+            return new MachineStates();
+        });
+    }
+
+    @Override
+    public void saveStates(String sn, MachineStates states) {
+        stateMap.put(sn, states);
+        log.debug("保存设备状态到内存: sn={}", sn);
+    }
+
+    @Override
+    public void removeStates(String sn) {
+        stateMap.remove(sn);
+        log.debug("从内存中移除设备状态: sn={}", sn);
+    }
+
+    @Override
+    public boolean exists(String sn) {
+        return stateMap.containsKey(sn);
+    }
+}

src/main/java/com/tuoheng/machine/statemachine/store/MachineStateStore.java

@@ -0,0 +1,42 @@
+package com.tuoheng.machine.statemachine.store;
+
+import com.tuoheng.machine.state.MachineStates;
+
+/**
+ * 设备状态存储接口
+ * 提供状态的存储和获取抽象，支持多种实现（内存、Redis等）
+ */
+public interface MachineStateStore {
+
+    /**
+     * 获取设备状态
+     * 如果设备状态不存在，返回一个新的默认状态对象
+     *
+     * @param sn 设备SN号
+     * @return 设备状态
+     */
+    MachineStates getStates(String sn);
+
+    /**
+     * 保存设备状态
+     *
+     * @param sn 设备SN号
+     * @param states 设备状态
+     */
+    void saveStates(String sn, MachineStates states);
+
+    /**
+     * 移除设备状态
+     *
+     * @param sn 设备SN号
+     */
+    void removeStates(String sn);
+
+    /**
+     * 检查设备状态是否存在
+     *
+     * @param sn 设备SN号
+     * @return 是否存在
+     */
+    boolean exists(String sn);
+}

src/main/java/com/tuoheng/machine/statemachine/store/RedisMachineStateStore.java

@@ -0,0 +1,81 @@
+package com.tuoheng.machine.statemachine.store;
+
+import com.tuoheng.machine.state.MachineStates;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Component;
+
+/**
+ * 基于 Redis 的设备状态存储实现
+ * 适用于多节点部署的生产环境
+ *
+ * 使用方式：
+ * 1. 在 application.properties 中配置：machine.state.store.type=redis
+ * 2. 实现 Redis 相关的序列化和反序列化逻辑
+ * 3. 配置 Redis 连接信息
+ *
+ * 注意：当前为空实现，需要在生产环境部署时完善
+ */
+@Slf4j
+@Component
+@ConditionalOnProperty(name = "machine.state.store.type", havingValue = "redis")
+public class RedisMachineStateStore implements MachineStateStore {
+
+    // TODO: 注入 RedisTemplate 或 StringRedisTemplate
+    // private final RedisTemplate<String, MachineStates> redisTemplate;
+
+    // TODO: 配置 Redis key 的前缀
+    // private static final String KEY_PREFIX = "machine:state:";
+
+    // TODO: 配置状态的过期时间（可选）
+    // private static final long EXPIRE_SECONDS = 86400; // 24小时
+
+    public RedisMachineStateStore() {
+        log.warn("使用 Redis 状态存储实现，但当前为空实现，请在生产环境部署前完善");
+    }
+
+    @Override
+    public MachineStates getStates(String sn) {
+        // TODO: 实现从 Redis 获取状态
+        // String key = KEY_PREFIX + sn;
+        // MachineStates states = redisTemplate.opsForValue().get(key);
+        // if (states == null) {
+        //     states = new MachineStates();
+        //     saveStates(sn, states);
+        // }
+        // return states;
+
+        log.warn("Redis 状态存储未实现，返回默认状态: sn={}", sn);
+        return new MachineStates();
+    }
+
+    @Override
+    public void saveStates(String sn, MachineStates states) {
+        // TODO: 实现保存状态到 Redis
+        // String key = KEY_PREFIX + sn;
+        // redisTemplate.opsForValue().set(key, states, EXPIRE_SECONDS, TimeUnit.SECONDS);
+        // log.debug("保存设备状态到 Redis: sn={}", sn);
+
+        log.warn("Redis 状态存储未实现，跳过保存: sn={}", sn);
+    }
+
+    @Override
+    public void removeStates(String sn) {
+        // TODO: 实现从 Redis 删除状态
+        // String key = KEY_PREFIX + sn;
+        // redisTemplate.delete(key);
+        // log.debug("从 Redis 中移除设备状态: sn={}", sn);
+
+        log.warn("Redis 状态存储未实现，跳过删除: sn={}", sn);
+    }
+
+    @Override
+    public boolean exists(String sn) {
+        // TODO: 实现检查 Redis 中是否存在状态
+        // String key = KEY_PREFIX + sn;
+        // return Boolean.TRUE.equals(redisTemplate.hasKey(key));
+
+        log.warn("Redis 状态存储未实现，返回 false: sn={}", sn);
+        return false;
+    }
+}