java 调用外部命令

import java.io.IOException;

import java.io.InputStream;

import java.io.InterruptedIOException;

import java.io.OutputStream;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

public class CommandRunner {

private boolean _waitForExit = true;

private String _command;

private int _timeout;

private InputStream _stdin;

private OutputStream _stdout;

private OutputStream _stderr;

private static final int BUF = 4096;

private int _xit;

private Throwable _thrownError;

private CyclicBarrier _barrier;

public CommandRunner(String _command) {

super();

this._timeout = -1;

this._command = _command;

setInputStream(null);

setStdErrorStream(System.err);

setStdOutputStream(System.out);

}

public int getExitValue() {

return _xit;

}

public void setCommand(String s) {

_command = s;

}

public String getCommand() {

return _command;

}

public void setInputStream(InputStream is) {

_stdin = is;

}

public void setStdOutputStream(OutputStream os) {

_stdout = os;

}

public void setStdErrorStream(OutputStream os) {

_stderr = os;

}

public void evaluate(String... args) throws IOException {

final String SPACE = " ";

StringBuilder sb = new StringBuilder(_command);

sb.append(SPACE);

final int length = args.length;

for (int i = 0; i < length; i++) {

String arg = args[i];

sb.append(arg);

if (i != length - 1) {

sb.append(SPACE);

}

}

String __command__ = sb.toString().trim();

System.out.println(__command__);

this.exec(__command__);

}

/**

*

* @return process exit value (return code) or -1 if timed out.

* @throws IOException

*/

public int exec(String command) throws IOException {

Process proc = Runtime.getRuntime().exec(command);

_barrier = new CyclicBarrier(3 + ((_stdin != null) ? 1 : 0));

PullerThread so = new PullerThread("STDOUT", proc.getInputStream(), _stdout);

so.setDaemon(true);

so.start();

PullerThread se = new PullerThread("STDERR", proc.getErrorStream(), _stderr);

se.setDaemon(true);

se.start();

PusherThread si = null;

if (_stdin != null) {

si = new PusherThread("STDIN", _stdin, proc.getOutputStream());

si.setDaemon(true);

si.start();

}

boolean _timedout = false;

long end = 0L;

if (_timeout < 0)

end = -1L;

else

end = System.currentTimeMillis() + _timeout * 1000;

//

try {

if (_timeout <= 0) {

_barrier.await();

} else {

_barrier.await(_timeout, TimeUnit.SECONDS);

}

} catch (TimeoutException ex) {

_timedout = true;

} catch (BrokenBarrierException bbe) {

/* IGNORE */

} catch (InterruptedException e) {

/* IGNORE */

}

// tell the io threads we are finished

if (si != null) {

si.interrupt();

}

so.interrupt();

se.interrupt();

_xit = -1;

if (!_timedout) {

if (_waitForExit) {

do {

try {

Thread.sleep(1000L);

_xit = proc.exitValue();

} catch (InterruptedException ie) {

if (Thread.interrupted()) {

break; // stop waiting on an interrupt for this

// thread

} else {

continue;

}

} catch (IllegalThreadStateException iltse) {

continue;

}

break;

} while ((end < 0L) || !(_timedout = (System.currentTimeMillis() > end)));

} else {

try {

_xit = proc.exitValue();

} catch (IllegalThreadStateException iltse) {

_timedout = true;

}

}

}

if (_waitForExit) {

proc.destroy();

}

return _xit;

}

public Throwable getThrownError() {

return _thrownError;

}

private class PumperThread extends Thread {

private OutputStream _os;

private InputStream _is;

private boolean _closeInput;

protected PumperThread(String name, InputStream is, OutputStream os, boolean closeInput) {

super(name);

_is = is;

_os = os;

_closeInput = closeInput;

}

public void run() {

try {

byte[] buf = new byte[BUF];

int read = 0;

while (!isInterrupted() && (read = _is.read(buf)) != -1) {

if (read == 0)

continue;

_os.write(buf, 0, read);

_os.flush();

}

} catch (InterruptedIOException iioe) {

// ignored

} catch (Throwable t) {

_thrownError = t;

} finally {

try {

if (_closeInput) {

_is.close();

} else {

_os.close();

}

} catch (IOException ioe) {

/* IGNORE */

}

}

try {

_barrier.await();

} catch (InterruptedException ie) {

/* IGNORE */

} catch (BrokenBarrierException bbe) {

/* IGNORE */

}

}

}

private class PusherThread extends PumperThread {

PusherThread(String name, InputStream is, OutputStream os) {

super(name, is, os, false);

}

}

private class PullerThread extends PumperThread {

PullerThread(String name, InputStream is, OutputStream os) {

super(name, is, os, true);

}

}

public int getTimeout() {

return _timeout;

}

public void setTimeout(int timeout) {

_timeout = timeout;

}

public boolean getWaitForExit() {

return _waitForExit;

}

public void setWaitForExit(boolean waitForExit) {

_waitForExit = waitForExit;

}

public static void main(String[] args) throws Exception {

CommandRunner cr = new CommandRunner(null);

// cr.evaluate("1", "H:\\ad-video-auto-find\\1h", "c:\\a_auto.txt",

// "c:\\b_auto.txt");

cr.setTimeout(1);

cr.exec("ipconfig");

}

}