Merge branch 'dyf-device' into jingquan

# Conflicts:
#	fys-admin/src/main/java/com/fuyuanshen/app/controller/AppVideoController.java

fys-admin/src/main/java/com/fuyuanshen/web/util/VideoProcessUtil.java

@@ -61,52 +61,82 @@ public class VideoProcessUtil {
         }
     }
 
+
     /**
      * 从视频中提取帧
+     *
+     * @param videoFile 视频文件对象
+     * @param frameRate 每秒提取的帧数（帧率）
+     * @param duration  需要提取的视频时长（秒）
+     * @param width     提取帧的宽度
+     * @param height    提取帧的高度
+     * @return 提取的帧图像列表
+     * @throws Exception 如果在提取过程中发生错误
      */
     private List<BufferedImage> extractFramesFromVideo(File videoFile, int frameRate, int duration, int width, int height) throws Exception {
+        // 初始化帧列表
         List<BufferedImage> frames = new ArrayList<>();
+        // 计算需要提取的总帧数 = 帧率 × 时长
         int totalFramesToExtract = frameRate * duration;
 
+        // 使用FFmpegFrameGrabber从视频文件中抓取帧
         try (FFmpegFrameGrabber grabber = FFmpegFrameGrabber.createDefault(videoFile)) {
+            // 启动抓取器
             grabber.start();
 
+            // 获取视频总帧数
             long totalFramesInVideo = grabber.getLengthInFrames();
+            // 获取视频帧率，如果获取不到则默认为30fps
             int fps = (int) Math.round(grabber.getFrameRate());
             if (fps <= 0) fps = 30;
 
+            // 计算视频总时长（秒）
             double durationSeconds = (double) totalFramesInVideo / fps;
+            // 检查视频时长是否满足要求
             if (durationSeconds < duration) {
                 throw new IllegalArgumentException("视频太短，至少需要 " + duration + " 秒");
             }
 
+            // 计算帧间隔，用于均匀分布提取的帧
             double frameInterval = (double) totalFramesInVideo / totalFramesToExtract;
 
+            // 循环提取指定数量的帧
             for (int i = 0; i < totalFramesToExtract; i++) {
+                // 计算目标帧号
                 int targetFrameNumber = (int) Math.round(i * frameInterval);
 
+                // 检查目标帧号是否超出视频范围
                 if (targetFrameNumber >= totalFramesInVideo) {
                     throw new IllegalArgumentException("目标帧超出范围: " + targetFrameNumber);
                 }
 
+                // 设置抓取器到目标帧
                 grabber.setFrameNumber(targetFrameNumber);
+                // 抓取当前帧
                 Frame frame = grabber.grab();
 
+                // 如果成功抓取到帧且帧图像不为空
                 if (frame != null && frame.image != null) {
+                    // 将帧转换为BufferedImage并裁剪到指定尺寸
                     BufferedImage bufferedImage = Java2DFrameUtils.toBufferedImage(frame);
                     frames.add(cropImage(bufferedImage, width, height));
                 } else {
+                    // 如果无法获取帧则抛出异常
                     throw new IllegalArgumentException("无法获取第 " + targetFrameNumber + "帧");
                 }
             }
 
+            // 停止抓取器
             grabber.stop();
         }
 
+        // 记录提取的帧数
         log.debug("从视频中提取了 {} 帧", frames.size());
+        // 返回提取的帧列表
         return frames;
     }
 
+
     /**
      * 将所有帧转换为 RGB565 格式字节数组
      */

fys-common/fys-common-core/src/main/java/com/fuyuanshen/common/core/utils/file/ImageCompressUtil.java

