Java中跨平台执行外部命令的挑战与最佳实践：以Calibre转换工具为例

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.charset.StandardCharsets; // 确保引入

// 假设Document, DocumentFormat, CalibreConfigData, CalibreConversion, ConversionException, log 等已定义
public class CalibreDocumentConverter {

    // 假设这些是依赖注入的或通过其他方式获取
    private HtmlDocumentConverter htmlDocumentConverter;
    private CalibreConfig calibreConfig;
    // private Logger log; // 假设log是SLF4J或其他日志实现

    public Document convert(Document document, DocumentFormat documentFormat) {
        Document htmlDocument = htmlDocumentConverter.convert(document, documentFormat);
        try {
            log.info("Converting document from {} to {}", getSourceFormat().toString(), getTargetFormat().toString());
            CalibreConfigData calibreData = calibreConfig.getConfigurationData(CalibreConversion.HTML_TO_MOBI);

            // 确保源HTML文件写入
            Path sourceFilePath = calibreData.getSourceFilePath();
            Files.write(sourceFilePath, htmlDocument.getContent());

            String calibreCommandPath = "/usr/src/calibre/ebook-convert"; // Calibre可执行文件的绝对路径
            Path tempHtmlFilePath = calibreData.getSourceFilePath(); // 源HTML文件路径
            Path outputMobiFilePath = calibreData.getConvertedFilePath(); // 目标MOBI文件路径

            // 构建命令数组
            // ProcessBuilder 推荐直接传递命令和参数，而不是通过 shell -c
            String[] command = {
                calibreCommandPath,
                tempHtmlFilePath.toAbsolutePath().toString(), // 使用绝对路径
                outputMobiFilePath.toAbsolutePath().toString() // 使用绝对路径
            };

            log.info("Executing Calibre command: {}", String.join(" ", command));

            ProcessBuilder pb = new ProcessBuilder(command);
            pb.inheritIO(); // 关键：将子进程的I/O重定向到当前Java进程的I/O流

            // 可选：设置工作目录，如果ebook-convert依赖于特定目录
            // pb.directory(calibreData.getFilesDirectoryPath().toFile()); 

            Process process = pb.start();
            int exitCode = process.waitFor(); // 等待进程完成

            log.info("Calibre conversion process exited with code: {}", exitCode);

            if (exitCode != 0) {
                // 如果退出码非零，表示转换失败
                throw new ConversionException("Calibre conversion failed with exit code: " + exitCode);
            }

            // 读取转换后的MOBI文件
            byte[] convertedFileAsBytes = Files.readAllBytes(outputMobiFilePath);

            // 清理临时文件（根据需要决定是否启用）
            // Files.deleteIfExists(calibreData.getSourceFilePath());
            // Files.deleteIfExists(calibreData.getConvertedFilePath());
            // Files.deleteIfExists(calibreData.getFilesDirectoryPath());

            return new Document(convertedFileAsBytes);
        } catch (InterruptedException | IOException e) {
            log.error("Conversion failed due to problem: " + e.getMessage(), e);
            throw new ConversionException("Conversion failed due to problem: " + e.getMessage(), e);
        }
    }

    // 假设getSourceFormat()和getTargetFormat()方法存在
    private Object getSourceFormat() { return null; }
    private Object getTargetFormat() { return null; }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

// ... 在convert方法内部 ...
    // ProcessBuilder pb = new ProcessBuilder(command);
    // Process process = pb.start();

    // 创建线程来读取标准输出和标准错误
    StringBuilder output = new StringBuilder();
    StringBuilder errorOutput = new StringBuilder();

    StreamGobbler outputGobbler = new StreamGobbler(process.getInputStream(), output::append);
    StreamGobbler errorGobbler = new StreamGobbler(process.getErrorStream(), errorOutput::append);

    Future<?> outputFuture = Executors.newSingleThreadExecutor().submit(outputGobbler);
    Future<?> errorFuture = Executors.newSingleThreadExecutor().submit(errorGobbler);

    // 等待进程完成，并设置超时
    boolean finished = process.waitFor(5, TimeUnit.MINUTES); // 5分钟超时

    if (!finished) {
        process.destroyForcibly(); // 强制终止进程
        throw new ConversionException("Calibre conversion timed out.");
    }

    // 等待I/O读取线程完成
    outputFuture.get(10, TimeUnit.SECONDS); // 确保读取完成
    errorFuture.get(10, TimeUnit.SECONDS);

    int exitCode = process.exitValue();
    log.info("Calibre conversion process exited with code: {}", exitCode);
    log.debug("Process Stdout: \n{}", output.toString());
    log.debug("Process Stderr: \n{}", errorOutput.toString());

    if (exitCode != 0) {
        throw new ConversionException("Calibre conversion failed with exit code: " + exitCode + 
                                       ". Error: " + errorOutput.toString());
    }
// ...

class StreamGobbler implements Runnable {
    private InputStream inputStream;
    private Consumer<String> consumer;

    public StreamGobbler(InputStream inputStream, Consumer<String> consumer) {
        this.inputStream = inputStream;
        this.consumer = consumer;
    }

    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                consumer.accept(line + "\n");
            }
        } catch (IOException e) {
            // 记录异常，但通常不应中断主流程
            System.err.println("Error reading stream: " + e.getMessage());
        }
    }
}