ProcessBuilder Classe

Definição

[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

Herança

Object

JavaObject

Object

ProcessBuilder

Atributos

RegisterAttribute

Comentários

Essa classe é usada para criar processos do sistema operacional.

Cada ProcessBuilder instância gerencia uma coleção de atributos de processo. O #start() método cria uma nova Process instância com esses atributos. O #start() método pode ser invocado repetidamente da mesma instância para criar novos subprocessos com atributos idênticos ou relacionados.

Cada construtor de processos gerencia esses atributos de processo:

<ul>

<li>um comando, uma lista de cadeias de caracteres que significa o arquivo de programa externo a ser invocado e seus argumentos, se houver. Quais listas de cadeias de caracteres representam um comando válido do sistema operacional depende do sistema. Por exemplo, é comum que cada argumento conceitual seja um elemento nesta lista, mas há sistemas operacionais em que os programas devem tokenizar cadeias de caracteres de linha de comando em si , em um sistema desse tipo, uma implementação Java pode exigir comandos para conter exatamente dois elementos.

<li>um ambiente, que é um mapeamento dependente do sistema de variáveis para valores. O valor inicial é uma cópia do ambiente do processo atual (consulte System#getenv()).

<li>um diretório de trabalho. O valor padrão é o diretório de trabalho atual do processo atual, geralmente o diretório nomeado pela propriedade user.dirdo sistema.

<li>"redirect-input">uma fonte de <i>de entrada</i> padrão. Por padrão, o subprocesso lê a entrada de um pipe. Java código pode acessar esse pipe por meio do fluxo de saída retornado por Process#getOutputStream(). No entanto, a entrada padrão pode ser redirecionada para outra origem usando #redirectInput(Redirect) redirectInput. Nesse caso, Process#getOutputStream() retornará um fluxo de saída nulo, para o qual:

<ul><li>os OutputStream#write(int) write métodos sempre lançam IOException<li>o OutputStream#close() close método não faz nada </ul>

<li>"redirect-output">um destino para <i>standard output</i> e <i>standard error</i>. Por padrão, o subprocesso grava a saída padrão e o erro padrão nos pipes. Java código pode acessar esses pipes por meio dos fluxos de entrada retornados e Process#getInputStream()Process#getErrorStream(). No entanto, a saída padrão e o erro padrão podem ser redirecionados para outros destinos usando #redirectOutput(Redirect) redirectOutput e #redirectError(Redirect) redirectError. Nesse caso, Process#getInputStream() e/ou Process#getErrorStream() retornará um fluxo de entrada nulo, para o qual:

<ul>li os métodos sempre retornam <>liInputStream#read() reado -1 método sempre retorna<> liInputStream#available() availableo 0 método não faz nada </ul >InputStream#close() close<>

<li>uma propriedade redirectErrorStream . Inicialmente, essa propriedade é false, o que significa que a saída padrão e a saída de erro de um subprocesso são enviados para dois fluxos separados, que podem ser acessados usando os métodos e Process#getInputStream() os Process#getErrorStream() métodos.

Se o valor for definido como true, em seguida:

<O erro padrão ul>li é mesclado com a saída padrão e sempre enviado para o mesmo destino (isso facilita a correlação de mensagens de erro com a saída correspondente) <li>o destino comum do erro padrão e a saída padrão pode ser redirecionada usando <>li#redirectOutput(Redirect) redirectOutputqualquer redirecionamento definido pelo < método é ignorado ao criar um subprocesso >li#redirectError(Redirect) redirectErrordo < qual o fluxo retornado sempre será um fluxo> de entrada nulo/ulProcess#getErrorStream()<>

</ul>

Modificar os atributos de um construtor de processos afetará os processos iniciados posteriormente pelo método desse #start() objeto, mas nunca afetará os processos iniciados anteriormente ou o próprio processo Java.

A maior parte da verificação de erros é executada pelo #start() método. É possível modificar o estado de um objeto para que isso #start() falhe. Por exemplo, definir o atributo de comando como uma lista vazia não gerará uma exceção, a menos que #start() seja invocada.

<forte>Observe que essa classe não está sincronizada.</strong> Se vários threads acessarem uma ProcessBuilder instância simultaneamente e pelo menos um dos threads modificar um dos atributos estruturalmente, ele deverá ser sincronizado externamente.

Iniciar um novo processo que usa o diretório de trabalho e o ambiente padrão é fácil:

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

Aqui está um exemplo que inicia um processo com um diretório de trabalho e um ambiente modificados e redireciona a saída padrão e o erro a serem acrescentados a um arquivo de 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;
            }

Para iniciar um processo com um conjunto explícito de variáveis de ambiente, primeiro chame java.util.Map#clear() Map.clear() antes de adicionar variáveis de ambiente.

Adicionado em 1.5.

Java documentação para java.lang.ProcessBuilder.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.