Java执行SQLPlus结果不一致原因及解决方法

1. 问题背景与现象分析

当尝试在Java应用程序中执行外部命令，特别是像SQL*Plus这样带有复杂参数和特殊字符（如引号、括号）的命令时，开发者可能会遇到一个常见问题：命令在Java中执行的输出与直接在操作系统的Shell中执行的输出不一致。

例如，一个旨在执行SQL脚本并期望捕获其错误输出的SQL*Plus命令：

sqlplus -s -LOGON /@"(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(Host= host1.com)(Port=1725))(ADDRESS=(PROTOCOL=TCP)(Host= host2.com)(Port=1725))(LOAD_BALANCE = ON)(FAILOVER = ON) (CONNECT_DATA = (SERVER = DEDICATED)(SERVICE_NAME=service.com)))" @Load.sql

当此命令直接在Shell中执行时，会如预期般显示SQL*Plus脚本的执行结果或错误信息，例如：

    BEGIN
*
ERROR at line 1:
ORA-20004: Data is not ready, please check control-M v8 jobs
ORA-06512: at "GLOBAL_OWNER.PKG_COMMON_UTILS", line 282
ORA-06512: at line 2

然而，当通过Java的Runtime.getRuntime().exec(String cmd)方法执行相同的命令字符串时，其输出却可能变成SQL*Plus的用法帮助信息，而非实际的执行结果：

SQL*Plus: Release 12.1.0.2.0 Production
Copyright (c) 1982, 2014, Oracle. All rights reserved.
Use SQL*Plus to execute SQL, PL/SQL and SQL*Plus statements.
Usage 1: sqlplus -H | -V
... (大量用法帮助信息) ...

这种现象表明，Java的Runtime.exec(String)方法未能正确解析命令字符串中的参数，导致SQL*Plus程序认为它没有收到任何有效参数，从而打印出其使用说明。

2. 问题根源：命令字符串解析的差异

Runtime.exec(String cmd)方法在内部会将传入的单个字符串命令传递给操作系统的默认Shell（如Windows上的cmd.exe或Unix/Linux上的/bin/sh或/bin/bash）来执行。这个过程涉及到Shell自身的命令解析逻辑。然而，Java的exec方法在将字符串传递给Shell之前，对字符串的解析方式可能与Shell直接解析的方式存在细微差异，尤其是在处理包含空格、引号、特殊字符（如()）的复杂参数时。

更重要的是，Runtime.exec(String)的这种行为在JDK 18及更高版本中已被标记为弃用，因为它确实在处理复杂命令时存在不确定性。当命令字符串包含空格或引号时，Java内部的默认分词器可能无法准确地将它们拆分为独立的参数，导致外部程序（如sqlplus）接收到错误或不完整的参数列表。

3. 解决方案：明确传递命令参数

为了解决这个问题，我们应该避免依赖Runtime.exec(String)的内部字符串解析机制，而是明确地将命令及其所有参数作为独立的字符串数组元素传递。Java提供了两种主要方法来实现这一点：

3.1 使用 Runtime.exec(String[] cmdarray)

此方法接收一个字符串数组，其中第一个元素是可执行命令本身，后续元素是其参数。这样，Java就不会尝试自行解析整个命令字符串，而是直接将每个数组元素作为一个独立的参数传递给外部进程。

示例代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.function.Consumer;

public class RunSqlPlusFixed {

    public static void main(String[] args) {
        // 注意：这里的用户/密码和连接字符串是示例，生产环境应避免硬编码或明文存储
        String userName = "";
        String password = "";
        String connectString = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(Host= host1.com)(Port=1725))(ADDRESS=(PROTOCOL=TCP)(Host= host2.com)(Port=1725))(LOAD_BALANCE = ON)(FAILOVER = ON) (CONNECT_DATA = (SERVER = DEDICATED)(SERVICE_NAME=service.com)))";
        String sqlScript = "@Load.sql"; // 假设Load.sql在当前工作目录

        // 将命令和每个参数作为独立的字符串元素放入数组
        String[] cmd = new String[] {
            "sqlplus",
            "-s",
            "-LOGON",
            userName + "/" + password + "@" + connectString, // 连接字符串作为一个整体参数
            sqlScript
        };

        Process process;
        try {
            process = Runtime.getRuntime().exec(cmd);

            // 重要的：必须消费进程的输出流和错误流，以避免进程阻塞
            StreamGobbler outputGobbler =
                    new StreamGobbler(process.getInputStream(), System.out::println);
            StreamGobbler errorGobbler =
                    new StreamGobbler(process.getErrorStream(), System.err::println);

            ExecutorService executorService = Executors.newFixedThreadPool(2);
            Future outputFuture = executorService.submit(outputGobbler);
            Future errorFuture = executorService.submit(errorGobbler);

            int exitCode = process.waitFor(); // 等待进程完成
            System.out.println("SQL*Plus process exited with code: " + exitCode);

            outputFuture.get(); // 确保输出流被完全读取
            errorFuture.get();  // 确保错误流被完全读取
            executorService.shutdown(); // 关闭线程池

        } catch (IOException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    // StreamGobbler 辅助类，用于异步读取进程的输入流
    private static class StreamGobbler implements Runnable {
        private InputStream inputStream;
        private Consumer consumer;

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

        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
                reader.lines().forEach(consumer);
            } catch (IOException e) {
                System.err.println("Error reading stream: " + e.getMessage());
            }
        }
    }
}

