java执行linux系统命令 • Worktile社区

fiy

Worktile&PingCode市场小伙伴

在Java中执行Linux系统命令有多种方式，可以使用Runtime类的exec方法、ProcessBuilder类、或者使用第三方库如Apache Commons Exec。下面分别介绍这些方法的使用。

1. 使用Runtime类的exec方法：
“`java
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class ExecuteCommand {
public static void main(String[] args) {
try {
String command = “ls -l”; // 要执行的命令
Process process = Runtime.getRuntime().exec(command);

BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}

int exitValue = process.waitFor();
System.out.println(“命令执行结果：” + exitValue);

process.destroy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`
上述代码使用Runtime类的exec方法执行了一个简单的命令”ls -l”，并将结果输出到控制台。需要注意的是，exec方法返回的是一个Process对象，可以通过该对象获取命令的执行结果和错误信息。

2. 使用ProcessBuilder类：
“`java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.List;

public class ExecuteCommand {
public static void main(String[] args) {
try {
List command = List.of(“ls”, “-l”); // 要执行的命令及参数
ProcessBuilder processBuilder = new ProcessBuilder(command);

Process process = processBuilder.start();

BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}

int exitValue = process.waitFor();
System.out.println(“命令执行结果：” + exitValue);
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`
上述代码使用ProcessBuilder类来构造命令及参数，然后通过start方法启动进程并执行命令。同样地，可以通过Process对象获取命令的执行结果和错误信息。

3. 使用Apache Commons Exec库：
“`java
import java.io.IOException;
import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecuteResultHandler;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.ExecuteException;
import org.apache.commons.exec.ExecuteStreamHandler;
import org.apache.commons.exec.PumpStreamHandler;

public class ExecuteCommand {
public static void main(String[] args) {
try {
String command = “ls -l”; // 要执行的命令
CommandLine commandLine = CommandLine.parse(command);
DefaultExecutor executor = new DefaultExecutor();

ExecuteStreamHandler streamHandler = new PumpStreamHandler(System.out);
executor.setStreamHandler(streamHandler);

DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
executor.execute(commandLine, resultHandler);

resultHandler.waitFor();
int exitValue = resultHandler.getExitValue();
System.out.println(“命令执行结果：” + exitValue);
} catch (IOException | InterruptedException | ExecuteException e) {
e.printStackTrace();
}
}
}
“`
上述代码使用Apache Commons Exec库来执行命令。通过CommandLine类构造命令，并使用DefaultExecutor类来执行命令。使用PumpStreamHandler将命令的输出重定向到System.out输出流。使用DefaultExecuteResultHandler类来异步处理命令的执行结果。

通过以上三种方法，你可以在Java中执行Linux系统命令，并获取执行结果。根据具体需求选择合适的方法来执行命令。

2年前 0条评论

worktile

Worktile官方账号

Java可以通过执行linux系统命令来与操作系统进行交互。下面是使用Java执行linux系统命令的一些常用方法：

1. 使用Runtime类的exec()方法
Runtime类提供了一个静态方法exec()，可以用来执行系统命令。下面是一个简单的示例：

“`java
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;

public class ExecuteCommand {
public static void main(String[] args) {
try {
String command = “ls -l”; // 要执行的系统命令
Process process = Runtime.getRuntime().exec(command); // 执行系统命令
InputStream inputStream = process.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line); // 输出命令执行结果
}
bufferedReader.close();
process.waitFor(); // 等待命令执行完成
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`

2. 使用ProcessBuilder类
ProcessBuilder类是一个用于创建进程的辅助类，它提供了更多的控制选项。下面是一个使用ProcessBuilder类执行系统命令的示例：

“`java
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.List;

public class ExecuteCommand {
public static void main(String[] args) {
try {
List command = List.of(“ls”, “-l”); // 要执行的系统命令，将命令及参数放入列表
ProcessBuilder processBuilder = new ProcessBuilder(command);
Process process = processBuilder.start(); // 执行系统命令
InputStream inputStream = process.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line); // 输出命令执行结果
}
bufferedReader.close();
process.waitFor(); // 等待命令执行完成
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`

3. 使用Apache Commons Exec库
Apache Commons Exec是一个开源库，提供了更高级别的执行系统命令的功能，比如管道、重定向等。需要添加commons-exec依赖后可以使用。下面是一个使用Apache Commons Exec库执行系统命令的示例：

“`java
import org.apache.commons.exec.*;

public class ExecuteCommand {
public static void main(String[] args) {
try {
CommandLine commandLine = new CommandLine(“ls”);
commandLine.addArgument(“-l”); // 添加命令参数
DefaultExecutor executor = new DefaultExecutor();
executor.setExitValue(0);
int exitValue = executor.execute(commandLine); // 执行系统命令
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`