@@ -3,18 +3,43 @@ package com.fuyuanshen.common.core.utils.file;
 import lombok.extern.slf4j.Slf4j;
 
 import javax.imageio.ImageIO;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.util.Iterator;
 
 /**
  * 图片压缩工具类
+ *
+ * @author AprilWind
  */
 @Slf4j
 public class ImageCompressUtil {
 
+    /**
+     * 默认压缩目标大小(100KB)
+     */
+    private static final int DEFAULT_COMPRESS_SIZE = 100 * 1024;
+
+    /**
+     * 默认触发压缩的大小(1MB)
+     */
+    private static final int DEFAULT_TRIGGER_SIZE = 1024 * 1024;
+
+    /**
+     * 压缩图片到指定大小以下(默认100KB)
+     *
+     * @param imageData 原始图片数据
+     * @return 压缩后的图片数据
+     */
+    public static byte[] compressImage(byte[] imageData) {
+        return compressImage(imageData, DEFAULT_COMPRESS_SIZE);
+    }
+
     /**
      * 压缩图片到指定大小以下
      *
@@ -36,24 +61,54 @@ public class ImageCompressUtil {
                 return imageData;
             }
 
-            // 计算压缩比例
+            // 检查图片是否包含透明度
-            double scale = Math.sqrt((double) maxSize / imageData.length);
+            boolean hasAlpha = hasAlpha(originalImage);
-            // 确保至少压缩到一半大小，避免压缩效果不明显
+            String formatName = hasAlpha ? "png" : "jpg";
-            scale = Math.max(scale, 0.5);
 
-            // 压缩图片
+            // 对于小尺寸PNG图片可跳过压缩以保持图像质量
-            byte[] compressedData = compressImageByScale(originalImage, scale);
+            if ("png".equals(formatName) && imageData.length <= 2 * maxSize) {
+                log.debug("PNG图片大小适中({} bytes)，跳过压缩", imageData.length);
+                return imageData;
+            }
+
+            // 先尝试质量压缩
+            byte[] compressedData = compressImageQuality(originalImage, formatName, 0.8f);
+
+            // 如果质量压缩后仍大于目标大小，则进行尺寸压缩
+            if (compressedData.length > maxSize) {
+                // 计算缩放比例
+                double scale = Math.sqrt((double) maxSize / compressedData.length);
+                scale = Math.max(scale, 0.5); // 最小缩放到原来的一半
+
+                // 尺寸压缩
+                compressedData = compressImageByScale(originalImage, scale, formatName);
+            }
 
             // 如果压缩后还是太大，继续压缩
             int attempts = 0;
             while (compressedData.length > maxSize && attempts < 5) {
-                scale *= 0.8; // 每次缩小20%
+                // 优先降低质量
-                compressedData = compressImageByScale(originalImage, scale);
+                float quality = Math.max(0.1f, 0.8f - attempts * 0.1f);
+                compressedData = compressImageQuality(originalImage, formatName, quality);
+                
+                // 如果质量压缩不够，再缩小尺寸
+                if (compressedData.length > maxSize) {
+                    double scale = 0.9 - attempts * 0.1; // 逐步缩小尺寸
+                    scale = Math.max(scale, 0.5);
+                    compressedData = compressImageByScale(originalImage, scale, formatName);
+                }
                 attempts++;
             }
 
-            log.info("图片压缩完成，原始大小: {} bytes, 压缩后大小: {} bytes, 压缩比例: {}",
+            log.info("图片压缩完成，原始大小: {} bytes, 压缩后大小: {} bytes, 压缩率: {}%",
-                    imageData.length, compressedData.length, String.format("%.2f", scale));
+                    imageData.length, compressedData.length, 
+                    String.format("%.2f", (1.0 - (double) compressedData.length / imageData.length) * 100));
+
+            // 如果压缩后反而变大了，则使用原始数据
+            if (compressedData.length >= imageData.length) {
+                log.debug("压缩后数据变大，使用原始数据");
+                return imageData;
+            }
 
             return compressedData;
         } catch (Exception e) {
@@ -62,16 +117,16 @@ public class ImageCompressUtil {
         }
     }
 
-
     /**
      * 按比例缩放图片
      *
      * @param originalImage 原始图片
      * @param scale         缩放比例
+     * @param formatName    图片格式
      * @return 缩放后的图片数据
      * @throws IOException IO异常
      */
-    private static byte[] compressImageByScale(BufferedImage originalImage, double scale) throws IOException {
+    private static byte[] compressImageByScale(BufferedImage originalImage, double scale, String formatName) throws IOException {
         int width = (int) (originalImage.getWidth() * scale);
         int height = (int) (originalImage.getHeight() * scale);
 
@@ -79,13 +134,73 @@ public class ImageCompressUtil {
         Image scaledImage = originalImage.getScaledInstance(width, height, Image.SCALE_SMOOTH);
         BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
         Graphics2D g2d = bufferedImage.createGraphics();
+        
+        // 绘制缩放后的图片
         g2d.drawImage(scaledImage, 0, 0, null);
         g2d.dispose();
 
-        // 输出为JPEG格式
+        // 输出为指定格式
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        ImageIO.write(bufferedImage, "jpg", baos);
+        ImageIO.write(bufferedImage, formatName, baos);
         return baos.toByteArray();
     }
 
+    /**
+     * 按质量压缩图片
+     *
+     * @param originalImage 原始图片
+     * @param formatName    图片格式
+     * @param quality       压缩质量(0.1-1.0)
+     * @return 压缩后的图片数据
+     * @throws IOException IO异常
+     */
+    private static byte[] compressImageQuality(BufferedImage originalImage, String formatName, float quality) throws IOException {
+        // 创建压缩参数
+        Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(formatName);
+        if (!writers.hasNext()) {
+            log.warn("找不到合适的图片写入器");
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ImageIO.write(originalImage, formatName, baos);
+            return baos.toByteArray();
+        }
+
+        ImageWriter writer = writers.next();
+        ImageWriteParam param = writer.getDefaultWriteParam();
+
+        // 设置压缩参数
+        if (param.canWriteCompressed()) {
+            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+            param.setCompressionQuality(quality);
+        }
+
+        // 写入压缩后的图片数据
+        ByteArrayOutputStream compressedOutputStream = new ByteArrayOutputStream();
+        writer.setOutput(ImageIO.createImageOutputStream(compressedOutputStream));
+        writer.write(null, new javax.imageio.IIOImage(originalImage, null, null), param);
+        writer.dispose();
+
+        return compressedOutputStream.toByteArray();
+    }
+
+    /**
+     * 检查图片是否包含透明度
+     *
+     * @param image 图片
+     * @return 是否包含透明度
+     */
+    private static boolean hasAlpha(BufferedImage image) {
+        return image.getType() == BufferedImage.TYPE_4BYTE_ABGR ||
+                image.getType() == BufferedImage.TYPE_INT_ARGB ||
+                image.getColorModel().hasAlpha();
+    }
+
+    /**
+     * 判断图片是否需要压缩(超过1MB)
+     *
+     * @param imageData 图片数据
+     * @return 是否需要压缩
+     */
+    public static boolean needCompress(byte[] imageData) {
+        return imageData.length > DEFAULT_TRIGGER_SIZE;
+    }
 }

fys-modules/fys-equipment/src/main/java/com/fuyuanshen/equipment/controller/DeviceController.java

@@ -3,9 +3,7 @@ package com.fuyuanshen.equipment.controller;
 
 import com.alibaba.excel.EasyExcel;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.fuyuanshen.common.core.constant.ResponseMessageConstants;
 import com.fuyuanshen.common.core.domain.R;
-import com.fuyuanshen.common.core.domain.ResponseVO;
 import com.fuyuanshen.common.core.domain.model.LoginUser;
 import com.fuyuanshen.common.core.utils.file.FileUtil;
 import com.fuyuanshen.common.mybatis.core.page.TableDataInfo;
@@ -18,7 +16,6 @@ import com.fuyuanshen.equipment.domain.dto.DeviceExcelImportDTO;
 import com.fuyuanshen.equipment.domain.dto.ImportResult;
 import com.fuyuanshen.equipment.domain.form.DeviceForm;
 import com.fuyuanshen.equipment.domain.query.DeviceQueryCriteria;
-import com.fuyuanshen.equipment.domain.vo.CustomerVo;
 import com.fuyuanshen.equipment.excel.DeviceImportParams;
 import com.fuyuanshen.equipment.excel.HeadValidateListener;
 import com.fuyuanshen.equipment.excel.UploadDeviceDataListener;

fys-modules/fys-equipment/src/main/java/com/fuyuanshen/equipment/converter/IgnoreFailedImageConverter.java

@@ -4,6 +4,8 @@ import com.alibaba.excel.converters.Converter;
 import com.alibaba.excel.metadata.GlobalConfiguration;
 import com.alibaba.excel.metadata.data.WriteCellData;
 import com.alibaba.excel.metadata.property.ExcelContentProperty;
+import com.fuyuanshen.common.core.utils.file.ImageCompressUtil;
+import com.fuyuanshen.common.redis.utils.RedisUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -12,12 +14,18 @@ import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
+import java.util.Base64;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 
 /**
  * @author: 默苍璃
  * @date: 2025-06-0618:56
  */
-
 public class IgnoreFailedImageConverter implements Converter<URL> {
     private static final Logger logger = LoggerFactory.getLogger(IgnoreFailedImageConverter.class);
 
@@ -25,6 +33,21 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
     private static final int MAX_RETRIES = 3;
     // 指数退避初始延迟（毫秒）
     private static final int INITIAL_DELAY = 1000;
+    // 图片压缩阈值(1MB)
+    private static final int COMPRESSION_THRESHOLD = 1024 * 1024;
+    // 压缩目标大小(100KB)
+    private static final int COMPRESSION_TARGET = 100 * 1024;
+    // 用于跟踪本次任务中使用到的URL缓存键
+    private static final ThreadLocal<Set<String>> USED_CACHE_KEYS = new ThreadLocal<Set<String>>() {
+        @Override
+        protected Set<String> initialValue() {
+            return new HashSet<>();
+        }
+    };
+
+    // 创建线程池用于并发处理图片
+    private static final ExecutorService IMAGE_PROCESSING_EXECUTOR = Executors.newFixedThreadPool(
+            Runtime.getRuntime().availableProcessors() * 2);
 
     @Override
     public Class<?> supportJavaTypeKey() {
@@ -34,21 +57,63 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
     @Override
     public WriteCellData<?> convertToExcelData(URL value, ExcelContentProperty contentProperty, GlobalConfiguration globalConfiguration) {
         if (value == null) {
-            logger.debug("图片URL为空");
+            logger.info("图片URL为空");
             return new WriteCellData<>(new byte[0]);
         }
 
+        try {
+            // 使用CompletableFuture异步处理图片加载
+            CompletableFuture<WriteCellData<?>> future = CompletableFuture.supplyAsync(() -> {
+                try {
+                    return loadImageData(value);
+                } catch (Exception e) {
+                    logger.error("异步加载图片失败: {}", value, e);
+                    return new WriteCellData<>(new byte[0]);
+                }
+            }, IMAGE_PROCESSING_EXECUTOR);
+
+            // 设置超时时间，防止长时间阻塞
+            return future.get(30, TimeUnit.SECONDS);
+        } catch (Exception e) {
+            logger.error("图片处理异常: {}", value, e);
+            return new WriteCellData<>(new byte[0]);
+        }
+    }
+
+    /**
+     * 加载图片数据的核心方法
+     * @param value 图片URL
+     * @return WriteCellData对象
+     */
+    private WriteCellData<?> loadImageData(URL value) {
+        String cacheKey = "excel:image:" + value.toString();
+
+        // 将当前使用的缓存键添加到集合中
+        USED_CACHE_KEYS.get().add(cacheKey);
+
+        // 尝试从缓存获取
+        String cachedData = RedisUtils.getCacheObject(cacheKey);
+        if (cachedData != null) {
+            // 从缓存中读取Base64编码的数据并解码
+            byte[] cachedBytes = Base64.getDecoder().decode(cachedData);
+            logger.info("从缓存获取图片数据: {}, 大小: {} 字节", value, cachedBytes.length);
+            return new WriteCellData<>(cachedBytes);
+        }
+
+        // 缓存未命中，从URL加载
         // 尝试多次加载图片
         for (int attempt = 1; attempt <= MAX_RETRIES; attempt++) {
             try {
-                logger.debug("开始加载图片: {}, 尝试次数: {}", value, attempt);
+                logger.info("开始加载图片: {}, 尝试次数: {}", value, attempt);
                 URLConnection conn = value.openConnection();
                 // 增加连接和读取超时时间
-                conn.setConnectTimeout(10000);  // 10秒连接超时
+                conn.setConnectTimeout(5000);  // 5秒连接超时
-                conn.setReadTimeout(30000);     // 30秒读取超时
+                conn.setReadTimeout(15000);     // 15秒读取超时
 
                 // 添加User-Agent避免被服务器拦截
                 conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 ExcelExporter/1.0");
+                // 添加Connection: close避免保持连接
+                conn.setRequestProperty("Connection", "close");
 
                 // 如果是HTTP连接，设置一些额外的属性
                 if (conn instanceof HttpURLConnection) {
@@ -62,34 +127,40 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
                     // 检查响应码
                     int responseCode = httpConn.getResponseCode();
                     if (responseCode != HttpURLConnection.HTTP_OK) {
-                        logger.warn("HTTP响应码异常: {}, URL: {}", responseCode, value);
+                        logger.info("HTTP响应码异常: {}, URL: {}", responseCode, value);
                         if (attempt < MAX_RETRIES) {
                             // 等待后重试
                             waitForRetry(attempt);
                             continue;
                         } else {
+                            // 将空数据写入缓存
+                            RedisUtils.setCacheObject(cacheKey, "");
                             return new WriteCellData<>(new byte[0]);
                         }
                     }
                 }
 
                 long contentLength = conn.getContentLengthLong();
-                logger.debug("连接建立成功，图片大小: {} 字节", contentLength);
+                logger.info("连接建立成功，图片大小: {} 字节", contentLength);
 
                 // 检查内容长度是否有效
                 if (contentLength == 0) {
-                    logger.warn("图片文件为空: {}", value);
+                    logger.info("图片文件为空: {}", value);
                     if (attempt < MAX_RETRIES) {
                         waitForRetry(attempt);
                         continue;
                     } else {
+                        // 将空数据写入缓存
+                        RedisUtils.setCacheObject(cacheKey, "");
                         return new WriteCellData<>(new byte[0]);
                     }
                 }
 
                 // 限制图片大小（防止过大文件导致内存问题）
                 if (contentLength > 10 * 1024 * 1024) { // 10MB限制
-                    logger.warn("图片文件过大 ({} bytes)，跳过加载: {}", contentLength, value);
+                    logger.info("图片文件过大 ({} bytes)，跳过加载: {}", contentLength, value);
+                    // 将空数据写入缓存
+                    RedisUtils.setCacheObject(cacheKey, "");
                     return new WriteCellData<>(new byte[0]);
                 }
 
@@ -100,43 +171,96 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
 
                     // 检查读取到的数据是否为空
                     if (bytes == null || bytes.length == 0) {
-                        logger.warn("读取到空的图片数据: {}", value);
+                        logger.info("读取到空的图片数据: {}", value);
                         if (attempt < MAX_RETRIES) {
                             waitForRetry(attempt);
                             continue;
                         } else {
+                            // 将空数据写入缓存
+                            RedisUtils.setCacheObject(cacheKey, "");
                             return new WriteCellData<>(new byte[0]);
                         }
                     }
 
-                    logger.debug("成功读取图片数据，大小: {} 字节", bytes.length);
+                    // 如果图片大于1MB，则进行压缩
+                    if (bytes.length > COMPRESSION_THRESHOLD) {
+                        logger.info("图片大小超过1MB ({} bytes)，开始压缩", bytes.length);
+                        long beforeCompressSize = bytes.length;
+
+                        // 先尝试质量压缩
+                        byte[] compressed = ImageCompressUtil.compressImage(bytes, COMPRESSION_TARGET);
+
+                        // 如果压缩后变大了，使用原始数据
+                        if (compressed.length >= bytes.length) {
+                            compressed = bytes;
+                        }
+
+                        bytes = compressed;
+                        long afterCompressSize = bytes.length;
+                        logger.info("图片压缩完成，压缩前大小: {} bytes, 压缩后大小: {} bytes, 压缩率: {}",
+                                beforeCompressSize, afterCompressSize,
+                                String.format("%.2f", (1.0 - (double) afterCompressSize / beforeCompressSize) * 100));
+                    }
+
+                    logger.info("成功读取图片数据，大小: {} 字节", bytes.length);
+                    // 将数据写入缓存，不设置过期时间，使用Base64编码存储
+                    String encodedData = Base64.getEncoder().encodeToString(bytes);
+                    RedisUtils.setCacheObject(cacheKey, encodedData);
                     return new WriteCellData<>(bytes);
                 }
             } catch (Exception e) {
-                logger.warn("图片加载失败: {}, 尝试次数: {}, 原因: {}", value, attempt, e.getMessage(), e);
+                logger.info("图片加载失败: {}, 尝试次数: {}, 原因: {}", value, attempt, e.getMessage(), e);
                 if (attempt < MAX_RETRIES) {
                     // 等待后重试
                     waitForRetry(attempt);
                 } else {
                     // 最后一次尝试也失败了
-                    logger.error("图片加载最终失败，已重试 {} 次: {}", MAX_RETRIES, value, e);
+                    logger.info("图片加载最终失败，已重试 {} 次: {}", MAX_RETRIES, value, e);
+                    // 将空数据写入缓存
+                    RedisUtils.setCacheObject(cacheKey, "");
                     return new WriteCellData<>(new byte[0]); // 返回空数组而不是 null
                 }
             }
         }
 
         // 所有尝试都失败了
+        // 将空数据写入缓存
+        RedisUtils.setCacheObject(cacheKey, "");
         return new WriteCellData<>(new byte[0]);
     }
 
+    /**
+     * 清理未使用的缓存
+     * 任务结束后调用此方法，删除本次任务中未使用的URL缓存
+     */
+    public static void cleanUnusedCache() {
+        Set<String> usedKeys = USED_CACHE_KEYS.get();
+        if (usedKeys != null && !usedKeys.isEmpty()) {
+            // 获取所有图片缓存键
+            Iterable<String> allKeys = RedisUtils.keys("excel:image:*");
+            if (allKeys != null) {
+                // 删除未使用的缓存
+                for (String key : allKeys) {
+                    if (!usedKeys.contains(key)) {
+                        RedisUtils.deleteObject(key);
+                        logger.info("删除未使用的缓存: {}", key);
+                    }
+                }
+            }
+            // 清理ThreadLocal
+            USED_CACHE_KEYS.remove();
+        }
+    }
+
     /**
      * 等待重试，使用指数退避策略
+     *
      * @param attempt 当前尝试次数
      */
     private void waitForRetry(int attempt) {
         try {
             long delay = (long) INITIAL_DELAY * (1L << (attempt - 1)); // 指数退避
-            logger.debug("等待 {} 毫秒后重试...", delay);
+            logger.info("等待 {} 毫秒后重试...", delay);
             Thread.sleep(delay);
         } catch (InterruptedException ie) {
             Thread.currentThread().interrupt();
@@ -162,11 +286,45 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
 
             // 如果读取的数据过大，提前终止
             if (totalBytes > 10 * 1024 * 1024) { // 10MB限制
-                logger.warn("读取的图片数据超过10MB限制，提前终止");
+                logger.info("读取的图片数据超过10MB限制，提前终止");
                 break;
             }
         }
 
         return outputStream.toByteArray();
     }
+
+    /**
+     * 预加载图片到缓存
+     * @param imageUrls 图片URL列表
+     */
+    public static void preloadImages(Set<URL> imageUrls) {
+        if (imageUrls == null || imageUrls.isEmpty()) {
+            return;
+        }
+
+        logger.info("开始预加载 {} 张图片", imageUrls.size());
+
+        // 使用并行流并发预加载图片
+        imageUrls.parallelStream().forEach(url -> {
+            try {
+                String cacheKey = "excel:image:" + url.toString();
+                // 如果缓存中没有，则异步加载
+                if (!RedisUtils.hasKey(cacheKey)) {
+                    CompletableFuture.runAsync(() -> {
+                        try {
+                            // 简化版图片加载逻辑，只加载到缓存
+                            new IgnoreFailedImageConverter().loadImageData(url);
+                        } catch (Exception e) {
+                            logger.warn("预加载图片失败: {}", url, e);
+                        }
+                    }, IMAGE_PROCESSING_EXECUTOR);
+                }
+            } catch (Exception e) {
+                logger.warn("预加载图片异常: {}", url, e);
+            }
+        });
+
+        logger.info("图片预加载任务已提交");
+    }
 }

fys-modules/fys-equipment/src/main/java/com/fuyuanshen/equipment/domain/dto/DeviceWithTypeExcelExportDTO.java

@@ -13,7 +13,7 @@ import java.net.URL;
  * 设备及完整类型信息导出DTO
  *
  * @author: 默苍璃
- * @date: 2025-11-0416:25
+ * @date: 2025-11-04 16:25
  */
 @Data
 @HeadRowHeight(20)  // 表头行高

fys-modules/fys-equipment/src/main/java/com/fuyuanshen/equipment/service/impl/DeviceExportService.java

@@ -83,6 +83,7 @@ public class DeviceExportService {
     }
 
 
+
     /**
      * 导出设备数据（包含完整设备类型信息）
      *
@@ -183,6 +184,7 @@ public class DeviceExportService {
         }
     }
 
+
     /**
      * 转换定位方式代码为中文描述
      *

fys-modules/fys-equipment/src/main/java/com/fuyuanshen/equipment/service/impl/DeviceServiceImpl.java

@@ -19,11 +19,8 @@ import com.fuyuanshen.common.satoken.utils.AppLoginHelper;
 import com.fuyuanshen.common.satoken.utils.LoginHelper;
 import com.fuyuanshen.customer.domain.Customer;
 import com.fuyuanshen.customer.mapper.CustomerMapper;
-import com.fuyuanshen.equipment.constants.DeviceConstants;
 import com.fuyuanshen.equipment.domain.*;
-import com.fuyuanshen.equipment.domain.bo.DeviceFenceAccessRecordBo;
 import com.fuyuanshen.equipment.domain.dto.AppDeviceBo;
-import com.fuyuanshen.equipment.domain.dto.FenceCheckResponse;
 import com.fuyuanshen.equipment.domain.form.DeviceForm;
 import com.fuyuanshen.equipment.domain.query.DeviceAssignmentQuery;
 import com.fuyuanshen.equipment.domain.query.DeviceQueryCriteria;
@@ -33,7 +30,10 @@ import com.fuyuanshen.equipment.enums.BindingStatusEnum;
 import com.fuyuanshen.equipment.enums.CommunicationModeEnum;
 import com.fuyuanshen.equipment.enums.DeviceActiveStatusEnum;
 import com.fuyuanshen.equipment.mapper.*;
-import com.fuyuanshen.equipment.service.*;
+import com.fuyuanshen.equipment.service.DeviceAssignmentsService;
+import com.fuyuanshen.equipment.service.DeviceService;
+import com.fuyuanshen.equipment.service.DeviceTypeGrantsService;
+import com.fuyuanshen.equipment.service.IDeviceGeoFenceService;
 import com.fuyuanshen.equipment.utils.FileHashUtil;
 import com.fuyuanshen.system.domain.vo.SysOssVo;
 import com.fuyuanshen.system.domain.vo.SysRoleVo;
@@ -41,15 +41,11 @@ import com.fuyuanshen.system.service.ISysOssService;
 import com.fuyuanshen.system.service.ISysRoleService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.multipart.MultipartFile;
 
-import java.io.File;
 import java.io.IOException;
 import java.sql.Timestamp;
-import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.*;
 
@@ -290,6 +286,10 @@ public class DeviceServiceImpl extends ServiceImpl<DeviceMapper, Device> impleme
         if (deviceForm.getFile() != null) {
             String fileHash = fileHashUtil.hash(deviceForm.getFile());
             SysOssVo upload = ossService.updateHash(deviceForm.getFile(), fileHash);
+            // 强制将HTTP替换为HTTPS
+            if (upload.getUrl() != null && upload.getUrl().startsWith("http://")) {
+                upload.setUrl(upload.getUrl().replaceFirst("^http://", "https://"));
+            }
             // 设置图片路径
             deviceForm.setDevicePic(upload.getUrl());
         }

fys-modules/fys-system/src/main/java/com/fuyuanshen/system/domain/SysOss.java

@@ -51,6 +51,7 @@ public class SysOss extends TenantEntity {
      * 服务商
      */
     private String service;
+
     /**
      * 内容哈希
      */

fys-modules/fys-system/src/main/java/com/fuyuanshen/system/service/impl/SysOssServiceImpl.java

@@ -6,6 +6,7 @@ import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fuyuanshen.common.core.utils.file.ImageCompressUtil;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
 import com.fuyuanshen.common.core.constant.CacheNames;
@@ -143,7 +144,7 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
         lqw.eq(StringUtils.isNotBlank(bo.getFileSuffix()), SysOss::getFileSuffix, bo.getFileSuffix());
         lqw.eq(StringUtils.isNotBlank(bo.getUrl()), SysOss::getUrl, bo.getUrl());
         lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
-            SysOss::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
+                SysOss::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
         lqw.eq(ObjectUtil.isNotNull(bo.getCreateBy()), SysOss::getCreateBy, bo.getCreateBy());
         lqw.eq(StringUtils.isNotBlank(bo.getService()), SysOss::getService, bo.getService());
         lqw.orderByAsc(SysOss::getOssId);
@@ -169,7 +170,7 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
 
     @Override
     public int updateHashById(long ossId, String fileHash) {
-        return baseMapper.updateHashById(ossId,fileHash);
+        return baseMapper.updateHashById(ossId, fileHash);
     }
 
 
@@ -191,6 +192,7 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
         storage.download(sysOss.getFileName(), response.getOutputStream(), response::setContentLengthLong);
     }
 
+
     /**
      * 上传 MultipartFile 到对象存储服务，并保存文件信息到数据库
      *
@@ -209,14 +211,22 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
         OssClient storage = OssFactory.instance();
         UploadResult uploadResult;
         try {
-            uploadResult = storage.uploadSuffix(file.getBytes(), suffix, file.getContentType());
+            byte[] imageData = file.getBytes();
+            // 检查是否需要压缩
+            if (ImageCompressUtil.needCompress(imageData)) {
+                // 压缩到100KB以内
+                imageData = ImageCompressUtil.compressImage(imageData);
+                // 使用压缩后的数据
+            }
+            uploadResult = storage.uploadSuffix(imageData, suffix, file.getContentType());
         } catch (IOException e) {
             throw new ServiceException(e.getMessage());
         }
         // 保存文件信息
-        return buildResultEntity(originalfileName, suffix, storage.getConfigKey(), uploadResult,hash);
+        return buildResultEntity(originalfileName, suffix, storage.getConfigKey(), uploadResult, hash);
     }
 
+
     /**
      * 上传 MultipartFile 到对象存储服务，并保存文件信息到数据库
      *
@@ -236,7 +246,7 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
             throw new ServiceException(e.getMessage());
         }
         // 保存文件信息
-        return buildResultEntity(originalfileName, suffix, storage.getConfigKey(), uploadResult,null);
+        return buildResultEntity(originalfileName, suffix, storage.getConfigKey(), uploadResult, null);
     }
 
     /**
@@ -252,11 +262,10 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
         OssClient storage = OssFactory.instance();
         UploadResult uploadResult = storage.uploadSuffix(file, suffix);
         // 保存文件信息
-        return buildResultEntity(originalfileName, suffix, storage.getConfigKey(), uploadResult,null);
+        return buildResultEntity(originalfileName, suffix, storage.getConfigKey(), uploadResult, null);
     }
 
 
-
     /**
      * 上传二进制数据到对象存储服务，并保存文件信息到数据库
      *
@@ -281,7 +290,7 @@ public class SysOssServiceImpl implements ISysOssService, OssService {
         uploadResult = storage.uploadSuffix(data, suffix, "image/jpeg"); // 假设是图片类型，可以根据实际需要修改
 
         // 保存文件信息
-        return buildResultEntity(fileName, suffix, storage.getConfigKey(), uploadResult,null);
+        return buildResultEntity(fileName, suffix, storage.getConfigKey(), uploadResult, null);
     }