Merge remote-tracking branch 'origin/develop' into zhanghongwei_branch

META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: com.campus.water.CampusWaterApplication
+

pom.xml

@@ -125,13 +125,34 @@
     </dependencies>
 
     <build>
-        <sourceDirectory>src</sourceDirectory>
+        <sourceDirectory>src/main/java</sourceDirectory>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>
             </resource>
         </resources>
         <plugins>
+            <!-- 1. 编译插件：解决Lombok注解处理器问题 -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.12.1</version>
+                <configuration>
+                    <source>23</source>
+                    <target>23</target>
+                    <encoding>UTF-8</encoding>
+                    <!-- 核心：Lombok注解处理器配置 -->
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>${lombok.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+
+            <!-- 2. Spring Boot打包插件 -->
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
@@ -142,7 +163,17 @@
                             <artifactId>lombok</artifactId>
                         </exclude>
                     </excludes>
+                    <!-- 必加：指定启动类（替换为你的实际路径） -->
+                    <mainClass>com.campus.water.CampusWaterApplication</mainClass>
                 </configuration>
+                <!-- 必加：生成可执行JAR -->
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
             </plugin>
         </plugins>
     </build>

src/main/java/com/campus/water/config/HttpsConfig.java

@@ -0,0 +1,46 @@
+package com.campus.water.config;
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+
+import java.io.IOException;
+
+@Configuration
+public class HttpsConfig {
+
+    // 优先级最高的过滤器，实现HTTP→HTTPS跳转
+    @Bean
+    @Order(Ordered.HIGHEST_PRECEDENCE)
+    public Filter httpToHttpsRedirectFilter() {
+        return new Filter() {
+            @Override
+            public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+                    throws IOException, ServletException {
+                HttpServletRequest req = (HttpServletRequest) request;
+                HttpServletResponse res = (HttpServletResponse) response;
+
+                // 仅处理HTTP请求，跳转到HTTPS
+                if ("http".equals(req.getScheme())) {
+                    String httpsUrl = "https://" + req.getServerName() + ":" + 8081 + req.getRequestURI();
+                    if (req.getQueryString() != null) {
+                        httpsUrl += "?" + req.getQueryString();
+                    }
+                    res.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
+                    res.setHeader("Location", httpsUrl);
+                    return;
+                }
+                chain.doFilter(request, response);
+            }
+
+            @Override
+            public void init(FilterConfig filterConfig) {}
+
+            @Override
+            public void destroy() {}
+        };
+    }
+}

src/main/java/com/campus/water/config/SecurityConfig.java

@@ -98,7 +98,7 @@ public class SecurityConfig {
     @Bean
     public CorsConfigurationSource corsConfigurationSource() {
         CorsConfiguration configuration = new CorsConfiguration();
-        configuration.setAllowedOrigins(Arrays.asList("http://localhost:5173"));
+        configuration.setAllowedOriginPatterns(Arrays.asList("**"));
         configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
         configuration.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type", "X-Requested-With"));
         configuration.setAllowCredentials(true);

src/main/java/com/campus/water/controller/GlobalExceptionHandler.java

@@ -1,19 +1,35 @@
 package com.campus.water.controller;
 
+import com.campus.water.entity.BusinessException;
 import com.campus.water.util.ResultVO;
-import org.springframework.security.access.AccessDeniedException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.validation.BindException;
+import org.springframework.validation.FieldError;
+import org.springframework.web.HttpMediaTypeNotSupportedException;
+import org.springframework.web.HttpRequestMethodNotSupportedException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
-import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.multipart.MaxUploadSizeExceededException;
+import org.springframework.web.servlet.NoHandlerFoundException;
 
-import java.time.format.DateTimeParseException;
-import java.util.Objects;
+import java.io.IOException;
+import java.nio.file.AccessDeniedException;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
 
 /**
  * 全局异常处理器 - 统一处理项目中所有控制器层异常
  */
 @RestControllerAdvice
+@Slf4j
 public class GlobalExceptionHandler {
 
     /**
@@ -26,6 +42,10 @@ public class GlobalExceptionHandler {
         if (msg.contains("AlertLevel") || msg.contains("AlertStatus")) {
             msg = "参数错误：告警级别可选值(info/warning/error/critical)，告警状态可选值(pending/resolved/closed)";
         }
+        // 设备ID格式错误特殊处理
+        if (msg.contains("设备ID") || msg.contains("deviceId")) {
+            msg = "设备ID格式错误，正确格式为WM/WS开头+3位数字（如WM001、WS123）";
+        }
         return ResultVO.error(400, "参数错误：" + msg);
     }
 
@@ -36,8 +56,15 @@ public class GlobalExceptionHandler {
     public ResultVO<Void> handleTypeMismatch(MethodArgumentTypeMismatchException e) {
         String errorMsg;
         // 特殊处理时间格式错误（告警查询的时间参数）
-        if (e.getCause() instanceof DateTimeParseException) {
+        if (e.getCause() instanceof java.time.format.DateTimeParseException) {
             errorMsg = "时间参数格式错误，正确格式：yyyy-MM-dd HH:mm:ss（示例：2025-12-05 10:30:00）";
+        } else if (e.getRequiredType() != null && e.getRequiredType().isEnum()) {
+            // 枚举类型转换错误处理
+            errorMsg = String.format(
+                    "参数[%s]枚举值错误，允许值：%s",
+                    e.getName(),
+                    getEnumValues(e.getRequiredType())
+            );
         } else {
             // 通用类型不匹配提示
             errorMsg = String.format(
@@ -51,21 +78,35 @@ public class GlobalExceptionHandler {
     }
 
     /**
-     * 处理权限不足异常（如非管理员/维修人员访问告警接口）
+     * 处理权限不足异常（如非管理员/维修人员访问受限接口）
      */
-    @ExceptionHandler(AccessDeniedException.class)
-    public ResultVO<Void> handleAccessDenied(AccessDeniedException e) {
-        return ResultVO.error(403, "权限不足：仅管理员/维修人员可访问告警相关功能");
+    @ExceptionHandler({AccessDeniedException.class, org.springframework.security.access.AccessDeniedException.class})
+    public ResultVO<Void> handleAccessDenied(Exception e) {
+        String roleMsg = "仅超级管理员可操作";
+        // 区分不同接口的权限提示
+        if (e.getMessage().contains("AREA_ADMIN")) {
+            roleMsg = "仅区域管理员及以上权限可操作";
+        } else if (e.getMessage().contains("REPAIRMAN")) {
+            roleMsg = "仅维修人员及管理员可操作";
+        }
+        return ResultVO.error(403, "权限不足：" + roleMsg);
     }
 
     /**
-     * 处理通用运行时异常（兜底）
+     * 处理资源不存在异常（如查询不存在的设备/用户）
      */
-    @ExceptionHandler(RuntimeException.class)
-    public ResultVO<Void> handleRuntimeException(RuntimeException e) {
-        // 生产环境建议添加日志记录，此处简化
-        // log.error("服务器运行时异常", e);
-        return ResultVO.error(500, "服务器内部错误：" + e.getMessage());
+    @ExceptionHandler(NoSuchElementException.class)
+    public ResultVO<Void> handleNoSuchElement(NoSuchElementException e) {
+        String msg = e.getMessage();
+        // 标准化资源不存在提示
+        if (msg.contains("设备")) {
+            return ResultVO.error(404, "设备不存在：" + msg.replace("No value present", "").trim());
+        } else if (msg.contains("管理员") || msg.contains("Admin")) {
+            return ResultVO.error(404, "管理员不存在：" + msg.replace("No value present", "").trim());
+        } else if (msg.contains("区域") || msg.contains("Area")) {
+            return ResultVO.error(404, "区域不存在：" + msg.replace("No value present", "").trim());
+        }
+        return ResultVO.error(404, "请求的资源不存在：" + msg);
     }
 
     /**
@@ -73,8 +114,176 @@ public class GlobalExceptionHandler {
      */
     @ExceptionHandler(MethodArgumentNotValidException.class)
     public ResultVO<Void> handleMethodArgumentNotValid(MethodArgumentNotValidException e) {
-        // 获取第一个验证失败的字段和消息
-        String errorMsg = Objects.requireNonNull(e.getBindingResult().getFieldError()).getDefaultMessage();
-        return ResultVO.badRequest(errorMsg); // 返回400状态码和具体错误信息
+        // 收集所有验证失败的字段和消息
+        List<String> errorMessages = e.getBindingResult().getFieldErrors().stream()
+                .map(error -> error.getField() + "：" + error.getDefaultMessage())
+                .collect(Collectors.toList());
+        return ResultVO.error(400, "参数验证失败：" + String.join("；", errorMessages));
+    }
+
+    /**
+     * 处理表单参数绑定异常（非@RequestBody的参数验证）
+     */
+    @ExceptionHandler(BindException.class)
+    public ResultVO<Void> handleBindException(BindException e) {
+        FieldError firstError = e.getBindingResult().getFieldError();
+        String errorMsg = firstError != null ?
+                firstError.getField() + "：" + firstError.getDefaultMessage() :
+                "参数绑定失败";
+        return ResultVO.error(400, "表单参数错误：" + errorMsg);
+    }
+
+    /**
+     * 处理缺失必填参数异常
+     */
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public ResultVO<Void> handleMissingParam(MissingServletRequestParameterException e) {
+        return ResultVO.error(400,
+                String.format("缺少必填参数：%s（类型：%s）",
+                        e.getParameterName(),
+                        e.getParameterType()));
+    }
+
+    /**
+     * 处理数据库唯一约束冲突异常
+     */
+    @ExceptionHandler(DuplicateKeyException.class)
+    public ResultVO<Void> handleDuplicateKey(DuplicateKeyException e) {
+        log.error("数据库唯一约束冲突", e);
+        String msg = "数据已存在，无法重复添加";
+        // 针对设备ID冲突特殊处理
+        if (e.getMessage().contains("device_id")) {
+            msg = "设备ID已存在，请更换设备ID后重试";
+        } else if (e.getMessage().contains("admin_name")) {
+            msg = "管理员用户名已存在，请更换用户名";
+        }
+        return ResultVO.error(409, msg);
+    }
+
+    /**
+     * 处理数据库完整性约束异常（外键关联等）
+     */
+    @ExceptionHandler(DataIntegrityViolationException.class)
+    public ResultVO<Void> handleDataIntegrityViolation(DataIntegrityViolationException e) {
+        log.error("数据库完整性约束异常", e);
+        String msg = "数据操作失败，可能存在关联数据";
+        if (e.getMessage().contains("foreign key constraint")) {
+            msg = "无法删除，该数据已被其他记录关联引用";
+        } else if (e.getMessage().contains("not null")) {
+            msg = "必填字段不能为空，请检查输入";
+        }
+        return ResultVO.error(400, msg);
+    }
+
+    /**
+     * 处理JSON解析异常（请求体格式错误）
+     */
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    public ResultVO<Void> handleHttpMessageNotReadable(HttpMessageNotReadableException e) {
+        log.error("请求体解析失败", e);
+        String msg = "请求数据格式错误，请检查JSON格式是否正确";
+        if (e.getMessage().contains("date-time")) {
+            msg = "日期时间格式错误，正确格式：yyyy-MM-dd HH:mm:ss";
+        }
+        return ResultVO.error(400, msg);
+    }
+
+    /**
+     * 处理不支持的HTTP方法异常
+     */
+    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
+    public ResultVO<Void> handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e) {
+        return ResultVO.error(405,
+                String.format("不支持的请求方法：%s，支持的方法：%s",
+                        e.getMethod(),
+                        String.join(",", e.getSupportedMethods())));
+    }
+
+    /**
+     * 处理不支持的媒体类型异常
+     */
+    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
+    public ResultVO<Void> handleHttpMediaTypeNotSupported(HttpMediaTypeNotSupportedException e) {
+        return ResultVO.error(415,
+                String.format("不支持的媒体类型：%s，支持的类型：%s",
+                        e.getContentType(),
+                        e.getSupportedMediaTypes()));
+    }
+
+    /**
+     * 处理文件上传大小超限异常
+     */
+    @ExceptionHandler(MaxUploadSizeExceededException.class)
+    public ResultVO<Void> handleMaxUploadSizeExceeded(MaxUploadSizeExceededException e) {
+        long maxSizeMB = e.getMaxUploadSize() / (1024 * 1024);
+        return ResultVO.error(413,
+                String.format("文件大小超限，最大支持：%dMB", maxSizeMB));
+    }
+
+    /**
+     * 处理IO异常（文件操作等）
+     */
+    @ExceptionHandler(IOException.class)
+    public ResultVO<Void> handleIOException(IOException e) {
+        log.error("IO操作异常", e);
+        String msg = "文件操作失败：" + e.getMessage();
+        if (e.getMessage().contains("Permission denied")) {
+            msg = "文件操作权限不足";
+        }
+        return ResultVO.error(500, msg);
+    }
+
+    /**
+     * 处理业务逻辑异常（自定义异常）
+     */
+    @ExceptionHandler(BusinessException.class)
+    public ResultVO<Void> handleBusinessException(BusinessException e) {
+        // 业务异常自带状态码和消息
+        return ResultVO.error(e.getCode(), e.getMessage());
+    }
+
+    /**
+     * 处理404异常
+     */
+    @ExceptionHandler(NoHandlerFoundException.class)
+    public ResultVO<Void> handleNoHandlerFound(NoHandlerFoundException e) {
+        return ResultVO.error(404,
+                String.format("请求的接口不存在：%s %s",
+                        e.getHttpMethod(),
+                        e.getRequestURL()));
+    }
+
+    /**
+     * 处理通用运行时异常（兜底）
+     */
+    @ExceptionHandler(RuntimeException.class)
+    public ResultVO<Void> handleRuntimeException(RuntimeException e) {
+        log.error("服务器运行时异常", e);
+        // 生产环境可根据异常类型返回更友好的提示
+        String msg = "服务器内部错误：" + e.getMessage();
+        // 对常见运行时异常进行特殊处理
+        if (e instanceof NullPointerException) {
+            msg = "系统处理异常：数据为空";
+        } else if (e instanceof IndexOutOfBoundsException) {
+            msg = "系统处理异常：数据索引越界";
+        }
+        return ResultVO.error(500, msg);
+    }
+
+    /**
+     * 工具方法：获取枚举类的所有值
+     */
+    private String getEnumValues(Class<?> enumClass) {
+        if (!enumClass.isEnum()) {
+            return "未知";
+        }
+        StringBuilder values = new StringBuilder();
+        for (Object enumConstant : enumClass.getEnumConstants()) {
+            values.append(enumConstant).append(",");
+        }
+        if (values.length() > 0) {
+            values.deleteCharAt(values.length() - 1);
+        }
+        return values.toString();
     }
 }

src/main/java/com/campus/water/entity/BusinessException.java

@@ -0,0 +1,55 @@
+package com.campus.water.entity; // 请确保这个包名与你的项目结构一致
+
+import org.springframework.http.HttpStatus;
+
+/**
+ * 自定义业务异常
+ * <p>
+ * 用于封装业务层抛出的、需要明确反馈给用户的异常信息。
+ * 例如：用户不存在、密码错误、工单状态不正确等。
+ * </p>
+ */
+public class BusinessException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 错误码，对应HTTP状态码
+     */
+    private int code;
+
+    /**
+     * 错误消息
+     */
+    private String message;
+
+    /**
+     * 构造函数
+     * @param code 错误码
+     * @param message 错误消息
+     */
+    public BusinessException(int code, String message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+    }
+
+    /**
+     * 构造函数，默认使用 400 Bad Request 状态码
+     * @param message 错误消息
+     */
+    public BusinessException(String message) {
+        this(HttpStatus.BAD_REQUEST.value(), message);
+    }
+
+    // --- Getters ---
+
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/com/campus/water/mapper/AlertRepository.java

@@ -58,4 +58,6 @@ public interface AlertRepository extends JpaRepository<Alert, Long> {
             List<Alert.AlertStatus> activeStatus,
             LocalDateTime timestamp
     );
+
+    List<Alert> findByResolvedByAndStatus(String repairmanId, Alert.AlertStatus alertStatus);
 }

src/main/java/com/campus/water/util/CommonUtils.java

@@ -554,4 +554,250 @@ public class CommonUtils {
             default -> "普通";
         };
     }
+
+
+    /**
+     * 设备MAC地址格式校验（12位十六进制，支持冒号/横线分隔或无分隔）
+     */
+    public static boolean validateMacAddress(String mac) {
+        if (isBlankWithFullWidth(mac)) {
+            return false;
+        }
+        // 去除分隔符，转为纯12位十六进制字符串
+        String pureMac = mac.replace(":", "").replace("-", "").trim().toLowerCase();
+        if (pureMac.length() != 12) {
+            return false;
+        }
+        return pureMac.matches("[0-9a-f]+");
+    }
+
+    /**
+     * 设备IP地址格式校验（IPv4）
+     */
+    public static boolean validateIpv4Address(String ip) {
+        if (isBlankWithFullWidth(ip)) {
+            return false;
+        }
+        String[] ipSegments = ip.split("\\.");
+        if (ipSegments.length != 4) {
+            return false;
+        }
+        try {
+            for (String segment : ipSegments) {
+                int num = Integer.parseInt(segment);
+                if (num < 0 || num > 255) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (NumberFormatException e) {
+            log.warn("IP地址格式错误：{}", ip);
+            return false;
+        }
+    }
+
+    /**
+     * 批量校验设备ID（返回无效ID列表）
+     */
+    public static List<String> batchValidateDeviceId(List<String> deviceIdList) {
+        List<String> invalidIds = new ArrayList<>();
+        if (isEmpty(deviceIdList)) {
+            return invalidIds;
+        }
+        for (String deviceId : deviceIdList) {
+            if (!validateDeviceId(deviceId)) {
+                invalidIds.add(deviceId);
+            }
+        }
+        return invalidIds;
+    }
+    /**
+     * 设备状态转换（中文转枚举/英文）
+     */
+    public static String convertCnToDeviceStatus(String cnStatus) {
+        if (isBlankWithFullWidth(cnStatus)) {
+            return "unknown";
+        }
+        return switch (cnStatus.trim()) {
+            case "在线" -> "online";
+            case "离线" -> "offline";
+            case "故障" -> "fault";
+            default -> "unknown";
+        };
+    }
+
+
+    /**
+     * 设备数据单位转换（MPa转Bar，1MPa=10Bar）
+     */
+    public static BigDecimal convertMpaToBar(BigDecimal mpa) {
+        if (!validateSensorValue(mpa)) {
+            return BigDecimal.ZERO;
+        }
+        return mpa.multiply(new BigDecimal("10")).setScale(2, RoundingMode.HALF_UP);
+    }
+
+    /**
+     * 设备数据单位转换（Bar转MPa）
+     */
+    public static BigDecimal convertBarToMpa(BigDecimal bar) {
+        if (!validateSensorValue(bar)) {
+            return BigDecimal.ZERO;
+        }
+        return bar.divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
+    }
+
+    /**
+     * 数字转中文数字（0-100，适配滤芯寿命/水位等展示）
+     */
+    public static String convertNumToCn(Integer num) {
+        if (num == null || num < 0 || num > 100) {
+            return "零";
+        }
+        String[] cnNums = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"};
+        if (num <= 10) {
+            return cnNums[num];
+        } else if (num < 20) {
+            return "十" + cnNums[num - 10];
+        } else if (num % 10 == 0) {
+            return cnNums[num / 10] + "十";
+        } else {
+            return cnNums[num / 10] + "十" + cnNums[num % 10];
+        }
+    }
+    /**
+     * 工单状态转换（枚举转中文）
+     */
+    public static String convertOrderStatusToCn(String status) {
+        if (isBlankWithFullWidth(status)) {
+            return "未知状态";
+        }
+        return switch (status.toLowerCase()) {
+            case "pending" -> "待处理";
+            case "processing" -> "处理中";
+            case "completed" -> "已完成";
+            case "cancelled" -> "已取消";
+            default -> "未知状态";
+        };
+    }
+
+    /**
+     * 工单类型转换（枚举转中文）
+     */
+    public static String convertOrderTypeToCn(String type) {
+        if (isBlankWithFullWidth(type)) {
+            return "未知类型";
+        }
+        return switch (type.toLowerCase()) {
+            case "repair" -> "故障维修";
+            case "maintenance" -> "定期保养";
+            case "inspection" -> "设备巡检";
+            default -> "未知类型";
+        };
+    }
+
+
+
+
+    /**
+     * 生成模拟告警信息（基于设备类型）
+     */
+    public static String generateMockAlertMessage(DeviceType type) {
+        String[] makerAlerts = {
+                "原水TDS值过高，超出阈值",
+                "纯水TDS值异常，滤芯可能失效",
+                "水压过低，设备无法正常制水",
+                "设备检测到漏水，需紧急处理",
+                "滤芯寿命不足，需尽快更换"
+        };
+        String[] supplyAlerts = {
+                "水位过低，需及时补水",
+                "水压异常，供水不稳定",
+                "水温过高，设备散热异常",
+                "出水流量过低，可能堵塞",
+                "设备离线，通信中断"
+        };
+        Random random = new Random();
+        if (DeviceType.water_maker.equals(type)) {
+            return makerAlerts[random.nextInt(makerAlerts.length)];
+        } else {
+            return supplyAlerts[random.nextInt(supplyAlerts.length)];
+        }
+    }
+    /**
+     * 字符串脱敏（通用，保留前n位后m位，中间用*填充）
+     */
+    public static String desensitizeString(String str, int keepPrefix, int keepSuffix) {
+        if (isBlankWithFullWidth(str)) {
+            return str;
+        }
+        int length = str.length();
+        if (length <= keepPrefix + keepSuffix) {
+            return str;
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append(str.substring(0, keepPrefix));
+        for (int i = 0; i < length - keepPrefix - keepSuffix; i++) {
+            sb.append("*");
+        }
+        sb.append(str.substring(length - keepSuffix));
+        return sb.toString();
+    }
+
+
+    /**
+     * 批量空值替换（列表）
+     */
+    public static <T> List<T> batchDefaultIfNull(List<T> list, T defaultValue) {
+        List<T> result = new ArrayList<>();
+        if (isEmpty(list)) {
+            return result;
+        }
+        for (T item : list) {
+            result.add(defaultIfNull(item, defaultValue));
+        }
+        return result;
+    }
+
+    /**
+     * 生成指定长度的随机数字字符串
+     */
+    public static String generateRandomNumStr(int length) {
+        if (length <= 0) {
+            return "";
+        }
+        Random random = new Random();
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; i++) {
+            sb.append(random.nextInt(10));
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 生成指定长度的随机字母字符串（大小写混合）
+     */
+    public static String generateRandomLetterStr(int length) {
+        if (length <= 0) {
+            return "";
+        }
+        Random random = new Random();
+        StringBuilder sb = new StringBuilder();
+        String letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        for (int i = 0; i < length; i++) {
+            sb.append(letters.charAt(random.nextInt(letters.length())));
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 计算两个日期的间隔天数
+     */
+    public static long calculateDayInterval(Date start, Date end) {
+        if (start == null || end == null) {
+            return 0;
+        }
+        long millisDiff = Math.abs(end.getTime() - start.getTime());
+        return millisDiff / (24 * 60 * 60 * 1000);
+    }
 }

src/main/resources/app2/package.json

@@ -14,6 +14,9 @@
   },
   "dependencies": {
     "@amap/amap-jsapi-loader": "^1.0.1",
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/cli": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
     "pinia": "^3.0.4",
     "vue": "^3.5.25",
     "vue-router": "^4.6.3"

src/main/resources/app2/src/services/api.js

@@ -2,7 +2,7 @@
 import axios from 'axios'
 
 const apiClient = axios.create({
-  baseURL: 'http://localhost:8080',
+  baseURL: 'http://120.46.151.248:8080',
   headers: {
     'Content-Type': 'application/json'
   }

src/main/resources/app2/vue.config.js

@@ -0,0 +1,15 @@
+const { defineConfig } = require('@vue/cli-service')
+
+module.exports = defineConfig({
+    transpileDependencies: true,
+    publicPath: './',  // 重要：使用相对路径
+    outputDir: 'dist',
+    devServer: {
+        proxy: {
+            '/api': {
+                target: 'http://localhost:8080',  // 后端地址
+                changeOrigin: true
+            }
+        }
+    }
+})

src/main/resources/application.yml

@@ -35,4 +35,12 @@ server:
       charset: UTF-8
       enabled: true
       force: true
-  port: 8080
+  port: 8081
+  ssl:
+      key-store: classpath:keystore.p12
+      key-store-password: 123456
+      key-store-type: PKCS12
+      key-alias: myhttps
+  additional-ports:
+    - port: 8080
+      protocol: HTTP

src/main/resources/zzz/src/services/api.js

@@ -4,7 +4,7 @@ import { useAuthStore } from '@/stores/auth'
 
 // 创建最基本的axios实例
 const apiClient = axios.create({
-  baseURL: 'http://localhost:8080',
+  baseURL: 'http://120.46.151.248:8080',
   headers: {
     'Content-Type': 'application/json'
   }