refactor: P0-P1 complete — field injection, logging, hardcoded values, resource mgmt

P0 fixes:
- MqttFaultConsumer: array index bounds check, NPE guard on null coordinates
- MqttStatusConsumer: NPE guard on null required fields
- TDegnineAlarm: ResultSet try-with-resources, SQL injection whitelist
- AbstractMqttConsumer: brokerUrl parsing validation, mqttPassword null guard

P1 fixes:
- Field injection → constructor injection (7 files: MqttFaultConsumer,
  MqttStatusConsumer, SysIndicatorsService, SysWorkorderService,
  TDengineService, TDegnineAlarm, AbstractMqttConsumer)
- SLF4J {} placeholder logging (4 places in AbstractMqttConsumer)
- Extract hardcoded constants: alarm status, date format, company ID prefix,
  webhook URL → IotProperties configuration
- TDengineService: dataSourceInitialized volatile, GZIP try-with-resources

Tests:
- Fix MqttStatusConsumerTest/MqttFaultConsumerTest/MqttGenericConsumerTest
  for new constructors (remove @InjectMocks, manual instantiation)
- 65/67 tests passing (2 TDengine JNI env-dependent failures excluded)

iot-platform/src/main/java/com/iot/platform/config/IotProperties.java

         private String username = "";
         private String password = "";
         private String chargeStationTopic = "station/ChargeStation/device/+/post/json";
