Jdk源码详解之ProcessBuilder类

Jdk源码详解之ProcessBuilder()类

1.ProcessBuilder类

2.方法简介

• 构造器ProcessBuilder

    /**
      Constructs a process builder with the specified operating
      system program and arguments.
      使用指定的操作系统以及参数构建一个process builder。

      This is a convenience constructor that sets the process builder's command 
      to a string list containing the same strings as the {@code command}
      array, in the same order.  
      这是一个方便的构造器，将process builder的命令转换成一个字符串列表，
      这个字符串列表与command 数组有着相同的字符串，同样，其顺序也相同。

      It is not checked whether command corresponds to a valid operating system
      command.
      这个是不被检查的：不管命令是否与操作系统相对应。
      
     @param command a string array containing the program and its arguments
     参数：command :一个包含程序以及该程序所需参数字符串数组
     */
    public ProcessBuilder(String... command) {
        this.command = new ArrayList<>(command.length);
        for (String arg : command)
            this.command.add(arg);
    }

• start()方法

/**
     Starts a new process using the attributes of this process builder.
     使用这个process builder的属性开始一个新的进程
	 
     The new process will invoke the command and arguments given by command(),
     in a working directory as given by #directory(),
     with a process environment as given by #environment().
     这个新的process将会调用由command()给出的命令以及参数，
	 在directory()给出的一个工作目录给，
	 以及environment()给出的一个process环境。
	 
	 
     This method checks that the command is a valid operating
     system command.  Which commands are valid is system-dependent,
     but at the very least the command must be a non-empty list of
     non-null strings.
     这个方法检测命令是一个有效的操作系统命令。哪些命令是有效的，这取决于依赖的系统，
	 但是至少，命令必须得是一个非空，非null的字符串。
	 
     
A minimal set of system dependent environment variables may
     be required to start a process on some operating systems.
     As a result, the subprocess may inherit additional environment variable
     settings beyond those in the process builder's {@link #environment()}.
     
     
If there is a security manager, its
     {@link SecurityManager#checkExec checkExec}
     method is called with the first component of this object's
     {@code command} array as its argument. This may result in
     a {@link SecurityException} being thrown.
     
     
Starting an operating system process is highly system-dependent.
     Among the many things that can go wrong are:
     

     
The operating system program file was not found.
     
Access to the program file was denied.
     
The working directory does not exist.
     
     
     
In such cases an exception will be thrown.  The exact nature
     of the exception is system-dependent, but it will always be a
     subclass of {@link IOException}.
     
     
Subsequent modifications to this process builder will not
     affect the returned {@link Process}.
     
     @return a new {@link Process} object for managing the subprocess
     *
     * @throws NullPointerException
     *         if an element of the command list is null
     *
     * @throws IndexOutOfBoundsException
     *         if the command is an empty list (has size {@code 0})
     *
     * @throws SecurityException
     *         if a security manager exists and
     *         

     *
     *         
its
     *         {@link SecurityManager#checkExec checkExec}
     *         method doesn't allow creation of the subprocess, or
     *
     *         
the standard input to the subprocess was
     *         {@linkplain #redirectInput redirected from a file}
     *         and the security manager's
     *         {@link SecurityManager#checkRead checkRead} method
     *         denies read access to the file, or
     *
     *         
the standard output or standard error of the
     *         subprocess was
     *         {@linkplain #redirectOutput redirected to a file}
     *         and the security manager's
     *         {@link SecurityManager#checkWrite checkWrite} method
     *         denies write access to the file
     *
     *         
     *
     * @throws IOException if an I/O error occurs
     *
     * @see Runtime#exec(String[], String[], java.io.File)
     */
    public Process start() throws IOException {
        // Must convert to array first -- a malicious user-supplied
        // list might try to circumvent the security check.
        String[] cmdarray = command.toArray(new String[command.size()]);
        cmdarray = cmdarray.clone();

        for (String arg : cmdarray)
            if (arg == null)
                throw new NullPointerException();
        // Throws IndexOutOfBoundsException if command is empty
        String prog = cmdarray[0];

        SecurityManager security = System.getSecurityManager();
        if (security != null)
            security.checkExec(prog);

        String dir = directory == null ? null : directory.toString();

        for (int i = 1; i < cmdarray.length; i++) {
            if (cmdarray[i].indexOf('\u0000') >= 0) {
                throw new IOException("invalid null character in command");
            }
        }

        try {
            return ProcessImpl.start(cmdarray,
                                     environment,
                                     dir,
                                     redirects,
                                     redirectErrorStream);
        } catch (IOException | IllegalArgumentException e) {
            String exceptionInfo = ": " + e.getMessage();
            Throwable cause = e;
            if ((e instanceof IOException) && security != null) {
                // Can not disclose the fail reason for read-protected files.
                try {
                    security.checkRead(prog);
                } catch (SecurityException se) {
                    exceptionInfo = "";
                    cause = se;
                }
            }
            // It's much easier for us to create a high-quality error
            // message than the low-level C code which found the problem.
            throw new IOException(
                "Cannot run program \"" + prog + "\""
                + (dir == null ? "" : " (in directory \"" + dir + "\")")
                + exceptionInfo,
                cause);
        }
    }