在上述代码中，SQL*Plus的连接字符串(DESCRIPTION=...)作为一个整体被传递给sqlplus命令，因为它在Shell中通常被视为一个单独的参数。通过将整个连接字符串与用户名/密码拼接，并将其作为数组中的一个元素，我们确保了sqlplus命令能够正确接收到它。

3.2 使用 ProcessBuilder (推荐)

ProcessBuilder类提供了更强大和灵活的方式来创建和管理外部进程。它允许你：

• 更清晰地定义命令和参数。
• 设置工作目录。
• 配置环境变量。
• 重定向标准输入、输出和错误流，例如将错误流重定向到输出流，简化流处理。

示例代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.function.Consumer;

public class RunSqlPlusProcessBuilder {

    public static void main(String[] args) {
        String userName = "";
        String password = "";
        String connectString = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(Host= host1.com)(Port=1725))(ADDRESS=(PROTOCOL=TCP)(Host= host2.com)(Port=1725))(LOAD_BALANCE = ON)(FAILOVER = ON) (CONNECT_DATA = (SERVER = DEDICATED)(SERVICE_NAME=service.com)))";
        String sqlScript = "Load.sql"; // 假设Load.sql在当前工作目录

        List command = new ArrayList<>();
        command.add("sqlplus");
        command.add("-s");
        command.add("-LOGON");
        command.add(userName + "/" + password + "@" + connectString); // 整个连接字符串作为单个参数
        command.add("@" + sqlScript); // 脚本路径

        ProcessBuilder processBuilder = new ProcessBuilder(command);
        // 可以设置工作目录，例如：
        // processBuilder.directory(new File("/path/to/sql/scripts"));

        // 将标准错误流重定向到标准输出流，这样只需要处理一个流
        processBuilder.redirectErrorStream(true);

        try {
            Process process = processBuilder.start();

            // 只需处理一个输出流（因为它包含了原始的stdout和stderr）
            StreamGobbler outputGobbler =
                    new StreamGobbler(process.getInputStream(), System.out::println);

            ExecutorService executorService = Executors.newSingleThreadExecutor();
            Future outputFuture = executorService.submit(outputGobbler);

            int exitCode = process.waitFor();
            System.out.println("SQL*Plus process exited with code: " + exitCode);

            outputFuture.get(); // 确保输出流被完全读取
            executorService.shutdown();

        } catch (IOException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    // StreamGobbler 辅助类保持不变
    private static class StreamGobbler implements Runnable {
        private InputStream inputStream;
        private Consumer consumer;

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

        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
                reader.lines().forEach(consumer);
            } catch (IOException e) {
                System.err.println("Error reading stream: " + e.getMessage());
            }
        }
    }
}

使用ProcessBuilder的redirectErrorStream(true)方法是一个非常有用的技巧，它能将进程的标准错误流合并到标准输出流中，从而简化了Java端对输出的处理，避免了同时管理两个流的复杂性。

4. 注意事项与最佳实践

1. 参数的正确拆分：无论是使用Runtime.exec(String[])还是ProcessBuilder，最关键的是要将命令和其所有参数正确地拆分成独立的字符串元素。任何在Shell中被视为一个整体的参数（即使它包含空格或特殊字符，如被引号包裹的部分），在Java的参数数组中也应该是一个单独的字符串元素。
2. 处理进程I/O流：这是执行外部进程时最容易被忽视但又至关重要的一点。外部进程的标准输出流（stdout）和标准错误流（stderr）可能会产生大量数据。如果不及时读取这些流，它们可能会填满操作系统的缓冲区，导致子进程阻塞，甚至父进程（Java应用程序）也可能因此挂起。因此，始终使用单独的线程（如StreamGobbler）来异步消费这些流是最佳实践。
3. 安全性：在代码中直接硬编码数据库用户名和密码是非常不安全的做法。在生产环境中，应使用更安全的机制来管理凭证，例如环境变量、配置文件加密、Java KeyStore或Vault服务。
4. 错误处理：捕获IOException（命令无法执行）、InterruptedException（等待进程时线程被中断）和ExecutionException（异步任务执行错误）是必要的。检查进程的退出码（process.waitFor()的返回值）也非常重要，因为非零退出码通常表示命令执行失败。
5. 资源管理：确保在进程完成后关闭所有相关的输入/输出流，并在不再需要时关闭ExecutorService。

通过遵循这些指导原则，您可以在Java应用程序中可靠地执行外部命令，并准确捕获其输出，从而避免因命令解析问题导致的意外行为。