【Java基础知识】java调用并执行shell脚本

1. 背景

我们在开发过程中，大部分是java开发， 而在文本处理过程中，主要就是脚本进行开发。脚本开发的特点就是在进行批处理的时候非常方便。 前阵子我遇到这么一个需求场景：

有一些特殊文件需要特殊环境才能操作，而部署上线后必须要在Linux环境执行，所以一直用Java开始发为主的我们，强大的新势力（Go、Python）估计就很难施展，总不能重新用Go或者Python重新构建项目吧！所以我们需要借助Java的Process类调用shell脚本处理一些任务！

2. 理论知识

2.1直接 Runtime.getRuntime().exec()方法

Java 中 Runtime.getRuntime().exec()方法给我们提供了调用并执行shell脚本的这个功能，而且Runtime.getRuntime()给我们提供了以下几种exec()方法：

//在单独的进程中执行指定的字符串命令。 
Process exec(String command) 

//在单独的进程中执行指定命令和变量。
Process exec(String[] cmdarray) 

//在指定环境的独立进程中执行指定命令和变量。 
Process exec(String[] cmdarray, String[] envp) 
 
//在指定环境和工作目录的独立进程中执行指定的命令和变量。
Process exec(String[] cmdarray, String[] envp, File dir) 
 
//在指定环境的单独进程中执行指定的字符串命令。
Process exec(String command, String[] envp) 
 
//在有指定环境和工作目录的独立进程中执行指定的字符串命令
Process exec(String command, String[] envp, File dir) 

• cmdarray: 包含所调用命令及其参数的数组。
• command: 一条指定的系统命令。
• envp: 字符串数组，其中每个元素的环境变量的设置格式为name=value；如果子进程应该继承当前进程的环境，则该参数为 null。
• dir: 子进程的工作目录；如果子进程应该继承当前进程的工作目录，则该参数为 null。

其中，其实cmdarray和command差不多，同时如果参数中如果没有envp参数或设为null，表示调用命令将在当前程序执行的环境中执行；如果没有dir参数或设为null，表示调用命令将在当前程序执行的目录中执行，因此调用到其他目录中的文件和脚本最好使用绝对路径。

细心的读者会发现，为了执行调用操作，JVM会启一个Process，所以我们可以通过调用Process类的以下方法，得知调用操作是否正确执行：

//导致当前线程等待，如有必要，一直要等到由该 Process 对象表示的进程已经终止。
abstract int waitFor()

// 返回值是进程的出口值。根据惯例，0 表示正常终止；否则，就表示异常失败。

另外，调用某些Shell命令或脚本时，会有返回值，那么我们如果捕获这些返回值或输出呢？为了解决这个问题，Process类提供了：

// 获取子进程的输入流。 最好对输入流进行缓冲。
abstract InputStream getInputStream() 

2.2 经过ProcessBuilder进行调度

每个 ProcessBuilder 实例管理一个进程属性集。start()) 方法利用这些属性创建一个新的 Process 实例。start()) 方法可以从同一实例重复调用，以利用相同的或相关的属性创建新的子进程。

每个进程生成器管理这些进程属性：

• 命令 是一个字符串列表，它表示要调用的外部程序文件及其参数（如果有）。在此，表示有效的操作系统命令的字符串列表是依赖于系统的。例如，每一个总体变量，通常都要成为此列表中的元素，但有一些操作系统，希望程序能自己标记命令行字符串——在这种系统中，Java 实现可能需要命令确切地包含这两个元素。
• 环境 是从变量 到值 的依赖于系统的映射。初始值是当前进程环境的一个副本（请参阅 System.getenv()）。
• 工作目录。默认值是当前进程的当前工作目录，通常根据系统属性 user.dir 来命名。
• redirectErrorStream 属性。最初，此属性为 false，意思是子进程的标准输出和错误输出被发送给两个独立的流，这些流可以通过 Process.getInputStream()) 和 Process.getErrorStream()) 方法来访问。如果将值设置为 true，标准错误将与标准输出合并。这使得关联错误消息和相应的输出变得更容易。在此情况下，合并的数据可从 Process.getInputStream()) 返回的流读取，而从 Process.getErrorStream()) 返回的流读取将直接到达文件尾。

修改进程构建器的属性将影响后续由该对象的 start()) 方法启动的进程，但从不会影响以前启动的进程或 Java 自身的进程。

大多数错误检查由 start()) 方法执行。可以修改对象的状态，但这样 start()) 将会失败。例如，将命令属性设置为一个空列表将不会抛出异常，除非包含了 start())。

注意

此类不是同步的。如果多个线程同时访问一个 ProcessBuilder，而其中至少一个线程从结构上修改了其中一个属性，它必须 保持外部同步。要利用一组明确的环境变量启动进程，在添加环境变量之前，首先调用 Map.clear()

ProcessBuilder(List<String> command) 利用指定的操作系统程序和参数构造一个进程生成器。

ProcessBuilder(String... command) 利用指定的操作系统程序和参数构造一个进程生成器。

