Lancement d'un commande avec Runtime.exec()

Dernière mise à jour le par cs_Julien39 .

Introduction

Ce tutoriel explique comment lancer une commande à l'aide de l'a classe Runtime.
Deux exemples sont donnés :

  • Une classe Ping qui permet de lancer une commande ping à l'aide de Runtime
  • Une classe LancementJava qui permet de lancer un programme java à l'aide de Runtime

Fonctionnement de Runtime.exec()

Lancement d'une commande

La fonction exec de la classe Runtime permet d'exécuter dans un processus différent du processus courant la commande passée en paramètre.

public Process exec(String command) throws IOException

Pour utiliser cette méthode :

        /* On récupère l'instance de Runtime */
        Runtime runtime = Runtime.getRuntime();
        
        /* On exécute la commande*/
        runtime.exec(commande);

Récupération des sorties

Lorsqu'on exécute la commande, on peut acéder au processus dans lequel s'exécute la commande :

Process process = runtime.exec(commande);

Code retour
On peut accéder au code retour à l'aide de waitFor() qui attendra la fin du processus
exitValue=process.waitFor();

Sortie/Erreur standard
Pour accéder à la sortie et à l'erreur standard, on peut utiliser la classe RecuperationSorties.
Dans cet exemple, stdin et stderr sont affichées dans la console.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * <b>
 * RecuperationSorties est la classe qui permet de récupérer   
 * les sorties d'une commande lancée avec Runtime et de les   
 * rediriger vers la console  
 * </b>  
 * <p>  
 * Cette classe est caractérisée par les informations suivantes :  
 * <ul>  
 * <li>Le flux à rediriger</li>  
 * </ul>  
 * </p>  
 * <p>  
 * Cette classe définit un thread, on peut lancer la récupération  
 * avec la méthode start().  
 * </p>  
 *   
 * @author Julien  
 * @version 1.0   
 */
public class RecuperationSorties extends Thread {  

        /**  Le flux à rediriger  */
        private InputStream flux;

        /**
         * <b>Constructeur de RecuperationSorties</b>
         * @param flux
         *  Le flux à rediriger
         */
        public RecuperationSorties(InputStream flux){
                this.flux = flux;
        }
        
        @Override
        public void run(){
                try {    
                        InputStreamReader reader = new InputStreamReader(flux);
                        BufferedReader br = new BufferedReader(reader);
                        String ligne=null;
                        while ( (ligne = br.readLine()) != null){
                                System.out.println(ligne);
                        }
                }
                catch (IOException ioe){
                        ioe.printStackTrace();
                }
        }
}

Elle contient également une classe RecuperationSorties qui permet de rediriger un flux vers la console dans un thread distinct du thread courant.

Exemples

Lancer une commande dos ping

import java.io.IOException; 

/**
 * <b>Ping est la classe qui permet de lancer un ping sur une machine</b>
 * <p>
 * Cette classe contient une méthode ping qui réalise un ping sur la machine dont l'ip est passée en paramètre
 * </p>
 * <p>
 * Cet exemple permet de vérifier si on peut joindre une machine grâce à un ping.  
 * La méthode ping permet de réaliser le ping sur une machine passée en parametre en  
 * utilisant la classe Runtime.  
 * </p>
 */
public class Ping {

        /**
         * Cette méhthode permet de réaliser un ping sur la machine dont l'ip est passée en paramètre
         * @param nomMachine
         *      L'adresse ip ou le nom de la machine à pinger
         * @return vrai si la machine est joignable par le ping et faux sinon
         */
        public boolean ping(String nomMachine){
                int exitValue=1;
                
                /* Récupération de l'environnement d'exécution */
                Runtime runtime = Runtime.getRuntime();
                
                try {
                        /* Création et lancement de processus qui fait le ping */
                        Process process = runtime.exec("cmd /c "+"ping "+nomMachine);
                        
                        /* Lancement du thread de récupération de la sortie standard */
                        new RecuperationSorties(process.getInputStream()).start();
                        
                        /* Lancement du thread de récupération de la sortie en erreur */
                        new RecuperationSorties(process.getErrorStream()).start();
                        
                        /* On enregistre le code retour */
                        exitValue=process.waitFor();
                }
                catch (IOException e) {
                        e.printStackTrace();
                }
                catch (InterruptedException e) {
                        e.printStackTrace();
                }
                return exitValue==0;
        }
        
        public static void main(String[] args){
                Ping exemple = new Ping();
                boolean trouve=exemple.ping("localhost");
                System.out.println(trouve);
        }
}

Lancement d'un programme java

import java.io.IOException;
/*
 * Cette classe montre comment lancer un programme java dans un programme java. 
 * Pour cela, on utilise la classe Runtime pour exécuter une commande windows
 */ 
public class LancementJava {

        private static final String dossierInstallation = "C:\\Program Files\\Java\\jre6";  
        
        public void lancerJava(String urlJarExecutable){
                
                /* Récupération de l'environnement d'exécution */  
                Runtime runtime = Runtime.getRuntime();
                
                try {
                        /* Création et lancement de processus qui lance le java */  
                        Process process = runtime.exec('"'+dossierInstallation+"\\bin\\java.exe" + '"' + " -jar " + '"' + urlJarExecutable + '"');
                        
                        /* Lancement du thread de récupération de la sortie standard */
                        new RecuperationSorties(process.getInputStream()).start();
                        
                        /* Lancement du thread de récupération de la sortie en erreur */
                        new RecuperationSorties(process.getErrorStream()).start();
                }
                catch (IOException e) {
                        e.printStackTrace();
                }
        }
        
        public static void main(String[] args){ 
                LancementJava exemple = new LancementJava();  
                exemple.lancerJava("C:\\Documents and Settings\\Julien\\Bureau\\Essai.jar");
        }

}

Code source complet

Le code utilisé pour ce tutoriel est téléchargeable ici : http://codes-sources.commentcamarche.net/source/54094-exemple-d-utilisation-de-la-classe-runtime

Traitement des images
Utilisation des PreparedStatement
Rejoignez-nous