Comment exécuter les commandes linux en code Java?
Je veux créer diff de deux fichiers. J'ai essayé de chercher du code dans Java qui le fait, mais je n'ai trouvé aucun code/code utilitaire simple pour cela. Par conséquent, j'ai pensé que si je pouvais en quelque sorte exécuter la commande linux diff/sdiff à partir de mon code Java et lui faire renvoyer un fichier qui stocke le diff, alors ce serait génial.
Supposons qu'il existe deux fichiers fichierA et fichierB. Je devrais pouvoir stocker leurs diff dans un fichier appelé fileDiff via mon code Java. Puis récupérer les données de fileDiff ne serait pas grave.
Regardez la méthode Runtime.exec (): http://docs.Oracle.com/javase/7/docs/api/Java/lang/Runtime.html#exec(Java.lang.String )
Vous pouvez utiliser Java.lang.Runtime.exec pour exécuter un code simple. Cela vous restitue une 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 montrera comment 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) {}
}
}
Une fois compilé et exécuté, il génère:
line: ./
line: ../
line: .classpath*
line: .project*
line: bin/
line: src/
exit: 0
comme prévu.
Vous pouvez également obtenir le flux error pour l'erreur standard de processus et le flux de sortie pour l'entrée standard de processus, ce qui prête à confusion. Dans ce contexte, l’entrée et la sortie sont inversées car il s’agit de l’entrée de le processus à celui-ci (c’est-à-dire la norme sortie du processus).
Si vous souhaitez fusionner la sortie standard du processus et l'erreur de Java (par opposition à l'utilisation de 2>&1 dans la commande réelle), vous devez rechercher dans ProcessBuilder .
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();
}
Écrivez les commandes linux dans le fichier de script. Une fois l'exécution terminée, vous pourrez lire le fichier diff en Java.
L'avantage de cette approche est que vous pouvez modifier les commandes sans changer de code Java.
Vous n'avez pas besoin de stocker le diff dans un 3ème fichier et de le lire ensuite. Vous utilisez plutôt le 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);
}
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 du type: cat test.txt | grep "mardi" | sed "s/kilogramme/kg/g" | Dans ce programme, trier .__ deviendra: Unix4j.cat ("test.txt"). grep ("mardi"). sed ("s/kilogramme/kg/g").
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();
}
Vous pouvez appeler des commandes d'exécution à partir de Java pour 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();
}
}
}
J'espère que ça aide.. :)
Les solutions suggérées pourraient être optimisées à l'aide de commons.io, en gérant le flux d'erreur et en utilisant des exceptions. Je suggérerais d’encapsuler comme ceci pour une utilisation dans Java 8 ou une 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);
}
}
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);
}
}
Fonction Java apportant le résultat de la commande Linux!
public String RunLinuxCommand(String cmd) throws IOException {
String linuxCommandResult = "";
Process p = Runtime.getRuntime().exec(cmd);
BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
try {
while ((linuxCommandResult = stdInput.readLine()) != null) {
return linuxCommandResult;
}
while ((linuxCommandResult = stdError.readLine()) != null) {
return "";
}
} catch (Exception e) {
return "";
}
return linuxCommandResult;
}