refactor: 全面规范化项目命名

变量名:
- weather → faultData（消除误导性命名）
- jingdu/weidu → longitude/latitude（消除中文拼音）
- jingduValue/weiduValue → longitudeValue/latitudeValue
- tdEngineshuju → tdEngineData（消除中文拼音）
- companyid → companyId
- controllername → controllerName
- tablename → tableNames

方法名（camelCase 规范化）:
- selectall → selectAll
- insertfault → insertFault, updatefault → updateFault
- insertalarm → insertAlarm
- createmessage → createMessage
- selecttables → selectTables, inserttables → insertTables
- selectjingweidu → selectCoordinates（消除中文拼音）
- triggermethod → triggerMethod
- 等 40+ 个 mapper/service 方法名

类名:
- Sysrealtime → SysRealtime
- SysrealtimeMapper → SysRealtimeMapper
- SysrealtimeService → SysRealtimeService
- 所有引用同步更新

iot-platform/src/main/java/com/iot/platform/domain/Sysrealtime.java → iot-platform/src/main/java/com/iot/platform/domain/SysRealtime.java

 package com.iot.platform.domain;
 
-public class Sysrealtime {
+public class SysRealtime {
     private String createTime;
     private String deviceId;
     private String timestamp;

iot-platform/src/main/java/com/iot/platform/mapper/DynamicSqlProvider.java

         return value.replace("'", "''");
     }
 
-    public String insertdevice(Map<String, String> parameters) {
+    public String insertDevice(Map<String, String> parameters) {
         String columnName = parameters.get("columnName");
-        String tdEngineshuju = parameters.get("value");
+        String tdEngineData = parameters.get("value");
 
         validateFieldName(columnName);
 
         sql.append("INSERT INTO sys_device(");
         sql.append(columnName);
         sql.append(") VALUES('");
-        sql.append(escapeValue(tdEngineshuju));
+        sql.append(escapeValue(tdEngineData));
         sql.append("')");
         return sql.toString();
     }
 
-    public String updatesysdevice(Map<String, String> parameters) {
+    public String updateSysDevice(Map<String, String> parameters) {
         String columnName = parameters.get("columnName");
-        String tdEngineshuju = parameters.get("value");
+        String tdEngineData = parameters.get("value");
 
         validateFieldName(columnName);
 
         sql.append("UPDATE sys_device SET ");
         sql.append(columnName);
         sql.append(" = '");
-        sql.append(escapeValue(tdEngineshuju));
+        sql.append(escapeValue(tdEngineData));
         sql.append("' WHERE ");
         sql.append(columnName);
         sql.append(" = '");
-        sql.append(escapeValue(tdEngineshuju));
+        sql.append(escapeValue(tdEngineData));
         sql.append("'");
         return sql.toString();
     }

iot-platform/src/main/java/com/iot/platform/mapper/SysAlarmMapper.java

 
 @Mapper
 public interface SysAlarmMapper {
-    void insertalarm(@Param("tableName")String tableName,@Param("faultId")String faultId,
+    void insertAlarm(@Param("tableName")String tableName,@Param("faultId")String faultId,
                      @Param("faultdescs")String faultdescs,
                      @Param("faultstatus")String faultstatus,
                      @Param("createtime")String createtime,

iot-platform/src/main/java/com/iot/platform/mapper/SysCarMapper.java

 @Mapper
 public interface SysCarMapper {
 
-    List<SysCar> selectcontrollerId();
+    List<SysCar> selectControllerId();
 
-    void updatecarposition(@Param("carPosition")String carPosition,@Param("carId")String carId);
+    void updateCarPosition(@Param("carPosition")String carPosition,@Param("carId")String carId);
 
 
-    List<SysCar> selectcarall();
+    List<SysCar> selectCarAll();
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysControllerMapper.java

 @Mapper
 public interface SysControllerMapper {
 
-    void insertsyscontroller(@Param("controllerId") String controllerId,
+    void insertSysController(@Param("controllerId") String controllerId,
                              @Param("timestamp") String timestamp,
                              @Param("fleetId") String fleetId,
                              @Param("name") String name,
                              @Param("path") String path,
                              @Param("deviceId") String deviceId);
 
-    void insertsyscontrollercmd(@Param("controllerId") String controllerId,
+    void insertSysControllerCmd(@Param("controllerId") String controllerId,
                                 @Param("timestamp") String timestamp,
                                 @Param("fleetId") String fleetId,
                                 @Param("name") String name,
                                 @Param("path") String path);
 
-    void insertsyscontrollerfault(@Param("controllerId") String controllerId,
+    void insertSysControllerFault(@Param("controllerId") String controllerId,
                                   @Param("timestamp") String timestamp,
                                   @Param("fleetId") String fleetId,
                                   @Param("name") String name,
                                   @Param("path") String path);
 
-    Integer selectsyscontrollercount(@Param("path") String path);
+    Integer selectSysControllerCount(@Param("path") String path);
 
-    Integer selectsyscontrollercountcmd(@Param("path") String path);
+    Integer selectSysControllerCmdCount(@Param("path") String path);
 
-    Integer selectsyscontrollercountfault(@Param("path") String path);
+    Integer selectSysControllerFaultCount(@Param("path") String path);
 
-    void updatecontrollerAccept(@Param("controllerId") String controllerId,
+    void updateControllerAccept(@Param("controllerId") String controllerId,
                                 @Param("timestamp") String timestamp,
                                 @Param("fleetId") String fleetId,
                                 @Param("name") String name,
                                 @Param("deviceId") String deviceId,
                                 @Param("updateTime") String updateTime);
 
-    SysController selectcontrollerpath(@Param("path") String path);
+    SysController selectControllerPath(@Param("path") String path);
 
-    List<String> selectall();
+    List<String> selectAll();
 
-    SysDevice selectjingweidu(@Param("tableName") String tableName, @Param("Name") String Name);
+    SysDevice selectCoordinates(@Param("tableName") String tableName, @Param("Name") String Name);
 
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysDeviceControlMapper.java

 @Mapper
 public interface SysDeviceControlMapper {
 
-    List<SysDeviceControl> selectdevice(@Param("tableType")String tableType);
+    List<SysDeviceControl> selectDevice(@Param("tableType")String tableType);
 
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysDeviceMapper.java

 
 @Mapper
 public interface SysDeviceMapper {
-    SysDevice selectsysdevice(@Param("tableName")String tableName,@Param("k")String k);
+    SysDevice selectSysDevice(@Param("tableName")String tableName,@Param("k")String k);
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysDeviceVoMapper.java

 
 @Mapper
 public interface SysDeviceVoMapper {
-    @SelectProvider(type = DynamicSqlProvider.class, method = "insertdevice")
-    boolean insertdevice(@Param("columnName")String columnName, @Param("value")String value);
+    @SelectProvider(type = DynamicSqlProvider.class, method = "insertDevice")
+    boolean insertDevice(@Param("columnName")String columnName, @Param("value")String value);
 
-    @SelectProvider(type = DynamicSqlProvider.class, method = "updatesysdevice")
-    boolean updatesysdevice(@Param("columnName")String columnName, @Param("value")String value);
+    @SelectProvider(type = DynamicSqlProvider.class, method = "updateSysDevice")
+    boolean updateSysDevice(@Param("columnName")String columnName, @Param("value")String value);
 //
-//    boolean insertdevice(@Param("deviceId")String deviceId,
+//    boolean insertDevice(@Param("deviceId")String deviceId,
 //                         @Param("deviceName")String deviceName,
 //                         @Param("soc")String soc,
 //                         @Param("chargingcapacity")String chargingcapacity,
 //                         @Param("capacitance")String capacitance,
 //                         @Param("power")String power);
 //
-//    boolean updatesysdevice(@Param("deviceId")String deviceId,
+//    boolean updateSysDevice(@Param("deviceId")String deviceId,
 //                            @Param("deviceName")String deviceName,
 //                            @Param("soc")String soc,
 //                            @Param("chargingcapacity")String chargingcapacity,

iot-platform/src/main/java/com/iot/platform/mapper/SysFaultMapper.java

 @Mapper
 public interface SysFaultMapper {
 
-    void insertfault(@Param("faultId") String faultId,
+    void insertFault(@Param("faultId") String faultId,
                      @Param("faultdescs") String faultdescs,
                      @Param("faultstatus") String faultstatus,
                      @Param("createtime") String createtime,
                      @Param("latitude") String latitude,
                      @Param("readpeople") String readpeople);
 
-    void updatefault(@Param("faultstatus")String faultstatus,
+    void updateFault(@Param("faultstatus")String faultstatus,
                      @Param("messageType")String messageType,
                      @Param("longitude")String longitude,
                      @Param("latitude")String latitude,
                      @Param("createtime")String createtime);
 
 
-    Integer selectfaultcount(@Param("fleetId")String fleetId);
+    Integer selectFaultCount(@Param("fleetId")String fleetId);
 
-    void createmessage(@Param("tableName")String tableName);
+    void createMessage(@Param("tableName")String tableName);
 
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysIndicatorsMapper.java

 @Mapper
 public interface SysIndicatorsMapper {
 
-    void insertindicators(@Param("workordercount")Integer workordercount,@Param("profit")Double profit,@Param("carId")String carId,@Param("createdata")String createdata);
+    void insertIndicators(@Param("workordercount")Integer workordercount,@Param("profit")Double profit,@Param("carId")String carId,@Param("createdata")String createdata);
 
-    void updateindicators(@Param("workordercount")Integer workordercount,@Param("profit")Double profit,@Param("carId")String carId,@Param("createdata")String createdata);
+    void updateIndicators(@Param("workordercount")Integer workordercount,@Param("profit")Double profit,@Param("carId")String carId,@Param("createdata")String createdata);
 
-    Integer selectcarcount(@Param("carId")String carId,@Param("createtime")String createtime);
+    Integer selectCarCount(@Param("carId")String carId,@Param("createtime")String createtime);
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysrealtimeMapper.java → iot-platform/src/main/java/com/iot/platform/mapper/SysRealtimeMapper.java

 import java.util.List;
 
 @Mapper
-public interface SysrealtimeMapper {
-    void createrealtime(@Param("tableName")String tableName);
-    List<String> selecttables();
-    void inserttables(@Param("tableName")String tableName,@Param("createTime")String createTime,@Param("deviceId")String deviceId,@Param("timestamp")String timestamp,@Param("k")String k,@Param("v")Object v);
-    void updatetables(@Param("tableName")String tableName,@Param("createTime")String createTime,@Param("v")Object v,@Param("timestamp")String timestamp,@Param("k")String k,@Param("deviceId")String deviceId);
-    Integer selectkey(@Param("tableName")String tableName,@Param("k")String k);
+public interface SysRealtimeMapper {
+    void createRealtime(@Param("tableName")String tableName);
+    List<String> selectTables();
+    void insertTables(@Param("tableName")String tableName,@Param("createTime")String createTime,@Param("deviceId")String deviceId,@Param("timestamp")String timestamp,@Param("k")String k,@Param("v")Object v);
+    void updateTables(@Param("tableName")String tableName,@Param("createTime")String createTime,@Param("v")Object v,@Param("timestamp")String timestamp,@Param("k")String k,@Param("deviceId")String deviceId);
+    Integer selectKey(@Param("tableName")String tableName,@Param("k")String k);
     List<String> selectAllKeys(@Param("tableName")String tableName);
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysStatusMapper.java

 @Mapper
 public interface SysStatusMapper {
 
-    void insertsysstatus(@Param("controllerId")String controllerId,@Param("fleetId")String fleetId,@Param("status")String status,@Param("createTime")String createTime);
-    void updatestatus(@Param("controllerId")String controllerId,@Param("fleetId")String fleetId,@Param("status")String status,@Param("createTime")String createTime);
+    void insertSysStatus(@Param("controllerId")String controllerId,@Param("fleetId")String fleetId,@Param("status")String status,@Param("createTime")String createTime);
+    void updateStatus(@Param("controllerId")String controllerId,@Param("fleetId")String fleetId,@Param("status")String status,@Param("createTime")String createTime);
 
-    Integer selectstatuscount(@Param("controllerId")String controllerId);
+    Integer selectStatusCount(@Param("controllerId")String controllerId);
 }

iot-platform/src/main/java/com/iot/platform/mapper/SysWorkorderMapper.java

 @Mapper
 public interface SysWorkorderMapper {
 
-    SysWorkorder selectdeviceId(@Param("controllerId")String controllerId);
-    Integer selectworkordercount(@Param("companyId")String companyId,@Param("data")String data);
-    Double selectwokroderprofit(@Param("companyId")String companyId,@Param("data")String data);
+    SysWorkorder selectDeviceId(@Param("controllerId")String controllerId);
+    Integer selectWorkorderCount(@Param("companyId")String companyId,@Param("data")String data);
+    Double selectWorkorderProfit(@Param("companyId")String companyId,@Param("data")String data);
 }

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

 
     @Override
     protected List<String> fetchTopics() {
-        return sysControllerService.selectall();
+        return sysControllerService.selectAll();
     }
 
     @Override
             return null;
         }
 
-        SysController sysController = sysControllerService.selectcontrollerpath(topic);
+        SysController sysController = sysControllerService.selectControllerPath(topic);
         if (sysController == null || sysController.getName() == null) {
             log.info("未找到 Topic 对应的 Controller: {}", topic);
             return null;

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

 
     private final SysControllerService sysControllerService;
     private final SysFaultService sysFaultService;
-    private final SysrealtimeService sysrealtimeService;
+    private final SysRealtimeService sysRealtimeService;
     private final SysAlarmService sysAlarmService;
     private final NumericIdGenerator numericIdGenerator;
     private final TdEngineAlarm tdEngineAlarm;
                              IotProperties iotProperties,
                              SysControllerService sysControllerService,
                              SysFaultService sysFaultService,
-                             SysrealtimeService sysrealtimeService,
+                             SysRealtimeService sysRealtimeService,
                              SysAlarmService sysAlarmService,
                              NumericIdGenerator numericIdGenerator,
                              TdEngineAlarm tdEngineAlarm,
         this.mqttFaultExecutor = mqttFaultExecutor;
         this.sysControllerService = sysControllerService;
         this.sysFaultService = sysFaultService;
-        this.sysrealtimeService = sysrealtimeService;
+        this.sysRealtimeService = sysRealtimeService;
         this.sysAlarmService = sysAlarmService;
         this.numericIdGenerator = numericIdGenerator;
         this.tdEngineAlarm = tdEngineAlarm;
         SysFault sysFault = JSON.parseObject(messageContent, SysFault.class);
         mqttFaultExecutor.submit(() -> {
             try {
-                triggermethod(topic, sysFault);
+                triggerMethod(topic, sysFault);
             } catch (Exception e) {
                 log.error("告警业务处理失败, topic={}, controllerId={}, error={}",
                         topic, sysFault.getController_id(), e.getMessage(), e);
         tdEngineAlarm.recordFailure(newMap, controllerName, table);
     }
 
-    void triggermethod(String topic, SysFault weather) {
+    void triggerMethod(String topic, SysFault faultData) {
 
-        String deviceId = weather.getDevice_id();
-        String type = weather.getType();
-        String desc = weather.getDesc();
-        String controllerId = weather.getController_id();
+        String deviceId = faultData.getDevice_id();
+        String type = faultData.getType();
+        String desc = faultData.getDesc();
+        String controllerId = faultData.getController_id();
 
         if (controllerId == null || controllerId.isEmpty()) {
             log.info("SysFault 缺少 controller_id，跳过处理");
             return;
         }
 
-        List<String> tablename = sysrealtimeService.selecttables();
-        if (tablename == null) {
-            tablename = Collections.emptyList();
+        List<String> tableNames = sysRealtimeService.selectTables();
+        if (tableNames == null) {
+            tableNames = Collections.emptyList();
         }
-        String controllername = controllerId + year + formattedMonth + "_fault";
+        String controllerName = controllerId + year + formattedMonth + "_fault";
 
         boolean tableExists = false;
-        for (String name : tablename) {
-            if (controllername.equals(name)) {
+        for (String name : tableNames) {
+            if (controllerName.equals(name)) {
                 tableExists = true;
                 break;
             }
         }
         if (!tableExists) {
-            sysFaultService.createmessage(controllername);
+            sysFaultService.createMessage(controllerName);
         }
 
-        SysDevice jingdu = sysControllerService.selectjingweidu(topics[0], "经度");
-        SysDevice weidu = sysControllerService.selectjingweidu(topics[0], "纬度");
-        if (jingdu == null || weidu == null) {
+        SysDevice longitude = sysControllerService.selectCoordinates(topics[0], "经度");
+        SysDevice latitude = sysControllerService.selectCoordinates(topics[0], "纬度");
+        if (longitude == null || latitude == null) {
             log.info("未查询到控制器经纬度信息: {}", topics[0]);
             return;
         }
-        String jingduValue = jingdu.getV();
-        String weiduValue = weidu.getV();
-        String companyid = COMPANY_ID_PREFIX + numericIdGenerator.nextId();
+        String longitudeValue = longitude.getV();
+        String latitudeValue = latitude.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)) {
-            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, "");
+            sysAlarmService.insertAlarm(controllerName, companyId, desc, ALARM_STATUS_TRIGGER, currentTimeStr, ALARM_STATUS_TRIGGER, controllerId, deviceId, longitudeValue, latitudeValue);
+            sysFaultService.insertFault(companyId, desc, ALARM_STATUS_TRIGGER, currentTimeStr, ALARM_STATUS_TRIGGER, controllerId, deviceId, longitudeValue, latitudeValue, "");
         } else if ("恢复".equals(type)) {
-            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);
+            sysAlarmService.insertAlarm(controllerName, companyId, desc, ALARM_STATUS_RECOVERED, currentTimeStr, ALARM_STATUS_TRIGGER, controllerId, deviceId, longitudeValue, latitudeValue);
+            sysFaultService.updateFault(ALARM_STATUS_RECOVERED, ALARM_STATUS_TRIGGER, longitudeValue, latitudeValue, desc, controllerId, deviceId, currentTimeStr);
         }
 
         // controllerId 白名单校验，防止 SSRF

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

     @Override
     protected void handleMessage(String topic, String messageContent) throws Exception {
         ControllerData controllerData = JSON.parseObject(messageContent, ControllerData.class);
-        triggermethod(controllerData);
+        triggerMethod(controllerData);
     }
 
-    private void triggermethod(ControllerData controllerData) throws Exception {
+    private void triggerMethod(ControllerData controllerData) throws Exception {
         String timestamp = controllerData.getTimestamp();
         String fleetId = controllerData.getFleet_id();
         String controllerId = controllerData.getController_id();
                 log.info("path 中缺少 deviceId，跳过: path={}", path);
                 continue;
             }
-            Integer count = sysControllerService.selectsyscontrollercount(path);
+            Integer count = sysControllerService.selectSysControllerCount(path);
             if (count <= 0) {
                 stringRedisTemplate.opsForHash().put(controllerId + ":" + name, "path", path);
-                sysControllerService.insertsyscontroller(controllerId, timestamp, fleetId, name, path, deviceId);
+                sysControllerService.insertSysController(controllerId, timestamp, fleetId, name, path, deviceId);
                 newControllerCount++;
             } else {
                 long ts;
                     ts = System.currentTimeMillis();
                 }
                 String date = DATE_TIME_FORMATTER.format(Instant.ofEpochMilli(ts));
-                sysControllerService.updatecontrollerAccept(controllerId, timestamp, fleetId, name, path, deviceId, date);
+                sysControllerService.updateControllerAccept(controllerId, timestamp, fleetId, name, path, deviceId, date);
             }
         }
         return newControllerCount;
                 log.info("CmdTopic 数据不完整，跳过: path={}, name={}", path, name);
                 continue;
             }
-            Integer count = sysControllerService.selectsyscontrollercountcmd(path);
+            Integer count = sysControllerService.selectSysControllerCmdCount(path);
             if (count <= 0) {
                 stringRedisTemplate.opsForHash().put(controllerId + "_cmd:" + name, "path", path);
-                sysControllerService.insertsyscontrollercmd(controllerId, timestamp, fleetId, name, path);
+                sysControllerService.insertSysControllerCmd(controllerId, timestamp, fleetId, name, path);
             }
         }
     }
             log.info("FaultProt 数据不完整，跳过: path={}, name={}", path, name);
             return;
         }
-        Integer count = sysControllerService.selectsyscontrollercountfault(path);
+        Integer count = sysControllerService.selectSysControllerFaultCount(path);
         if (count <= 0) {
             stringRedisTemplate.opsForHash().put(controllerId + "_fault:" + name, "path", path);
-            sysControllerService.insertsyscontrollerfault(controllerId, timestamp, fleetId, name, path);
+            sysControllerService.insertSysControllerFault(controllerId, timestamp, fleetId, name, path);
         }
     }
 }

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

     @Resource
     public SysAlarmMapper sysAlarmMapper;
 
-    public void insertalarm(String tableName,String faultId,String faultdescs,String faultstatus,String createtime,String messageType,String controllerId,String deviceId,String longitude,String latitude){
+    public void insertAlarm(String tableName,String faultId,String faultdescs,String faultstatus,String createtime,String messageType,String controllerId,String deviceId,String longitude,String latitude){
         if (tableName == null || !TABLE_NAME_PATTERN.matcher(tableName).matches()) {
             throw new IllegalArgumentException("非法表名: " + tableName);
         }
-        sysAlarmMapper.insertalarm(tableName,faultId, faultdescs, faultstatus, createtime, messageType,controllerId,deviceId,longitude,latitude);
+        sysAlarmMapper.insertAlarm(tableName,faultId, faultdescs, faultstatus, createtime, messageType,controllerId,deviceId,longitude,latitude);
     }
 
 }

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

     @Resource
     public SysCarMapper sysCarMapper;
 
-    public List<SysCar> selectcontrollerId(){
-        return sysCarMapper.selectcontrollerId();
+    public List<SysCar> selectControllerId(){
+        return sysCarMapper.selectControllerId();
     }
-    public void updatecarposition(String carPosition,String carId){
-        sysCarMapper.updatecarposition(carPosition, carId);
+    public void updateCarPosition(String carPosition,String carId){
+        sysCarMapper.updateCarPosition(carPosition, carId);
     }
-    public List<SysCar> selectcarall(){
-        return sysCarMapper.selectcarall();
+    public List<SysCar> selectCarAll(){
+        return sysCarMapper.selectCarAll();
     }
 }

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

     @Resource
     public SysControllerMapper sysControllerMapper;
 
-    public void insertsyscontroller(String controllerId, String timestamp, String fleetId,
+    public void insertSysController(String controllerId, String timestamp, String fleetId,
                                     String name, String path, String deviceId) {
-        sysControllerMapper.insertsyscontroller(controllerId, timestamp, fleetId, name, path, deviceId);
+        sysControllerMapper.insertSysController(controllerId, timestamp, fleetId, name, path, deviceId);
     }
 
-    public void insertsyscontrollercmd(String controllerId, String timestamp, String fleetId,
+    public void insertSysControllerCmd(String controllerId, String timestamp, String fleetId,
                                        String name, String path) {
-        sysControllerMapper.insertsyscontrollercmd(controllerId, timestamp, fleetId, name, path);
+        sysControllerMapper.insertSysControllerCmd(controllerId, timestamp, fleetId, name, path);
     }
 
-    public void insertsyscontrollerfault(String controllerId, String timestamp, String fleetId,
+    public void insertSysControllerFault(String controllerId, String timestamp, String fleetId,
                                          String name, String path) {
-        sysControllerMapper.insertsyscontrollerfault(controllerId, timestamp, fleetId, name, path);
+        sysControllerMapper.insertSysControllerFault(controllerId, timestamp, fleetId, name, path);
     }
 
-    public Integer selectsyscontrollercount(String path) {
-        return sysControllerMapper.selectsyscontrollercount(path);
+    public Integer selectSysControllerCount(String path) {
+        return sysControllerMapper.selectSysControllerCount(path);
     }
 
-    public Integer selectsyscontrollercountcmd(String path) {
-        return sysControllerMapper.selectsyscontrollercountcmd(path);
+    public Integer selectSysControllerCmdCount(String path) {
+        return sysControllerMapper.selectSysControllerCmdCount(path);
     }
 
-    public Integer selectsyscontrollercountfault(String path) {
-        return sysControllerMapper.selectsyscontrollercountfault(path);
+    public Integer selectSysControllerFaultCount(String path) {
+        return sysControllerMapper.selectSysControllerFaultCount(path);
     }
 
-    public void updatecontrollerAccept(String controllerId, String timestamp, String fleetId,
+    public void updateControllerAccept(String controllerId, String timestamp, String fleetId,
                                        String name, String path, String deviceId, String updateTime) {
-        sysControllerMapper.updatecontrollerAccept(controllerId, timestamp, fleetId, name, path, deviceId, updateTime);
+        sysControllerMapper.updateControllerAccept(controllerId, timestamp, fleetId, name, path, deviceId, updateTime);
     }
 
-    public SysController selectcontrollerpath(String path) {
-        return sysControllerMapper.selectcontrollerpath(path);
+    public SysController selectControllerPath(String path) {
+        return sysControllerMapper.selectControllerPath(path);
     }
 
-    public List<String> selectall() {
-        return sysControllerMapper.selectall();
+    public List<String> selectAll() {
+        return sysControllerMapper.selectAll();
     }
 
-    public SysDevice selectjingweidu(String tableName, String Name) {
+    public SysDevice selectCoordinates(String tableName, String Name) {
         if (tableName == null || !TABLE_NAME_PATTERN.matcher(tableName).matches()) {
             throw new IllegalArgumentException("非法表名: " + tableName);
         }
-        return sysControllerMapper.selectjingweidu(tableName, Name);
+        return sysControllerMapper.selectCoordinates(tableName, Name);
     }
 }

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

     @Resource
     public SysDeviceControlMapper sysDeviceControlMapper;
 
-    public List<SysDeviceControl> selectdevice(@Param("tableType")String tableType){
-        return sysDeviceControlMapper.selectdevice(tableType);
+    public List<SysDeviceControl> selectDevice(@Param("tableType")String tableType){
+        return sysDeviceControlMapper.selectDevice(tableType);
     }
 }

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

     @Resource
     public SysDeviceMapper sysDeviceMapper;
 
-    public SysDevice selectsysdevice(String tableName, String k) {
+    public SysDevice selectSysDevice(String tableName, String k) {
         if (tableName == null || !TABLE_NAME_PATTERN.matcher(tableName).matches()) {
             throw new IllegalArgumentException("非法表名: " + tableName);
         }
-        return sysDeviceMapper.selectsysdevice(tableName, k);
+        return sysDeviceMapper.selectSysDevice(tableName, k);
     }
 }

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

 public class SysDeviceVoService {
     @Resource
     public SysDeviceVoMapper sysDeviceVoMapper;
-    public boolean insertdevice(String columnName,String value){
-        return sysDeviceVoMapper.insertdevice(columnName, value);
+    public boolean insertDevice(String columnName,String value){
+        return sysDeviceVoMapper.insertDevice(columnName, value);
     }
 
-    public boolean updatesysdevice(String columnName,String value){
-        return sysDeviceVoMapper.updatesysdevice(columnName, value);
+    public boolean updateSysDevice(String columnName,String value){
+        return sysDeviceVoMapper.updateSysDevice(columnName, value);
     }
-//    public boolean insertdevice(String deviceId,String deviceName,String soc,String chargingcapacity,String dischargecapacity,String dateTime,String greenelectricity,String statecharge,String capacitance,String power){
-//        return sysDeviceVoMapper.insertdevice(deviceId, deviceName, soc, chargingcapacity, dischargecapacity, dateTime, greenelectricity, statecharge, capacitance, power);
+//    public boolean insertDevice(String deviceId,String deviceName,String soc,String chargingcapacity,String dischargecapacity,String dateTime,String greenelectricity,String statecharge,String capacitance,String power){
+//        return sysDeviceVoMapper.insertDevice(deviceId, deviceName, soc, chargingcapacity, dischargecapacity, dateTime, greenelectricity, statecharge, capacitance, power);
 //    }
 //
-//    public boolean updatesysdevice(String deviceId,String deviceName,String soc,String chargingcapacity,String dischargecapacity,String dateTime,String greenelectricity,String statecharge, String capacitance,String power){
-//        return sysDeviceVoMapper.updatesysdevice(deviceId, deviceName, soc, chargingcapacity, dischargecapacity, dateTime, greenelectricity, statecharge, capacitance, power);
+//    public boolean updateSysDevice(String deviceId,String deviceName,String soc,String chargingcapacity,String dischargecapacity,String dateTime,String greenelectricity,String statecharge, String capacitance,String power){
+//        return sysDeviceVoMapper.updateSysDevice(deviceId, deviceName, soc, chargingcapacity, dischargecapacity, dateTime, greenelectricity, statecharge, capacitance, power);
 //    }
     public Integer selectcount(String deviceId){
         return sysDeviceVoMapper.selectcount(deviceId);

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

     @Resource
     public SysFaultMapper sysFaultMapper;
 
-    public void insertfault(String faultId,
+    public void insertFault(String faultId,
                             String faultdescs,
                             String faultstatus,
                             String createtime,
                             String longitude,
                             String latitude,
                             String readpeople){
-        sysFaultMapper.insertfault(faultId,faultdescs,faultstatus,createtime,messageType,controllerId,deviceId,longitude,latitude,readpeople);
+        sysFaultMapper.insertFault(faultId,faultdescs,faultstatus,createtime,messageType,controllerId,deviceId,longitude,latitude,readpeople);
     }
 
-    public void updatefault(
+    public void updateFault(
                      String faultstatus,
                      String messageType,
                      String longitude,
                      String controllerId,
                      String deviceId,
                      String createtime){
-        sysFaultMapper.updatefault(faultstatus, messageType, longitude, latitude, faultdescs, controllerId, deviceId, createtime);
+        sysFaultMapper.updateFault(faultstatus, messageType, longitude, latitude, faultdescs, controllerId, deviceId, createtime);
     }
 
-    public Integer selectfaultcount(@Param("fleetId")String fleetId){
-        return sysFaultMapper.selectfaultcount(fleetId);
+    public Integer selectFaultCount(@Param("fleetId")String fleetId){
+        return sysFaultMapper.selectFaultCount(fleetId);
     }
-    public void createmessage(@Param("tableName")String tableName){
+    public void createMessage(@Param("tableName")String tableName){
         if (tableName == null || !TABLE_NAME_PATTERN.matcher(tableName).matches()) {
             throw new IllegalArgumentException("非法表名: " + tableName);
         }
-        sysFaultMapper.createmessage(tableName);
+        sysFaultMapper.createMessage(tableName);
     }
 
 

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

     }
 
 
-    public void insertindicators(Integer workordercount, Double profit, String carId,String createdata){
-        sysIndicatorsMapper.insertindicators(workordercount, profit, carId,createdata);
+    public void insertIndicators(Integer workordercount, Double profit, String carId,String createdata){
+        sysIndicatorsMapper.insertIndicators(workordercount, profit, carId,createdata);
     }
 
-    public void updateindicators(Integer workordercount,Double profit,String carId,String createdata){
-        sysIndicatorsMapper.updateindicators(workordercount, profit, carId,createdata);
+    public void updateIndicators(Integer workordercount,Double profit,String carId,String createdata){
+        sysIndicatorsMapper.updateIndicators(workordercount, profit, carId,createdata);
     }
 
-    public Integer selectcarcount(String carId,String createtime){
-        return sysIndicatorsMapper.selectcarcount(carId, createtime);
+    public Integer selectCarCount(String carId,String createtime){
+        return sysIndicatorsMapper.selectCarCount(carId, createtime);
     }
 
 }

iot-platform/src/main/java/com/iot/platform/service/SysrealtimeService.java → iot-platform/src/main/java/com/iot/platform/service/SysRealtimeService.java

 package com.iot.platform.service;
 
-import com.iot.platform.mapper.SysrealtimeMapper;
+import com.iot.platform.mapper.SysRealtimeMapper;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import java.util.regex.Pattern;
 
 @Service
-public class SysrealtimeService {
-    private static final Logger log = LoggerFactory.getLogger(SysrealtimeService.class);
+public class SysRealtimeService {
+    private static final Logger log = LoggerFactory.getLogger(SysRealtimeService.class);
     private static final Pattern TABLE_NAME_PATTERN = Pattern.compile("^[a-zA-Z0-9_]+$");
     private static final int MAX_TABLE_NAME_LENGTH = 64;
 
     @Resource
-    public SysrealtimeMapper sysrealtimeMapper;
+    public SysRealtimeMapper sysRealtimeMapper;
 
-    public void createrealtime(String tableName) {
+    public void createRealtime(String tableName) {
         validateTableName(tableName);
         log.info("准备创建表: [{}]", tableName);
-        sysrealtimeMapper.createrealtime(tableName);
+        sysRealtimeMapper.createRealtime(tableName);
         log.info("表[{}]创建成功", tableName);
     }
 
-    public List<String> selecttables() {
-        return sysrealtimeMapper.selecttables();
+    public List<String> selectTables() {
+        return sysRealtimeMapper.selectTables();
     }
 
-    public void inserttables(String tableName, String createTime, String deviceId, String timestamp, String k, Object v) {
+    public void insertTables(String tableName, String createTime, String deviceId, String timestamp, String k, Object v) {
         validateTableName(tableName);
-        sysrealtimeMapper.inserttables(tableName, createTime, deviceId, timestamp, k, v);
+        sysRealtimeMapper.insertTables(tableName, createTime, deviceId, timestamp, k, v);
     }
 
-    public void updatetables(String tableName, String createTime, Object v, String timestamp, String k, String deviceId) {
+    public void updateTables(String tableName, String createTime, Object v, String timestamp, String k, String deviceId) {
         validateTableName(tableName);
-        sysrealtimeMapper.updatetables(tableName, createTime, v, timestamp, k, deviceId);
+        sysRealtimeMapper.updateTables(tableName, createTime, v, timestamp, k, deviceId);
     }
 
-    public Integer selectkey(String tableName, String k) {
+    public Integer selectKey(String tableName, String k) {
         validateTableName(tableName);
-        return sysrealtimeMapper.selectkey(tableName, k);
+        return sysRealtimeMapper.selectKey(tableName, k);
     }
 
     public List<String> selectAllKeys(String tableName) {
         validateTableName(tableName);
-        return sysrealtimeMapper.selectAllKeys(tableName);
+        return sysRealtimeMapper.selectAllKeys(tableName);
     }
 
     private void validateTableName(String tableName) {

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

     @Resource
     public SysStatusMapper sysStatusMapper;
 
-    public void insertsysstatus(String controllerId, String fleetId, String status,String createTime){
-        sysStatusMapper.insertsysstatus(controllerId, fleetId, status,createTime);
+    public void insertSysStatus(String controllerId, String fleetId, String status,String createTime){
+        sysStatusMapper.insertSysStatus(controllerId, fleetId, status,createTime);
     }
-    public void updatestatus(String controllerId,String fleetId, String status, String createTime){
-        sysStatusMapper.updatestatus(controllerId,fleetId, status, createTime);
+    public void updateStatus(String controllerId,String fleetId, String status, String createTime){
+        sysStatusMapper.updateStatus(controllerId,fleetId, status, createTime);
     }
-    public Integer selectstatuscount(String controllerId){
-        return sysStatusMapper.selectstatuscount(controllerId);
+    public Integer selectStatusCount(String controllerId){
+        return sysStatusMapper.selectStatusCount(controllerId);
     }
 }

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

 
 
 
-    public Integer selectworkordercount(String companyId,String data){
-        return sysWorkorderMapper.selectworkordercount(companyId,data);
+    public Integer selectWorkorderCount(String companyId,String data){
+        return sysWorkorderMapper.selectWorkorderCount(companyId,data);
     }
-    public Double selectwokroderprofit(String companyId,String data){
-        return sysWorkorderMapper.selectwokroderprofit(companyId,data);
+    public Double selectWorkorderProfit(String companyId,String data){
+        return sysWorkorderMapper.selectWorkorderProfit(companyId,data);
     }
 }

iot-platform/src/main/resources/mapper/SysAlarmMapper.xml

         <result column="messageType" property="messageType"/>
     </resultMap>
 
-    <insert id="insertalarm">
+    <insert id="insertAlarm">
         insert into `${tableName}`(faultId,faultdescs,faultstatus,createtime,messageType,controller_id,device_id,longitude,latitude)
         values(#{faultId},#{faultdescs},#{faultstatus},#{createtime},#{messageType},#{controllerId},#{deviceId},#{longitude},#{latitude})
     </insert>

iot-platform/src/main/resources/mapper/SysCarMapper.xml

         <result column="controllerId" property="controllerId"/>
     </resultMap>
 
-    <select id="selectcontrollerId" resultMap="BaseResultMap">
+    <select id="selectControllerId" resultMap="BaseResultMap">
         select
             c.car_id carId,
             cc.controller_id controllerId
         from sys_car c
         RIGHT join sys_car_controller cc on c.car_id=cc.car_id
     </select>
-    <update id="updatecarposition">
+    <update id="updateCarPosition">
         update sys_car set car_position=#{carPosition} where car_id=#{carId}
     </update>
 
-    <select id="selectcarall" resultMap="BaseResultMap">
+    <select id="selectCarAll" resultMap="BaseResultMap">
         select car_id carId
         from sys_car
     </select>

iot-platform/src/main/resources/mapper/SysControllerMapper.xml

         <result column="path" property="path"/>
     </resultMap>
 
-    <insert id="insertsyscontroller">
+    <insert id="insertSysController">
         insert into controller_accept(controller_id, timestamp, fleet_id, name, path, device_id)
         values (#{controllerId}, #{timestamp}, #{fleetId}, #{name}, #{path}, #{deviceId})
     </insert>
-    <insert id="insertsyscontrollercmd">
+    <insert id="insertSysControllerCmd">
         insert into controller_issue(controller_id, timestamp, fleet_id, name, path)
         values (#{controllerId}, #{timestamp}, #{fleetId}, #{name}, #{path})
     </insert>
-    <insert id="insertsyscontrollerfault">
+    <insert id="insertSysControllerFault">
         insert into controller_fault(controller_id, timestamp, fleet_id, name, path)
         values (#{controllerId}, #{timestamp}, #{fleetId}, #{name}, #{path})
     </insert>
 
 
-    <select id="selectsyscontrollercount" resultType="Integer">
+    <select id="selectSysControllerCount" resultType="Integer">
         select COUNT(*) count
         from controller_accept
         where path =#{path}
     </select>
 
-    <select id="selectsyscontrollercountcmd" resultType="Integer">
+    <select id="selectSysControllerCmdCount" resultType="Integer">
         select COUNT(*) count
         from controller_issue
         where path =#{path}
     </select>
-    <select id="selectsyscontrollercountfault" resultType="Integer">
+    <select id="selectSysControllerFaultCount" resultType="Integer">
         select COUNT(*)
         from controller_fault
         where path = #{path}
     </select>
-    <update id="updatecontrollerAccept">
+    <update id="updateControllerAccept">
         update controller_accept
         set controller_id=#{controllerId},
             timestamp=#{timestamp},
     </update>
 
 
-    <select id="selectcontrollerpath" resultMap="BaseResultMap">
+    <select id="selectControllerPath" resultMap="BaseResultMap">
         select controller_id controllerId, timestamp timestamp, fleet_id fleetId, name name, path path
         FROM controller_accept
         where path =#{path}
     </select>
-    <select id="selectall" resultType="String">
+    <select id="selectAll" resultType="String">
         select path path
         from controller_accept
     </select>

iot-platform/src/main/resources/mapper/SysDeviceControlMapper.xml

         <result column="createOperationId" property="createOperationId"/>
         <result column="tableType" property="tableType"/>
     </resultMap>
-    <select id="selectdevice" resultMap="BaseResultMap">
+    <select id="selectDevice" resultMap="BaseResultMap">
         select
             id id,
             device_name deviceName,

iot-platform/src/main/resources/mapper/SysDeviceMapper.xml

         <result column="v" property="v"/>
     </resultMap>
 
-    <select id="selectsysdevice" resultMap="BaseResultMap">
+    <select id="selectSysDevice" resultMap="BaseResultMap">
         select v from `${tableName}` where k=#{k}
     </select>
 </mapper>

iot-platform/src/main/resources/mapper/SysDeviceVoMapper.xml

         <result column="power" property="power"/>
     </resultMap>
 
-<!--    <insert id="insertdevice">-->
+<!--    <insert id="insertDevice">-->
 <!--        insert into sys_device(device_id,-->
 <!--                               device_name,-->
 <!--                               soc,-->
 <!--            #{power})-->
 <!--    </insert>-->
 
-<!--    <update id="updatesysdevice">-->
+<!--    <update id="updateSysDevice">-->
 <!--        update sys_device set device_name=#{deviceName},-->
 <!--                              soc=#{soc},-->
 <!--                              chargingcapacity=#{chargingcapacity},-->

iot-platform/src/main/resources/mapper/SysFaultMapper.xml

         <result column="desc" property="desc"/>
     </resultMap>
 
-    <insert id="insertfault">
+    <insert id="insertFault">
         insert into alert_data(faultId,faultdescs,faultstatus,createtime,messageType,controller_id,device_id,longitude,latitude,readpeople)
         VALUES(#{faultId},#{faultdescs},#{faultstatus},#{createtime},#{messageType},#{controllerId},#{deviceId},#{longitude},#{latitude},#{readpeople})
     </insert>
-    <insert id="updatefault">
+    <insert id="updateFault">
         update alert_data set faultstatus=#{faultstatus},
                              messageType=#{messageType},
                              longitude=#{longitude},
         LIMIT 1;
     </insert>
 
-    <select id="selectfaultcount" resultType="Integer">
+    <select id="selectFaultCount" resultType="Integer">
         select count(*) from alert_data where device_id=#{deviceId}
     </select>
-    <update id="createmessage">
+    <update id="createMessage">
         CREATE TABLE `${tableName}` (
         `faultId` varchar(255) DEFAULT NULL COMMENT '消息id',
         `faultdescs` varchar(255) DEFAULT NULL COMMENT '故障描述',

iot-platform/src/main/resources/mapper/SysIndicatorsMapper.xml

         <result column="profit" property="profit"/>
         <result column="carId" property="carId"/>
     </resultMap>
-    <insert id="insertindicators">
+    <insert id="insertIndicators">
         insert into sys_indicators(workordercount,profit,car_id,createdata)
         value(#{workordercount},#{profit},#{carId},#{createdata})
     </insert>
 
-    <update id="updateindicators">
+    <update id="updateIndicators">
         update sys_indicators set workordercount=#{workordercount},profit=#{profit}
         where car_id=#{carId} and createdata=#{createdata}
     </update>
 
-    <select id="selectcarcount" resultType="integer">
+    <select id="selectCarCount" resultType="integer">
         select count(*)
         from sys_indicators
         where car_id=#{carId}

iot-platform/src/main/resources/mapper/SysrealtimeMapper.xml → iot-platform/src/main/resources/mapper/SysRealtimeMapper.xml

 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.iot.platform.mapper.SysrealtimeMapper">
+<mapper namespace="com.iot.platform.mapper.SysRealtimeMapper">
     <!-- 通用查询映射结果 -->
-    <resultMap id="BaseResultMap" type="com.iot.platform.domain.Sysrealtime">
+    <resultMap id="BaseResultMap" type="com.iot.platform.domain.SysRealtime">
         <result column="createTime" property="createTime"/>
         <result column="deviceId" property="deviceId"/>
         <result column="timestamp" property="timestamp"/>
         <result column="k" property="k"/>
         <result column="v" property="v"/>
     </resultMap>
-    <update id="createrealtime">
+    <update id="createRealtime">
         CREATE TABLE IF NOT EXISTS `${tableName}` (
             create_time VARCHAR(255) NOT NULL COMMENT '时间戳',
             device_id VARCHAR(255) NOT NULL COMMENT '设备id',
         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='实时数据信息';
     </update>
 
-    <select id="selecttables" resultType="String">
+    <select id="selectTables" resultType="String">
         SHOW TABLES;
     </select>
-    <insert id="inserttables">
+    <insert id="insertTables">
         insert into `${tableName}`(create_time,device_id,timestamp,k,v) values(#{createTime},#{deviceId},#{timestamp},#{k},#{v})
     </insert>
-    <update id="updatetables">
+    <update id="updateTables">
         update `${tableName}` set create_time=#{createTime},v=#{v},timestamp=#{timestamp} where k=#{k} and device_id=#{deviceId}
     </update>
 
-    <select id="selectkey" resultType="Integer">
+    <select id="selectKey" resultType="Integer">
         select COUNT(*) from `${tableName}` where k=#{k}
     </select>
 

iot-platform/src/main/resources/mapper/SysStatusMapper.xml

         <result column="fleetId" property="fleetId"/>
         <result column="status" property="status"/>
     </resultMap>
-    <insert id="insertsysstatus">
+    <insert id="insertSysStatus">
         Insert into controller_status(controller_id,fleet_id,status,create_time) values(#{controllerId},#{fleetId},#{status},#{createTime})
     </insert>
-    <update id="updatestatus">
+    <update id="updateStatus">
         update controller_status set fleet_id=#{fleetId},status=#{status},create_time=#{createTime} where controller_id=#{controllerId}
     </update>
-    <select id="selectstatuscount" resultType="Integer">
+    <select id="selectStatusCount" resultType="Integer">
         select COUNT(*) from controller_status where controller_id=#{controllerId}
     </select>
 </mapper>

iot-platform/src/main/resources/mapper/SysWorkorderMapper.xml

     <resultMap id="BaseResultMap" type="com.iot.platform.domain.SysWorkorder">
         <result column="driverId" property="driverId"/>
     </resultMap>
-    <select id="selectdeviceId" resultMap="BaseResultMap">
+    <select id="selectDeviceId" resultMap="BaseResultMap">
         select w.driver_id deviceId from sys_car_controller cc
         LEFT JOIN sys_car c on cc.car_id=c.car_id
         LEFT JOIN sys_workorder w on w.car_id=c.car_id
     </select>
 
 
-    <select id="selectworkordercount" resultType="integer">
+    <select id="selectWorkorderCount" resultType="integer">
         select
         count(*)
         from sys_workorder
         and workorder_createtime=#{data}
     </select>
 
-    <select id="selectwokroderprofit" resultType="double">
+    <select id="selectWorkorderProfit" resultType="double">
         select
         sum(mondel)
         from sys_workorder

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

     }
 
     @Test
-    @DisplayName("fetchTopics 应返回 sysControllerService.selectall() 的结果")
+    @DisplayName("fetchTopics 应返回 sysControllerService.selectAll() 的结果")
     void fetchTopics_delegatesToService() {
         List<String> expected = Arrays.asList("topic/1", "topic/2");
-        when(sysControllerService.selectall()).thenReturn(expected);
+        when(sysControllerService.selectAll()).thenReturn(expected);
 
         List<String> result = consumer.fetchTopics();
 
         assertThat(result).isEqualTo(expected);
-        verify(sysControllerService).selectall();
+        verify(sysControllerService).selectAll();
     }
 
     @Test
     @DisplayName("fetchTopics 应处理 null 返回值")
     void fetchTopics_nullReturn_returnsNull() {
-        when(sysControllerService.selectall()).thenReturn(null);
+        when(sysControllerService.selectAll()).thenReturn(null);
 
         List<String> result = consumer.fetchTopics();
 

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

     private SysFaultService sysFaultService;
 
     @Mock
-    private SysrealtimeService sysrealtimeService;
+    private SysRealtimeService sysRealtimeService;
 
     @Mock
     private SysWorkorderService sysWorkorderService;
     void setUp() {
         mqttFaultConsumer = new MqttFaultConsumer(
                 mqttFaultExecutor, abstractConsumerExecutor, iotProperties,
-                sysControllerService, sysFaultService, sysrealtimeService,
+                sysControllerService, sysFaultService, sysRealtimeService,
                 sysAlarmService, numericIdGenerator,
                 tdEngineAlarm, restTemplate);
 
     @Test
     @DisplayName("insertTDegine maps keys correctly via KEY_MAPPING")
     void insertTDegine_mapsKeysCorrectly() throws SQLException {
-        Map<String, Object> weather = new HashMap<>();
-        weather.put("timestamp", "2024-01-01T00:00:00Z");
-        weather.put("type", "触发");
-        weather.put("desc", "overtemperature");
-        weather.put("other", "value");
+        Map<String, Object> faultData = new HashMap<>();
+        faultData.put("timestamp", "2024-01-01T00:00:00Z");
+        faultData.put("type", "触发");
+        faultData.put("desc", "overtemperature");
+        faultData.put("other", "value");
 
         String topic = "controller1/fault_prot";
 
-        mqttFaultConsumer.insertTdEngine(weather, topic);
+        mqttFaultConsumer.insertTdEngine(faultData, topic);
 
         verify(tdEngineAlarm).recordFailure(argThat(map ->
                 "2024-01-01T00:00:00Z".equals(map.get("devicetimestamp"))
     @Test
     @DisplayName("insertTDegine splits topic correctly")
     void insertTDegine_splitsTopicCorrectly() throws SQLException {
-        Map<String, Object> weather = new HashMap<>();
-        weather.put("timestamp", "2024-01-01T00:00:00Z");
+        Map<String, Object> faultData = new HashMap<>();
+        faultData.put("timestamp", "2024-01-01T00:00:00Z");
 
         String topic = "myController/fault_prot";
         LocalDate now = LocalDate.now();
         int month = now.getMonthValue();
         String expectedTable = "myController_" + year + String.format("%02d", month);
 
-        mqttFaultConsumer.insertTdEngine(weather, topic);
+        mqttFaultConsumer.insertTdEngine(faultData, topic);
 
         verify(tdEngineAlarm).recordFailure(anyMap(), eq("myController"), eq(expectedTable));
     }
         String topic = "ctrl1/fault_prot";
         String messageContent = "{\"device_id\":\"dev1\",\"controller_id\":\"ctrl1\",\"timestamp\":\"2024-01-01T00:00:00Z\",\"type\":\"触发\",\"code\":1,\"desc\":\"overtemperature\"}";
 
-        SysDevice jingdu = new SysDevice();
-        jingdu.setV("116.3974");
-        SysDevice weidu = new SysDevice();
-        weidu.setV("39.9093");
+        SysDevice longitude = new SysDevice();
+        longitude.setV("116.3974");
+        SysDevice latitude = new SysDevice();
+        latitude.setV("39.9093");
 
-        lenient().when(sysrealtimeService.selecttables()).thenReturn(Collections.singletonList("ctrl1" + LocalDate.now().getYear() + String.format("%02d", LocalDate.now().getMonthValue()) + "_fault"));
-        lenient().when(sysControllerService.selectjingweidu("ctrl1", "经度")).thenReturn(jingdu);
-        lenient().when(sysControllerService.selectjingweidu("ctrl1", "纬度")).thenReturn(weidu);
+        lenient().when(sysRealtimeService.selectTables()).thenReturn(Collections.singletonList("ctrl1" + LocalDate.now().getYear() + String.format("%02d", LocalDate.now().getMonthValue()) + "_fault"));
+        lenient().when(sysControllerService.selectCoordinates("ctrl1", "经度")).thenReturn(longitude);
+        lenient().when(sysControllerService.selectCoordinates("ctrl1", "纬度")).thenReturn(latitude);
         lenient().when(numericIdGenerator.nextId()).thenReturn("123456789");
 
         mqttFaultConsumer.handleMessage(topic, messageContent);
     }
 
     @Test
-    @DisplayName("triggermethod with 触发 type calls insertalarm and insertfault")
+    @DisplayName("triggerMethod with 触发 type calls insertAlarm and insertFault")
     void triggermethod_triggerType_callsInsertAlarmAndInsertFault() {
-        SysFault weather = new SysFault();
-        weather.setDevice_id("dev1");
-        weather.setController_id("ctrl1");
-        weather.setTimestamp("2024-01-01T00:00:00Z");
-        weather.setType("触发");
-        weather.setDesc("overtemperature");
+        SysFault faultData = new SysFault();
+        faultData.setDevice_id("dev1");
+        faultData.setController_id("ctrl1");
+        faultData.setTimestamp("2024-01-01T00:00:00Z");
+        faultData.setType("触发");
+        faultData.setDesc("overtemperature");
 
         String topic = "ctrl1/fault_prot";
 
-        SysDevice jingdu = new SysDevice();
-        jingdu.setV("116.3974");
-        SysDevice weidu = new SysDevice();
-        weidu.setV("39.9093");
+        SysDevice longitude = new SysDevice();
+        longitude.setV("116.3974");
+        SysDevice latitude = new SysDevice();
+        latitude.setV("39.9093");
 
-        when(sysrealtimeService.selecttables()).thenReturn(Collections.singletonList("ctrl1" + LocalDate.now().getYear() + String.format("%02d", LocalDate.now().getMonthValue()) + "_fault"));
-        when(sysControllerService.selectjingweidu("ctrl1", "经度")).thenReturn(jingdu);
-        when(sysControllerService.selectjingweidu("ctrl1", "纬度")).thenReturn(weidu);
+        when(sysRealtimeService.selectTables()).thenReturn(Collections.singletonList("ctrl1" + LocalDate.now().getYear() + String.format("%02d", LocalDate.now().getMonthValue()) + "_fault"));
+        when(sysControllerService.selectCoordinates("ctrl1", "经度")).thenReturn(longitude);
+        when(sysControllerService.selectCoordinates("ctrl1", "纬度")).thenReturn(latitude);
         when(numericIdGenerator.nextId()).thenReturn("123456789");
 
-        mqttFaultConsumer.triggermethod(topic, weather);
+        mqttFaultConsumer.triggerMethod(topic, faultData);
 
-        verify(sysAlarmService).insertalarm(anyString(), eq("GJ123456789"), eq("overtemperature"), eq("0"), anyString(), eq("0"), eq("ctrl1"), eq("dev1"), eq("116.3974"), eq("39.9093"));
-        verify(sysFaultService).insertfault(eq("GJ123456789"), eq("overtemperature"), eq("0"), anyString(), eq("0"), eq("ctrl1"), eq("dev1"), eq("116.3974"), eq("39.9093"), eq(""));
+        verify(sysAlarmService).insertAlarm(anyString(), eq("GJ123456789"), eq("overtemperature"), eq("0"), anyString(), eq("0"), eq("ctrl1"), eq("dev1"), eq("116.3974"), eq("39.9093"));
+        verify(sysFaultService).insertFault(eq("GJ123456789"), eq("overtemperature"), eq("0"), anyString(), eq("0"), eq("ctrl1"), eq("dev1"), eq("116.3974"), eq("39.9093"), eq(""));
     }
 
     @Test
-    @DisplayName("triggermethod with 恢复 type calls insertalarm and updatefault")
+    @DisplayName("triggerMethod with 恢复 type calls insertAlarm and updateFault")
     void triggermethod_recoverType_callsInsertAlarmAndUpdateFault() {
-        SysFault weather = new SysFault();
-        weather.setDevice_id("dev1");
-        weather.setController_id("ctrl1");
-        weather.setTimestamp("2024-01-01T00:00:00Z");
-        weather.setType("恢复");
-        weather.setDesc("overtemperature recovered");
+        SysFault faultData = new SysFault();
+        faultData.setDevice_id("dev1");
+        faultData.setController_id("ctrl1");
+        faultData.setTimestamp("2024-01-01T00:00:00Z");
+        faultData.setType("恢复");
+        faultData.setDesc("overtemperature recovered");
 
         String topic = "ctrl1/fault_prot";
 
-        SysDevice jingdu = new SysDevice();
-        jingdu.setV("116.3974");
-        SysDevice weidu = new SysDevice();
-        weidu.setV("39.9093");
+        SysDevice longitude = new SysDevice();
+        longitude.setV("116.3974");
+        SysDevice latitude = new SysDevice();
+        latitude.setV("39.9093");
 
-        when(sysrealtimeService.selecttables()).thenReturn(Collections.singletonList("ctrl1" + LocalDate.now().getYear() + String.format("%02d", LocalDate.now().getMonthValue()) + "_fault"));
-        when(sysControllerService.selectjingweidu("ctrl1", "经度")).thenReturn(jingdu);
-        when(sysControllerService.selectjingweidu("ctrl1", "纬度")).thenReturn(weidu);
+        when(sysRealtimeService.selectTables()).thenReturn(Collections.singletonList("ctrl1" + LocalDate.now().getYear() + String.format("%02d", LocalDate.now().getMonthValue()) + "_fault"));
+        when(sysControllerService.selectCoordinates("ctrl1", "经度")).thenReturn(longitude);
+        when(sysControllerService.selectCoordinates("ctrl1", "纬度")).thenReturn(latitude);
         when(numericIdGenerator.nextId()).thenReturn("987654321");
 
-        mqttFaultConsumer.triggermethod(topic, weather);
+        mqttFaultConsumer.triggerMethod(topic, faultData);
 
-        verify(sysAlarmService).insertalarm(anyString(), eq("GJ987654321"), eq("overtemperature recovered"), eq("1"), anyString(), eq("0"), eq("ctrl1"), eq("dev1"), eq("116.3974"), eq("39.9093"));
-        verify(sysFaultService).updatefault(eq("1"), eq("0"), eq("116.3974"), eq("39.9093"), eq("overtemperature recovered"), eq("ctrl1"), eq("dev1"), anyString());
+        verify(sysAlarmService).insertAlarm(anyString(), eq("GJ987654321"), eq("overtemperature recovered"), eq("1"), anyString(), eq("0"), eq("ctrl1"), eq("dev1"), eq("116.3974"), eq("39.9093"));
+        verify(sysFaultService).updateFault(eq("1"), eq("0"), eq("116.3974"), eq("39.9093"), eq("overtemperature recovered"), eq("ctrl1"), eq("dev1"), anyString());
     }
 }

iot-platform/src/test/java/com/iot/platform/service/SysrealtimeServiceTest.java → iot-platform/src/test/java/com/iot/platform/service/SysRealtimeServiceTest.java

 package com.iot.platform.service;
 
-import com.iot.platform.mapper.SysrealtimeMapper;
+import com.iot.platform.mapper.SysRealtimeMapper;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import static org.mockito.Mockito.*;
 
 @ExtendWith(MockitoExtension.class)
-class SysrealtimeServiceTest {
+class SysRealtimeServiceTest {
 
     @Mock
-    private SysrealtimeMapper sysrealtimeMapper;
+    private SysRealtimeMapper sysRealtimeMapper;
 
     @InjectMocks
-    private SysrealtimeService service;
+    private SysRealtimeService service;
 
     @Test
-    @DisplayName("createrealtime: 空表名应抛出 IllegalArgumentException")
+    @DisplayName("createRealtime: 空表名应抛出 IllegalArgumentException")
     void createrealtime_nullTableName_throws() {
-        assertThatThrownBy(() -> service.createrealtime(null))
+        assertThatThrownBy(() -> service.createRealtime(null))
             .isInstanceOf(IllegalArgumentException.class)
             .hasMessageContaining("表名不能为空");
     }
 
     @Test
-    @DisplayName("createrealtime: SQL注入表名应抛出 IllegalArgumentException")
+    @DisplayName("createRealtime: SQL注入表名应抛出 IllegalArgumentException")
     void createrealtime_sqlInjectionTableName_throws() {
-        assertThatThrownBy(() -> service.createrealtime("users; DROP TABLE users;"))
+        assertThatThrownBy(() -> service.createRealtime("users; DROP TABLE users;"))
             .isInstanceOf(IllegalArgumentException.class)
             .hasMessageContaining("非法表名");
     }
 
     @Test
-    @DisplayName("createrealtime: 超长表名应抛出 IllegalArgumentException")
+    @DisplayName("createRealtime: 超长表名应抛出 IllegalArgumentException")
     void createrealtime_tooLongTableName_throws() {
-        assertThatThrownBy(() -> service.createrealtime("a".repeat(65)))
+        assertThatThrownBy(() -> service.createRealtime("a".repeat(65)))
             .isInstanceOf(IllegalArgumentException.class)
             .hasMessageContaining("表名过长");
     }
 
     @Test
-    @DisplayName("createrealtime: 合法表名应调用 mapper")
+    @DisplayName("createRealtime: 合法表名应调用 mapper")
     void createrealtime_validTableName_callsMapper() {
-        service.createrealtime("device_data_202401");
-        verify(sysrealtimeMapper).createrealtime("device_data_202401");
+        service.createRealtime("device_data_202401");
+        verify(sysRealtimeMapper).createRealtime("device_data_202401");
     }
 
     @Test
-    @DisplayName("inserttables: 非法表名应抛出异常且不调用 mapper")
+    @DisplayName("insertTables: 非法表名应抛出异常且不调用 mapper")
     void inserttables_invalidTableName_throwsWithoutCallingMapper() {
-        assertThatThrownBy(() -> service.inserttables("bad;name", "2024-01-01", "D1", "ts", "k", "v"))
+        assertThatThrownBy(() -> service.insertTables("bad;name", "2024-01-01", "D1", "ts", "k", "v"))
             .isInstanceOf(IllegalArgumentException.class);
-        verifyNoInteractions(sysrealtimeMapper);
+        verifyNoInteractions(sysRealtimeMapper);
     }
 
     @Test
-    @DisplayName("updatetables: 合法表名应调用 mapper")
+    @DisplayName("updateTables: 合法表名应调用 mapper")
     void updatetables_validTableName_callsMapper() {
-        service.updatetables("dev_001", "2024-01-01", "v1", "ts", "key1", "D1");
-        verify(sysrealtimeMapper).updatetables("dev_001", "2024-01-01", "v1", "ts", "key1", "D1");
+        service.updateTables("dev_001", "2024-01-01", "v1", "ts", "key1", "D1");
+        verify(sysRealtimeMapper).updateTables("dev_001", "2024-01-01", "v1", "ts", "key1", "D1");
     }
 
     @Test
-    @DisplayName("selectkey: 非法表名应抛出异常")
+    @DisplayName("selectKey: 非法表名应抛出异常")
     void selectkey_invalidTableName_throws() {
-        assertThatThrownBy(() -> service.selectkey("--comment", "k"))
+        assertThatThrownBy(() -> service.selectKey("--comment", "k"))
             .isInstanceOf(IllegalArgumentException.class)
             .hasMessageContaining("非法表名");
     }
     @DisplayName("selectAllKeys: 合法表名应调用 mapper")
     void selectAllKeys_validTableName_callsMapper() {
         service.selectAllKeys("realtime_001");
-        verify(sysrealtimeMapper).selectAllKeys("realtime_001");
+        verify(sysRealtimeMapper).selectAllKeys("realtime_001");
     }
 }