# iot-simulate

**Repository Path**: chenfei6095/iot-simulate

## Basic Information

- **Project Name**: iot-simulate
- **Description**: 物联网设备数据模拟生成系统
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-29
- **Last Updated**: 2025-06-29

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

---

### **物联网设备数据模拟生成系统（基于 Java 技术栈）**

---

#### **一、设计目标**
1. **协议规范驱动**：根据预定义的协议规范（如 Modbus、MQTT、HTTP、IEC 61850 等），模拟生成设备数据。
2. **动态配置**：通过 YAML/JSON 配置文件定义设备通信参数和数据生成逻辑。
3. **数据格式转换**：将模拟数据转换为目标协议的字节流或文本格式（如 JSON）。
4. **扩展性**：支持新增协议类型和数据生成策略。
5. **性能与稳定性**：高并发模拟生成，支持断网续传和日志记录。

---

#### **二、技术选型**
- **语言**：Java 17
- **框架**：Spring Boot 3.x（支持 JDK 17）
- **核心库**：
    - **配置管理**：`Spring @ConfigurationProperties`
    - **数据生成**：`Apache Commons Math`（随机数生成）
    - **协议转换**：`Jackson`（JSON 序列化）、`Modbus4J`（Modbus 协议生成）
    - **策略模式**：`Spring @Component` 注解管理生成策略
- **日志**：`Logback` + `ELK Stack`
- **监控**：`Spring Boot Actuator` + `Prometheus`

---

#### **三、系统架构设计**
```
+-------------------+       +-------------------+       +-------------------+
|   配置解析层      |       |   数据生成层       |       |   协议转换层       |
| (YAML/JSON)       |<----->| (策略驱动生成)    |<----->| (字节流/JSON)     |
+-------------------+       +-------------------+       +-------------------+
```

---

#### **四、核心模块设计**
##### **1. 配置解析层**
- **配置文件结构**（YAML 示例）：
  ```yaml
  devices:
    - id: device_001
      protocol: modbus_tcp
      ip: 192.168.1.101
      port: 502
      data:
        - register: 40001
          name: temperature
          type: float
          strategy: random
          range: [20.0, 30.0]
    - id: device_002
      protocol: mqtt
      topic: device/data
      data:
        - name: voltage
          type: int
          strategy: fixed
          value: 220
  ```

- **配置绑定**：
  ```java
  @ConfigurationProperties(prefix = "devices")
  public class DeviceConfig {
      private List<Device> devices;
      // Getter/Setter
  }

  public class Device {
      private String id;
      private String protocol;
      private Map<String, Object> config;
      private List<Register> data;
      // Getter/Setter
  }
  ```

##### **2. 数据生成层**
- **策略模式实现**：
    - 定义接口 `GenerationStrategy`：
      ```java
      public interface DataGenerationStrategy {
          Object generate(Map<String, Object> config);
      }
      ```
    - 实现随机数策略：
      ```java
      @Component("random")
      public class RandomGenerationStrategy implements DataGenerationStrategy {
          @Override
          public Object generate(Map<String, Object> config) {
              double min = (double) config.get("min");
              double max = (double) config.get("max");
              return Math.random() * (max - min) + min;
          }
      }
      ```
    - 实现固定值策略：
      ```java
      @Component("fixed")
      public class FixedValueStrategy implements DataGenerationStrategy {
          @Override
          public Object generate(Map<String, Object> config) {
              return config.get("value");
          }
      }
      ```

- **数据生成引擎**：
  ```java
  @Service
  public class DataGenerator {
      private final Map<String, DataGenerationStrategy> strategies;

      public DataGenerator(Map<String, DataGenerationStrategy> strategies) {
          this.strategies = strategies;
      }

      public Map<String, Object> generateData(Register register) {
          DataGenerationStrategy strategy = strategies.get(register.getStrategy());
          Object value = strategy.generate(register.getConfig());
          return Map.of(register.getName(), value);
      }
  }
  ```

##### **3. 协议转换层**
- **协议适配器接口**：
  ```java
  public interface ProtocolAdapter {
      byte[] convertToBytes(Map<String, Object> data);
      String convertToJson(Map<String, Object> data);
  }
  ```

