文档章节

java中调用shell脚本的方法总结

双月通天
 双月通天
发布于 2016/03/22 16:00
字数 2425
阅读 1594
收藏 4

        从事java开发已经有了大半年的时间,一直没有在java里面调用shell脚本,以前在c语言里面用过system、popen或者execl等函数来调用过shell脚本,感觉非常好用,其实java里面也可以调用shell脚本,用两种调用shell脚本的方法。     

1.使用ProcessBuilder

ProcessBuilder pb=new ProcessBuilder(cmd);
pb.start();

代码如下:

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

public class JavaShellUtil1 {
    public static void main(String[] args) {
         ProcessBuilder builder=new ProcessBuilder("/bin/sh","-c","/home/songjy.sh a b >/home/songjy.log 2>&1");
         builder.directory(new File("/home/"));
         int runningStatus = 0;
         String s = null;
    
         try {
            Process pro=builder.start();
            System.out.println("the shell script running");
            try {
                runningStatus=pro.waitFor();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
        if(runningStatus!=0){
            System.out.println("脚本执行失败");
        }else{
            System.out.println("脚本执行成功");
        }
    
        System.out.println("11111111111");
    }
}

但是这个两种方法都有个问题,执行诸如

:ps -ef | grep -v grep或者 /home/songjy.sh a b >/home/songjy.log 2>&1"

 带有管道或重定向的命令就会出错。我们都知道使用以上两种方法执行命令时,如果带有参数就要把命令分割成数组或者List传入,不然会被当成一个整体执行(会出错,比如执行"ps -e")。对于|,<,>号来说,这样做也不行。对于Linux系统,解决方法就是把整个命令都当成sh的参数传入,用sh来执行命令。

ProcessBuilder builder=new ProcessBuilder("/bin/sh","-c","/home/songjy.sh a b >/home/songjy.log 2>&1");

Windows下把sh换成cmd.exe就行了。

       这儿其实还做了另外的一个处理,就是将标准输入和标准出错打印重定向到日志里面,就要就不用用pid.getInputStream 和pid.getErrorStream 去将其读出来了(防止会一直阻塞,java一直等待shell的返回 

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

2.使用Runtime

Runtime.getRuntime().exec(cmd)

import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
 
//http://kongcodecenter.iteye.com/blog/1231177
//参考http://siye1982.iteye.com/blog/592405
//参考http://blog.csdn.net/christophe2008/article/details/6046456
public class JavaShellUtil {
    // 基本路径
    private static final String basePath = "/home/";
 
    // 记录Shell执行状况的日志文件的位置(绝对路径)
    private static final String executeShellLogFile = basePath
            + "executeShell.log";
 
    // 发送文件到Kondor系统的Shell的文件名(绝对路径)
    private static final String sendKondorShellName = basePath
            + "songjy.sh";
 
    public int executeShell(String shellCommand) throws IOException {
        System.out.println("shellCommand:"+shellCommand);
        int success = 0;
        StringBuffer stringBuffer = new StringBuffer();
        BufferedReader bufferedReader = null;
BufferedReader stdError=null;
        // 格式化日期时间,记录日志时使用
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:SS ");
 
        try {
            stringBuffer.append(dateFormat.format(new Date()))
                    .append("准备执行Shell命令 ").append(shellCommand)
                    .append(" \r\n");
            
            Process pid = null;
            String[] cmd = { "/bin/sh", "-c", shellCommand };
            // 执行Shell命令
            pid = Runtime.getRuntime().exec(cmd);
            if (pid != null) {
                stringBuffer.append("进程号:").append(pid.toString())
                        .append("\r\n");
                
                // bufferedReader用于读取Shell的输出内容
                bufferedReader = new BufferedReader(new InputStreamReader(pid.getInputStream()));
//读到标准出错的信息
stdError = new BufferedReader(new InputStreamReader(pid.getErrorStream()));
//这个是或得脚本执行的返回值
                int status=pid.waitFor();
                
                
//如果脚本执行的返回值不是0,则表示脚本执行失败,否则(值为0)脚本执行成功。
                if(status!=0)
                 {
                    stringBuffer.append("shell脚本执行失败!");
                 } else{
                    stringBuffer.append("shell脚本执行成功!");
                }
            } else {
                stringBuffer.append("没有pid\r\n");
            }
            stringBuffer.append(dateFormat.format(new Date())).append(
                    "Shell命令执行完毕\r\n执行结果为:\r\n");
            
            //将标准输入流上面的内容写到stringBuffer里面
            String line = null;
            // 读取Shell的输出内容,并添加到stringBuffer中
            while (bufferedReader != null
                    && (line = bufferedReader.readLine()) != null) {
                stringBuffer.append(line).append("\r\n");
            }
            
            //将标准输入流上面的内容写到stringBuffer里面
String line1 = null;
while(stdError !=null &&(line1 = stdError.readLine()) != null){
stringBuffer.append(line1).append("\r\n");
}
            System.out.println("stringBuffer:"+stringBuffer);
        } catch (Exception ioe) {
            stringBuffer.append("执行Shell命令时发生异常:\r\n").append(ioe.getMessage())
                    .append("\r\n");
        } finally {
            if (bufferedReader != null) {
                OutputStreamWriter outputStreamWriter = null;
                try {
                    bufferedReader.close();
                    // 将Shell的执行情况输出到日志文件中
                    OutputStream outputStream = new FileOutputStream(executeShellLogFile);
                    outputStreamWriter = new OutputStreamWriter(outputStream, "UTF-8");
                    outputStreamWriter.write(stringBuffer.toString());
                    System.out.println("stringBuffer.toString():"+stringBuffer.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    outputStreamWriter.close();
                }
            }
            success = 1;
        }
        return success;
    }
 
    public static void main(String[] args) {
        try {
            new JavaShellUtil().executeShell(sendKondorShellName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

       这个里面就是用pid.getInputStream 和pid.getErrorStream  去读缓冲区的。

3.由此可以总结出java里面创建进程的两种方法       

在Java中,可以通过两种方式来创建进程,总共涉及到5个主要的类。

  第一种方式是通过Runtime.exec()方法来创建一个进程,第二种方法是通过ProcessBuilder的start方法来创建进程。下面就来讲一讲这2种方式的区别和联系。

  首先要讲的是Process类,Process类是一个抽象类,在它里面主要有几个抽象的方法,这个可以通过查看Process类的源代码得知:

  位于java.lang.Process路径下:

public abstract class Process
{
    
    abstract public OutputStream getOutputStream();   //获取进程的输出流
      
    abstract public InputStream getInputStream();    //获取进程的输入流
 
    abstract public InputStream getErrorStream();   //获取进程的错误流
 
    abstract public int waitFor() throws InterruptedException;   //让进程等待
  
    abstract public int exitValue();   //获取进程的退出标志
 
    abstract public void destroy();   //摧毁进程
}

1)通过ProcessBuilder创建进程

  ProcessBuilder是一个final类,它有两个构造器:

public final class ProcessBuilder
{
    private List<String> command;
    private File directory;
    private Map<String,String> environment;
    private boolean redirectErrorStream;
 
    public ProcessBuilder(List<String> command) {
    if (command == null)
        throw new NullPointerException();
    this.command = command;
    }
 
    public ProcessBuilder(String... command) {
    this.command = new ArrayList<String>(command.length);
    for (String arg : command)
        this.command.add(arg);
    }
....
}

构造器中传递的是需要创建的进程的命令参数,第一个构造器是将命令参数放进List当中传进去,第二构造器是以不定长字符串的形式传进去。

  那么我们接着往下看,前面提到是通过ProcessBuilder的start方法来创建一个新进程的,我们看一下start方法中具体做了哪些事情。下面是start方法的具体实现源代码:

public Process start() throws IOException {
  // Must convert to array first -- a malicious user-supplied
  // list might try to circumvent the security check.
  String[] cmdarray = command.toArray(new String[command.size()]);
  for (String arg : cmdarray)
    if (arg == null)
    throw new NullPointerException();
  // Throws IndexOutOfBoundsException if command is empty
   String prog = cmdarray[0];
 
  SecurityManager security = System.getSecurityManager();
  if (security != null)
     security.checkExec(prog);
 
  String dir = directory == null ? null : directory.toString();
 
  try {
    return ProcessImpl.start(cmdarray,
                 environment,
                 dir,
                 redirectErrorStream);
  } catch (IOException e) {
     // It's much easier for us to create a high-quality error
     // message than the low-level C code which found the problem.
     throw new IOException(
    "Cannot run program \"" + prog + "\""
     + (dir == null ? "" : " (in directory \"" + dir + "\")")
     + ": " + e.getMessage(),
     e);
 }
}

    该方法返回一个Process对象,该方法的前面部分相当于是根据命令参数以及设置的工作目录进行一些参数设定,最重要的是try语句块里面的一句:

return ProcessImpl.start(cmdarray,
                    environment,
                    dir,
                    redirectErrorStream);

    说明真正创建进程的是这一句,注意调用的是ProcessImpl类的start方法,此处可以知道start必然是一个静态方法。那么ProcessImpl又是什么类呢?该类同样位于java.lang.ProcessImpl路径下,看一下该类的具体实现:


ProcessImpl也是一个final类,它继承了Process类:

final class ProcessImpl extends Process {
 
    // System-dependent portion of ProcessBuilder.start()
    static Process start(String cmdarray[],
             java.util.Map<String,String> environment,
             String dir,
             boolean redirectErrorStream)
    throws IOException
    {
        String envblock = ProcessEnvironment.toEnvironmentBlock(environment);
        return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);
    }
 ....
}

   这是ProcessImpl类的start方法的具体实现,而事实上start方法中是通过这句来创建一个ProcessImpl对象的:

return new ProcessImpl(cmdarray, envblock, dir, redirectErrorStream);

   而在ProcessImpl中对Process类中的几个抽象方法进行了具体实现。

  说明事实上通过ProcessBuilder的start方法创建的是一个ProcessImpl对象。

public class Test {
    public static void main(String[] args) throws IOException  {
        ProcessBuilder pb = new ProcessBuilder("cmd","/c","ipconfig/all");
        Process process = pb.start();
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}
 

     第一步是最关键的,就是将命令字符串传给ProcessBuilder的构造器,一般来说,是把字符串中的每个独立的命令作为一个单独的参数,不过也可以按照顺序放入List中传进去。

  至于其他很多具体的用法不在此进行赘述,比如通过ProcessBuilder的environment方法和directory(File directory)设置进程的环境变量以及工作目录等,感兴趣的朋友可以查看相关API文档。

2)通过Runtime的exec方法来创建进程

  首先还是来看一下Runtime类和exec方法的具体实现,Runtime,顾名思义,即运行时,表示当前进程所在的虚拟机实例。

  由于任何进程只会运行于一个虚拟机实例当中,所以在Runtime中采用了单例模式,即只会产生一个虚拟机实例:

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
 
    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
    return currentRuntime;
    }
 
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    ...
 }

   从这里可以看出,由于Runtime类的构造器是private的,所以只有通过getRuntime去获取Runtime的实例。接下来着重看一下exec方法 实现,在Runtime中有多个exec的不同重载实现,但真正最后执行的是这个版本的exec方法:

public Process exec(String[] cmdarray, String[] envp, File dir)
   throws IOException {
   return new ProcessBuilder(cmdarray)
       .environment(envp)
       .directory(dir)
       .start();
   }

   可以发现,事实上通过Runtime类的exec创建进程的话,最终还是通过ProcessBuilder类的start方法来创建的。

  下面看一个例子,看一下通过Runtime的exec如何创建进程,还是前面的例子,调用cmd,获取ip地址信息:

public class Test {
    public static void main(String[] args) throws IOException  {
        String cmd = "cmd "+"/c "+"ipconfig/all";
        Process process = Runtime.getRuntime().exec(cmd);
        Scanner scanner = new Scanner(process.getInputStream());
         
        while(scanner.hasNextLine()){
            System.out.println(scanner.nextLine());
        }
        scanner.close();
    }
}

要注意的是,exec方法不支持不定长参数(ProcessBuilder是支持不定长参数的),所以必须先把命令参数拼接好再传进去。

参考文章

   http://www.cnblogs.com/dolphin0520/p/3913517.html

 http://luckykapok918.blog.163.com/blog/static/205865043201210272168556/

 http://www.cnblogs.com/ChrisWang/archive/2009/12/02/use-java-lang-process-and-processbuilder-to-create-native-application-process.html

 http://lavasoft.blog.51cto.com/62575/15662/



© 著作权归作者所有

双月通天
粉丝 40
博文 280
码字总数 221441
作品 0
徐汇
程序员
私信 提问
关于 Java Scripting API 您不知道的 5 件事

现在,许多 Java 开发人员都喜欢在 Java 平台中使用脚本语言,但是使用编译到 Java 字节码中的动态语言有时是不可行的。在某些情况中,直接编写一个 Java 应用程序的脚本 部分 或者在一个脚本...

红薯
2010/09/12
495
2
spark程序中调用shell脚本

scala直接调用shell脚本是不行的,但是可以利用java调用shell脚本然后在spark代码中引入java代码实现。 参考:java代码调用shell脚本 shell脚本必须在spark的driver端调用,在worker端只能处...

神秘的寇先森
02/27
0
0
Jmeter之Bean shell使用

 上一篇简单介绍了下Jmeter中的Bean shell,本文是对上文的一个补充,主要总结下常用的几种场景和方法,相信这些基本可以涵盖大部分的需求。本节内容如下: 一、操作变量 二、操作属性 三、...

覃光林
2018/05/10
0
0
通过Shell脚本用JDBC连数据库脱离项目框架执行Java业务流程

一.概述 如果项目中需要使用到定时任务来完成某些业务,一般有两种做法:定时任务依赖于项目;定时任务用批处理(windows执行)或者shell脚本(Linux)启动,不依赖于项目。 个人觉得,定时任...

谢思华
2015/08/10
0
0
java里执行linux命令,关于死锁的问题

最近在用Java调用ffmpeg的命令,所以记录下踩到的坑 如果要在Java中调用shell脚本时,可以使用Runtime.exec或ProcessBuilder.start。它们都会返回一个Process对象,通过这个Process可以对获取...

TonyStarkSir
2018/07/28
0
0

没有更多内容

加载失败,请刷新页面

加载更多

GitLab Auto DevOps功能与Kubernetes集成教程

介 绍 在这篇文章中,我们将介绍如何将GitLab的Auto DevOps功能与Rancher管理的Kubernetes集群连接起来,利用Rancher v2.2.0中引入的授权集群端点的功能。通过本文,你将能全面了解GitLab如何...

RancherLabs
12分钟前
3
0
基本类型 引用类型的问题

用concat()拷贝了个数组 ,原数组包含了引用类型, tempAee === this.dynacArr[0][this.dynacArr[1]][0] //false 虽然拷贝了个数组 , tempAee[0] === this.dynacArr[0][this.dynacArr[1]][......

东东笔记
13分钟前
1
0
Linux下Java运行.class文件,报错找不到或无法加载主类

Linux下Java运行.class文件,报错找不到或无法加载主类 classpath配置的错误,所以找不到.class文件。 原先的etc/profile中的classpath配置 export CLASSPATH=$JAVA_HOME/lib/tools.jar 更改...

Mr_Tea伯奕
24分钟前
1
0
vue 日期计算

搞开发少不了对时间进行加减操作,尤其是前端对日期操作不能单纯的加减,不然31+1 变成32号就扯了。比如推算前几分钟、后几分钟,,前几天、后几天,前几月、后几月等等相关操作。 百度找半天...

朝如青丝暮成雪
36分钟前
1
0
非递归实现后序遍历二叉树

问题描述 从键盘接受输入先序序列,以二叉链表作为存储结构,建立二叉树(以先序来建立)并对其进行后序遍历,然后将遍历结果打印输出。要求采用非递归方法实现。 解题思路 Push根结点到第一...

niithub
49分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部