问和OutputStream操作

EN

    System.out.println( "hello" );
    String line;

    Process process = Runtime.getRuntime ().exec ("cmd.exe /c slcanterm.exe");

    InputStream stderr = process.getErrorStream ();
    InputStream stdout = process.getInputStream ();

    BufferedReader reader = new BufferedReader (new InputStreamReader(stdout));
    BufferedReader error = new BufferedReader (new InputStreamReader(stderr));

    new Thread() {
        public void run() {
            try {
                String err;
                while ((err = error.readLine ()) != null)     
                    System.out.println ("[Stderr] " + err);
            } catch (Exception e) {
                e.printStackTrace();
            }

    }}.start();

    while ((line = reader.readLine ()) != null)     
        System.out.println ("[Stdout] " + line);

    System.out.println( "buy" );

class CommandRunner implements Closeable {

    private Process cmd;
    private OutputStreamWriter stdin;
    private BufferedReader stderr;
    private BufferedReader stdout;

    private static class ArtificialOutput {
        public List<String> inputLines;
        public String finalMarker;

        public ArtificialOutput(List<String> inputLines, String finalMarker) {
            super();
            this.inputLines = inputLines;
            this.finalMarker = finalMarker;
        }
    }

    public CommandRunner() throws IOException {
        cmd = Runtime.getRuntime().exec("cmd.exe");
        stdin = new OutputStreamWriter(cmd.getOutputStream());
        stderr = new BufferedReader(new InputStreamReader(cmd.getErrorStream()));
        stdout = new BufferedReader(new InputStreamReader(cmd.getInputStream()));   

        // turn off echo of commands (also skips any console header lines)
        execute("echo off", StdinWriter.WRITE_NOTHING, StdoutProcessor.IGNORE);
    }

    @Override
    public void close() throws IOException {
        stdin.close();
        stdout.close();
        stderr.close();
        cmd.destroy();
    }

    public void execute(String command, StdinWriter writer, StdoutProcessor processor) throws IOException {             
        processOutput(executeCommand(command, writer), processor);
    }

    private ArtificialOutput executeCommand(String command, StdinWriter writer) throws IOException {
        List<String> lines = new ArrayList<String>();

        // add command as input line
        lines.add(command);

        // add all custom input lines
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        try (OutputStreamWriter bufferWriter = new OutputStreamWriter(buffer)) {
            writer.write(bufferWriter);
        }

        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(buffer.toByteArray())))) {
            String line = null;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
        }

        // add stdout and sterr markers as input lines
        String marker = "--- MARKER " + System.currentTimeMillis() + Math.random();
        lines.add("echo " + marker + ">&2");
        lines.add("echo " + marker);

        // write everything to stdin
        for (String line : lines) {
            stdin.write(line + System.lineSeparator());
        }
        stdin.flush();

        // our artificial outputs (with echo off) are the input lines and the closing marker
        return new ArtificialOutput(lines, marker);
    }

    private void processOutput(ArtificialOutput artificialOutput, StdoutProcessor processor) throws IOException {
        byte[] output = readUntilMarker(artificialOutput, stdout);
        byte[] errors = readUntilMarker(artificialOutput, stderr);

        if (errors.length > 0) {
            processor.processError(new BufferedReader(new InputStreamReader(new ByteArrayInputStream(errors))));
        }

        processor.processOuput(new BufferedReader(new InputStreamReader(new ByteArrayInputStream(output))));
    }

    private byte[] readUntilMarker(ArtificialOutput artificialOutput, BufferedReader reader) throws IOException {
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();

        try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(buffer))) {;
            String line;
            while ((line = reader.readLine()) != null) {
                // ignore input lines because cmd.exe outputs every input character
                if (artificialOutput.inputLines.remove(line)) {
                    continue;
                }

                // the final marker indicates the command has ended
                if (line.equals(artificialOutput.finalMarker)) {
                    break;
                }

                // everything else is the command output
                writer.write(line + System.lineSeparator());
            }
        }

        return buffer.toByteArray();
    }

}

try (CommandRunner cmd = new CommandRunner()) {
    cmd.execute("dir", StdinWriter.WRITE_NOTHING, StdoutProcessor.PRINT);
    cmd.execute("echo something", StdinWriter.WRITE_NOTHING, StdoutProcessor.PRINT);
}