webentwicklung-frage-antwort-db.com.de

Wie führe ich Linux-Befehle in Java-Code aus?

Ich möchte diff aus zwei Dateien erstellen. Ich habe versucht, in Java nach Code zu suchen, der dies tut, aber es wurde kein einfacher Code/Utility-Code gefunden. Daher dachte ich, wenn ich irgendwie den linux diff/sdiff-Befehl von meinem Java-Code ausführen und eine Datei zurückgeben könnte, in der der diff gespeichert ist, dann wäre er großartig.

Angenommen, es gibt zwei Dateien fileA und fileB. Ich sollte in der Lage sein, ihren Unterschied in einer Datei namens fileDiff durch meinen Java-Code zu speichern. Dann wäre das Abrufen von Daten aus fileDiff keine große Sache.

33
chitresh
22
mort

Sie können Java.lang.Runtime.exec verwenden, um einfachen Code auszuführen. Dadurch erhalten Sie eine Process zurück, und Sie können die Standardausgabe direkt lesen, ohne die Ausgabe vorübergehend auf der Festplatte speichern zu müssen.

Hier ist zum Beispiel ein vollständiges Programm, das zeigt, wie es geht:

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

Beim Kompilieren und Ausführen wird Folgendes ausgegeben:

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

wie erwartet.

Sie können auch den Fehlerstrom für den Prozessstandardfehler und Ausgabestrom für die Prozessstandardeingabe erhalten, verwirrend genug. In diesem Zusammenhang sind die Eingabe und die Ausgabe umgekehrt, da ihre Eingabe von des Prozesses zu diesem (d. H. Der Standard Ausgabe des Prozesses) erfolgt.

Wenn Sie die Prozessstandardausgabe und -fehler von Java zusammenführen möchten (anstatt 2>&1 im eigentlichen Befehl zu verwenden), sollten Sie in ProcessBuilder nachschlagen.

41
paxdiablo

Sie können auch eine Shell-Skriptdatei schreiben und diese Datei aus dem Java-Code aufrufen. Wie nachfolgend dargestellt

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

Schreiben Sie die Linux-Befehle in die Skriptdatei. Sobald die Ausführung abgeschlossen ist, können Sie die Diff-Datei in Java lesen.

Der Vorteil dieses Ansatzes ist, dass Sie die Befehle ändern können, ohne Java-Code zu ändern.

15
Naveen

Sie brauchen den Diff nicht in einer 3. Datei zu speichern und dann von dort aus einzulesen. Stattdessen verwenden Sie 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);
}
12
codaddict

versuchen Sie, unix4j zu verwenden. Es geht um eine Bibliothek in Java, um den Linux-Befehl auszuführen. Zum Beispiel, wenn Sie einen Befehl wie: cat test.txt | grep "Tuesday" | sed "s/Kilogramm/kg/g" | sort in diesem Programm wird zu: Unix4j.cat ("test.txt"). grep ("Tuesday"). sed ("s/kilogramm/kg/g"). sort ();

5
b10n1k
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();
}  
5
YoK

Sie können Laufzeitbefehle von Java aus für Windows und Linux aufrufen.

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

Ich hoffe es hilft.. :)

2
Sarat Chandra

Die vorgeschlagenen Lösungen können mithilfe von commons.io, der Behandlung des Fehlerstroms und der Verwendung von Ausnahmen optimiert werden. Ich würde vorschlagen, so umzuschließen, um in Java 8 oder höher verwendet zu werden:

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

}
1
Martin

wenn die Öffnung in Fenstern

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

Java-Funktion für Linux-Befehlsergebnis!

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;
}
0
Kailas Kakade