ProcessBuilder Classe

Definizione

[Android.Runtime.Register("java/lang/ProcessBuilder", DoNotGenerateAcw=true)]
public sealed class ProcessBuilder : Java.Lang.Object

[<Android.Runtime.Register("java/lang/ProcessBuilder", DoNotGenerateAcw=true)>]
type ProcessBuilder = class
    inherit Object

Ereditarietà

Object

JavaObject

Object

ProcessBuilder

Attributi

RegisterAttribute

Commenti

Questa classe viene usata per creare processi del sistema operativo.

Ogni ProcessBuilder istanza gestisce una raccolta di attributi di processo. Il #start() metodo crea una nuova Process istanza con tali attributi. Il #start() metodo può essere richiamato ripetutamente dalla stessa istanza per creare nuovi sottoprocessi con attributi identici o correlati.

Ogni generatore di processi gestisce questi attributi di processo:

<ul>

<li>a command, un elenco di stringhe che indica il file di programma esterno da richiamare e i relativi argomenti, se presenti. Gli elenchi di stringhe rappresentano un comando valido del sistema operativo dipendente dal sistema. Ad esempio, è comune che ogni argomento concettuale sia un elemento in questo elenco, ma ci sono sistemi operativi in cui i programmi devono tokenizzare le stringhe della riga di comando stessi. In un sistema di questo tipo un'implementazione di Java potrebbe richiedere che i comandi contengano esattamente due elementi.

<li>un ambiente, che è un mapping dipendente dal sistema dalle variabili ai valori. Il valore iniziale è una copia dell'ambiente del processo corrente (vedere System#getenv()).

<li>una directory di lavoro. Il valore predefinito è la directory di lavoro corrente del processo corrente, in genere la directory denominata dalla proprietà user.dirdi sistema .

<li>"redirect-input">a source of <i>standard input</i>. Per impostazione predefinita, il sottoprocesso legge l'input da una pipe. Java codice può accedere a questa pipe tramite il flusso di output restituito da Process#getOutputStream(). Tuttavia, l'input standard può essere reindirizzato a un'altra origine usando #redirectInput(Redirect) redirectInput. In questo caso, Process#getOutputStream() restituirà un flusso di output Null, per il quale:

<ul><li>i OutputStream#write(int) write metodi sempre throw IOException<li>il OutputStream#close() close metodo non esegue alcuna <operazione /ul>

<li>"redirect-output">a destination for <i>standard output</i> and <i>standard error</i>. Per impostazione predefinita, il sottoprocesso scrive l'output standard e l'errore standard nelle pipe. Java codice può accedere a queste pipe tramite i flussi di input restituiti da Process#getInputStream() e Process#getErrorStream(). Tuttavia, l'output standard e l'errore standard possono essere reindirizzati ad altre destinazioni usando #redirectOutput(Redirect) redirectOutput e #redirectError(Redirect) redirectError. In questo caso, Process#getInputStream() e/o Process#getErrorStream() restituirà un flusso di input Null, per il quale:

<ul><li>i InputStream#read() read metodi restituiscono -1<sempre li il > metodo restituisceInputStream#available() available0 sempre li<>il InputStream#close() close metodo non esegue alcuna <operazione /ul>

<li>una proprietà redirectErrorStream . Inizialmente, questa proprietà è false, ovvero l'output standard e l'output degli errori di un subprocesso vengono inviati a due flussi separati, a cui è possibile accedere usando i Process#getInputStream() metodi e Process#getErrorStream() .

Se il valore è impostato su true, allora:

<l'errore standard ul><li viene unito all'output standard e viene sempre inviato alla stessa destinazione (in questo modo è più facile correlare i messaggi di errore con l'output corrispondente) >li<>la destinazione comune dell'errore standard e l'output standard può essere reindirizzato usando #redirectOutput(Redirect) redirectOutput<li>qualsiasi reindirizzamento impostato dal #redirectError(Redirect) redirectError metodo viene ignorato quando si crea un sottoprocesso <li>dal flusso restituito Process#getErrorStream() sarà sempre un flusso< di input Null/ul>

</ul>

La modifica degli attributi di un generatore di processi influirà sui processi avviati successivamente dal metodo dell#start()'oggetto, ma non influirà mai sui processi avviati in precedenza o sul processo Java stesso.

La maggior parte del controllo degli errori viene eseguita dal #start() metodo . È possibile modificare lo stato di un oggetto in modo che #start() non riesca. Ad esempio, l'impostazione dell'attributo di comando su un elenco vuoto non genererà un'eccezione a meno che non #start() venga richiamata.

<strong>Si noti che questa classe non è sincronizzata.</strong> Se più thread accedono contemporaneamente a un'istanza ProcessBuilder e almeno uno dei thread modifica uno degli attributi in modo strutturale, deve essere sincronizzato esternamente.

L'avvio di un nuovo processo che usa la directory di lavoro predefinita e l'ambiente è semplice:

{@code
            Process p = new ProcessBuilder("myCommand", "myArg").start();
            }

Di seguito è riportato un esempio che avvia un processo con una directory di lavoro e un ambiente di lavoro modificati e reindirizza l'output standard e l'errore da aggiungere a un file di log:

{@code
            ProcessBuilder pb =
              new ProcessBuilder("myCommand", "myArg1", "myArg2");
            Map<String, String> env = pb.environment();
            env.put("VAR1", "myValue");
            env.remove("OTHERVAR");
            env.put("VAR2", env.get("VAR1") + "suffix");
            pb.directory(new File("myDir"));
            File log = new File("log");
            pb.redirectErrorStream(true);
            pb.redirectOutput(Redirect.appendTo(log));
            Process p = pb.start();
            assert pb.redirectInput() == Redirect.PIPE;
            assert pb.redirectOutput().file() == log;
            assert p.getInputStream().read() == -1;
            }

Per avviare un processo con un set esplicito di variabili di ambiente, chiamare java.util.Map#clear() Map.clear() prima di aggiungere variabili di ambiente.

Aggiunto nella versione 1.5.

per java.lang.ProcessBuilder.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.