通过Java执行系统命令,与cmd中或者终端上一样执行shell命令一样。
最典型的用法:
1、Runtime.getRuntime().exec();会在给定的环境和工作目录下启动一个独立的进程运行外部命令。
2、new ProcessBuilder(cmdArray).start();
从JDK1.5开始,官方提供并推荐使用ProcessBuilder类进行shell命令操作。
首先介绍Runtime类提供了如下方法:
public long totalMemory();//返回所有可用内存空间
public long maxMemory();//返回最大可用内存空间
public long freeMemory();//返回空余内存空间
public void gc();(如果内存东西过大)手动实现JVM的gc机制。
public Process exec(String command)throws IOException//执行外部命令
Runtime.getRuntime().availableProcessors();//返回jvm可用的处理器数量
Runtime常见的几个重写的参数方法:
public Process exec(String command) throws IOException
public Process exec(String cmdarray[]) throws IOException
public Process exec(String command, String[] envp) throws IOException
public Process exec(String command, String[] envp, File dir) throws IOException
public Process exec(String[] cmdarray, String[] envp) throws IOException
public Process exec(String[] cmdarray, String[] envp, File dir) throws IOException
对上面进行解释:
1、command:一个命令,可能包含参数和命令
2、envp:环境变量的设置;格式(name=value,name=null),null表示子进程继承当前的运行时的环境。
3、dir:子进程工作目录,null表示继承当前进程的工作目录
4、cmdarray:包含多个命令的数组,可以是命令也可以是参数
简单实现:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.junit.Test;
public class Demo {
@Test
public void testName() throws Exception {
// 调用命令
Runtime runtime = Runtime.getRuntime();
Process process = null;
try{
process = runtime.exec("javac"); // 用法1:调用一个外部程序
// process = runtime.exec("cmd /c dir"); // 用法2:调用一个指令(可包含参数)
// process = runtime.exec("cmd /c test.bat", null, new File("D:\\test.test.bat")); // 用法3:调用一个.bat文件或者exe文件
// 存放要输出的行数据
String line = null;
// 输出返回的报错信息
System.out.println("=================ErrorStream===================");
BufferedReader inErr = new BufferedReader(new InputStreamReader(process.getErrorStream()));
while ((line = inErr.readLine()) != null) {
System.out.println(line);
}
// 输出正常的返回信息
System.out.println("=================InputStream===================");
BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream()));
while ((line = in.readLine()) != null) {
System.out.println(line);
}
// 获取退出码
int exitVal = process.waitFor(); // 等待进程运行结束
//如果返回0表示执行成功,返回1表示在还行失败
System.out.println("exitVal = " + exitVal);
} catch (Exception e) {
e.printStackTrace();
}finally{
if (process != null) {
process.destroy();
}
}
}
}
使用Process.waitFor()
和Process.exitValue()的区别:
Process.waitFor()
与Process.exitValue()
同样会返回外部程序的执行结果,但是exitValue()
会阻塞直到外部程序运行结束。
指令介绍:
cmd /c dir 是执行完dir命令后关闭命令窗口。
cmd /k dir 是执行完dir命令后不关闭命令窗口。
cmd /c start dir 会打开一个新窗口后执行dir指令,原窗口会关闭。
cmd /k start dir 会打开一个新窗口后执行dir指令,原窗口不会关闭。
Runtime.exec()
不是一个命令行工具:相对于系统命令行工具,Runtime.exec(..)
会更加局限并且不具备跨平台功能,命令行能接收的任意字符串,Runtime.exec(..)
并不一定能接收。这个陷阱通常出现在Runtime.exec(String)
这个接收单个字符串执行外部命令的方法中。造成这个混乱的原因之一在于Runtime.exec(String)
将传递的字符串作为外部命令的参数,而命令行中可以区分一个字符串中的多个命令。
如何解决?
就是把jechoHTT类里面输出的内容,保存到test.txt
public class CommandLineExec {
public static void main(String[] args) throws IOException, InterruptedException {
FileOutputStream fos = new FileOutputStream("test.txt");
Process pid = Runtime.getRuntime().exec("java Test$jechoHTT");
new Thread(new OutputHandlerRunnable(pid.getInputStream(), fos)).start();
new Thread(new OutputHandlerRunnable(pid.getErrorStream())).start();
int exitValue = pid.waitFor();
System.out.println("Process exitValue: " + exitValue);
fos.flush();
fos.close();
}
private static class OutputHandlerRunnable implements Runnable {
private InputStream in;
private OutputStream os;
public OutputHandlerRunnable(InputStream in) {
this.in = in;
}
// add redirect
public OutputHandlerRunnable(InputStream in, OutputStream redirect) {
this(in);
this.os = redirect;
}
@Override
public void run() {
try (BufferedReader bufr = new BufferedReader(new InputStreamReader(this.in))) {
PrintWriter pw = null;
if (this.os != null) {
pw = new PrintWriter(this.os);
}
String line = null;
while ((line = bufr.readLine()) != null) {
System.out.println(line);
if (pw != null) {
// redirect
pw.println(line);
}
}
if (pw != null) {
pw.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static class jechoHTT {
public static void main(String[] args) {
System.out.println("Hello World!!!");
}
}
}
我们在介绍一下ProcessBuilder这个方法执行外部命令:
优点:配置环境变量时更优雅、对当前目录的控制也更合理、错误流重定向特别方便 、进程控制更简洁。
ProcessBuilder基本方法介绍:
构造方法摘要
ProcessBuilder(List<String> command)
利用指定的操作系统程序和参数构造一个进程生成器。
ProcessBuilder(String... command)
利用指定的操作系统程序和参数构造一个进程生成器。
方法摘要
command()
返回此进程生成器的操作系统程序和参数。
command(List<String> command)
设置此进程生成器的操作系统程序和参数。
command(String... command)
设置此进程生成器的操作系统程序和参数。
directory()
返回此进程生成器的工作目录。
directory(File directory)
设置此进程生成器的工作目录。
environment()
返回此进程生成器环境的字符串映射视图。
redirectErrorStream()
通知进程生成器是否合并标准错误和标准输出。
redirectErrorStream(boolean redirectErrorStream)
设置此进程生成器的 redirectErrorStream 属性。
start()
使用此进程生成器的属性启动一个新进程。
基本用法:
public class ProcessTool {
public static void main(String[] args) throws IOException {
execWindowCmd();
}
public static void execWindowCmd() throws IOException {
ProcessBuilder pb = new ProcessBuilder();// 命令
Map<String, String> env = pb.environment();// 独立环境变量
System.out.println(env);// 打印环境变量
env.put("MY_NAME", "KING");// 添加环境变量key-value
pb.redirectErrorStream(true);// 重定向错误输出流到正常输出流
try {
pb.directory(new File("d://test1"));// 设置目录test1
pb.command("cmd", "/c", "dir");// 执行命令
Process process1;
process1 = pb.start();// 启动进程
BufferedReader br1;
br1 = new BufferedReader(new InputStreamReader(process1.getInputStream(), "gbk"));
String line1 = null;
while ((line1 = br1.readLine()) != null) {
System.out.println(line1);
}
pb.directory(new File("d://test2"));// 设置目录test2
pb.command("cmd", "/c", "dir", ">>", "test1.log");// 执行命令,把结果输出到test1.log
Process process2 = pb.start();// 启动进程
BufferedReader br2 = new BufferedReader(new InputStreamReader(process2.getInputStream(), "gbk"));
String line2 = null;
while ((line2 = br2.readLine()) != null) {//因为结果输出到了文件,所以本处无信息返回
System.out.println(line2);
}
} catch (IOException e) {
e.printStackTrace();
throw e;
}
}
}
ProcessBuilder和Process的区别:
1、ProcessBuilder为进程提供了更多的控制,而Process的功能相对来说简单的多
2、ProcessBuilder是一个final类,有两个带参数的构造方法,你可以通过构造方法来直接创建ProcessBuilder的对象。而Process是一个抽象类,一般都通过Runtime.exec()和ProcessBuilder.start()来间接创建其实例。
ProcessBuilder的api:
内部类
方法 | 描述 |
---|---|
static class ProcessBuilder.Redirect | 表示子进程的输入源或者输出的目的 |
构造器
方法 | 描述 |
---|---|
ProcessBuilder (String... command) | 使用操作系统程序 和参数创建一个进程生成器 |
ProcessBuilder (List<String> command) | 使用操作系统程序和参数创建一个进程生成器 |
方法
取出或设置程序和参数的方法
方法 | 描述 |
---|---|
List<String> command() | 返回操作系统程序和该程序的参数。 |
ProcessBuilder command(List<String> command) | 设置这个进程生成器的 操作系统程序 和 参数。 |
ProcessBuilder command(String... command) | 置这个进程生成器的 操作系统程序 和 参数。 |
取出或设置工作目录的方法
方法 | 描述 |
---|---|
File directory() | 返回此进程生成器的工作目录。 |
ProcessBuilder directory(File directory) | 设置进程生成器的工作目录。 |
设置标准 IO 的方法
方法 | 描述 |
---|---|
ProcessBuilder redirectOutput(File file) | 使用文件作为标准输出 |
ProcessBuilder redirectOutput(ProcessBuilder.Redirect destination) | 使用 Redirect 对象作为标准输出 |
ProcessBuilder redirectInput(File file) | 重定向标准输入到文件中 |
ProcessBuilder redirectInput(ProcessBuilder.Redirect source) | 重定向标准输入 |
ProcessBuilder redirectError(File file) | 将标出错误输出设置到文件中 |
ProcessBuilder redirectError(ProcessBuilder.Redirect destination) | 设置标准错误输出的目标 |
取出标准 IO 的方法
方法 | 描述 |
---|---|
ProcessBuilder.Redirect redirectInput() | 返回表示标准输入 的 Redirect 实例 |
ProcessBuilder.Redirect redirectError() | 返回表示标准错误输出 的 Redirect 实例 |
ProcessBuilder.Redirect redirectOutput() | 返回表示标出输出 的目标的 Redirect 实例 |
合并标准输出相关的方法
方法 | 描述 |
---|---|
ProcessBuilder inheritIO() | 子进程和父进程使用相同的标准输入,标准输出,标准错误输出 |
ProcessBuilder redirectErrorStream(boolean redirectErrorStream) | 设置 redirectErrorStream 属性 |
boolean redirectErrorStream() | 判断进程生成器是否合并了标准错误输出和标准输出。 |
其他方法
方法 | 描述 |
---|---|
Map<String,String> environment() | 返回保存进程生成器的环境变量的 Map 集合 |
启动进程方法
方法 | 描述 |
---|---|
Process start() | 使用进程生成器中设置的属性启动新一个新的进程 |
Process 类 API 整理
杀死子进程
方法 | 描述 |
---|---|
abstract void destroy() | 杀死子流程 |
Process destroyForcibly() | 杀死子流程 |
获取子进程的 IO
方法 | 描述 |
---|---|
abstract InputStream getErrorStream() | 返回连接到子进程的错误输出的输入流 |
abstract InputStream getInputStream() | 返回连接到子进程的正常输出的输入流. |
abstract OutputStream getOutputStream() | 返回连接到子进程的正常输入的输出流 |
其他方法
方法 | 描述 |
---|---|
abstract int exitValue() | 返回子进程的退出值 |
boolean isAlive() | 测试子流程是否有效 |
等待子进程
方法 | 描述 |
---|---|
abstract int waitFor() | 使当前线程等待 Process 对象表示的进程终止 |
boolean waitFor(long timeout, TimeUnit unit) | 使当前线程在必要时等待,直到此 Process 对象代表的子进程终止或经过指定的等待时间为止。 |
以上内容均来自网上参考整理。