ProcessBuilder Classe

Définition

[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

Héritage

Object

JavaObject

Object

ProcessBuilder

Attributs

RegisterAttribute

Remarques

Cette classe est utilisée pour créer des processus de système d’exploitation.

Chaque ProcessBuilder instance gère une collection d’attributs de processus. La #start() méthode crée une instance Process avec ces attributs. La #start() méthode peut être appelée à plusieurs reprises à partir de la même instance pour créer de nouveaux sous-processus avec des attributs identiques ou associés.

Chaque générateur de processus gère ces attributs de processus :

<ul>

<li>a command, une liste de chaînes qui signifie que le fichier de programme externe doit être appelé et ses arguments, le cas échéant. Quelles listes de chaînes représentent une commande de système d’exploitation valide dépend du système. Par exemple, il est courant que chaque argument conceptuel soit un élément de cette liste, mais il existe des systèmes d’exploitation où les programmes sont censés tokeniser eux-mêmes des chaînes de ligne de commande , sur un tel système, une implémentation Java peut nécessiter des commandes pour contenir exactement deux éléments.

<li>un environnement, qui est un mappage dépendant du système des variables aux valeurs. La valeur initiale est une copie de l’environnement du processus actuel (voir System#getenv()).

<li>a working directory. La valeur par défaut est le répertoire de travail actuel du processus actuel, généralement le répertoire nommé par la propriété user.dirsystème .

<li>"redirect-input">une source d’entrée<></i> standard. Par défaut, le sous-processus lit l’entrée à partir d’un canal. Java code peut accéder à ce canal via le flux de sortie retourné par Process#getOutputStream(). Toutefois, l’entrée standard peut être redirigée vers une autre source à l’aide #redirectInput(Redirect) redirectInputde . Dans ce cas, Process#getOutputStream() retourne un flux de sortie Null pour lequel :

<ul>li les méthodes lèvent <>toujours liOutputStream#write(int) writela IOException méthode ne fait rien </ul >OutputStream#close() close<>

<li>"redirect-output">a destination pour <i>standard output</i> et <i>standard error</i>. Par défaut, le sous-processus écrit la sortie standard et l’erreur standard dans les canaux. Java code peut accéder à ces canaux via les flux d’entrée retournés par Process#getInputStream() et Process#getErrorStream(). Toutefois, la sortie standard et l’erreur standard peuvent être redirigées vers d’autres destinations à l’aide #redirectOutput(Redirect) redirectOutput et #redirectError(Redirect) redirectError. Dans ce cas, Process#getInputStream() et/ou Process#getErrorStream() retourne un flux d’entrée Null pour lequel :

<ul><li>les InputStream#read() read méthodes retournent -1<toujours li>la InputStream#available() available méthode toujours renvoie 0<li>la InputStream#close() close méthode ne fait rien </ul>

<li>a redirectErrorStream , propriété. Initialement, cette propriété est false, ce qui signifie que la sortie standard et la sortie d’erreur d’un sous-processus sont envoyées à deux flux distincts, qui sont accessibles à l’aide des méthodes et Process#getInputStream() des Process#getErrorStream() méthodes.

Si la valeur est définie truesur , puis :

<L’erreur standard ul>li est fusionnée avec la sortie standard et toujours envoyée à la même destination (cela facilite la mise en corrélation des messages d’erreur avec la sortie correspondante) <li>la destination commune de l’erreur standard et la sortie standard peut être redirigée à l’aide <>de li#redirectOutput(Redirect) redirectOutputtoute redirection définie par la méthode est ignorée lors de la < création d’un sous-processus >li#redirectError(Redirect) redirectErrorle flux retourné < sera toujours un flux> d’entrée Null/ulProcess#getErrorStream()<>

</ul>

La modification des attributs d'un générateur de processus affecte les processus démarrés par la suite par la méthode de #start() cet objet, mais n'affecte jamais les processus démarrés précédemment ou le processus Java lui-même.

La plupart des vérifications des erreurs sont effectuées par la #start() méthode. Il est possible de modifier l’état d’un objet afin qu’il #start() échoue. Par exemple, la définition de l’attribut de commande sur une liste vide ne lève pas d’exception, sauf si #start() elle est appelée.

< >notez que cette classe n’est pas synchronisée.</strong> Si plusieurs threads accèdent simultanément à une ProcessBuilder instance et qu’au moins un des threads modifie l’un des attributs structurellement, il doit être synchronisé en externe.

Le démarrage d’un nouveau processus qui utilise le répertoire de travail et l’environnement par défaut est facile :

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

Voici un exemple qui démarre un processus avec un répertoire de travail et un environnement modifiés, et redirige la sortie et l’erreur standard à ajouter à un fichier journal :

{@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;
            }

Pour démarrer un processus avec un ensemble explicite de variables d’environnement, appelez java.util.Map#clear() Map.clear() d’abord avant d’ajouter des variables d’environnement.

Ajouté à la version 1.5.

Java documentation pour java.lang.ProcessBuilder.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.