从事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 command;
private File directory;
private Map environment;
private boolean redirectErrorStream;
public ProcessBuilder(List command) {
if (command == null)
throw new NullPointerException();
this.command = command;
}
public ProcessBuilder(String... command) {
this.command = new ArrayList(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 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对象。
第一步是最关键的，就是将命令字符串传给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 Runtime are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the Runtime 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是支持不定长参数的)，所以必须先把命令参数拼接好再传进去。
参考文章