Java多图上传功能压缩处理后GIF动图无法播放问题求助

核心问题原因 #

• 原生ImageIO.read()方法读取GIF格式资源时，仅会加载第一帧数据，直接丢弃了剩余帧和动画时序信息，压缩处理后自然只有静态图
• 代码中创建压缩后的BufferedImage时硬编码了BufferedImage.TYPE_INT_BGR格式，该格式不支持透明通道，还会破坏GIF原有色彩配置
• 直接通过ImageIO.write写单帧BufferedImage到GIF文件，完全没有写入动画相关的控制块信息

修复思路 #

区分处理静态图和GIF动图两种场景：

1. 先判断文件类型，如果是GIF格式，不要用普通的BufferedImage处理逻辑，改用GIF帧遍历处理方案
2. 静态图（JPG/PNG等）可以沿用现有压缩逻辑，GIF需要逐帧调整尺寸后重新组装为动图
3. 注意保留GIF的循环次数、每帧的延迟时间、透明色等元数据

代码修改建议 #

首先补充GIF处理的工具逻辑，再修改原有主逻辑即可：

public class FileHandler {

    private static final int MAX_WIDTH = 780;
    private static final int MAX_HEIGHT = 1000;
    // 新增GIF格式标识
    private static final String GIF_SUFFIX = "gif";

    public List<ImageModel> parseFileInfo(String boardType, List<MultipartFile> multipartFiles) throws Exception {

        List<ImageModel> fileList = new ArrayList<>();

        if (multipartFiles.isEmpty()) {
            return fileList;
        }

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
        String current_date = simpleDateFormat.format(new Date());

        // 路径拼接改用File.separator兼容不同操作系统，避免硬写\\仅支持Windows
        String absolutePath = new File("").getAbsolutePath() + File.separator + "src" + File.separator + "main" + File.separator;

        String path = "uploads/images/" + boardType + "/" + current_date;
        File file = new File(absolutePath + path);
        if (!file.exists()) {
            file.mkdirs();
        }

        for (MultipartFile multipartFile : multipartFiles) {
            if (multipartFile.isEmpty()) {
                continue;
            }
            String originalFilename = multipartFile.getOriginalFilename();
            // 修复后缀获取逻辑，避免文件名带多个点时取错后缀
            String suffix = originalFilename.substring(originalFilename.lastIndexOf(".") + 1).toLowerCase();
            String new_file_name = System.nanoTime() + "." + suffix;
            File outputFile = new File(absolutePath + path + File.separator + new_file_name);

            if (GIF_SUFFIX.equals(suffix)) {
                // GIF单独走动图压缩逻辑
                handleGifCompress(multipartFile.getInputStream(), outputFile);
            } else {
                // 静态图沿用原有逻辑，修复硬编码图片类型问题
                BufferedImage originalImage = ImageIO.read(multipartFile.getInputStream());
                int imageType = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB : originalImage.getType();
                int width = originalImage.getWidth();
                int height = originalImage.getHeight();

                Dimension imgSize = new Dimension(width, height);
                Dimension boundary = new Dimension(MAX_WIDTH, MAX_HEIGHT);
                Dimension newImgSize = getScaledDimension(imgSize, boundary);

                Image resizedImage = originalImage.getScaledInstance(newImgSize.width, newImgSize.height, Image.SCALE_SMOOTH);
                // 取消硬编码TYPE_INT_BGR，沿用原图类型避免丢失透明通道
                BufferedImage newImage = new BufferedImage(newImgSize.width, newImgSize.height, imageType);
                Graphics graphics = newImage.getGraphics();
                graphics.drawImage(resizedImage, 0, 0, null);
                graphics.dispose();

                try{
                    ImageIO.write(newImage, suffix, outputFile);
                }catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            // 此处补全ImageModel组装逻辑，原代码返回的fileList为空
        }

        return fileList;
    }

    // GIF逐帧压缩处理方法
    private void handleGifCompress(InputStream inputStream, File outputFile) throws IOException {
        ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
        reader.setInput(ImageIO.createImageInputStream(inputStream));
        int frameCount = reader.getNumImages(true);

        // 读取原GIF元数据配置
        IIOMetadata metadata = reader.getImageMetadata(0);
        String metaFormatName = metadata.getNativeMetadataFormatName();
        ImageWriter gifWriter = ImageIO.getImageWritersByFormatName("gif").next();
        ImageWriteParam writeParam = gifWriter.getDefaultWriteParam();
        ImageTypeSpecifier typeSpecifier = reader.getImageTypes(0).next();
        IIOMetadata outputMetadata = gifWriter.getDefaultImageMetadata(typeSpecifier, writeParam);
        outputMetadata.setFromTree(metaFormatName, metadata.getAsTree(metaFormatName));

        gifWriter.setOutput(ImageIO.createImageOutputStream(outputFile));
        gifWriter.prepareWriteSequence(outputMetadata);

        // 逐帧处理压缩并保留帧元数据
        for (int i = 0; i < frameCount; i++) {
            BufferedImage frame = reader.read(i);
            Dimension imgSize = new Dimension(frame.getWidth(), frame.getHeight());
            Dimension boundary = new Dimension(MAX_WIDTH, MAX_HEIGHT);
            Dimension newImgSize = getScaledDimension(imgSize, boundary);

            Image resizedFrame = frame.getScaledInstance(newImgSize.width, newImgSize.height, Image.SCALE_SMOOTH);
            BufferedImage newFrame = new BufferedImage(newImgSize.width, newImgSize.height, frame.getType());
            Graphics2D g = newFrame.createGraphics();
            g.drawImage(resizedFrame, 0, 0, null);
            g.dispose();

            IIOMetadata frameMeta = reader.getImageMetadata(i);
            frameMeta.setFromTree(metaFormatName, frameMeta.getAsTree(metaFormatName));
            gifWriter.writeToSequence(new IIOImage(newFrame, null, frameMeta), writeParam);
        }
        gifWriter.endWriteSequence();
        gifWriter.dispose();
        reader.dispose();
    }

    // 原有等比缩放逻辑补全
    private Dimension getScaledDimension(Dimension imgSize, Dimension boundary) {
        int originalWidth = imgSize.width;
        int originalHeight = imgSize.height;
        int boundWidth = boundary.width;
        int boundHeight = boundary.height;
        int newWidth = originalWidth;
        int newHeight = originalHeight;

        if (originalWidth > boundWidth) {
            newWidth = boundWidth;
            newHeight = (newWidth * originalHeight) / originalWidth;
        }
        if (newHeight > boundHeight) {
            newHeight = boundHeight;
            newWidth = (newHeight * originalWidth) / originalHeight;
        }
        return new Dimension(newWidth, newHeight);
    }
}

内容的提问来源于stack exchange，提问作者Minnie