Comment exécuter un fichier de commandes à partir de mon application Java?

Dans mon application Java, je souhaite exécuter un fichier batch qui appelle " scons -Q implicit-deps-changed build\file_load_type export\file_load_type"

Il semble que je ne parviens même pas à exécuter mon fichier batch. Je suis à court d'idées.

Voici ce que j'ai en Java:

Runtime.
   getRuntime().
   exec("build.bat", null, new File("."));

Auparavant, j'avais un fichier Python Sconscript que je voulais exécuter mais comme cela ne fonctionnait pas, j'ai décidé d'appeler le script via un fichier de commandes, mais cette méthode n'a pas encore réussi.

Les fichiers batch ne sont pas un exécutable. Ils ont besoin d'une application pour les exécuter (c'est-à-dire cmd).

Sous UNIX, le fichier de script a shebang (#!) Au début d'un fichier pour spécifier le programme qui l'exécute. Le double-clic dans Windows est effectué par l'Explorateur Windows. CreateProcessne sait rien à ce sujet.

Runtime.
   getRuntime().
   exec("cmd /c start \"\" build.bat");

Remarque: Avec la start \"\"commande, une fenêtre de commande distincte sera ouverte avec un titre vide et toute sortie du fichier de commandes y sera affichée. Il devrait également fonctionner uniquement avec `cmd / c build.bat", auquel cas la sortie peut être lue depuis le sous-processus en Java si vous le souhaitez.

Parfois, le temps du processus d'exécution du thread est supérieur au temps du processus d'attente du thread JVM, cela se produit lorsque le processus que vous appelez prend un certain temps à être traité, utilisez la commande waitFor () comme suit:

try{    
    Process p = Runtime.getRuntime().exec("file location here, don't forget using / instead of \\ to make it interoperable");
    p.waitFor();

}catch( IOException ex ){
    //Validate the case the file can't be accesed (not enought permissions)

}catch( InterruptedException ex ){
    //Validate the case the process is being stopped by some external situation     

}

De cette façon, la JVM s'arrêtera jusqu'à ce que le processus que vous invoquez soit terminé avant de continuer avec la pile d'exécution de thread.

Runtime runtime = Runtime.getRuntime();
try {
    Process p1 = runtime.exec("cmd /c start D:\\temp\\a.bat");
    InputStream is = p1.getInputStream();
    int i = 0;
    while( (i = is.read() ) != -1) {
        System.out.print((char)i);
    }
} catch(IOException ioException) {
    System.out.println(ioException.getMessage() );
}

Pour exécuter des fichiers de commandes en utilisant java si vous parlez de ...

String path="cmd /c start d:\\sample\\sample.bat";
Runtime rn=Runtime.getRuntime();
Process pr=rn.exec(path);`

Cela devrait le faire.

ProcessBuilder est le moyen Java 5/6 d'exécuter des processus externes.

L'exécutable utilisé pour exécuter les scripts batch est celui cmd.exequi utilise l' /cindicateur pour spécifier le nom du fichier batch à exécuter:

Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", "build.bat"});

Théoriquement, vous devriez également pouvoir exécuter Scons de cette manière, même si je n'ai pas testé ceci:

Runtime.getRuntime().exec(new String[]{"scons", "-Q", "implicit-deps-changed", "build\file_load_type", "export\file_load_type"});

EDIT: Amara, vous dites que cela ne fonctionne pas. L'erreur que vous avez répertoriée est l'erreur que vous obtiendrez lors de l'exécution de Java à partir d'un terminal Cygwin sur une boîte Windows; est-ce ce que vous faites? Le problème avec cela est que Windows et Cygwin ont des chemins différents, donc la version Windows de Java ne trouvera pas l'exécutable scons sur votre chemin Cygwin. Je peux vous expliquer davantage si cela s'avère être votre problème.

Process p = Runtime.getRuntime().exec( 
  new String[]{"cmd", "/C", "orgreg.bat"},
  null, 
  new File("D://TEST//home//libs//"));

testé avec jdk1.5 et jdk1.6

Cela fonctionnait bien pour moi, j'espère que cela aidera les autres aussi. pour obtenir cela, j'ai lutté plus de jours. :(

J'ai eu le même problème. Cependant, parfois, CMD n'a pas réussi à exécuter mes fichiers. C'est pourquoi je crée un temp.bat sur mon bureau, ensuite ce temp.bat va exécuter mon fichier, et ensuite le fichier temporaire va être supprimé.

Je sais que c'est un code plus gros, mais a fonctionné pour moi à 100% lorsque même Runtime.getRuntime (). Exec () a échoué.

// creating a string for the Userprofile (either C:\Admin or whatever)
String userprofile = System.getenv("USERPROFILE");

BufferedWriter writer = null;
        try {
            //create a temporary file
            File logFile = new File(userprofile+"\\Desktop\\temp.bat");   
            writer = new BufferedWriter(new FileWriter(logFile));

            // Here comes the lines for the batch file!
            // First line is @echo off
            // Next line is the directory of our file
            // Then we open our file in that directory and exit the cmd
            // To seperate each line, please use \r\n
            writer.write("cd %ProgramFiles(x86)%\\SOME_FOLDER \r\nstart xyz.bat \r\nexit");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                // Close the writer regardless of what happens...
                writer.close();
            } catch (Exception e) {
            }

        }

        // running our temp.bat file
        Runtime rt = Runtime.getRuntime();
        try {

            Process pr = rt.exec("cmd /c start \"\" \""+userprofile+"\\Desktop\\temp.bat" );
            pr.getOutputStream().close();
        } catch (IOException ex) {
            Logger.getLogger(MainFrame.class.getName()).log(Level.SEVERE, null, ex);

        }
        // deleting our temp file
        File databl = new File(userprofile+"\\Desktop\\temp.bat");
        databl.delete();

Ce qui suit fonctionne bien:

String path="cmd /c start d:\\sample\\sample.bat";
Runtime rn=Runtime.getRuntime();
Process pr=rn.exec(path);

Ce code exécutera deux commandes.bat qui existent dans le chemin C: / folders / folder.

Runtime.getRuntime().exec("cd C:/folders/folder & call commands.bat");

Pour développer la réponse de @ Isha, vous pouvez simplement faire ce qui suit pour obtenir la sortie renvoyée (post-facto pas en temps réel) du script qui a été exécuté:

try {
    Process process = Runtime.getRuntime().exec("cmd /c start D:\\temp\\a.bat");
    System.out.println(process.getText());
} catch(IOException e) {
    e.printStackTrace();
}