[Java]使用Apache Commons Execs调用脚本
概述
写这篇的主要目的是为了整理和记录，归档以便之后查阅。segmentfault
我以前在SF上提问了一个问题：如何正确使用PipedInputStream和PipedOutputStreamapp
问题中提到的Apache Commons Execs这个库，相比咱们原来使用原生的Runtime和Process有很多优势。
对比我以前写过的代码，总结一下：异步
- 简化路径处理
若是要调用的脚本的路径存在空格，Apache Commons Execs会自动帮忙加上转义字符 - 兼容Windows环境
使用原生Runtime和Process方式时，必须手工为调用bat脚本加上cmd /c，好比把test.bat脚本拼接成cmd /c才向Runtime.exec方法传入这个脚本做为第一个参数 - 支持超时设置
原生的Runtime和Process并无直接支持超时的设置，但网上也有在原生基础上作的超时功能的封装，大概是基于循环按期检查的机制。在SF上也有相似的文章，其中的代码大可参考一下，我要提醒的是，须要注意异步线程不能给及时返回结果的问题。
在个人项目需求中，规定要得到脚本的退出码，标准输出、错误输出。另外，还有可能要从标注输出中解析获得一个描述成功或失败的结果，大概就是过滤脚本的标准输出，捕获感兴趣的某一行，最后要预留超时设置的接口。还有，须要支持字符编码设置，在Windows下对象调试程序颇有帮助，所以，咱们能够列表表示整个需求。ide
| 序号 | 需求 | 是否必须 |
|---|---|---|
| 1 | 退出码、标准输出、错误输出 | 是 |
| 2 | 得到脚本提供的结果描述 | 是 |
| 3 | 设置超时 | 否 |
| 4 | 设置字符编码 | 否 |
设计思路
1. 定义抽象类预制总体流程
public abstract class AbstractCommonExecs {
private String bin; //脚本
private List<String> arguments; //参数
//Constructor method
//封装返回结果
public ExecResult exec() throws IOException {
try{
Executor executor = getExecutor(); //执行线程
CommandLine cmdLine = getCommandLine(); //脚本命令参数等
if(supportWatchdog()) { //是否支持监视 用于设置超时等
executor.setWatchdog(getWatchdog());
}
executor.setStreamHandler(streamHandler); //设置处理标注输出和错误输出的Handler
int ret = executor.execute(cmdLine); //得到退出码
}catch(ExecuteException e) {
int ret = e.getExitValue(); //若是出现异常还能得到退出码 关于这个仔细想一想
}
}
}
1.1 抽象类接收脚本和参数，类型和形式还能够是别的形式测试
1.2 对外提供的exec方法返回的是退出码、标准输出、错误输出和脚本提供的结果描述ui
1.3 经过getXXX方法的形式能够将具体的实现交给具体实现类来完成this
2. 如何处理输出
为了从Executor中得到标准输出和错误输出，是须要向Executor传入一个streamHandler的是，这是一个基于字节流式的Handler，为了支持字符编码的设计，
最终处理时咱们还须要将它转成字符流并设置目标字符编码，好比在Windows开发环境下设置为GBK。编码
executor.setStreamHandler(streamHandler); //设置处理标注输出和错误输出的Handler
这里先提两种很是有效的作法，一种是基于ByteArrayOutStream的，一种是官方封装的LogOutputStream。第一种，线程
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ByteArrayOutputStream errorStream = new ByteArrayOutputStream();
PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream,errorStream);
executor.setStreamHandler(streamHandler);
exec.execute(cmdline);
String out = outputStream.toString("gbk"); //设置编码
String error = errorStream.toString("gbk"); //设置编码
第二种，参考这个答案。设计
第二种是没法设置字符编码的，而第一种是得到了整个标准输出和错误输出后再设置字符编码的。
若是采用这种方式，为了知足从标准输出解析某个特殊结果是须要对这个标准输出作切分，再循环判断的。
最后我采用的是PipedInputStream和PipedOutStream的方式，这也是为何会有这个问题如何正确使用PipedInputStream和PipedOutputStream
。为了让处理标注输出、错误输出和结果描述看起来比较统一，我使用了回调的方式。
3. 回调方式处理
private void readInputStream(PipedInputStream pis, OutputCallback ...cbs) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(pis, getEncoding()));
String line = null;
while((line = br.readLine()) != null) {
for(OutputCallback cb : cbs) {
cb.parse(line); //这里能够得到结果描述
}
}
}
4. 说明
总体思路上的抽象已经作到了，可是还不够完全，抽象类exec方法体内业务逻辑仍是过于耦合的。
完整代码
ExecResult代码，
public class ExecResult {
private int exitCode;
private String stdout;
private String stderr;
private String codeInfo;
//getter and setter
}
OutputCallback接口代码，
public interface OutputCallback {
public void parse(String line);
}
AbstractCommonExecs代码，
public abstract class AbstractCommonExecs {
private Logger log = LoggerFactory.getLogger(AbstractCommonExecs.class);
private static final String DEFAULT_ENCODING = "UTF-8";
private String encoding = DEFAULT_ENCODING;
private String bin;
private List<String> arguments;
public AbstractCommonExecs(String bin, List<String> arguments) {
this.bin = bin;
this.arguments = arguments;
}
public ExecResult exec() throws IOException{
ExecResult er = new ExecResult();
//ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PipedOutputStream outputStream = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream(outputStream);
ByteArrayOutputStream errorStream = new ByteArrayOutputStream();
CodeInfoCallback codeInfoCb = new CodeInfoCallback();
StdOutputCallback stdoutCb = new StdOutputCallback();
ErrorOutputCallback stderrCb = new ErrorOutputCallback();
String stdout = null;
String stderr = null;
try {
Executor executor = getExecutor();
CommandLine cmdLine = getCommandLine();
log.info("Executing script {}",cmdLine.toString());
if(supportWatchdog()) {
executor.setWatchdog(getWatchdog());
}
PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream,errorStream);
executor.setStreamHandler(streamHandler);
int ret = executor.execute(cmdLine);
readInputStream(pis, stdoutCb, codeInfoCb);
pis.close();
readErrorStream(errorStream, stderrCb);
stdout = join(stdoutCb.getLines());
stderr = stderrCb.getErrors();
log.info("output from script {} is {}", this.bin, stdout);
log.info("error output from script {} is {}", this.bin, stderr);
log.info("exit code from script {} is {}", this.bin, ret);
er.setStdout(stdout);
er.setStderr(stderr);
er.setCodeInfo(codeInfoCb.getCodeInfo());
er.setExitCode(ret);
return er;
} catch (ExecuteException e) {
if(pis != null) {
readInputStream(pis, stdoutCb, codeInfoCb);
pis.close();
}
if(errorStream != null) {
readErrorStream(errorStream, stderrCb);
}
stdout = join(stdoutCb.getLines());
stderr = stderrCb.getErrors();
int ret = e.getExitValue();
log.info("output from script {} is {}", this.bin, stdout);
log.info("error output from script {} is {}", this.bin, stderr);
log.info("exit code from script {} is {}", this.bin, ret);
er.setStdout(stdout);
er.setStderr(stderr);
er.setCodeInfo(codeInfoCb.getCodeInfo());
er.setExitCode(ret);
return er;
}
}
/**
* 接口回调的方式解析脚本的错误输出
* @param baos
* @param cbs
* @throws IOException
*/
private void readErrorStream(ByteArrayOutputStream baos, OutputCallback ...cbs) throws IOException {
String err = baos.toString(getEncoding());
for(OutputCallback cb : cbs) {
cb.parse(err);
}
}
/**
* 接口回调的方式解析脚本的标准输出
* @param pis
* @param cbs
* @throws IOException
*/
private void readInputStream(PipedInputStream pis, OutputCallback ...cbs) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(pis, getEncoding()));
String line = null;
while((line = br.readLine()) != null) {
for(OutputCallback cb : cbs) {
cb.parse(line);
}
}
}
public Executor getExecutor() {
Executor executor = new DefaultExecutor();
executor.setWorkingDirectory(new File(this.bin).getParentFile());
return executor;
}
public CommandLine getCommandLine() {
String fullCommand = bin + join(arguments);
return CommandLine.parse(fullCommand);
}
protected String join(List<String> arguments) {
if(arguments == null || arguments.isEmpty()) {
return "";
}
StringBuilder sb = new StringBuilder();
for(String arg : arguments) {
sb.append(" ").append(arg);
}
return sb.toString();
}
/**
* @return the encoding
*/
protected String getEncoding() {
return encoding;
}
/**
* @param encoding the encoding to set
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
* @return the bin
*/
protected String getBin() {
return bin;
}
/**
* @param bin the bin to set
*/
public void setBin(String bin) {
this.bin = bin;
}
/**
* @return the arguments
*/
protected List<String> getArguments() {
return arguments;
}
/**
* @param arguments the arguments to set
*/
public void setArguments(List<String> arguments) {
this.arguments = arguments;
}
public abstract boolean supportWatchdog();
public abstract ExecuteWatchdog getWatchdog();
}
测试
1. 支持字符编码设置的测试
public class GbkCommonExecs extends AbstractCommonExecs{
/**
* @param bin
* @param arguments
*/
public GbkCommonExecs(String bin, List<String> arguments) {
super(bin, arguments);
}
/* (non-Javadoc)
* @see com.bingosoft.proxy.helper.AbstractCommonExecs#supportWatchdog()
*/
@Override
public boolean supportWatchdog() {
// TODO implement AbstractCommonExecs.supportWatchdog
return false;
}
/* (non-Javadoc)
* @see com.bingosoft.proxy.helper.AbstractCommonExecs#getWatchdog()
*/
@Override
public ExecuteWatchdog getWatchdog() {
// TODO implement AbstractCommonExecs.getWatchdog
return null;
}
//提供这个编码便可
public String getEncoding() {
return "GBK";
}
public static void main(String[] args) throws IOException {
String bin = "ping";
String arg1 = "127.0.0.1";
List<String> arguments = new ArrayList<String>();
arguments.add(arg1);
AbstractCommonExecs executable = new GbkCommonExecs(bin, arguments);
ExecResult er = executable.exec();
System.out.println(er.getExitCode());
System.out.println(er.getStdout());
System.out.println(er.getStderr());
}
}
2. 支持超时设置的测试
设置监视狗就能设置超时
public class TimeoutCommonExecs extends AbstractCommonExecs{
private Logger log = LoggerFactory.getLogger(TimeoutCommonExecs.class);
private long timeout = 10 * 1000; // 10 seconds
public TimeoutCommonExecs(String bin, List<String> arguments) {
super(bin, arguments);
}
public TimeoutCommonExecs(String bin, List<String> arguments, long timeout) {
super(bin, arguments);
this.timeout = timeout;
}
public boolean supportWatchdog() {
return true; // 使用监视狗 监视脚本执行超时的状况
}
public ExecuteWatchdog getWatchdog() {
ExecuteWatchdog watchdog = new ExecuteWatchdog(this.timeout);
return watchdog;
}
/**
* @return the timeout
*/
public long getTimeout() {
return timeout;
}
/**
* @param timeout the timeout to set
*/
public void setTimeout(long timeout) {
this.timeout = timeout;
}
}
为了方便在Windows下测试
public class TimeoutGbkCommonExecs extends TimeoutCommonExecs{
public TimeoutGbkCommonExecs(String bin, List<String> arguments, long timeout) {
super(bin, arguments, timeout);
}
//字符编码设置
public String getEncoding() {
return "GBK";
}
public static void main(String[] args) throws IOException {
String bin = "ping";
String arg1 = "-t"; //不断ping
String arg2 = "127.0.0.1";
List<String> arguments = new ArrayList<String>();
arguments.add(arg1);
arguments.add(arg2);
AbstractCommonExecs executable = new TimeoutGbkCommonExecs(bin, arguments, 5 * 1000);
ExecResult er = executable.exec();
System.out.println(er.getExitCode());
System.out.println(er.getStdout());
System.out.println(er.getStderr());
}
}
相关文章
- 1. Apache Commons BeanUtils使用笔记
- 2. Apache Commons-logging使用实例
- 3. java使用ScriptEngine: 使用java调用脚本、解析表达式
- 4. Java调用python脚本
- 5. JAVA调用R脚本
- 6. java中调用python脚本
- 7. Java调用Python脚本
- 8. JAVA调用Python脚本
- 9. JAVA调用Shell脚本
- 10. Java调用shell脚本
- 更多相关文章...
- • 在Java程序中使用Redis - Redis教程
- • Redis基本安装和使用 - Redis教程
- • Composer 安装与使用
- • Java Agent入门实战（一）-Instrumentation介绍与使用
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
