如何在java代码中运行linux命令？

Question

我想创建两个文件的差异。我试图在Java中搜索代码，但没有找到任何简单的代码/实用程序代码。因此，我想如果我能以某种方式从我的java代码运行linux diff/sdiff命令并使其返回一个存储diff的文件，那么它将会很棒。

假设有两个文件fileA和fileB。我应该能够通过我的java代码将它们的差异存储在一个名为fileDiff的文件中。然后从fileDiff获取数据不会有什么大不了的。

Answer 1

有一个看的Runtime.exec（）方法： http://docs.oracle.com/javase/7/docs/api/java/lang/Runtime.html#exec(java.lang.String)

Answer 2

你不需要的DIFF存储在第三个文件，然后在阅读相反，您使用的Runtime.exec

Process p = Runtime.getRuntime().exec("diff fileA fileB");                                      
BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream())); 
while ((s = stdInput.readLine()) != null) { 
     System.out.println(s); 
} 

Answer 3

您可以使用java.lang.Runtime.exec来运行简单的代码。这会使您返回Process，您可以直接读取其标准输出，而无需将输出临时存储在磁盘上。

例如，这里有一个完整的程序，将展示如何做到这一点：

import java.io.BufferedReader; 
import java.io.InputStreamReader; 

public class testprog { 
    public static void main(String args[]) { 
     String s; 
     Process p; 
     try { 
      p = Runtime.getRuntime().exec("ls -aF"); 
      BufferedReader br = new BufferedReader(
       new InputStreamReader(p.getInputStream())); 
      while ((s = br.readLine()) != null) 
       System.out.println("line: " + s); 
      p.waitFor(); 
      System.out.println ("exit: " + p.exitValue()); 
      p.destroy(); 
     } catch (Exception e) {} 
    } 
} 

编译和运行之后，它输出：

line: ./ 
line: ../ 
line: .classpath* 
line: .project* 
line: bin/ 
line: src/ 
exit: 0 

预期。

您还可以获得用于过程标准错误的error stream和用于过程标准输入的output stream，足够容易混淆。在这种情况下，由于输入从过程到该过程（即过程的标准输出），所以输入和输出相反。

如果您想合并Java的进程标准输出和错误（与实际命令中使用2>&1相反），您应该查看ProcessBuilder。

Answer 4

Runtime run = Runtime.getRuntime(); 
//The best possible I found is to construct a command which you want to execute 
//as a string and use that in exec. If the batch file takes command line arguments 
//the command can be constructed a array of strings and pass the array as input to 
//the exec method. The command can also be passed externally as input to the method. 

Process p = null; 
String cmd = "ls"; 
try { 
    p = run.exec(cmd); 

    p.getErrorStream(); 
    p.waitFor(); 

} 
catch (IOException e) { 
    e.printStackTrace(); 
    System.out.println("ERROR.RUNNING.CMD"); 

}finally{ 
    p.destroy(); 
} 

Answer 5

您还可以编写一个shell脚本文件并从java代码中调用该文件。如下图所示

{ 
    Process proc = Runtime.getRuntime().exec("./your_script.sh");       
    proc.waitFor(); 
} 

在脚本文件中写入linux命令，一旦执行结束，您可以在Java中读取diff文件。

这种方法的优点是您可以更改不改变java代码的命令。

Answer 6

尝试使用unix4j。它是关于在java中运行linux命令的库。例如，如果您得到如下命令： cat test.txt | grep“星期二”| sed“s/kilogram/kg/g”|在此程序中排序 将变为： Unix4j.cat（“test.txt”）。grep（“Tuesday”）.sed（“s/kilogram/kg/g”）。分类（）;从Java

Answer 7

如果在Windows

try { 
     //chm file address 
     String chmFile = System.getProperty("user.dir") + "/chm/sample.chm"; 
     Desktop.getDesktop().open(new File(chmFile)); 
    } catch (IOException ex) { 
     Logger.getLogger(Frame.class.getName()).log(Level.SEVERE, null, ex); 
     { 
      JOptionPane.showMessageDialog(null, "Terjadi Kesalahan", "Error", JOptionPane.WARNING_MESSAGE); 
     } 
    } 

Answer 8

开放，您可以调用运行时命令两个的Windows和Linux的。

import java.io.*; 

public class Test{ 
    public static void main(String[] args) 
    { 
      try 
      { 
      Process process = Runtime.getRuntime().exec("pwd"); // for Linux 
      //Process process = Runtime.getRuntime().exec("cmd /c dir"); //for Windows 

      process.waitFor(); 
      BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); 
      String line; 
       while ((line=reader.readLine())!=null) 
       { 
       System.out.println(line); 
       } 
      }  
       catch(Exception e) 
      { 
       System.out.println(e); 
      } 
      finally 
      { 
       process.destroy(); 
      } 
    } 
} 

希望它有助于.. :)

Answer 9

建议的解决方案可以使用commons.io进行优化，处理错误流，以及使用异常。我建议在Java 8或更高版本中使用这样的包装：

public static List<String> execute(final String command) throws ExecutionFailedException, InterruptedException, IOException { 
    try { 
     return execute(command, 0, null, false); 
    } catch (ExecutionTimeoutException e) { return null; } /* Impossible case! */ 
} 

public static List<String> execute(final String command, final long timeout, final TimeUnit timeUnit) throws ExecutionFailedException, ExecutionTimeoutException, InterruptedException, IOException { 
    return execute(command, 0, null, true); 
} 

public static List<String> execute(final String command, final long timeout, final TimeUnit timeUnit, boolean destroyOnTimeout) throws ExecutionFailedException, ExecutionTimeoutException, InterruptedException, IOException { 
    Process process = new ProcessBuilder().command("bash", "-c", command).start(); 
    if(timeUnit != null) { 
     if(process.waitFor(timeout, timeUnit)) { 
      if(process.exitValue() == 0) { 
       return IOUtils.readLines(process.getInputStream(), StandardCharsets.UTF_8); 
      } else { 
       throw new ExecutionFailedException("Execution failed: " + command, process.exitValue(), IOUtils.readLines(process.getInputStream(), StandardCharsets.UTF_8)); 
      } 
     } else { 
      if(destroyOnTimeout) process.destroy(); 
      throw new ExecutionTimeoutException("Execution timed out: " + command); 
     } 
    } else { 
     if(process.waitFor() == 0) { 
      return IOUtils.readLines(process.getInputStream(), StandardCharsets.UTF_8); 
     } else { 
      throw new ExecutionFailedException("Execution failed: " + command, process.exitValue(), IOUtils.readLines(process.getInputStream(), StandardCharsets.UTF_8)); 
     } 
    } 
} 

public static class ExecutionFailedException extends Exception { 

    private static final long serialVersionUID = 1951044996696304510L; 

    private final int exitCode; 
    private final List<String> errorOutput; 

    public ExecutionFailedException(final String message, final int exitCode, final List<String> errorOutput) { 
     super(message); 
     this.exitCode = exitCode; 
     this.errorOutput = errorOutput; 
    } 

    public int getExitCode() { 
     return this.exitCode; 
    } 

    public List<String> getErrorOutput() { 
     return this.errorOutput; 
    } 

} 

public static class ExecutionTimeoutException extends Exception { 

    private static final long serialVersionUID = 4428595769718054862L; 

    public ExecutionTimeoutException(final String message) { 
     super(message); 
    } 

}