+        private String alarmWebhookUrl = "https://esos-iot.com:9443/syscar/gaojing";
 
         public String getBrokerUrl() {
             return brokerUrl;
         public void setChargeStationTopic(String chargeStationTopic) {
             this.chargeStationTopic = chargeStationTopic;
         }
+
+        public String getAlarmWebhookUrl() {
+            return alarmWebhookUrl;
+        }
+
+        public void setAlarmWebhookUrl(String alarmWebhookUrl) {
+            this.alarmWebhookUrl = alarmWebhookUrl;
+        }
     }
 
     /**

iot-platform/src/main/java/com/iot/platform/mqtt/AbstractMqttConsumer.java

 
     protected final Logger log = LoggerFactory.getLogger(getClass());
 
-    @Autowired
-    protected IotProperties iotProperties;
-
+    protected final IotProperties iotProperties;
     protected final ExecutorService executorService;
 
     private String brokerUrl;
     protected MqttConnectOptions connOpts;
     protected volatile boolean isMqttConnected = false;
 
-    protected AbstractMqttConsumer(ExecutorService executorService) {
+    protected AbstractMqttConsumer(ExecutorService executorService, IotProperties iotProperties) {
         this.executorService = executorService;
+        this.iotProperties = iotProperties;
     }
 
     protected abstract String getSubscribeTopic();
         this.brokerUrl = iotProperties.getMqtt().getBrokerUrl();
         String brokerAddr = this.brokerUrl.replace("tcp://", "");
         int colonIdx = brokerAddr.lastIndexOf(':');
+        if (colonIdx <= 0 || colonIdx == brokerAddr.length() - 1) {
+            throw new IllegalArgumentException("MQTT broker-url 格式无效，期望 tcp://host:port，实际: " + this.brokerUrl);
+        }
         this.brokerHost = brokerAddr.substring(0, colonIdx);
         this.brokerPort = Integer.parseInt(brokerAddr.substring(colonIdx + 1));
         this.mqttUsername = iotProperties.getMqtt().getUsername();
         connOpts.setAutomaticReconnect(true);
         connOpts.setConnectionTimeout(10);
         connOpts.setUserName(mqttUsername);
+        if (mqttPassword == null) {
+            mqttPassword = "";
+        }
         connOpts.setPassword(mqttPassword.toCharArray());
     }
 
         mqttClient.setCallback(new MqttCallback() {
             @Override
             public void connectionLost(Throwable cause) {
-                log.error("MQTT连接断开，开始重连：" + cause.getMessage());
+                log.error("MQTT连接断开，开始重连: {}", cause.getMessage());
                 isMqttConnected = false;
                 reconnect();
             }
             if (connectToken.isComplete()) {
                 mqttClient.subscribe(getSubscribeTopic(), QOS);
                 isMqttConnected = true;
-                log.info("MQTT连接成功，已订阅主题：" + getSubscribeTopic());
+                log.info("MQTT连接成功，已订阅主题: {}", getSubscribeTopic());
             }
         }
     }
                     mqttClient.connect(connOpts);
                     mqttClient.subscribe(getSubscribeTopic(), QOS);
                     isMqttConnected = true;
-                    log.info("MQTT重连成功（第" + attempt + "次尝试）");
+                    log.info("MQTT重连成功（第{}次尝试）", attempt);
                     break;
                 }
             } catch (MqttException | InterruptedException e) {
-                log.error("MQTT重连失败（第" + attempt + "次尝试）：" + e.getMessage());
+                log.error("MQTT重连失败（第{}次尝试）: {}", attempt, e.getMessage());
                 if (attempt == maxReconnectAttempts) {
                     log.error("已达最大重连次数，停止重连");
                 }

iot-platform/src/main/java/com/iot/platform/mqtt/MqttFaultConsumer.java

 package com.iot.platform.mqtt;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.iot.platform.config.IotProperties;
 import com.iot.platform.domain.SysDevice;
 import com.iot.platform.domain.SysFault;
 import com.iot.platform.service.*;
 @Component
 public class MqttFaultConsumer extends AbstractMqttConsumer {
 
-    @Autowired
-    public SysControllerService sysControllerService;
-    @Autowired
-    public SysFaultService sysFaultService;
-    @Autowired
-    public SysrealtimeService sysrealtimeService;
-    @Autowired
-    public SysWorkorderService sysWorkorderService;
-    @Autowired
-    public SysAlarmService sysAlarmService;
-    @Autowired
-    public NumericIdGenerator numericIdGenerator;
-    @Autowired
-    public TDegnineAlarm tDegnineAlarm;
-    @Autowired
-    private RestTemplate restTemplate;
+    private final SysControllerService sysControllerService;
+    private final SysFaultService sysFaultService;
+    private final SysrealtimeService sysrealtimeService;
+    private final SysWorkorderService sysWorkorderService;
+    private final SysAlarmService sysAlarmService;
+    private final NumericIdGenerator numericIdGenerator;
+    private final TDegnineAlarm tDegnineAlarm;
+    private final RestTemplate restTemplate;
+
+    private static final String ALARM_STATUS_TRIGGER = "0";
+    private static final String ALARM_STATUS_RECOVERED = "1";
+    private static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
+    private static final String COMPANY_ID_PREFIX = "GJ";
 
     private final ObjectMapper objectMapper = new ObjectMapper();
     private final ExecutorService mqttFaultExecutor;
 
     @Autowired
     public MqttFaultConsumer(@Qualifier("mqttFaultExecutor") ExecutorService mqttFaultExecutor,
-                             @Qualifier("abstractConsumerExecutor") ExecutorService executorService) {
-        super(executorService);
+                             @Qualifier("abstractConsumerExecutor") ExecutorService executorService,
+                             IotProperties iotProperties,
+                             SysControllerService sysControllerService,
+                             SysFaultService sysFaultService,
+                             SysrealtimeService sysrealtimeService,
+                             SysWorkorderService sysWorkorderService,
+                             SysAlarmService sysAlarmService,
+                             NumericIdGenerator numericIdGenerator,
+                             TDegnineAlarm tDegnineAlarm,
+                             RestTemplate restTemplate) {
+        super(executorService, iotProperties);
         this.mqttFaultExecutor = mqttFaultExecutor;
+        this.sysControllerService = sysControllerService;
+        this.sysFaultService = sysFaultService;
+        this.sysrealtimeService = sysrealtimeService;
+        this.sysWorkorderService = sysWorkorderService;
+        this.sysAlarmService = sysAlarmService;
+        this.numericIdGenerator = numericIdGenerator;
+        this.tDegnineAlarm = tDegnineAlarm;
+        this.restTemplate = restTemplate;
     }
 
     private static final Map<String, String> KEY_MAPPING = new HashMap<>();
     }
 
     public void insertTDegine(Map<String, Object> weather, String topic) throws SQLException {
+        String[] topicParts = topic.split("/");
+        if (topicParts.length < 2) {
+            log.warn("无效的topic格式，缺少分隔符: {}", topic);
+            return;
+        }
         LocalDate localDate = LocalDate.now();
         int year = localDate.getYear();
         int month = localDate.getMonthValue();
-        String supertablename = topic.split("/")[0];
-        String table = topic.split("/")[0] + "_" + year + month;
+        String supertablename = topicParts[0];
+        String table = topicParts[0] + "_" + year + month;
 
         Map<String, Object> newMap = new HashMap<>();
         for (Map.Entry<String, Object> entry : weather.entrySet()) {
                 newMap.put(originalKey, value);
             }
         }
-        tDegnineAlarm.shibaihou(newMap, supertablename, table, topic.split("/")[1]);
+        tDegnineAlarm.shibaihou(newMap, supertablename, table, topicParts[1]);
     }
 
     public void triggermethod(String topic, SysFault weather) {
 
         String controllerId = weather.getController_id();
         String[] topics = topic.split("/");
+        if (topics.length == 0) {
+            log.warn("无效的topic格式: {}", topic);
+            return;
+        }
 
         List<String> tablename = sysrealtimeService.selecttables();
         List<Boolean> a = new ArrayList<>();
             sysFaultService.createmessage(controllername);
         }
 
+        SysDevice jingdu = sysControllerService.selectjingweidu(topics[0], "经度");
+        SysDevice weidu = sysControllerService.selectjingweidu(topics[0], "纬度");
+        if (jingdu == null || weidu == null) {
+            log.warn("未查询到控制器经纬度信息: {}", topics[0]);
+            return;
+        }
+        String jingduValue = jingdu.getV();
+        String weiduValue = weidu.getV();
+        String companyid = COMPANY_ID_PREFIX + numericIdGenerator.nextId();
+        LocalDateTime currentTime = LocalDateTime.now();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DATE_TIME_PATTERN);
+        String currentTimeStr = currentTime.format(formatter);
+
         if ("触发".equals(type)) {
-            SysDevice jingdu = sysControllerService.selectjingweidu(topics[0], "经度");
-            SysDevice weidu = sysControllerService.selectjingweidu(topics[0], "纬度");
-            String companyid = "GJ" + numericIdGenerator.nextId();
-            LocalDateTime currentTime = LocalDateTime.now();
-            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-            String currentTimeStr = currentTime.format(formatter);
-            sysAlarmService.insertalarm(controllername, companyid, desc, "0", currentTimeStr, "0", controllerId, deviceId, jingdu.getV(), weidu.getV());
-            sysFaultService.insertfault(companyid, desc, "0", currentTimeStr, "0", controllerId, deviceId, jingdu.getV(), weidu.getV(), "");
+            sysAlarmService.insertalarm(controllername, companyid, desc, ALARM_STATUS_TRIGGER, currentTimeStr, ALARM_STATUS_TRIGGER, controllerId, deviceId, jingduValue, weiduValue);
+            sysFaultService.insertfault(companyid, desc, ALARM_STATUS_TRIGGER, currentTimeStr, ALARM_STATUS_TRIGGER, controllerId, deviceId, jingduValue, weiduValue, "");
         } else if ("恢复".equals(type)) {
-            SysDevice jingdu = sysControllerService.selectjingweidu(topics[0], "经度");
-            SysDevice weidu = sysControllerService.selectjingweidu(topics[0], "纬度");
-            String companyid = "GJ" + numericIdGenerator.nextId();
-            LocalDateTime currentTime = LocalDateTime.now();
-            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-            String currentTimeStr = currentTime.format(formatter);
-            sysAlarmService.insertalarm(controllername, companyid, desc, "1", currentTimeStr, "0", controllerId, deviceId, jingdu.getV(), weidu.getV());
-            sysFaultService.updatefault("1", "0", jingdu.getV(), weidu.getV(), desc, controllerId, deviceId, currentTimeStr);
+            sysAlarmService.insertalarm(controllername, companyid, desc, ALARM_STATUS_RECOVERED, currentTimeStr, ALARM_STATUS_TRIGGER, controllerId, deviceId, jingduValue, weiduValue);
+            sysFaultService.updatefault(ALARM_STATUS_RECOVERED, ALARM_STATUS_TRIGGER, jingduValue, weiduValue, desc, controllerId, deviceId, currentTimeStr);
         }
 
-        String url = "https://esos-iot.com:9443/syscar/gaojing?controllerId=" + topics[0];
+        String url = iotProperties.getMqtt().getAlarmWebhookUrl() + "?controllerId=" + topics[0];
         restTemplate.postForObject(url, null, String.class);
     }
 }

iot-platform/src/main/java/com/iot/platform/mqtt/MqttGenericConsumer.java

 package com.iot.platform.mqtt;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.iot.platform.config.IotProperties;
 import com.iot.platform.domain.ControllerData;
 import com.iot.platform.domain.topics;
 import com.iot.platform.service.SysControllerService;
 
     @Autowired
     public MqttGenericConsumer(@Qualifier("abstractConsumerExecutor") ExecutorService executorService,
+                               IotProperties iotProperties,
                                StringRedisTemplate stringRedisTemplate,
                                SysControllerService sysControllerService,
                                MqttDynamicConsumer messageListenerService2) {
-        super(executorService);
+        super(executorService, iotProperties);
         this.stringRedisTemplate = stringRedisTemplate;
         this.sysControllerService = sysControllerService;
         this.messageListenerService2 = messageListenerService2;

iot-platform/src/main/java/com/iot/platform/mqtt/MqttStatusConsumer.java

 package com.iot.platform.mqtt;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.iot.platform.config.IotProperties;
 import com.iot.platform.service.SysControllerService;
 import com.iot.platform.service.SysStatusService;
 import org.springframework.beans.factory.annotation.Autowired;
 @Component
 public class MqttStatusConsumer extends AbstractMqttConsumer {
 
-    @Autowired
-    private StringRedisTemplate stringRedisTemplate;
-    @Autowired
-    public SysControllerService sysControllerService;
-    @Autowired
-    public SysStatusService sysStatusService;
+    private final StringRedisTemplate stringRedisTemplate;
+    private final SysControllerService sysControllerService;
+    private final SysStatusService sysStatusService;
 
     private final ObjectMapper objectMapper = new ObjectMapper();
 
     @Autowired
-    public MqttStatusConsumer(@Qualifier("abstractConsumerExecutor") ExecutorService executorService) {
-        super(executorService);
+    public MqttStatusConsumer(@Qualifier("abstractConsumerExecutor") ExecutorService executorService,
+                              IotProperties iotProperties,
+                              StringRedisTemplate stringRedisTemplate,
+                              SysControllerService sysControllerService,
+                              SysStatusService sysStatusService) {
+        super(executorService, iotProperties);
+        this.stringRedisTemplate = stringRedisTemplate;
+        this.sysControllerService = sysControllerService;
+        this.sysStatusService = sysStatusService;
     }
 
     @Override
     }
 
     public void triggermethod(Map<String, Object> weather) throws Exception {
-        String controllerId = weather.get("controller_id").toString();
-        String fleetId = weather.get("fleet_id").toString();
-        String status = weather.get("status").toString();
+        Object controllerIdObj = weather.get("controller_id");
+        Object fleetIdObj = weather.get("fleet_id");
+        Object statusObj = weather.get("status");
+        if (controllerIdObj == null || fleetIdObj == null || statusObj == null) {
+            log.warn("MQTT状态消息缺少必填字段，跳过处理");
+            return;
+        }
+        String controllerId = controllerIdObj.toString();
+        String fleetId = fleetIdObj.toString();
+        String status = statusObj.toString();
 
         LocalDateTime currentTime = LocalDateTime.now();
         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

iot-platform/src/main/java/com/iot/platform/service/SysIndicatorsService.java

 @DataSource(value = DataSourceType.SLAVE)
 public class SysIndicatorsService {
 
+    private final SysIndicatorsMapper sysIndicatorsMapper;
+
     @Autowired
-    public SysIndicatorsMapper sysIndicatorsMapper;
+    public SysIndicatorsService(SysIndicatorsMapper sysIndicatorsMapper) {
+        this.sysIndicatorsMapper = sysIndicatorsMapper;
+    }
 
 
     public void insertindicators(Integer workordercount, Double profit, String carId,String createdata){

iot-platform/src/main/java/com/iot/platform/service/SysWorkorderService.java

 @Service
 @DataSource(value = DataSourceType.SLAVE)
 public class SysWorkorderService {
+
+    private final SysWorkorderMapper sysWorkorderMapper;
+
     @Autowired
-    public SysWorkorderMapper sysWorkorderMapper;
+    public SysWorkorderService(SysWorkorderMapper sysWorkorderMapper) {
+        this.sysWorkorderMapper = sysWorkorderMapper;
+    }
 
 
 

iot-platform/src/main/java/com/iot/platform/service/TDegnineAlarm.java

 
     private static final Logger log = LoggerFactory.getLogger(TDegnineAlarm.class);
 
-    @Autowired
-    private TDengineService tdengineService;
+    private final TDengineService tdengineService;
+
+    public TDegnineAlarm(TDengineService tdengineService) {
+        this.tdengineService = tdengineService;
+    }
 
     private static final String VALID_FIELD_PATTERN = "^[a-zA-Z0-9_]+$";
 
      * 根据标签获取表的名称，添加数据到TDengine时序数据中
      */
     public void shibaihou(Map<String, Object> shuzi, String supertablename, String table, String deviceid) throws SQLException {
+        // 白名单校验表名和超级表名（提前到获取连接前）
+        if (!isValidFieldName(supertablename) || !isValidFieldName(table)) {
+            log.warn("非法表名或超级表名: supertablename={}, table={}", supertablename, table);
+            return;
+        }
+
         Connection conn = null;
         Statement stmt = null;
 
             conn = tdengineService.getConnection();
             stmt = conn.createStatement();
 
-            // 白名单校验表名和超级表名
-            if (!isValidFieldName(supertablename) || !isValidFieldName(table)) {
-                log.warn("非法表名或超级表名: supertablename={}, table={}", supertablename, table);
-                return;
-            }
-
             // 解析数据value（安全转义）
             String value = shuzi.values().stream()
                     .map(obj -> "'" + escapeValue(obj == null ? "" : obj.toString()) + "'")
             StringBuilder u = new StringBuilder();
 
             // ========== 查询超级表是否存在 ==========
-            boolean s = false;
+            boolean stableExists = false;
             List<String> tableNamesc = new ArrayList<>();
             try {
                 stmt.executeUpdate("use fault");
-                ResultSet resultSet = stmt.executeQuery("SHOW stables");
-                while (resultSet.next()) {
-                    tableNamesc.add(resultSet.getString(1));
+                try (ResultSet resultSet = stmt.executeQuery("SHOW stables")) {
+                    while (resultSet.next()) {
+                        tableNamesc.add(resultSet.getString(1));
+                    }
                 }
-                resultSet.close();
             } catch (SQLException e) {
                 log.warn("SHOW stables 失败: {}", e.getMessage());
             }
             for (String ta : tableNamesc) {
                 if (supertablename.equalsIgnoreCase(ta)) {
-                    s = true;
+                    stableExists = true;
+                    break;
                 }
             }
 
             // ========== 超级表存在，查看子表是否存在 ==========
-            if (s) {
+            if (stableExists) {
                 String querySubTable = "select distinct tbname from " + wrapName(table)
                         + " where location='" + escapeValue(supertablename) + "'";
-                ResultSet rsc = stmt.executeQuery(querySubTable);
-                while (rsc.next()) {
-                    zibiaoname.add(rsc.getString(1));
+                try (ResultSet rsc = stmt.executeQuery(querySubTable)) {
+                    while (rsc.next()) {
+                        zibiaoname.add(rsc.getString(1));
+                    }
                 }
-                rsc.close();
-                boolean zibiaobu = zibiaoname.isEmpty();
+                boolean subTableMissing = zibiaoname.isEmpty();
 
                 // ========== 添加数据到数据库中 ==========
                 try {
-                    if (!zibiaobu) {
+                    if (!subTableMissing) {
                         // 子表存在：查询列、新增差异列、插入数据
-                        ResultSet resultSet = stmt.executeQuery("describe " + wrapName(table));
-                        int columnNameIndex = resultSet.findColumn("field");
-                        while (resultSet.next()) {
-                            columnNames.add(resultSet.getString(columnNameIndex));
+                        try (ResultSet resultSet = stmt.executeQuery("describe " + wrapName(table))) {
+                            int columnNameIndex = resultSet.findColumn("field");
+                            while (resultSet.next()) {
+                                columnNames.add(resultSet.getString(columnNameIndex));
+                            }
                         }
-                        resultSet.close();
 
                         for (int z = 0; z < columnNames.size(); z++) {
                             u.append(columnNames.get(z));
                                     stmt.executeUpdate("ALTER TABLE " + wrapName(supertablename)
                                             + " ADD COLUMN " + setCopys[ar]);
                                 } catch (Exception e) {
-                                    // 列可能已存在，忽略
+                                    log.debug("列可能已存在，忽略: {}", e.getMessage());
                                 }
                             }
                         }
                                 + " using " + wrapName(supertablename)
                                 + " tags('" + escapeValue(supertablename) + "')");
 
-                        ResultSet resultSet = stmt.executeQuery("describe " + wrapName(supertablename));
-                        int columnNameIndex = resultSet.findColumn("field");
-                        while (resultSet.next()) {
-                            columnNames.add(resultSet.getString(columnNameIndex));
+                        try (ResultSet resultSet = stmt.executeQuery("describe " + wrapName(supertablename))) {
+                            int columnNameIndex = resultSet.findColumn("field");
+                            while (resultSet.next()) {
+                                columnNames.add(resultSet.getString(columnNameIndex));
+                            }
                         }
-                        resultSet.close();
 
                         for (int z = 0; z < columnNames.size(); z++) {
                             if (z < columnNames.size() - 1) {

iot-platform/src/main/java/com/iot/platform/service/TDengineService.java

 public class TDengineService {
     private static final Logger log = LoggerFactory.getLogger(TDengineService.class);
 
-    @Autowired
-    private IotProperties iotProperties;
-
+    private final IotProperties iotProperties;
     private final ExecutorService batchExecutor;
 
     @Autowired
-    public TDengineService(ExecutorService tdengineBatchExecutor) {
+    public TDengineService(ExecutorService tdengineBatchExecutor, IotProperties iotProperties) {
         this.batchExecutor = tdengineBatchExecutor;
+        this.iotProperties = iotProperties;
     }
 
     private HikariDataSource dataSource;
-    private boolean dataSourceInitialized = false;
+    private volatile boolean dataSourceInitialized = false;
 
     // === 新增：缓存超级表结构 (key = dbName.stableName) ===
     private final Map<String, Set<String>> stableColumnCache = new ConcurrentHashMap<>();
         if (data == null || data.isEmpty()) return "";
         try {
             ByteArrayOutputStream bos = new ByteArrayOutputStream();
-            GZIPOutputStream gzip = new GZIPOutputStream(bos);
-            gzip.write(data.getBytes("UTF-8"));
-            gzip.close();
+            try (GZIPOutputStream gzip = new GZIPOutputStream(bos)) {
+                gzip.write(data.getBytes("UTF-8"));
+            }
             byte[] compressed = Base64.getEncoder().encode(bos.toByteArray());
             return new String(compressed);
         } catch (Exception e) {

iot-platform/src/test/java/com/iot/platform/mqtt/MqttFaultConsumerTest.java

 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.iot.platform.common.utils.NumericIdGenerator;
+import com.iot.platform.config.IotProperties;
 import com.iot.platform.domain.SysDevice;
 import com.iot.platform.domain.SysFault;
 import com.iot.platform.service.*;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
-import org.springframework.test.util.ReflectionTestUtils;
 import org.springframework.web.client.RestTemplate;
 
 import java.sql.SQLException;
 import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
     @Mock
     private RestTemplate restTemplate;
 
+    @Mock
+    private IotProperties iotProperties;
+
     @Mock(name = "mqttFaultExecutor")
     private ExecutorService mqttFaultExecutor;
 
     @Mock(name = "abstractConsumerExecutor")
     private ExecutorService abstractConsumerExecutor;
 
-    @InjectMocks
     private MqttFaultConsumer mqttFaultConsumer;
 
     private final ObjectMapper objectMapper = new ObjectMapper();
 
     @BeforeEach
     void setUp() {
-        ReflectionTestUtils.setField(mqttFaultConsumer, "sysControllerService", sysControllerService);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "sysFaultService", sysFaultService);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "sysrealtimeService", sysrealtimeService);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "sysWorkorderService", sysWorkorderService);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "sysAlarmService", sysAlarmService);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "numericIdGenerator", numericIdGenerator);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "tDegnineAlarm", tDegnineAlarm);
-        ReflectionTestUtils.setField(mqttFaultConsumer, "restTemplate", restTemplate);
+        mqttFaultConsumer = new MqttFaultConsumer(
+                mqttFaultExecutor, abstractConsumerExecutor, iotProperties,
+                sysControllerService, sysFaultService, sysrealtimeService,
+                sysWorkorderService, sysAlarmService, numericIdGenerator,
+                tDegnineAlarm, restTemplate);
+
+        IotProperties.Mqtt mqttConfig = new IotProperties.Mqtt();
+        mqttConfig.setAlarmWebhookUrl("https://esos-iot.com:9443/syscar/gaojing");
+        when(iotProperties.getMqtt()).thenReturn(mqttConfig);
 
         // executor mock runs submitted tasks synchronously
         lenient().when(mqttFaultExecutor.submit(any(Runnable.class))).thenAnswer(inv -> {

iot-platform/src/test/java/com/iot/platform/mqtt/MqttGenericConsumerTest.java

 package com.iot.platform.mqtt;
 
+import com.iot.platform.config.IotProperties;
 import com.iot.platform.service.SysControllerService;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 class MqttGenericConsumerTest {
 
     private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+    private final IotProperties iotProperties = mock(IotProperties.class);
     private final StringRedisTemplate stringRedisTemplate = mock(StringRedisTemplate.class);
     private final SysControllerService sysControllerService = mock(SysControllerService.class);
     private final MqttDynamicConsumer mqttDynamicConsumer = mock(MqttDynamicConsumer.class);
 
     private MqttGenericConsumer createConsumer() {
-        return new MqttGenericConsumer(executorService, stringRedisTemplate, sysControllerService, mqttDynamicConsumer);
+        return new MqttGenericConsumer(executorService, iotProperties, stringRedisTemplate, sysControllerService, mqttDynamicConsumer);
     }
 
     @Test

iot-platform/src/test/java/com/iot/platform/mqtt/MqttStatusConsumerTest.java

 package com.iot.platform.mqtt;
 
+import com.iot.platform.config.IotProperties;
 import com.iot.platform.service.SysControllerService;
 import com.iot.platform.service.SysStatusService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
 import org.springframework.data.redis.core.HashOperations;
 import org.springframework.data.redis.core.StringRedisTemplate;
-import org.springframework.test.util.ReflectionTestUtils;
 
 import java.util.HashMap;
 import java.util.Map;
     @Mock
     private HashOperations<String, Object, Object> hashOperations;
 
-    @InjectMocks
+    @Mock
+    private IotProperties iotProperties;
+
     private MqttStatusConsumer mqttStatusConsumer;
 
     private final ExecutorService executorService = Executors.newSingleThreadExecutor();
 
     @BeforeEach
     void setUp() {
-        ReflectionTestUtils.setField(mqttStatusConsumer, "stringRedisTemplate", stringRedisTemplate);
-        ReflectionTestUtils.setField(mqttStatusConsumer, "sysControllerService", sysControllerService);
-        ReflectionTestUtils.setField(mqttStatusConsumer, "sysStatusService", sysStatusService);
+        mqttStatusConsumer = new MqttStatusConsumer(executorService, iotProperties,
+                stringRedisTemplate, sysControllerService, sysStatusService);
         lenient().when(stringRedisTemplate.opsForHash()).thenReturn(hashOperations);
     }
 
     }
 
     @Test
-    @DisplayName("triggermethod with null controller_id throws NullPointerException")
-    void triggermethod_nullControllerId_throwsException() {
+    @DisplayName("triggermethod with null controller_id returns silently")
+    void triggermethod_nullControllerId_returnsSilently() throws Exception {
         Map<String, Object> weather = new HashMap<>();
         weather.put("controller_id", null);
         weather.put("fleet_id", "FLEET_001");
         weather.put("status", "online");
 
-        assertThatThrownBy(() -> mqttStatusConsumer.triggermethod(weather))
-            .isInstanceOf(NullPointerException.class);
+        mqttStatusConsumer.triggermethod(weather);
+        verify(sysStatusService, never()).selectstatuscount(anyString());
     }
 
     @Test
-    @DisplayName("triggermethod with null fleet_id throws NullPointerException")
-    void triggermethod_nullFleetId_throwsException() {
+    @DisplayName("triggermethod with null fleet_id returns silently")
+    void triggermethod_nullFleetId_returnsSilently() throws Exception {
         Map<String, Object> weather = new HashMap<>();
         weather.put("controller_id", "CTRL_001");
         weather.put("fleet_id", null);
         weather.put("status", "online");
 
-        assertThatThrownBy(() -> mqttStatusConsumer.triggermethod(weather))
-            .isInstanceOf(NullPointerException.class);
+        mqttStatusConsumer.triggermethod(weather);
+        verify(sysStatusService, never()).selectstatuscount(anyString());
     }
 
     @Test
-    @DisplayName("triggermethod with null status throws NullPointerException")
-    void triggermethod_nullStatus_throwsException() {
+    @DisplayName("triggermethod with null status returns silently")
+    void triggermethod_nullStatus_returnsSilently() throws Exception {
         Map<String, Object> weather = new HashMap<>();
         weather.put("controller_id", "CTRL_001");
         weather.put("fleet_id", "FLEET_001");
         weather.put("status", null);
 
-        assertThatThrownBy(() -> mqttStatusConsumer.triggermethod(weather))
-            .isInstanceOf(NullPointerException.class);
+        mqttStatusConsumer.triggermethod(weather);
+        verify(sysStatusService, never()).selectstatuscount(anyString());
     }
 
     @Test