web-dev-qa-db-fra.com

Equivalent Linux pour «cmd / C démarrer" Titre "" C: \ Dossier \ fichier.bat "»

J'ai un programme Java qui exécute un fichier de commandes sous Windows avec Runtime.getRuntime().exec() à l'aide de la commande suivante:

_cmd /C start "Title" "C:\Folder\file.bat"
_

Le programme Java se termine rapidement car cmd /C exécute la commande, puis se termine. (1) et start "Title" "C:\Folder\file.bat" lance le script de traitement par lots (2). Ainsi, le processus (le fichier de commandes) continuera à s'exécuter indépendamment .

Supposons maintenant que j’ai un script Shell (par exemple file.sh), que je souhaite lancer à partir de Java et a un comportement similaire. Comment pourrait-il être la commande équivalente (3) sous Linux?

Notes

  1. Voir CMD.exe (Environnement de commande) | Windows CMD | SS64.com
  2. Voir Démarrer - Démarrer un programme | Windows CMD | SS64.com
  3. Le titre ("Title") n'est pas obligatoire.
command-linebashjava
1
Paul Vargas

La manière de lancer un script est de donner son chemin:

/path/to/script.sh

Pour qu'il continue si le processus parent se termine, vous pouvez simplement le lancer en arrière-plan en ajoutant &:

/path/to/script.sh &

Donc, si vous avez, par exemple, un script en appelant un autre comme ceci:

#!/bin/bash
script2.sh &

Vous pouvez exécuter script1.sh qui appellera script2.sh et, puisqu'il est envoyé en arrière-plan, quitte immédiatement.

5
terdon

Vous avez plusieurs options, les plus intéressantes sont les suivantes:

  • Si c'est pour Ubuntu, vous pouvez utiliser gnome-terminal:

    gnome-terminal -c "/home/$USER/file.sh" -t "Title"

  • Si vous voulez le rendre compatible avec la plupart des linux, vous pouvez utiliser xterm:

    xterm -T "Title" -e "/home/$USER/file.sh"

Le chemin est /home/$USER/file.sh (équivalent Windows 7: C:\Users\%UserProfile%\file.bat)

Le contenu de file.sh peut ressembler à ceci:

#!/bin/bash

echo "In a World without Walls nor Fences, the people don't need Windows and Gates"
sleep 2
1
Helio

Différentes façons d’exécuter un script sous Linux: mon nom de script arbitraire est foo.bat

ex1: $bash foo.bat

ex2: $./foo.bat

ex3: $echo $(~/Desktop/foo.bat)

ex4: `~/Desktop/foo.bat`

ex5: $ /path/to/Shell/script/foo.bat

 ex1: il s’agit d’un fichier ordinaire, nous l’exécutons avec bash 
 ex2: nous avons marqué foo.bat comme exécutable. ($ chmod + x foo.bat) 
 ex3: Substitution de commande 
 ex4: exécuter en utilisant "` `" 
 ex5: nous indique le chemin d'accès à l'exécutable.

Ce sont les plus communs. J'éviterais d'appeler des choses comme gnome-terminal et xterm. Ce sont des coquilles moins communes comparées à des choses comme bash et sh. Par exemple, j'utilise Ubuntu mate. Je n'ai ni xterm ni gnome-terminal. Mais, j'ai bash, et sh. comme presque tout autre personne sous Linux/mac osx.

Vous pouvez apprécier ce tutoriel sur l’exécution de scripts here

le script foo.bat fait ceci:

$ ./foo.bat
Having a bash ./foo.bat

où son contenu sont:

$ cat foo.bat 
#!/bin/bash
echo -e "Having a bash" $0

Je pense que l'utilisation de $ 0 peut vous donner la fonctionnalité de titre que vous souhaitez peut-être. Beaucoup plus de possibilités existent.

1
j0h

Si j'ai bien compris, vous souhaitez exécuter une commande externe à partir de Java et laisser le processus Java se poursuivre (de manière asynchrone) pendant que cette commande externe continue également de s'exécuter?

Voici un petit test que j'ai fouetté:

[tai@flenux runproc ] $ ls
filecreator.sh  ProcRunner.class  ProcRunner.Java

[tai@flenux runproc ] $ cat filecreator.sh 
touch newfile

[tai@flenux runproc ] $ cat ProcRunner.Java 

public class ProcRunner {
    public static void main(String[] args) {
        try {
            Runtime.getRuntime().exec(args);
            Thread.sleep(2000);
            System.out.println("Done");
        } catch(Exception e) {
            System.err.println(e.toString() );
        }
    }
}

[tai@flenux runproc ] $ Java ProcRunner bash filecreator.sh 
Done

[tai@flenux runproc ] $ ls
filecreator.sh  newfile  ProcRunner.class  ProcRunner.Java

[tai@flenux runproc ] $

Java exécute avec succès le programme (qui crée simplement le fichier "newfile"); il continue également de son côté à imprimer le message Done après avoir appelé l'exécutable.

Si vous souhaitez également qu'une fenêtre de terminal s'ouvre, préfixez la chaîne d'appel

Runtime.getRuntime().exec(["gnome-terminal", "-e"]+args);

Donc, pour répondre à votre question, il semble que vous appelez simplement la méthode que vous avez spécifiée. Avez-vous un comportement différent?

1
taifwa