Comment faire pour exécuter les commandes linux dans le code java?

Question

Je veux créer diff de deux fichiers. J'ai essayé de chercher du code dans Java qui le fait, mais je n'ai pas trouvé de code/code utilitaire simple pour cela. Par conséquent, je me suis dit que si je pouvais exécuter une commande linux diff/sdiff à partir de mon code java et que je retournerais un fichier qui stocke le diff, ce serait génial. Supposons qu'il existe deux fichiers fileA et fileB. Je devrais être capable de stocker leur diff dans un fichier appelé fileDiff via mon code java. Ensuite, récupérer des données à partir de fichierDiff serait pas un gros problème.

Answer 1

Jetez un oeil à la méthode Runtime.exec():. http://docs.oracle.com/javase/7/docs/api/java/lang/Runtime.html#exec(java.lang.String)

Answer 2

Vous ne devez pas stocker la diff dans un 3ème fichier, puis lu à partir de la place que vous utiliser la 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

Vous pouvez utiliser java.lang.Runtime.exec pour exécuter du code simple. Cela vous donne un Process et vous pouvez lire sa sortie standard directement sans avoir à stocker temporairement la sortie sur le disque.

Par exemple, voici un programme complet qui mettra en valeur la façon de le faire:

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) {} 
    } 
} 

fois compilé et exécuté, il affiche:

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

comme prévu.

Vous pouvez également obtenir le error stream pour l'erreur standard de processus, et output stream pour l'entrée standard de processus, assez confusingly. Dans ce contexte, l'entrée et la sortie sont inversées puisqu'il est entré du processus à celui-ci (c'est-à-dire la sortie standard du processus).

Si vous souhaitez fusionner la sortie standard du processus et l'erreur à partir de Java (par opposition à l'utilisation de 2>&1 dans la commande actuelle), vous devez rechercher 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

Vous pouvez également écrire un fichier de script shell et appeler ce fichier à partir du code Java. comme indiqué ci-dessous

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

les commandes Écrivez linux dans le fichier de script, une fois que l'exécution est terminée, vous pouvez lire le fichier diff en Java. L'avantage de cette approche est que vous pouvez changer les commandes sans changer le code java.

Answer 6

essayez d'utiliser unix4j. Il s'agit d'une bibliothèque en Java pour exécuter la commande linux. par exemple si vous avez une commande comme: cat test.txt | grep "Mardi" | sed "s/kilogramme/kg/g" | sort dans ce programme deviendra: Unix4j.cat ("test.txt"). grep ("Mardi"). sed ("s/kg/kg/g").Trier();

Answer 7

si l'ouverture dans les fenêtres

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

Vous pouvez appeler la gestion du temps des commandes à partir de Java pour les de Windows et 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(); 
      } 
    } 
} 

it helps .. :)

Answer 9

Les solutions proposées pourraient être optimisés à l'aide commons.io, la manipulation du flux d'erreur, et l'utilisation des exceptions. Je suggère d'envelopper comme celui-ci pour une utilisation en Java 8 ou version ultérieure:

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); 
    } 

}