Wie führt man ein Unix-Shell-Skript aus Java-Code aus?

Question

Es ist recht einfach, einen Unix-Befehl von Java aus auszuführen.

Runtime.getRuntime().exec(myCommand);

Aber ist es möglich, ein Unix-Shell-Skript mit Java-Code auszuführen? Wenn ja, wäre es eine gute Praxis, ein Shell-Skript aus Java-Code heraus auszuführen?

Answer 1

Dies ist eine späte Antwort. Ich dachte jedoch daran, den Kampf, den ich führen musste, um ein Shell-Skript von einer Spring-Boot-Anwendung aus ausführen zu lassen, für zukünftige Entwickler darzustellen.

1. Ich habe in Spring-Boot gearbeitet und konnte die Datei, die von meiner Java-Anwendung ausgeführt werden sollte, nicht finden, und es kam zu folgenden Problemen FileNotFoundFoundException . Ich musste die Datei im Ordner resources Verzeichnis und musste die zu scannende Datei in pom.xml während die Anwendung wie folgt gestartet wurde.

   <resources>
       <resource>
           <directory>src/main/resources</directory>
           <filtering>true</filtering>
           <includes>
               <include>**/*.xml</include>
               <include>**/*.properties</include>
               <include>**/*.sh</include>
           </includes>
       </resource>
   </resources>

2. Danach hatte ich Probleme beim Ausführen der Datei, und es kam zurück error code = 13, Permission Denied . Dann musste ich die Datei durch Ausführen dieses Befehls ausführbar machen - chmod u+x myShellScript.sh

Schließlich konnte ich die Datei mit folgendem Codeschnipsel ausführen.

public void runScript() {
    ProcessBuilder pb = new ProcessBuilder("src/main/resources/myFile.sh");
    try {
        Process p;
        p = pb.start();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ich hoffe, das löst das Problem von jemandem.

Answer 2

Hier ist ein Beispiel, wie man ein Unix-Bash- oder Windows-Bat/cmd-Skript von Java aus ausführt. Es können Argumente an das Skript übergeben und Ausgaben vom Skript empfangen werden. Die Methode akzeptiert eine beliebige Anzahl von Argumenten.

public static void runScript(String path, String... args) {
    try {
        String[] cmd = new String[args.length + 1];
        cmd[0] = path;
        int count = 0;
        for (String s : args) {
            cmd[++count] = args[count - 1];
        }
        Process process = Runtime.getRuntime().exec(cmd);
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        try {
            process.waitFor();
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
        while (bufferedReader.ready()) {
            System.out.println("Received from script: " + bufferedReader.readLine());
        }
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
        System.exit(1);
    }
}

Bei der Ausführung unter Unix/Linux muss der Pfad Unix-ähnlich sein (mit '/' als Trennzeichen), bei der Ausführung unter Windows ist '\' zu verwenden. Hier ist ein Beispiel für ein Bash-Skript (test.sh), das eine beliebige Anzahl von Argumenten erhält und jedes Argument verdoppelt:

#!/bin/bash
counter=0
while [ $# -gt 0 ]
do
  echo argument $((counter +=1)): $1
  echo doubling argument $((counter)): $(($1+$1))
  shift
done

Bei einem Anruf

runScript("path_to_script/test.sh", "1", "2")

unter Unix/Linux lautet die Ausgabe:

Received from script: argument 1: 1
Received from script: doubling argument 1: 2
Received from script: argument 2: 2
Received from script: doubling argument 2: 4

Hier ist ein einfaches cmd-Windows-Skript test.cmd, das die Anzahl der Eingabeargumente zählt:

@echo off
set a=0
for %%x in (%*) do Set /A a+=1 
echo %a% arguments received

Beim Aufruf des Skripts unter Windows

  runScript("path_to_script\\test.cmd", "1", "2", "3")

Die Ausgabe lautet

Received from script: 3 arguments received

Answer 3

Ich denke, mit

System.getProperty("os.name"); 

Überprüfung des Betriebssystems auf kann die Shell/Bash-Skripte verwalten, wenn solche unterstützt werden. ob es notwendig ist, den Code portabel zu machen.

Answer 4

Das ist möglich, führen Sie es einfach wie jedes andere Programm aus. Stellen Sie nur sicher, dass Ihr Skript die richtige #! (she-bang) als erste Zeile des Skripts enthält, und vergewissern Sie sich, dass die Datei über Ausführungsrechte verfügt.

Wenn es sich zum Beispiel um ein Bash-Skript handelt, setzen Sie #!/bin/bash an den Anfang des Skripts, außerdem chmod +x .

Auch was die Frage angeht, ob es eine gute Praxis ist, nein, ist es nicht, besonders nicht für Java, aber wenn es Ihnen eine Menge Zeit spart, ein großes Skript zu portieren, und Sie nicht extra dafür bezahlt werden ;) sparen Sie Ihre Zeit, führen Sie das Skript aus, und setzen Sie die Portierung nach Java auf Ihre langfristige ToDo-Liste.

Answer 5

  String scriptName = PATH+"/myScript.sh";
  String commands[] = new String[]{scriptName,"myArg1", "myArg2"};

  Runtime rt = Runtime.getRuntime();
  Process process = null;
  try{
      process = rt.exec(commands);
      process.waitFor();
  }catch(Exception e){
      e.printStackTrace();
  }