Avvio di un processo in Java?

Question

C'è un modo per avviare un processo in Java? in .Net questo è fatto con ad esempio:

System.Diagnostics.Process.Start("processname"); 

Esiste un equivalente in Java in modo da poter poi lasciare l'utente a trovare l'applicazione e quindi sarebbe funzionare per qualsiasi sistema operativo?

Answer 1

http://www.rgagnon.com/javadetails/java-0014.html

import java.io.*; 
public class CmdExec { 

    public static void main(String args[]) { 
    try { 
     String line; 
     Process p = Runtime.getRuntime().exec 
     (System.getenv("windir") +"\\system32\\"+"tree.com /A"); 
     BufferedReader input = 
     new BufferedReader 
      (new InputStreamReader(p.getInputStream())); 
     while ((line = input.readLine()) != null) { 
     System.out.println(line); 
     } 
     input.close(); 
    } 
    catch (Exception err) { 
     err.printStackTrace(); 
    } 
    } 
} 

È possibile ottenere il percorso locale usando le proprietà del sistema o un approccio simile.

http://download.oracle.com/javase/tutorial/essential/environment/sysprop.html

Answer 2

Vedere Runtime.exec() e la classe Process. Nella sua forma più semplice:

Process myProcess = Runtime.getRuntime().exec(command); 
... 

Si noti che è anche bisogno di leggere il processo di uscita (ad esempio: myProcess.getInputStream()) - o il processo si bloccherà in alcuni sistemi. Questo può essere altamente confuso la prima volta e dovrebbe essere incluso in qualsiasi introduzione a queste API. Vedi la risposta di James P. per un esempio.

Si potrebbe anche voler esaminare la nuova ProcessBuilder di classe, il che rende più facile cambiare le variabili di ambiente e per invocare sottoprocessi:

Process myProcess = new ProcessBuilder(command, arg).start(); 
... 

Answer 3

La libreria di classi Java rappresenta processi esterni che utilizzano la classe java.lang.Process. I processi possono essere generati utilizzando un java.lang.ProcessBuilder:

Process process = new ProcessBuilder("processname").start(); 

o l'interfaccia più vecchio esposto dai sovraccarichi exec metodi sulla classe java.lang.Runtime:

Process process = Runtime.getRuntime().exec("processname"); 

Entrambi questi frammenti di codice deporrà le uova un nuovo processo, che di solito esegue in modo asincrono e può essere interagito con l'oggetto Process risultante. Se è necessario verificare che il processo sia terminato (o attendere che finisca), non dimenticare di controllare che il valore di uscita (codice di uscita) restituito da process.exitValue() o process.waitFor() sia come previsto (0 per la maggior parte dei programmi), poiché l'eccezione viene generata se il processo esce in modo anomalo.

noti inoltre che il codice addizionale è spesso necessario gestire correttamente il processo di I/O, come descritto nella documentation for the Process class (enfasi aggiunta):

Per default, il sottoprocesso creato non avere il proprio terminale o console. Tutte le operazioni di I/O standard (ovvero stdin, stdout, stderr) verranno reindirizzate al processo principale, a cui è possibile accedere tramite gli stream ottenuti utilizzando i metodi getOutputStream(), getInputStream() e getErrorStream(). Il processo padre utilizza questi flussi per alimentare l'input e ottenere l'output dal sottoprocesso. Poiché alcune piattaforme native forniscono solo dimensioni del buffer limitate per flussi di input e output standard, l'errore per scrivere in modo tempestivo il flusso di input o leggere il flusso di output del sottoprocesso può causare il blocco del sottoprocesso o persino il deadlock.

Un modo per fare in modo che I/O è correttamente gestito e che il valore di uscita indica il successo è quello di utilizzare una libreria come jproc che si occupa con la complessità di catturare stdout e stderr, e offre una semplice interfaccia sincrona a eseguire processi esterni:

ProcResult result = new ProcBuilder("processname").run(); 

jproc è disponibile tramite Maven centrale:

<dependency> 
     <groupId>org.buildobjects</groupId> 
     <artifactId>jproc</artifactId> 
     <version>2.2.0</version> 
</dependency> 

Answer 4

Qui è la logica. supponiamo che vogliamo eseguire la calcolatrice di Windows utilizzando Java:

Process p = Runtime.getRuntime().exec(System.getenv("windir") + "\\system32\\" + "calc.exe");