Hey there! Handling thousands of HEIC files in a Java backend is totally feasible, and I’ve got two solid approaches to share—starting with the most seamless, pure-Java solution that’s perfect for backend integration.

1. Pure Java Approach: TwelveMonkeys ImageIO Extension #

This is hands-down the best option for most Java backend workflows. It’s cross-platform, doesn’t require any system-level dependencies, and integrates directly with Java’s built-in ImageIO API.

Step 1: Add Dependencies #

First, include the TwelveMonkeys HEIC plugin in your project. For Maven, add these to your pom.xml:

<dependencies>
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-core</artifactId>
        <version>3.10.1</version> <!-- Use latest stable version -->
    </dependency>
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-heic</artifactId>
        <version>3.10.1</version>
    </dependency>
</dependencies>

Step 2: Core Conversion Code #

This code registers the HEIC plugin, reads the HEIC file, and writes it as JPG or PNG. It handles single-image HEIC files (the most common case):

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.FileImageInputStream;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;

public class HeicConverter {

    // Register the HEIC plugin on class load
    static {
        try {
            Class.forName("com.twelvemonkeys.imageio.plugins.heic.HEICImageReaderSpi");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("Failed to load HEIC ImageIO plugin", e);
        }
    }

    /**
     * Convert a single HEIC file to JPG
     */
    public static void convertToJpg(File heicInput, File jpgOutput) throws IOException {
        convertHeicToFormat(heicInput, jpgOutput, "JPG");
    }

    /**
     * Convert a single HEIC file to PNG
     */
    public static void convertToPng(File heicInput, File pngOutput) throws IOException {
        convertHeicToFormat(heicInput, pngOutput, "PNG");
    }

    private static void convertHeicToFormat(File heicInput, File output, String format) throws IOException {
        // Get a HEIC-compatible ImageReader
        Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("HEIC");
        if (!readers.hasNext()) {
            throw new IOException("No HEIC reader available—check your dependencies");
        }

        ImageReader reader = readers.next();
        try (FileImageInputStream inputStream = new FileImageInputStream(heicInput)) {
            reader.setInput(inputStream);
            BufferedImage image = reader.read(0); // Read the first image in the HEIC file

            // Write the image to the output format
            if (!ImageIO.write(image, format, output)) {
                throw new IOException("Failed to write image as " + format);
            }
        } finally {
            reader.dispose(); // Clean up resources
        }
    }
}

Step 3: Batch Processing Optimization #

With thousands of files, single-threaded conversion will be slow. Use a thread pool to parallelize the work:

import java.io.File;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class BatchHeicProcessor {
    // Use as many threads as your CPU has cores (adjust if memory is tight)
    private static final int THREAD_POOL_SIZE = Runtime.getRuntime().availableProcessors();

    public static void batchConvertToJpg(File heicDirectory, File outputDirectory) throws IOException, InterruptedException {
        setupOutputDirectory(outputDirectory);
        File[] heicFiles = getHeicFiles(heicDirectory);

        ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        for (File heicFile : heicFiles) {
            File jpgFile = new File(outputDirectory, heicFile.getName().replace(".heic", ".jpg"));
            executor.submit(() -> {
                try {
                    HeicConverter.convertToJpg(heicFile, jpgFile);
                    System.out.println("Successfully converted: " + heicFile.getName());
                } catch (IOException e) {
                    System.err.println("Failed to convert " + heicFile.getName() + ": " + e.getMessage());
                }
            });
        }

        // Shutdown executor and wait for all tasks to finish
        executor.shutdown();
        if (!executor.awaitTermination(2, TimeUnit.HOURS)) {
            System.err.println("Conversion timed out—some files may not be processed");
        }
    }

    private static void setupOutputDirectory(File outputDirectory) throws IOException {
        if (!outputDirectory.exists() && !outputDirectory.mkdirs()) {
            throw new IOException("Failed to create output directory: " + outputDirectory.getAbsolutePath());
        }
    }

    private static File[] getHeicFiles(File heicDirectory) throws IOException {
        File[] heicFiles = heicDirectory.listFiles((dir, name) -> name.toLowerCase().endsWith(".heic"));
        if (heicFiles == null || heicFiles.length == 0) {
            throw new IOException("No HEIC files found in directory: " + heicDirectory.getAbsolutePath());
        }
        return heicFiles;
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        File heicDir = new File("/path/to/your/heic/files");
        File outputDir = new File("/path/to/jpg/output");
        batchConvertToJpg(heicDir, outputDir);
    }
}

2. Alternative: Call External Tools (libheif) #

If you encounter edge cases where TwelveMonkeys can’t handle a HEIC file (e.g., rare encoding variants), you can use the libheif command-line tool. This requires installing libheif on your server:

• Ubuntu/Debian: sudo apt install libheif-examples
• macOS: brew install libheif

Here’s how to call it from Java:

import java.io.File;
import java.io.IOException;

public class ExternalHeicConverter {
    public static void convertToJpg(File heicInput, File jpgOutput) throws IOException, InterruptedException {
        ProcessBuilder processBuilder = new ProcessBuilder(
                "heif-convert",
                heicInput.getAbsolutePath(),
                jpgOutput.getAbsolutePath()
        );
        // Redirect tool output/errors to your console for debugging
        processBuilder.inheritIO();
        Process process = processBuilder.start();

        int exitCode = process.waitFor();
        if (exitCode != 0) {
            throw new IOException("libheif conversion failed with exit code: " + exitCode);
        }
    }
}

Key Notes & Troubleshooting #

• Dependency Versions: Always use the latest stable version of TwelveMonkeys to support newer HEIC formats.
• Memory Management: Large images can cause OutOfMemoryErrors. If this happens, reduce the thread pool size or use ImageIO’s progressive loading features.
• Metadata Preservation: TwelveMonkeys preserves basic EXIF data, but for full metadata support, pair it with the metadata-extractor library to copy metadata manually.
• Error Handling: Add retry logic for failed conversions in batch processing to handle transient issues.

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