- **Modbus 协议适配器**：
  ```java
  @Component("modbus_tcp")
  public class ModbusTcpAdapter implements ProtocolAdapter {
      @Override
      public byte[] convertToBytes(Map<String, Object> data) {
          // 构造 Modbus 寄存器写入报文（示例：40001 寄存器值为 25.5）
          byte[] payload = new byte[4];
          Float value = (Float) data.get("temperature");
          byte[] bytes = ByteBuffer.allocate(4).putFloat(value).array();
          return bytes;
      }

      @Override
      public String convertToJson(Map<String, Object> data) {
          return "Modbus data: " + data;
      }
  }
  ```

- **MQTT 协议适配器**：
  ```java
  @Component("mqtt")
  public class MqttAdapter implements ProtocolAdapter {
      @Override
      public byte[] convertToBytes(Map<String, Object> data) {
          // MQTT 无需字节转换，直接返回 JSON 字符串
          return new byte[0];
      }

      @Override
      public String convertToJson(Map<String, Object> data) {
          ObjectMapper mapper = new ObjectMapper();
          return mapper.writeValueAsString(data);
      }
  }
  ```

##### **4. 数据输出层**
- **文件输出**（模拟生成数据到本地文件）：
  ```java
  @Service
  public class FileOutputService {
      public void writeData(String deviceId, String data) {
          Path path = Paths.get("output/" + deviceId + ".json");
          Files.write(path, data.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
      }
  }
  ```

- **内存缓存**（支持断网续传）：
  ```java
  @Service
  public class DataCache {
      private final Queue<String> retryQueue = new LinkedBlockingQueue<>();

      public void add(String data) {
          retryQueue.add(data);
      }

      public String poll() {
          return retryQueue.poll();
      }
  }
  ```

---

#### **五、动态扩展与配置**
- **新增协议支持**：
    1. 实现新的 `ProtocolAdapter` 并标记 `@Component("new_protocol")`。
    2. 在配置文件中定义设备的 `protocol: new_protocol`。

- **新增生成策略**：
    1. 实现 `DataGenerationStrategy` 并标记 `@Component("new_strategy")`。
    2. 在配置文件中设置 `strategy: new_strategy`。

---

#### **六、验证与测试**
- **单元测试**：
  ```java
  @SpringBootTest
  public class DataGeneratorTest {
      @Autowired
      private DataGenerator generator;

      @Test
      void testRandomStrategy() {
          Register register = new Register();
          register.setStrategy("random");
          register.setConfig(Map.of("min", 20.0, "max", 30.0));
          Map<String, Object> data = generator.generateData(register);
          assertTrue((Double) data.get("temperature") >= 20.0 && (Double) data.get("temperature") <= 30.0);
      }
  }
  ```

- **协议转换测试**：
  ```java
  @SpringBootTest
  public class ModbusAdapterTest {
      @Autowired
      private ProtocolAdapter modbusAdapter;

      @Test
      void testConvertToBytes() {
          Map<String, Object> data = Map.of("temperature", 25.5f);
          byte[] bytes = modbusAdapter.convertToBytes(data);
          assertEquals(4, bytes.length);
      }
  }
  ```

---

#### **七、部署与运维**
- **容器化部署**：
  ```dockerfile
  FROM openjdk:17-jdk-slim
  COPY target/gateway.jar app.jar
  ENTRYPOINT ["java", "-jar", "app.jar"]
  ```

- **监控与日志**：
    - **日志聚合**：集成 `ELK Stack` 收集日志。
    - **健康检查**：通过 `/actuator/health` 检查服务状态。

---

### **八、总结**
本方案聚焦于 **基于协议规范的模拟数据生成**，完全避免了实际网络通信代码（如 `Bootstrap` 启动）。核心设计包括：
1. **配置驱动**：通过 YAML 定义设备协议和数据规则。
2. **策略模式**：灵活支持随机数、固定值等多种数据生成策略。
3. **协议适配器**：将模拟数据转换为目标协议的字节流或 JSON。
4. **扩展性**：通过 Spring 组件化支持新增协议和策略。

适用于物联网设备仿真、协议测试等场景，满足 Java 技术栈下的高效模拟需求。

## 许可证

本项目使用 Apache 2.0 许可证。详情请查看 LICENSE 文件。