作者：BaseCN Email:basecn@163.com

-----------------------------------------------

Jsch是JAVA的SSH客户端，使用的目的是执行远程服务器上的命令。

关于Session的使用，创建连接后这个session是一直可用的，所以不需要关闭。由Session中open的Channel在使用后应该关闭。

测试了exec的方式，具体参考jsch自带example中的Exec.java。

有两个问题：

1、无法执行多条命令，每次ChannelExec在connect前要先setCommand，最后一次的设置生效。

2、由于第一个原因的限制，如果执行的命令需要环境变量(如JAVA_HOME)，就没有办法了。这种方式执行基本的ls,ps之类的命令没有问题，需要复杂的环境变量时有点力不从心。

要是哪位知道exec如何解决上面现两个问题，请分享一下！

-----------------------------------------------

虽然exec可以得到命令的执行结果，但无法满足应用，无奈之下放弃exec转而使用ChannelShell。

在使用ChannelShell的时候需要特别关注jsch的输入和输出流的设置。

输出

为了得到脚本的运行结果，设置jsch的outputStream为FileOutputStream，把shell的输出结果保存到本地文件。虽然最简单的方式是设置System.out为jsch的OutputStream，在控制台看到结果，只是无法保存下来。

FileOutputStream fileOut =newFileOutputStream( outputFileName );

channelShell.setOutputStream( fileOut );

输入

短时间运行的程序，输入可以直接设置为System.in，而长期运行的程序不能使用人工方式输入，必须由程序自动生成命令来执行。所以使用PipeStream来实现字符串输入命令：

PipedInputStream pipeIn =newPipedInputStream();

PipedOutputStream pipeOut = newPipedOutputStream( pipeIn );

channelShell.setInputStream( pipeIn );

调用pipeOut.write( cmd.getBytes() );把生成的命令输出给ssh。

运行

jsch是以多线程方式运行的，所以代码在connect后如果不disconnect Channel和Session，以及相关的Stream，程序会一直等待，直到关闭，目前还没有找到判断关闭或主动关闭的方法，相信应该有这方面的机制。

要注意一个问题，相关的Stream和Channel是一定要关闭的，那么应该在什么时候来关。执行connect后，jsch接收客户端结果需要一定的时间(以秒计)，如果马上关闭session就会发现什么都没接收到或内容不全。

可以采取两个办法来解决这个问题，一个开源一个节流

1、在connect增加一个等待延迟，等待1~2秒，这个是开源；

2、减小server端脚本的执行时间，这个是节流。给命令加上"nohup XXXX > output &"，以后台方式运行，并把运行结果输出到服务器端的本地目录下。这样脚本的执行时间可以是最小。

-----------------------------------------------

最后还有一点注意，使用shell时，看到有的朋友说执行后没有结果。解决的办法是在命令后加上"/n"字符，server端就认为是一条完整命令了。很奇怪的特性！

-----------------------------------------------

附上类代码

packagejsch;

importstaticjava.lang.String.format;

importjava.io.Closeable;

importjava.io.FileOutputStream;

importjava.io.IOException;

importjava.io.InputStream;

importjava.io.PipedInputStream;

importjava.io.PipedOutputStream;

importcom.jcraft.jsch.ChannelExec;

importcom.jcraft.jsch.ChannelShell;

importcom.jcraft.jsch.JSch;

importcom.jcraft.jsch.Session;

importcom.jcraft.jsch.UserInfo;

importcom.nsm.hermes.wand.Wand;

publicclassSshExecuter

implementsCloseable{

staticlonginterval = 1000L;

staticinttimeout =3000;

privateSshInfo sshInfo =null;

privateJSch jsch =null;

privateSession session =null;

privateSshExecuter( SshInfo info )throwsException{

sshInfo = info;

jsch = newJSch();

jsch.addIdentity( sshInfo.getKey() );

session = jsch.getSession(  sshInfo.getUser(),

sshInfo.getHost(),

sshInfo.getPort() );

UserInfo ui = newSshUserInfo( sshInfo.getPassPhrase() );

session.setUserInfo( ui );

session.connect();

}

publiclongshell( String cmd, String outputFileName )

throwsException{

longstart = System.currentTimeMillis();

ChannelShell channelShell = (ChannelShell)session.openChannel( "shell");

PipedInputStream pipeIn = newPipedInputStream();

PipedOutputStream pipeOut = newPipedOutputStream( pipeIn );

FileOutputStream fileOut = newFileOutputStream( outputFileName );

channelShell.setInputStream( pipeIn );

channelShell.setOutputStream( fileOut );

channelShell.connect( timeout );

pipeOut.write( cmd.getBytes() );

Thread.sleep( interval );

pipeOut.close();

pipeIn.close();

fileOut.close();

channelShell.disconnect();

returnSystem.currentTimeMillis() - start;

}

publicintexec( String cmd )

throwsException{

ChannelExec channelExec = (ChannelExec)session.openChannel( "exec");

channelExec.setCommand( cmd );

channelExec.setInputStream( null);

channelExec.setErrStream( System.err );

InputStream in = channelExec.getInputStream();

channelExec.connect();

intres = -1;

StringBuffer buf = newStringBuffer(1024);

byte[] tmp =newbyte[1024];

while(true) {

while( in.available() >0) {

inti = in.read( tmp,0,1024);

if( i <0)break;

buf.append( newString( tmp,0, i ) );

}

if( channelExec.isClosed() ) {

res = channelExec.getExitStatus();

System.out.println( format( "Exit-status: %d", res ) );

break;

}

Wand.waitA( 100);

}

System.out.println( buf.toString() );

channelExec.disconnect();

returnres;

}

publicstaticSshExecuter newInstance()

throwsException{

String host = "localhost";

Integer port = 22;

String user = "hadoop";

String key = "./id_dsa";

String passPhrase = "";

SshInfo i = newSshInfo( host, port, user, key, passPhrase );

returnnewSshExecuter( i );

}

publicSession getSession(){

returnsession;

}

publicvoidclose()

throwsIOException{

getSession().disconnect();

}

}

classSshInfo{

String host = null;

Integer port = 22;

String user = null;

String key = null;

String passPhrase = null;

publicSshInfo( String host,

Integer port,

String user,

String key,

String passPhrase ){

super();

this.host = host;

this.port = port;

this.user = user;

this.key = key;

this.passPhrase = passPhrase;

}

publicString getHost(){

returnhost;

}

publicInteger getPort(){

returnport;

}

publicString getUser(){

returnuser;

}

publicString getKey(){

returnkey;

}

publicString getPassPhrase(){

returnpassPhrase;

}

}

classSshUserInfoimplementsUserInfo{

privateString passphrase =null;

publicSshUserInfo( String passphrase ){

super();

this.passphrase = passphrase;

}

publicString getPassphrase(){

returnpassphrase;

}

publicString getPassword(){

returnnull;

}

publicbooleanpromptPassphrase( String pass ){

returntrue;

}

publicbooleanpromptPassword( String pass ){

returntrue;

}

publicbooleanpromptYesNo( String arg0 ){

returntrue;

}

publicvoidshowMessage( String m ){

System.out.println( m );

}

}