Java调用SQLPlus异常排查与解决方法

问题描述

在Java应用程序中，开发者可能需要通过外部进程执行系统命令，例如调用Oracle SQLPlus来执行SQL或PL/SQL脚本。然而，当使用Runtime.getRuntime().exec(String cmd)方法执行包含复杂参数（特别是带有空格和引号的连接字符串）的SQLPlus命令时，观察到的输出可能并非预期的脚本执行结果，而是SQL*Plus的帮助信息或用法说明。

例如，直接在操作系统命令行中执行如下SQL*Plus命令可以正常获取到PL/SQL执行的错误信息：

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

预期输出（例如PL/SQL错误）：

    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
...
Use SQL*Plus to execute SQL, PL/SQL and SQL*Plus statements.
Usage 1: sqlplus -H | -V
...

根本原因分析

这种差异的根本原因在于Runtime.getRuntime().exec(String cmd)方法与操作系统shell解析命令的方式不同。

1. Runtime.exec(String cmd)的限制： 当传入单个字符串作为命令时，Runtime.exec(String)不会像shell那样智能地解析引号和空格。它会尝试将整个字符串作为一个整体来执行，或者简单地根据空格进行分割，但不会正确处理引号内的内容为一个参数。这意味着，复杂的连接字符串（如"(DESCRIPTION=...)"）在被传递给sqlplus时，可能被错误地分割或解释，导致sqlplus命令无法识别正确的参数，从而回退到显示其用法说明。

2. Shell的智能解析： 相反，当在命令行中直接执行时，shell（如Bash、CMD等）会负责解析命令字符串。它能够识别引号，并将引号内的内容作为一个整体的参数传递给目标程序（sqlplus）。

解决方案

为了解决这个问题，我们需要确保Java将命令参数以与shell相同的方式传递给外部程序。这可以通过两种主要方式实现：

方案一：使用 Runtime.exec(String[] cmdarray)

此方法允许您将命令及其所有参数作为字符串数组的单独元素传递。这样，Java就不会尝试自行解析整个命令字符串，而是将每个数组元素作为一个独立的参数传递给外部进程。

示例代码：

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

public class RunSqlPlusCorrected {

    public static void main(String[] args) {
        try {
            // 将命令及其参数分解为字符串数组的每个元素
            String[] cmdArray = new String[] {
                "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"
            };

            Process process = Runtime.getRuntime().exec(cmdArray);

            // 使用StreamGobbler处理标准输出和标准错误流
            StreamGobbler outputGobbler =
                    new StreamGobbler(process.getInputStream(), System.out::println);
            StreamGobbler errorGobbler =
                    new StreamGobbler(process.getErrorStream(), System.err::println);

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

            int exitCode = process.waitFor();
            System.out.println("Exited with code: " + exitCode);

            outputFuture.get(); // 等待输出流处理完成
            errorFuture.get();  // 等待错误流处理完成

        } 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) {
                e.printStackTrace();
            }
        }
    }
}

注意事项：

• Runtime.exec(String)在JDK 18中已被标记为弃用，因为它在处理复杂命令时确实存在解析问题。推荐使用ProcessBuilder。
• 将命令的每个组成部分（包括命令本身、选项、参数和文件路径）作为数组的一个独立元素。
• 对于包含空格但需要作为一个整体的参数，例如连接字符串，将其作为一个独立的字符串元素放入数组中。如果该参数内部包含引号，则这些引号也应作为该字符串的一部分。

方案二：使用 ProcessBuilder (推荐)

ProcessBuilder类提供了更强大和灵活的方式来创建和管理外部进程。它允许您设置工作目录、环境变量，以及更精细地控制标准输入、输出和错误流的重定向。

示例代码：

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

public class RunSqlPlusWithProcessBuilder {

    public static void main(String[] args) {
        try {
            // 将命令及其参数分解为字符串数组的每个元素
            String[] cmdArray = new String[] {
                "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"
            };

            ProcessBuilder pb = new ProcessBuilder(cmdArray);
            // 可以设置工作目录，例如：pb.directory(new File("/path/to/script/directory"));
            // 可以设置环境变量，例如：pb.environment().put("VAR_NAME", "VAR_VALUE");

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

            Process process = pb.start();

            // 使用StreamGobbler处理合并后的输出流
            StreamGobbler outputGobbler =
                    new StreamGobbler(process.getInputStream(), System.out::println);

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

            int exitCode = process.waitFor();
            System.out.println("Exited with code: " + exitCode);

            outputFuture.get(); // 等待输出流处理完成

        } 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) {
                e.printStackTrace();
            }
        }
    }
}

ProcessBuilder的优势：

• 参数解析： 像Runtime.exec(String[])一样，ProcessBuilder构造函数接受一个字符串列表或数组，确保每个参数都被正确传递，避免了shell解析问题。
• 流重定向： ProcessBuilder提供了丰富的流重定向选项，例如redirectOutput(), redirectError(), redirectInput()，以及非常实用的redirectErrorStream(true)，它可以将标准错误流合并到标准输出流，简化了流处理逻辑，避免了死锁的风险（当父进程不及时读取子进程的输出流时，子进程可能会因为缓冲区满而阻塞）。
• 环境和目录： 可以方便地设置子进程的工作目录和环境变量，这对于某些需要特定环境才能正确运行的命令非常有用。
• 链式调用： ProcessBuilder支持链式调用，使得代码更简洁易读。

总结

当在Java中执行外部命令，特别是那些参数复杂或包含特殊字符（如空格、引号）的命令时，应避免使用Runtime.getRuntime().exec(String cmd)。最佳实践是使用Runtime.getRuntime().exec(String[] cmdarray)或更推荐的java.lang.ProcessBuilder类。通过将命令及其参数分解为独立的字符串数组元素，可以确保这些参数被正确传递给外部进程，从而获得预期的执行结果。同时，务必正确处理外部进程的标准输出和标准错误流，以避免进程阻塞和获取完整的执行信息。对于数据库操作，尽管直接调用sqlplus在某些特定场景下有用，但通常更推荐使用JDBC驱动程序进行数据库交互，因为它提供了更安全、高效和类型安全的编程接口。