导出图片压缩

# 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

@@ -72,13 +72,13 @@ public class ImageCompressUtil {
             }
 
             // 先尝试质量压缩
-            byte[] compressedData = compressImageQuality(originalImage, formatName, 0.8f);
+            byte[] compressedData = compressImageQuality(originalImage, formatName, 0.7f);
 
             // 如果质量压缩后仍大于目标大小，则进行尺寸压缩
             if (compressedData.length > maxSize) {
                 // 计算缩放比例
                 double scale = Math.sqrt((double) maxSize / compressedData.length);
-                scale = Math.max(scale, 0.5); // 最小缩放到原来的一半
+                scale = Math.max(scale, 0.2); // 最小缩放到原来的20%
 
                 // 尺寸压缩
                 compressedData = compressImageByScale(originalImage, scale, formatName);
@@ -86,20 +86,36 @@ public class ImageCompressUtil {
 
             // 如果压缩后还是太大，继续压缩
             int attempts = 0;
-            while (compressedData.length > maxSize && attempts < 5) {
+            while (compressedData.length > maxSize && attempts < 15) { // 增加尝试次数到15次
                 // 优先降低质量
-                float quality = Math.max(0.1f, 0.8f - attempts * 0.1f);
+                float quality = Math.max(0.01f, 0.7f - attempts * 0.1f); // 最低质量降至0.01
                 compressedData = compressImageQuality(originalImage, formatName, quality);
                 
                 // 如果质量压缩不够，再缩小尺寸
                 if (compressedData.length > maxSize) {
-                    double scale = 0.9 - attempts * 0.1; // 逐步缩小尺寸
+                    double scale = 0.8 - attempts * 0.15; // 更积极地缩小尺寸
-                    scale = Math.max(scale, 0.5);
+                    scale = Math.max(scale, 0.1); // 最小缩放到原来的10%
                     compressedData = compressImageByScale(originalImage, scale, formatName);
                 }
                 attempts++;
             }
 
+            // 如果经过多次尝试仍然大于目标大小，则强制压缩到目标大小以下
+            if (compressedData.length > maxSize) {
+                // 强制尺寸压缩到目标大小
+                double finalScale = Math.sqrt((double) maxSize / compressedData.length) * 0.8; // 留一些余量
+                finalScale = Math.max(finalScale, 0.05); // 至少保留5%的尺寸
+                compressedData = compressImageByScale(originalImage, finalScale, formatName);
+                
+                // 如果仍然太大，强制质量压缩
+                if (compressedData.length > maxSize) {
+                    // 计算需要的质量值
+                    float finalQuality = (float) maxSize / compressedData.length * 0.7f; // 留一些余量
+                    finalQuality = Math.max(finalQuality, 0.005f); // 至少保留0.5%的质量
+                    compressedData = compressImageQuality(originalImage, formatName, finalQuality);
+                }
+            }
+
             log.info("图片压缩完成，原始大小: {} bytes, 压缩后大小: {} bytes, 压缩率: {}%",
                     imageData.length, compressedData.length, 
                     String.format("%.2f", (1.0 - (double) compressedData.length / imageData.length) * 100));
@@ -110,6 +126,12 @@ public class ImageCompressUtil {
                 return imageData;
             }
 
+            // 特殊处理：如果目标大小是50KB或更小，确保最终结果符合要求
+            if (maxSize <= 50 * 1024 && compressedData.length > maxSize) {
+                // 使用更强力的压缩策略
+                compressedData = forceCompressToSize(originalImage, formatName, maxSize);
+            }
+
             return compressedData;
         } catch (Exception e) {
             log.error("图片压缩失败: {}", e.getMessage(), e);
@@ -117,6 +139,63 @@ public class ImageCompressUtil {
         }
     }
 
+    /**
+     * 强制压缩到指定大小
+     * 
+     * @param originalImage 原始图片
+     * @param formatName 图片格式
+     * @param maxSize 目标大小
+     * @return 压缩后的图片数据
+     */
+    private static byte[] forceCompressToSize(BufferedImage originalImage, String formatName, int maxSize) throws IOException {
+        byte[] result = null;
+        int width = originalImage.getWidth();
+        int height = originalImage.getHeight();
+        
+        // 通过不断缩小尺寸来达到目标大小
+        double scale = 0.9;
+        do {
+            int newWidth = (int) (width * scale);
+            int newHeight = (int) (height * scale);
+            
+            // 创建缩放后的图片
+            Image scaledImage = originalImage.getScaledInstance(newWidth, newHeight, Image.SCALE_SMOOTH);
+            BufferedImage bufferedImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
+            Graphics2D g2d = bufferedImage.createGraphics();
+            
+            // 绘制缩放后的图片
+            g2d.drawImage(scaledImage, 0, 0, null);
+            g2d.dispose();
+            
+            // 以最低质量压缩
+            result = compressImageQuality(bufferedImage, formatName, 0.01f);
+            
+            if (result.length <= maxSize) {
+                break;
+            }
+            
+            scale -= 0.1;
+        } while (scale > 0.1 && result.length > maxSize);
+        
+        // 如果还是太大，强制调整大小
+        if (result.length > maxSize) {
+            // 计算精确的缩放比例
+            double targetScale = Math.sqrt((double) maxSize / result.length) * 0.9;
+            int newWidth = Math.max((int) (width * targetScale), 5);
+            int newHeight = Math.max((int) (height * targetScale), 5);
+            
+            Image scaledImage = originalImage.getScaledInstance(newWidth, newHeight, Image.SCALE_SMOOTH);
+            BufferedImage bufferedImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
+            Graphics2D g2d = bufferedImage.createGraphics();
+            g2d.drawImage(scaledImage, 0, 0, null);
+            g2d.dispose();
+            
+            result = compressImageQuality(bufferedImage, formatName, 0.005f);
+        }
+        
+        return result;
+    }
+
     /**
      * 按比例缩放图片
      *
@@ -130,6 +209,10 @@ public class ImageCompressUtil {
         int width = (int) (originalImage.getWidth() * scale);
         int height = (int) (originalImage.getHeight() * scale);
 
+        // 确保最小尺寸不小于5像素
+        width = Math.max(width, 5);
+        height = Math.max(height, 5);
+
         // 创建缩放后的图片
         Image scaledImage = originalImage.getScaledInstance(width, height, Image.SCALE_SMOOTH);
         BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

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

@@ -17,6 +17,10 @@ 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: 默苍璃
@@ -30,9 +34,9 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
     // 指数退避初始延迟（毫秒）
     private static final int INITIAL_DELAY = 1000;
     // 图片压缩阈值(1MB)
-    private static final int COMPRESSION_THRESHOLD = 1024 * 1024;
+    private static final int COMPRESSION_THRESHOLD = 100 * 1024;
-    // 压缩目标大小(100KB)
+    // 压缩目标大小(50KB)
-    private static final int COMPRESSION_TARGET = 100 * 1024;
+    private static final int COMPRESSION_TARGET = 50 * 1024;
     // 用于跟踪本次任务中使用到的URL缓存键
     private static final ThreadLocal<Set<String>> USED_CACHE_KEYS = new ThreadLocal<Set<String>>() {
         @Override
@@ -41,12 +45,15 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
         }
     };
 
+    // 创建线程池用于并发处理图片
+    private static final ExecutorService IMAGE_PROCESSING_EXECUTOR = Executors.newFixedThreadPool(
+            Runtime.getRuntime().availableProcessors() * 2);
+
     @Override
     public Class<?> supportJavaTypeKey() {
         return URL.class;
     }
 
-
     @Override
     public WriteCellData<?> convertToExcelData(URL value, ExcelContentProperty contentProperty, GlobalConfiguration globalConfiguration) {
         if (value == null) {
@@ -54,6 +61,32 @@ public class IgnoreFailedImageConverter implements Converter<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();
 
         // 将当前使用的缓存键添加到集合中
@@ -75,11 +108,13 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
                 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) {
@@ -152,11 +187,20 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
                     if (bytes.length > COMPRESSION_THRESHOLD) {
                         logger.info("图片大小超过1MB ({} bytes)，开始压缩", bytes.length);
                         long beforeCompressSize = bytes.length;
-                        bytes = ImageCompressUtil.compressImage(bytes, COMPRESSION_TARGET);
+
+                        // 先尝试质量压缩
+                        byte[] compressed = ImageCompressUtil.compressImage(bytes, COMPRESSION_TARGET);
+
+                        // 如果压缩后变大了，使用原始数据
+                        if (compressed.length >= bytes.length) {
+                            compressed = bytes;
+                        }
+
+                        bytes = compressed;
                         long afterCompressSize = bytes.length;
-                        logger.info("图片压缩完成，压缩前大小: {} bytes, 压缩后大小: {} bytes, 压缩率: {}%", 
+                        logger.info("图片压缩完成，压缩前大小: {} bytes, 压缩后大小: {} bytes, 压缩率: {}",
-                                   beforeCompressSize, afterCompressSize,
+                                beforeCompressSize, afterCompressSize,
-                                   String.format("%.2f", (1.0 - (double) afterCompressSize / beforeCompressSize) * 100));
+                                String.format("%.2f", (1.0 - (double) afterCompressSize / beforeCompressSize) * 100));
                     }
 
                     logger.info("成功读取图片数据，大小: {} 字节", bytes.length);
@@ -209,7 +253,6 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
         }
     }
 
-
     /**
      * 等待重试，使用指数退避策略
      *
@@ -225,7 +268,6 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
         }
     }
 
-
     /**
      * 替代 FileUtils.readInputStream 的自定义方法
      *
@@ -253,4 +295,38 @@ public class IgnoreFailedImageConverter implements Converter<URL> {
         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/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;
+
     /**
      * 内容哈希
      */