4. 使用JSch库
如果需要在远程服务器上执行linux系统命令，可以使用JSch库。JSch是一个Java实现的SSH2协议的库，可以用于连接远程服务器并执行命令。需要导入jsch依赖后可以使用。下面是一个使用JSch库连接远程服务器并执行系统命令的示例：

“`java
import com.jcraft.jsch.*;

public class ExecuteCommand {
public static void main(String[] args) {
try {
JSch jSch = new JSch();
Session session = jSch.getSession(“username”, “hostname”, 22); // 连接远程服务器
session.setPassword(“password”); // 设置密码
session.setConfig(“StrictHostKeyChecking”, “no”);
session.connect();
ChannelExec channel = (ChannelExec) session.openChannel(“exec”);
channel.setCommand(“ls -l”); // 要执行的系统命令
channel.connect();
InputStream inputStream = channel.getInputStream();
byte[] buffer = new byte[1024];
StringBuilder result = new StringBuilder();
while (inputStream.read(buffer) != -1) {
result.append(new String(buffer));
}
System.out.println(result.toString()); // 输出命令执行结果
channel.disconnect();
session.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`

5. 使用Java的Process类
Java的Process类提供了执行系统命令的功能。可以通过获取Process的输出流来获取命令执行结果。下面是一个使用Process类执行系统命令的示例：

“`java
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.Process;

public class ExecuteCommand {
public static void main(String[] args) {
try {
ProcessBuilder processBuilder = new ProcessBuilder(“ls”, “-l”); // 要执行的系统命令
Process process = processBuilder.start();
InputStream inputStream = process.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line); // 输出命令执行结果
}
bufferedReader.close();
process.waitFor(); // 等待命令执行完成
} catch (Exception e) {
e.printStackTrace();
}
}
}
“`

以上是使用Java执行linux系统命令的一些常用方法。根据实际需求选择合适的方法来执行系统命令。需要注意的是，在执行系统命令时应该避免使用不信任的用户输入，以防止命令注入攻击。

2年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

要在Java中执行Linux系统命令，可以使用Java的Runtime类或ProcessBuilder类。

1. 使用Runtime类执行命令：

首先，使用Runtime.getRuntime()方法获取Runtime对象。

接下来，可以使用exec()方法来执行命令。exec()方法有多种重载形式，其中一种形式可以直接传入一个命令字符串。

“`java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class ExecuteLinuxCommand {
public static void main(String[] args) {
try {
// 获取Runtime对象
Runtime runtime = Runtime.getRuntime();

// 执行命令
Process process = runtime.exec(“ls -l”);

// 获取命令输出流
InputStream inputStream = process.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

// 读取输出结果
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}

// 关闭流
bufferedReader.close();
inputStream.close();

// 等待命令执行完成
int exitCode = process.waitFor();
System.out.println(“Exit Code: ” + exitCode);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
“`

上述代码使用Runtime.getRuntime().exec(“ls -l”)命令执行了一个Linux的ls命令，并将结果输出到控制台。在读取命令输出流之前，需要等待命令执行完成，可以使用waitFor()方法来等待命令执行完成，并获取命令的退出码。

2. 使用ProcessBuilder类执行命令：

与使用Runtime类不同，ProcessBuilder类提供了更灵活的方式来执行命令。

“`java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class ExecuteLinuxCommand {
public static void main(String[] args) {
try {
// 创建ProcessBuilder对象
ProcessBuilder processBuilder = new ProcessBuilder(“ls”, “-l”);

// 设置命令执行目录
processBuilder.directory(new File(“/path/to/directory”));

// 启动命令
Process process = processBuilder.start();

// 获取命令输出流
InputStream inputStream = process.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

// 读取输出结果
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}

// 关闭流
bufferedReader.close();
inputStream.close();

// 等待命令执行完成
int exitCode = process.waitFor();
System.out.println(“Exit Code: ” + exitCode);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
“`

上述代码使用ProcessBuilder类创建一个命令，设置了命令执行的目录，并使用start()方法来启动命令。其他部分与使用Runtime类相似。

无论是使用Runtime类还是ProcessBuilder类来执行Linux系统命令，都需要注意以下几点：
– 命令的参数需要按照正确的格式提供。
– 如果需要获取命令的输出结果，需要及时读取命令输出流，否则可能会导致阻塞或死锁。
– 程序需要等待命令执行完成后，再进行后续操作。
– 需要处理可能抛出的异常，如IOException和InterruptedException等。

2年前 0条评论