方法摘要	
List<String>	command() 返回此进程生成器的操作系统程序和参数。
ProcessBuilder	command(List<String> command) 设置此进程生成器的操作系统程序和参数。
ProcessBuilder	command(String... command) 设置此进程生成器的操作系统程序和参数。
File	directory() 返回此进程生成器的工作目录。
ProcessBuilder	directory(File directory) 设置此进程生成器的工作目录。
Map<String,String>	environment() 返回此进程生成器环境的字符串映射视图。
boolean	redirectErrorStream() 通知进程生成器是否合并标准错误和标准输出。
ProcessBuilder	redirectErrorStream(boolean redirectErrorStream) 设置此进程生成器的 redirectErrorStream 属性。
Process	start() 使用此进程生成器的属性启动一个新进程。

2.3 Runtime对比ProcessBuilder

• Runtime方式： 此为最常见的一种运行方式，历史最悠久，使应用程序能够与其运行的环境相连接，但是在读取上还存在一些不便性，正常的输出流与错误流得分开读取。其他功能基本相同。
• ProcessBuilder：此为jdk1.5加入的，它没有将应用程序与其运行的环境相连接。这个就需要自己设置其相关的信息。但它提供了将正常流与流程流合并在一起的解决办法，只需要设置redirectErrorStream（错误流重定向到标准数据流）属性即可。

3. 调用shell 命令

public class ReadCmdLine {
    public static void main(String args[]) {
        callShellByExec("docker info");
    }

    /**
     * 使用 exec 调用shell脚本
     * @param shellString
     */
    public static void callShellByExec(String shellString) {
        BufferedReader reader = null;
        try {
            Process process = Runtime.getRuntime().exec(shellString);
            int exitValue = process.waitFor();
            if (0 != exitValue) {
                log.error("call shell failed. error code is :" + exitValue);
            }
            // 返回值
            reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line = null;
            while ((line = reader.readLine()) != null) {
                System.out.println("mac@wxw %  " + line);
            }
        } catch (Throwable e) {
            log.error("call shell failed. " + e);
        }
    }
}

4. 调用shell脚本

Java调用Shell命令和调用Shell脚本的操作一模一样。我这里介绍另外几个方面：

1. 给脚本传递参数；
2. 捕获调用的输出结果；
3. envp的使用。

给脚本传递参数，这个操作很简单，无非是把参数加到调用命令后面组成String，或String[]。

4.1 通过ProcessBuilder进行调度

这种方法比较直观，而且参数的设置也比较方便， 比如我在实践中的代码(我隐藏了部分业务代码)：

ProcessBuilder pb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, param1,
                                               param2, param3);
        pb.directory(new File(SHELL_FILE_DIR));
        int runningStatus = 0;
        String s = null;
        try {
            Process p = pb.start();
            try {
                runningStatus = p.waitFor();
            } catch (InterruptedException e) {
            }
 
        } catch (IOException e) {
        }
        if (runningStatus != 0) {
        }
        return;

这里有必要解释一下几个参数：

• RUNNING_SHELL_FILE：要运行的脚本
• SHELL_FILE_DIR：要运行的脚本所在的目录； 当然你也可以把要运行的脚本写成全路径。
• runningStatus：运行状态，0标识正常。 详细可以看java文档。
• param1, param2, param3：可以在RUNNING_SHELL_FILE脚本中直接通过1,2,$3分别拿到的参数。

4.2 直接通过系统Runtime执行shell

p = Runtime.getRuntime().exec(SHELL_FILE_DIR + RUNNING_SHELL_FILE + " "+param1+" "+param2+" "+param3);
p.waitFor();

我们发现，通过Runtime的方式并没有builder那么方便，特别是参数方面，必须自己加空格分开，因为exec会把整个字符串作为shell运行。

捕获调用输出信息，前面也提到过用Process.getInputStream()。不过，建议最好对输入流进行缓冲：

BufferedReader input = 
      new BufferedReader(new InputStreamReader(process.getInputStream()));

另外，envp是一个String[]，并且String[]中的每一个元素的形式是：name=value。如：我的Linux系统中没有以下环境变量，但是我把它们写在Java代码中，作为envp：

val=2
call=Bash Shell

• 我要调用的Shell脚本是：/root/experiment/test.sh。

#!/usr/bin/env bash
 
