// 用法：Runtime.getRuntime.exec("命令")
String shpath="/test/test.sh" //程序路径
Process process =null
String mand1 = “chmod 777 ” + shpath
try {
Runtime.getRuntime.exec(mand1 ).waitFor
} catch (IOException e1) {
e1.printStackTrace
}catch (InterruptedException e) {
e.printStackTrace
}
String var="201102" /参数
String mand2 = “/bin/sh ” + shpath + ” ” + var
Runtime.getRuntime.exec(mand2).waitFor
如何在java中执行shell脚本// 用法：Runtime.getRuntime.exec("命令")
String shpath="/test/test.sh"//程序路径
Process process =null
String mand1 = “chmod 777 ” + shpath
try {
Runtime.getRuntime.exec(mand1 ).waitFor
} catch (IOException e1) {
e1.printStackTrace
}catch (InterruptedException e) {
e.printStackTrace
}
String var="201102"/参数
String mand2 = “/bin/sh ” + shpath + ” ” + var
Runtime.getRuntime.exec(mand2).waitFor
java怎么调用shell脚本String cmdstring = "chmod a+x test.sh"
Process proc = Runtime.getRuntime.exec(cmdstring)
proc.waitFor //阻塞，直到上述命令执行完
cmdstring = "bash test.sh" //这里也可以是ksh等
proc = Runtime.getRuntime.exec(cmdstring)
// 注意下面的 *** 作
string ls_1
BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(proc.getInputStream)
while ( (ls_1=bufferedReader.readLine) != null)
bufferedReader.close
proc.waitFor
为什么要有上面那段 *** 作呢？
原因是：可执行程序的输出可能会比较多，而运行窗口的输出缓冲区有限，会造成waitFor一直阻塞。解决的办法是，利用Java提供的Process类提供的getInputStream,getErrorStream方法让Java虚拟机截获被调用程序的标准输出、错误输出，在waitfor命令之前读掉输出缓冲区中的内容。
如何在java中执行shell脚本在java中执行shell脚本 用法：Runtime.getRuntime.exec("命令")
String shpath="/test/test.sh"//程序路径
Process process =null
String mand1 = “chmod 777 ” + shpath
try {
Runtime.getRuntime.exec(mand1 ).waitFor
} catch (IOException e1) {
e1.printStackTrace
}catch (InterruptedException e) {
e.printStackTrace
}
String var="201102"/参数
String mand2 = “/bin/sh ” + shpath + ” ” + var
Runtime.getRuntime.exec(mand2).waitFor
标签：作文经典 上一篇：一个人带头的成语 一个猪头带头的成语 下一篇：描写长城的语句 描写长城美景的语句怎么通过java去调用并执行shell脚本以及问题总结
以下是我在公司项目中实际应用到的：
/**
* 执行系统命令
* @time 2016/10/17$ 17:05$
*/
public final class SystemmandExecutor {
protected static Logger logger = LoggerFactory.getLogger(ShareDiskFileUtils.class)
public static final boolean isWindow
public static final boolean isLinux
static {
String osname = System.getProperty("os.name").toLowerCase
isWindow = osname.contains("win")
isLinux = osname.contains("linux")
logger.info("系统环境： " + (isLinux ? "Linux" : "Window"))
}
/**
* 执行命令
*/
public static Process executemand(String mand) throws IOException, InterruptedException {
logger.info("执行系统命令： " + mand)
Process process = Runtime.getRuntime.exec(getCmdArray(mand))
new StreamPrinter(process.getInputStream, logger).start
new StreamPrinter(process.getErrorStream, logger).start
process.waitFor
return process
}
/**
* 这个非常重要， 如果你直接执行mand，会出现一些问题，如果参数中包含一些空格，", ' 之类的特殊字符，将会执行失败，
*/
private static String[] getCmdArray(String mand) {
if (isWindow) {
return new String[]{"cmd", "/c", mand}
}
if (isLinux) {
return new String[]{"/bin/sh", "-c", mand}
}
return new String[]{"cmd", "/c", mand}
}
}
怎么通过java去调用并执行shell脚本以及问题总结// 用法：Runtime.getRuntime.exec("命令")
String shpath="/test/test.sh"//程序路径
Process process =null
String mand1 = “chmod 777 ” + shpath
try {
Runtime.getRuntime.exec(mand1 ).waitFor
} catch (IOException e1) {
e1.printStackTrace
}catch (InterruptedException e) {
e.printStackTrace
}
String var="201102"/参数
String mand2 = “/bin/sh ” + shpath + ” ” + var
Runtime.getRuntime.exec(mand2).waitFor
java怎么执行shell脚本如果shell脚本和java程序运行在不同的服务器上，可以使用远程执行Linux命令执行包，使用ssh2协议连接远程服务器，并发送执行命令就行了，ganymed.ssh2相关mave配置如下，你可以自己百度搜索相关资料。
如果shell脚本和java程序在同一台服务器上，
这里不得不提到java的process类了。
process这个类是一个抽象类，封装了一个进程（你在调用linux的命令或者shell脚本就是为了执行一个在linux下执行的程序，所以应该使用process类）。
process类提供了执行从进程输入，执行输出到进程，等待进程完成，检查进程的推出状态，以及shut down掉进程。
.ganymed.ssh2
ganymed-ssh2-build
210
本地执行命令代码如下：
String shpath="/test/test.sh" //程序路径
Process process =null
String mand1 = “chmod 777 ” + shpath
process = Runtime.getRuntime.exec(mand1)
process.waitFor
如何在java中执行shell脚本1、最常用的方法：
Process p = Runtime.getRuntime.exec(SHELL_FILE_DIR + RUNNING_SHELL_FILE +
" "+param1+" "+param2+" "+param3)
int runnngStatus = p.waitFor
2、通过ProcessBuilder进行调度，这种方法比较直观，而且参数的设置也比较方便：
ProcessBuilder pb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, param1,
param2, param3)
pb.directory(new File(SHELL_FILE_DIR))
int runningStatus = 0
String s = null
try {
Process p = pb.start
try {
runningStatus = p.waitFor
} catch (InterruptedException e) {
e.printStackTrace
}
} catch (IOException e) {
e.printStackTrace
}
if (runningStatus != 0) {
}
return
参数说明：
RUNNING_SHELL_FILE：要运行的脚本
SHELL_FILE_DIR：要运行的脚本所在的目录； 当然你也可以把要运行的脚本写成全路径。
runningStatus：运行状态，0标识正常。 详细可以看java文档。
param1, param2, param3：可以在RUNNING_SHELL_FILE脚本中直接通过1,1,2,$3分别拿到的参数。
怎么通过java去调用并执行shell脚本以及问题总结对于第一个问题：java抓取，并且把结果打包。那么比较直接的做法就是，java接收各种消息（db，metaq等等），然后借助于jstorm集群进行调度和抓取。
最后把抓取的结果保存到一个文件中，并且通过调用shell打包， 回传。 也许有同学会问，
为什么不直接把java调用odps直接保存文件，答案是，我们的集群不是hz集群，直接上传odps速度很有问题，因此先打包比较合适。（这里不纠结设计了，我们回到正题）
java调用shell的方法
通过ProcessBuilder进行调度
这种方法比较直观，而且参数的设置也比较方便， 比如我在实践中的代码(我隐藏了部分业务代码)：
ProcessBuilderpb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, param1,
param2, param3)
pb.directory(new File(SHELL_FILE_DIR))
int runningStatus = 0
String s = null
try {
Process p = pb.start
try {
runningStatus = p.waitFor
} catch (InterruptedException e) {
}
} catch (IOException e) {
}
if (runningStatus != 0) {
}
return
这里有必要解释一下几个参数：
RUNNING_SHELL_FILE：要运行的脚本
SHELL_FILE_DIR：要运行的脚本所在的目录； 当然你也可以把要运行的脚本写成全路径。
runningStatus：运行状态，0标识正常。 详细可以看java文档。
param1, param2, param3：可以在RUNNING_SHELL_FILE脚本中直接通过1,2,$3分别拿到的参数。
直接通过系统Runtime执行shell
这个方法比较暴力，也比较常用， 代码如下：
p = Runtime.getRuntime.exec(SHELL_FILE_DIR + RUNNING_SHELL_FILE + " "+param1+" "+param2+" "+param3)
p.waitFor
我们发现，通过Runtime的方式并没有builder那么方便，特别是参数方面，必须自己加空格分开，因为exec会把整个字符串作为shell运行。
可能存在的问题以及解决方法
如果你觉得通过上面就能满足你的需求，那么可能是要碰壁了。你会遇到以下情况。
没权限运行
这个情况我们团队的朱东方就遇到了， 在做DTS迁移的过程中，要执行包里面的shell脚本， 解压出来了之后，发现执行不了。 那么就按照上面的方法授权吧
java进行一直等待shell返回
这个问题估计更加经常遇到。 原因是， shell脚本中有echo或者print输出， 导致缓冲区被用完了! 为了避免这种情况， 一定要把缓冲区读一下， 好处就是，可以对shell的具体运行状态进行log出来。 比如上面我的例子中我会变成：
ProcessBuilderpb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, keyword.trim,
taskId.toString, fileName)
pb.directory(new File(CASPERJS_FILE_DIR))
int runningStatus = 0
String s = null
try {
Process p = pb.start
BufferedReaderstdInput = new BufferedReader(new InputStreamReader(p.getInputStream))
BufferedReaderstdError = new BufferedReader(new InputStreamReader(p.getErrorStream))
while ((s = stdInput.readLine) != null) {
LOG.error(s)
}
while ((s = stdError.readLine) != null) {
LOG.error(s)
}
try {
runningStatus = p.waitFor
} catch (InterruptedException e) {
}
记得在start之后， waitFor（）之前把缓冲区读出来打log， 就可以看到你的shell为什么会没有按照预期运行。 这个还有一个好处是，可以读shell里面输出的结果， 方便java代码进一步 *** 作。
也许你还会遇到这个问题，明明手工可以运行的命令，java调用的shell中某一些命令居然不能执行，报错：命令不存在！
比如我在使用casperjs的时候，手工去执行shell明明是可以执行的，但是java调用的时候，发现总是出错。
通过读取缓冲区就能发现错误日志了。 我发现即便自己把安装的casperjs的bin已经加入了path中（/etc/profile,
各种bashrc中）还不够。 比如：
exportNODE_HOME="/home/admin/node"
exportCASPERJS_HOME="/home/admin/casperjs"
exportPHANTOMJS_HOME="/home/admin/phantomjs"
exportPATH=$PATH:$JAVA_HOME/bin:/root/bin:$NODE_HOME/bin:$CASPERJS_HOME/bin:$PHANTOMJS_HOME/bin
原来是因为java在调用shell的时候，默认用的是系统的/bin/下的指令。特别是你用root权限运行的时候。 这时候，你要在/bin下加软链了。针对我上面的例子，就要在/bin下加软链：
ln -s /home/admin/casperjs/bin/casperjscasperjs
ln -s /home/admin/node/bin/nodenode
ln -s /home/admin/phantomjs/bin/phantomjsphantomjs
这样，问题就可以解决了。
如果是通过java调用shell进行打包，那么要注意路径的问题了
因为shell里面tar的压缩和解压可不能直接写：
tar -zcf /home/admin/data/result.tar.gz /home/admin/data/result
直接给你报错，因为tar的压缩源必须到路径下面， 因此可以写成
tar -zcf /home/admin/data/result.tar.gz -C /home/admin/data/ result
如果我的shell是在jar包中怎么办？
答案是：解压出来。再按照上面指示进行 *** 作。（1）找到路径
String jarPath = findClassJarPath(ClassLoaderUtil.class)
JarFiletopLevelJarFile = null
try {
topLevelJarFile = new JarFile(jarPath)
Enumeration entries = topLevelJarFile.entries
while (entries.hasMoreElements) {
JarEntryentry = entries.nextElement
if (!entry.isDirectory entry.getName.endsWith(".sh")) {
对你的shell文件进行处理
}
}
对文件处理的方法就简单了，直接touch一个临时文件，然后把数据流写入，代码：
FileUtils.touch(tempjline)
tempjline.deleteOnExit
FileOutputStreamfos = new FileOutputStream(tempjline)
IOUtils.copy(ClassLoaderUtil.class.getResourceAsStream(r), fos)
fos.close
如何在java中执行shell脚本首先你可以百度搜一下 java Process 类的用法，很多博文都有讲解。
另外我补充一下我再使用过程中的一些点：
process = Runtime.getRuntime.exec(new String[]{"/bin/sh","-c",shellContext})
其中 shellContext 是shel脚本字符串
这句提交的时候，不少博文 exec中是直接提交shellContext。
但是对于一些场景不适用，取出来数据跟直接运行shell脚本有差异，可以改成我这种写法。
标签：作文经典 上一篇：一个人带头的成语 一个猪头带头的成语 下一篇：描写长城的语句 描写长城美景的语句*** 运行shell脚本
* @param shell 需要运行的shell脚本
*/
public static void execShell(String shell){
try {
Runtime rt = Runtime.getRuntime()
rt.exec(shell)
} catch (Exception e) {
e.printStackTrace()
}
}
/**
* 运行shell
*
* @param shStr
*需要执行的shell
* @return
* @throws IOException
*/
public static List runShell(String shStr) throws Exception {
List<String>strList = new ArrayList()
Process process
process = Runtime.getRuntime().exec(new String[]{"/bin/sh","-c",shStr},null,null)
InputStreamReader ir = new InputStreamReader(process
.getInputStream())
LineNumberReader input = new LineNumberReader(ir)
String line
process.waitFor()
while ((line = input.readLine()) != null){
strList.add(line)
}
return strList
}
对于第一个问题：java抓取，并且把结果打包。那么比较直接的做法就是，java接收各种消息（db，metaq等等），然后借助于jstorm集群进行调度和抓取。最后把抓取的结果保存到一个文件中，并且通过调用shell打包， 回传。 也许有同学会问，
为什么不直接把java调用odps直接保存文件，答案是，我们的集群不是hz集群，直接上传odps速度很有问题，因此先打包比较合适。（这里不纠结设计了，我们回到正题）
java调用shell的方法
通过ProcessBuilder进行调度
这种方法比较直观，而且参数的设置也比较方便， 比如我在实践中的代码(我隐藏了部分业务代码)：
ProcessBuilderpb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, param1,
param2, param3)
pb.directory(new File(SHELL_FILE_DIR))
int runningStatus = 0
String s = null
try {
Process p = pb.start()
try {
runningStatus = p.waitFor()
} catch (InterruptedException e) {
}
} catch (IOException e) {
}
if (runningStatus != 0) {
}
return
这里有必要解释一下几个参数：
RUNNING_SHELL_FILE：要运行的脚本
SHELL_FILE_DIR：要运行的脚本所在的目录； 当然你也可以把要运行的脚本写成全路径。
runningStatus：运行状态，0标识正常。 详细可以看java文档。
param1, param2, param3：可以在RUNNING_SHELL_FILE脚本中直接通过1,2,$3分别拿到的参数。
直接通过系统Runtime执行shell
这个方法比较暴力，也比较常用， 代码如下：
p = Runtime.getRuntime().exec(SHELL_FILE_DIR + RUNNING_SHELL_FILE + " "+param1+" "+param2+" "+param3)
p.waitFor()
我们发现，通过Runtime的方式并没有builder那么方便，特别是参数方面，必须自己加空格分开，因为exec会把整个字符串作为shell运行。
可能存在的问题以及解决方法
如果你觉得通过上面就能满足你的需求，那么可能是要碰壁了。你会遇到以下情况。
没权限运行
这个情况我们团队的朱东方就遇到了， 在做DTS迁移的过程中，要执行包里面的shell脚本， 解压出来了之后，发现执行不了。 那么就按照上面的方法授权吧
java进行一直等待shell返回
这个问题估计更加经常遇到。 原因是， shell脚本中有echo或者print输出， 导致缓冲区被用完了! 为了避免这种情况， 一定要把缓冲区读一下， 好处就是，可以对shell的具体运行状态进行log出来。 比如上面我的例子中我会变成：
ProcessBuilderpb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, keyword.trim(),
taskId.toString(), fileName)
pb.directory(new File(CASPERJS_FILE_DIR))
int runningStatus = 0
String s = null
try {
Process p = pb.start()
BufferedReaderstdInput = new BufferedReader(new InputStreamReader(p.getInputStream()))
BufferedReaderstdError = new BufferedReader(new InputStreamReader(p.getErrorStream()))
while ((s = stdInput.readLine()) != null) {
LOG.error(s)
}
while ((s = stdError.readLine()) != null) {
LOG.error(s)
}
try {
runningStatus = p.waitFor()
} catch (InterruptedException e) {
}
记得在start()之后， waitFor（）之前把缓冲区读出来打log， 就可以看到你的shell为什么会没有按照预期运行。 这个还有一个好处是，可以读shell里面输出的结果， 方便java代码进一步 *** 作。
也许你还会遇到这个问题，明明手工可以运行的命令，java调用的shell中某一些命令居然不能执行，报错：命令不存在！
比如我在使用casperjs的时候，手工去执行shell明明是可以执行的，但是java调用的时候，发现总是出错。
通过读取缓冲区就能发现错误日志了。 我发现即便自己把安装的casperjs的bin已经加入了path中（/etc/profile,
各种bashrc中）还不够。 比如：
exportNODE_HOME="/home/admin/node"
exportCASPERJS_HOME="/home/admin/casperjs"
exportPHANTOMJS_HOME="/home/admin/phantomjs"
exportPATH=$PATH:$JAVA_HOME/bin:/root/bin:$NODE_HOME/bin:$CASPERJS_HOME/bin:$PHANTOMJS_HOME/bin
原来是因为java在调用shell的时候，默认用的是系统的/bin/下的指令。特别是你用root权限运行的时候。 这时候，你要在/bin下加软链了。针对我上面的例子，就要在/bin下加软链：
ln -s /home/admin/casperjs/bin/casperjscasperjs
ln -s /home/admin/node/bin/nodenode
ln -s /home/admin/phantomjs/bin/phantomjsphantomjs
这样，问题就可以解决了。
如果是通过java调用shell进行打包，那么要注意路径的问题了
因为shell里面tar的压缩和解压可不能直接写：
tar -zcf /home/admin/data/result.tar.gz /home/admin/data/result
直接给你报错，因为tar的压缩源必须到路径下面， 因此可以写成
tar -zcf /home/admin/data/result.tar.gz -C /home/admin/data/ result
如果我的shell是在jar包中怎么办？
答案是：解压出来。再按照上面指示进行 *** 作。（1）找到路径
String jarPath = findClassJarPath(ClassLoaderUtil.class)
JarFiletopLevelJarFile = null
try {
topLevelJarFile = new JarFile(jarPath)
Enumeration<JarEntry>entries = topLevelJarFile.entries()
while (entries.hasMoreElements()) {
JarEntryentry = entries.nextElement()
if (!entry.isDirectory() entry.getName().endsWith(".sh")) {
对你的shell文件进行处理
}
}
对文件处理的方法就简单了，直接touch一个临时文件，然后把数据流写入，代码：
FileUtils.touch(tempjline)
tempjline.deleteOnExit()
FileOutputStreamfos = new FileOutputStream(tempjline)
IOUtils.copy(ClassLoaderUtil.class.getResourceAsStream(r), fos)
fos.close()
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）