java執行sh腳本
文件名確實不對
.sh文件才是linux下的批處理文件，它不認bat的
另外要保證.sh中調用的其他函數在當前目錄下能正常運行
B. 如何在java中執行shell腳本
1、最常用的方法：
Processp=Runtime.getRuntime().exec(SHELL_FILE_DIR+RUNNING_SHELL_FILE+
""+param1+""+param2+""+param3);
intrunnngStatus=p.waitFor();
2、通過ProcessBuilder進行調度，這種方法比較直觀，而且參數的設置也比較方便：
ProcessBuilderpb=newProcessBuilder("./"+RUNNING_SHELL_FILE,param1,
param2,param3);
pb.directory(newFile(SHELL_FILE_DIR));
intrunningStatus=0;
Strings=null;
try{
Processp=pb.start();
try{
runningStatus=p.waitFor();
}catch(InterruptedExceptione){
e.printStackTrace();
}
}catch(IOExceptione){
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分別拿到的參數。
C. 如何在java中執行shell腳本
import java.io.IOException;
public class test {
public static void main(String[] args) throws IOException,InterruptedException {
//Runtime.getRuntime().exec("/Users/lijialiang/codetest/stop.sh jmeter");
//Runtime.getRuntime().exec(new String[]{"/bin/sh","-c","/codetest/stop.sh jmeter"});
//Runtime.getRuntime().exec(new String[]{"/bin/sh","-c","ps -ef | grep jmeter | grep -v 'grep' |awk '{print $2}'>>result.txt"});
Runtime.getRuntime().exec(new String[]{"/bin/sh","-c","ps -ef | grep <span style="font-family: Arial, Helvetica, sans-serif;">jmeter</span><span style="font-family: Arial, Helvetica, sans-serif;"> | awk '{print $2}' | xargs kill -9"});</span>
//Thread.sleep(100000);
}
}
D. 如何在java中執行shell腳本
過CommandHelper.execute方法可以執行命令，該類實現
復制代碼代碼如下:
package javaapplication3;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
*
* @author chenshu
*/
public class CommandHelper {
//default time out, in millseconds
public static int DEFAULT_TIMEOUT;
public static final int DEFAULT_INTERVAL = 1000;
public static long START;
public static CommandResult exec(String command) throws IOException, InterruptedException {
Process process = Runtime.getRuntime().exec(command);
CommandResult commandResult = wait(process);
if (process != null) {
process.destroy();
}
return commandResult;
}
private static boolean isOverTime() {
return System.currentTimeMillis() - START >= DEFAULT_TIMEOUT;
}
private static CommandResult wait(Process process) throws InterruptedException, IOException {
BufferedReader errorStreamReader = null;
BufferedReader inputStreamReader = null;
try {
errorStreamReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
inputStreamReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
//timeout control
START = System.currentTimeMillis();
boolean isFinished = false;
for (;;) {
if (isOverTime()) {
CommandResult result = new CommandResult();
result.setExitValue(CommandResult.EXIT_VALUE_TIMEOUT);
result.setOutput("Command process timeout");
return result;
}
if (isFinished) {
CommandResult result = new CommandResult();
result.setExitValue(process.waitFor());
//parse error info
if (errorStreamReader.ready()) {
StringBuilder buffer = new StringBuilder();
String line;
while ((line = errorStreamReader.readLine()) != null) {
buffer.append(line);
}
result.setError(buffer.toString());
}
//parse info
if (inputStreamReader.ready()) {
StringBuilder buffer = new StringBuilder();
String line;
while ((line = inputStreamReader.readLine()) != null) {
buffer.append(line);
}
result.setOutput(buffer.toString());
}
return result;
}
try {
isFinished = true;
process.exitValue();
} catch (IllegalThreadStateException e) {
// process hasn't finished yet
isFinished = false;
Thread.sleep(DEFAULT_INTERVAL);
}
}
} finally {
if (errorStreamReader != null) {
try {
errorStreamReader.close();
} catch (IOException e) {
}
}
if (inputStreamReader != null) {
try {
inputStreamReader.close();
} catch (IOException e) {
}
}
}
}
}
CommandHelper類使用了CommandResult對象輸出結果錯誤信息。該類實現
復制代碼代碼如下:
package javaapplication3;
/**
*
* @author chenshu
*/
public class CommandResult {
public static final int EXIT_VALUE_TIMEOUT=-1;
private String output;
void setOutput(String error) {
output=error;
}
String getOutput(){
return output;
}
int exitValue;
void setExitValue(int value) {
exitValue=value;
}
int getExitValue(){
return exitValue;
}
private String error;
/**
* @return the error
*/
public String getError() {
return error;
}
/**
* @param error the error to set
*/
public void setError(String error) {
this.error = error;
}
}
E. 怎麼通過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<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.(ClassLoaderUtil.class.getResourceAsStream(r), fos);
fos.close();
F. 啟動Java應用的Shell腳本
對於Java應用程序（非web應用） 在部署後 常常需要一個啟動腳本來載入一些第三方的jar包 並啟動應用
對於java應用程序 我一般喜歡將程序的目錄結構寫成如下的方式
myapp
| lib
| bin
| packages
一些配置文件和屬性文件
一個startup sh 或bat啟動腳本
其中 packages是程序的根包 其中有子包和class文件等
在包中 有一個Main calss的類 這個作為程序的入口
下面給出一個最一般的寫法
startup sh #!/bin/sh
programdir=
num=$#
temp=$CLASSPATH
#setting libs path
libs= /lib/*
append(){
temp=$temp : $
}
for file in $libs; do
append $file
done
export CLASSPATH=$temp: : /:$programdir
export LANG=zh_CN
nohup java classpath $CLASSPATH packaages xxx yyy Main &
這樣 只要按照上面的方式組織程序 啟動腳本就需要改動下Main前面的包路徑即可
nohup 上面腳本中最後一行前有nohup 這是將程序的輸入輸出都將附加到當前目錄的 nohup out 文件中
lishixin/Article/program/Java/hx/201311/25993
G. 怎樣在java代碼中調用執行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;
}
H. Java中的JSP怎麼調用shell腳本
用.sh 腳本call 第一不會超時的，第二隻要你後台call進去了，就算前台超時了 後台還是一直在執行 建議把你的java program打包成jar 直接call 你的jar 包 列子 #!/bin/bash java -cp ./config:/activation.jar:/axis.jar:test.jar com.Test.run param1，param2 -cp 是你文件 path config 是你配置文件放置位置， jar 和 sh script 同一級目錄（可以根據你具體自己修改） 最後只是你需要run 的class了， 在class 裡面去call 你對應的procere
I. sh腳本如何自動執行java程序，並且該腳本如何被定期調用
各位好我有一個問題，是這樣： 環境：有一套管理系統（包括聯機和批量），該管理系統白天運行聯機系統，晚上運行批量系統。 目的：聯機系統運行到晚上，會停掉，這時候通過在unix下的sh腳本調用並且啟動批量系統。 sh腳本可以調用java程序，通過java程序就可以啟動了批量系統。 andilyliao 寫道最簡單的方法 你可以用java寫一個job 然後每天晚上執行sh mginobili 寫道可以在腳本中 實現一個定時功能啊 比如每隔半小時 檢查一次當前的時間 如果到了晚上 就停止聯機系統，運行批量系統 當然前提是 這個sh腳本要一直保持運行狀態 並且其錯誤處理機制要完善問題補充：哦。你的意思是不是這樣啊， 這個sh腳本作為一個定時器，定時調用啟動聯機系統或者批量系統的程序。 通過while（1）這樣一個循環，一直運行不中斷，然後sleep一定時間，就調用聯機的啟動程序，再過一定時間，關閉聯機啟動批量系統。
J. 如何在java程序中調用linux命令或者shell腳本
做到這，主要依賴2個類：Process和Runtime。
首先看一下Process類：
ProcessBuilder.start() 和 Runtime.exec 方法創建一個本機進程，並返回 Process 子類的一個實例，
該實例可用來控制進程並獲得相關信息。Process 類提供了執行從進程輸入、執行輸出到進程、等待進程完成、
檢查進程的退出狀態以及銷毀（殺掉）進程的方法。
創建進程的方法可能無法針對某些本機平台上的特定進程很好地工作，比如，本機窗口進程，守護進程，Microsoft Windows
上的 Win16/DOS 進程，或者 shell 腳本。創建的子進程沒有自己的終端或控制台。它的所有標准 io（即 stdin、stdout 和 stderr）
操作都將通過三個流 (getOutputStream()、getInputStream() 和 getErrorStream()) 重定向到父進程。
父進程使用這些流來提供到子進程的輸入和獲得從子進程的輸出。因為有些本機平台僅針對標准輸入和輸出流提供有限的緩沖區大小，
如果讀寫子進程的輸出流或輸入流迅速出現失敗，則可能導致子進程阻塞，甚至產生死鎖。
當沒有 Process 對象的更多引用時，不是刪掉子進程，而是繼續非同步執行子進程。
對於帶有 Process 對象的 Java 進程，沒有必要非同步或並發執行由 Process 對象表示的進程。
特別需要注意的是：
1，創建的子進程沒有自己的終端控制台，所有標注操作都會通過三個流
(getOutputStream()、getInputStream() 和 getErrorStream()) 重定向到父進程（父進程可通過這些流判斷子進程的執行情況）
2，因為有些本機平台僅針對標准輸入和輸出流提供有限的緩沖區大小，如果讀寫子進程的輸出流或輸入流迅速出現失敗，
則可能導致子進程阻塞，甚至產生死鎖
abstract void destroy()
殺掉子進程。
abstract int exitValue()
返回子進程的出口值。根據慣例，值0表示正常終止。
abstract InputStream getErrorStream()
獲取子進程的錯誤流。
abstract InputStream getInputStream()
獲取子進程的輸入流。
abstract OutputStream getOutputStream()
獲取子進程的輸出流。
abstract int waitFor()
導致當前線程等待，如有必要，一直要等到由該 Process 對象表示的進程已經終止。
如果已終止該子進程，此方法立即返回。如果沒有終止該子進程，調用的線程將被阻塞，直到退出子進程。
特別需要注意：如果子進程中的輸入流，輸出流或錯誤流中的內容比較多，最好使用緩存（注意上面的情況2）
再來看一下Runtime類：
每個Java應用程序都有一個Runtime類實例，使應用程序能夠與其運行的環境相連接。可以通過getRuntime方法獲取當前運行時環境。
應用程序不能創建自己的Runtime類實例。
介紹幾個主要方法：
Process exec(String command)
在單獨的進程中執行指定的字元串命令。
Process exec(String command, String[] envp)
在指定環境的單獨進程中執行指定的字元串命令。
Process exec(String command, String[] envp, File dir)
在有指定環境和工作目錄的獨立進程中執行指定的字元串命令。
Process exec(String[] cmdarray)
在單獨的進程中執行指定命令和變數。
Process exec(String[] cmdarray, String[] envp)
在指定環境的獨立進程中執行指定命令和變數。
Process exec(String[] cmdarray, String[] envp, File dir)
在指定環境和工作目錄的獨立進程中執行指定的命令和變數。
command：一條指定的系統命令。
envp：環境變數字元串數組，其中每個環境變數的設置格式為name=value；如果子進程應該繼承當前進程的環境，則該參數為null。
dir：子進程的工作目錄；如果子進程應該繼承當前進程的工作目錄，則該參數為null。
cmdarray：包含所調用命令及其參數的數組。
以下為示例（要打成可執行jar包扔到linux下執行）：
public class test {
public static void main(String[] args){
InputStream in = null;
try {
Process pro = Runtime.getRuntime().exec(new String[]{"sh",
"/home/test/test.sh","select admin from M_ADMIN",
"/home/test/result.txt"});
pro.waitFor();
in = pro.getInputStream();
BufferedReader read = new BufferedReader(new InputStreamReader(in));
String result = read.readLine();
System.out.println("INFO:"+result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
在這用的是Process exec(String[] cmdarray)這個方法
/home/test/test.sh腳本如下：
#!/bin/sh
#查詢sql
SQL=$1
#查詢結果保存文件
RESULT_FILE=$2
#資料庫連接
DB_NAME=scott
DB_PWD=tiger
DB_SERVER=DB_TEST
RESULT=`sqlplus -S ${DB_NAME}/${DB_PWD}@${DB_SERVER}<< !
set heading off
set echo off
set pages 0
set feed off
set linesize 3000
${SQL}
/
commit
/
!`
echo "${RESULT}" >> ${RESULT_FILE}
echo 0;
特別需要注意的是，當需要執行的linux命令帶有管道符時（例如：ps -ef|grep java），用上面的方法是不行的，解決方式是將需要執行的命令作為參數傳給shell
public class Test {
public static void main(String[] args) throws Exception{
String[] cmds = {"/bin/sh","-c","ps -ef|grep java"};
Process pro = Runtime.getRuntime().exec(cmds);
pro.waitFor();
InputStream in = pro.getInputStream();
BufferedReader read = new BufferedReader(new InputStreamReader(in));
String line = null;
while((line = read.readLine())!=null){
System.out.println(line);
}
}
}
PS:
Runtime.getRuntime().exec()這種調用方式在java虛擬機中是十分消耗資源的，即使命令可以很快的執行完畢，頻繁的調用時創建進程消耗十分客觀。
java虛擬機執行這個命令的過程是，首先克隆一條和當前虛擬機擁有一樣環境變數的進程，再用這個新的進程執行外部命令，最後退出這個進程。頻繁的創建對CPU和內存的消耗很大。