args=1
if [ $# -eq 1 ];then
 args=$1
 echo "The argument is: $args"
fi
 
echo "This is a $call"
start=`date +%s`
sleep 3s
end=`date +%s`
cost=$((($end - $start) * $args * $val))
echo "Cost Time: $cost"

• Java调用代码是：

private void callScript(String script, String args, String... workspace){
 try {
 String cmd = "sh " + script + " " + args;
//     String[] cmd = {"sh", script, "4"};
 File dir = null;
 if(workspace[0] != null){
  dir = new File(workspace[0]);
  System.out.println(workspace[0]);
 }
 String[] evnp = {"val=2", "call=Bash Shell"};
 process = Runtime.getRuntime().exec(cmd, evnp, dir);
//      process = Runtime.getRuntime().exec(cmd);
 BufferedReader input = new BufferedReader(new InputStreamReader(process.getInputStream()));
 String line = "";
 while ((line = input.readLine()) != null) {
  System.out.println(line);
 }
 input.close();
 }
 catch (Exception e){
 e.printStackTrace();
 }
}
 
public static void main(String[] args) {
 // TODO Auto-generated method stub
 CallShell call = new CallShell();
 call.callScript("test.sh", "4", "/root/experiment/");
}

5. 可能存在的问题以及解决方法

如果你觉得通过上面就能满足你的需求，那么可能是要碰壁了。你会遇到以下情况。

5.1 没权限运行

要执行包里面的shell脚本， 解压出来了之后，发现执行不了。 那么就按照上面的方法授权吧

ProcessBuilder builder = new ProcessBuilder("/bin/chmod", "755", tempFile.getPath());
            Process process = builder.start();
            int rc = process.waitFor();

5.2 java进行一直等待shell返回

这个问题估计更加经常遇到。 原因是， shell脚本中有echo或者print输出， 导致缓冲区被用完了! 为了避免这种情况， 一定要把缓冲区读一下， 好处就是，可以对shell的具体运行状态进行log出来。 比如上面我的例子中我会变成：

ProcessBuilder pb = 
          new ProcessBuilder("./" + RUNNING_SHELL_FILE, keyword.trim(),
                                  taskId.toString(), fileName);
        pb.directory(new File(CASPERJS_FILE_DIR));
        int runningStatus = 0;
        String s = null;
        try {
            Process p = pb.start();
            BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
            BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            while ((s = stdInput.readLine()) != null) {
                LOG.error(s);
            }
            while ((s = stdError.readLine()) != null) {
                LOG.error(s);
            }
            try {
                runningStatus = p.waitFor();
            } catch (InterruptedException e) {
            }
 

记得在start()之后， waitFor（）之前把缓冲区读出来打log， 就可以看到你的shell为什么会没有按照预期运行。 这个还有一个好处是，可以读shell里面输出的结果， 方便java代码进一步操作。

也许你还会遇到这个问题，明明手工可以运行的命令，java调用的shell中某一些命令居然不能执行，报错：命令不存在！

比如我在使用casperjs的时候，手工去执行shell明明是可以执行的，但是java调用的时候，发现总是出错。 通过读取缓冲区就能发现错误日志了。 我发现即便自己把安装的casperjs的bin已经加入了path中（/etc/profile, 各种bashrc中）还不够。 比如：

export NODE_HOME="/home/admin/node"
export CASPERJS_HOME="/home/admin/casperjs"
export PHANTOMJS_HOME="/home/admin/phantomjs"
export PATH=$PATH:$JAVA_HOME/bin:/root/bin:$NODE_HOME/bin:$CASPERJS_HOME/bin:$PHANTOMJS_HOME/bin
 

原来是因为java在调用shell的时候，默认用的是系统的/bin/下的指令。特别是你用root权限运行的时候。 这时候，你要在/bin下加软链了。针对我上面的例子，就要在/bin下加软链：

ln -s /home/admin/casperjs/bin/casperjs casperjs;
ln -s /home/admin/node/bin/node node;
ln -s /home/admin/phantomjs/bin/phantomjs phantomjs;

这样，问题就可以解决了。

5.3 如果是通过java调用shell进行打包，那么要注意路径的问题

因为shell里面tar的压缩和解压可不能直接写：

tar -zcf /home/admin/data/result.tar.gz /home/admin/data/result

直接给你报错，因为tar的压缩源必须到路径下面， 因此可以写成

tar -zcf /home/admin/data/result.tar.gz -C /home/admin/data/ result

5.4 如果我的shell是在jar包中怎么办？

答案是：解压出来。再按照上面指示进行操作。

String jarPath = findClassJarPath(ClassLoaderUtil.class);
     JarFile topLevelJarFile = null;
        try {
            topLevelJarFile = new JarFile(jarPath);
            Enumeration<JarEntry> entries = topLevelJarFile.entries();
            while (entries.hasMoreElements()) {
                JarEntry entry = entries.nextElement();
                if (!entry.isDirectory() && entry.getName().endsWith(".sh")) {
                    对你的shell文件进行处理
                }
            }

对文件处理的方法就简单了，直接touch一个临时文件，然后把数据流写入，代码：

FileUtils.touch(tempjline);
tempjline.deleteOnExit();
FileOutputStream fos = new FileOutputStream(tempjline);
IOUtils.copy(ClassLoaderUtil.class.getResourceAsStream(r), fos);
fos.close();

有这个东东，相信大家会减少踩坑，而且大胆地使用java和脚本之间的交互吧。 java可以调用shell，那么shell再调用其他就方便了。 记得一点， 不要过度地依赖缓冲区进行线程之间的通信。原因自己去学习吧。

相关文章

1. Java调用Shell命令和脚本的实现
2. java去调用并执行shell脚本以及问题总结

3. Java进程Runtime、Process、ProcessBuilder调用外部程序