java连接远程服务器之manyged-ssh2 (windows和linux)

一、所需要的jar包

　　需要借助Ganymed SSH的jar包:  ganymed-ssh2-262.jar

　　下载地址： http://www.ganymed.ethz.ch/ssh2/

　　API详情:  http://www.ganymed.ethz.ch/ssh2/javadoc/ch/ethz/ssh2/package-summary.html

二、实现原理

　　Ganymed SSH-2 java在整个访问过程中担当SSH的客户端，由于Linux系统自带SSH服务，所以可以直接访问Linux系统并执行相关命令，而 Windows系统则需要首先安装SSH服务。

三、windows下ssh服务安装与配置

　　当远程服务器为Windows系统时， 需要在远程服务器中安装Windows版的SSH服务，比如：freesshd。

　  freesshd下载地址： http://www.freesshd.com/?ctt=download

    freesshd安装与配置：（可以参考：http://www.cnblogs.com/xred/archive/2012/04/21/2461627.html）

　　1.安装完freesshd后，首选在[Users]下添加用来远程连接的win系统用户，此处采用密码认证的方式,允许使用shell：

2.然后再在【Authentication】下设置允许密码认证方式：

3.到[Server status]下查看SSH服务器状态，确保启动即可。最后点击【确定】即可。

四、java代码实现远程连接服务器并执行命令

1、接收执行命令返回pojo

 package com.mu.mujup.governor.base.tomcatOper;

 public class Result {
     private String stdOut;
     private String stdErr;
     private int status;
     public int getStatus() {
         return status;
     }
     public void setStatus(int status) {
         this.status = status;
     }
     public String getStdOut() {
         return stdOut;
     }
     public void setStdOut(String stdOut) {
         this.stdOut = stdOut;
     }
     public String getStdErr() {
         return stdErr;
     }
     public void setStdErr(String stdErr) {
         this.stdErr = stdErr;
     }
 }

Result

2、给前台返回对象

 package com.mu.mujup.governor.base.tomcatOper;

 public class BackEntity {

     private int status;
     private String errMessage;
     private String operator;
     public int getStatus() {
         return status;
     }
     public void setStatus(int status) {
         this.status = status;
     }
     public String getOperator() {
         return operator;
     }
     public void setOperator(String operator) {
         this.operator = operator;
     }
     public String getErrMessage() {
         return errMessage;
     }
     public void setErrMessage(String errMessage) {
         this.errMessage = errMessage;
     }

 }

BackEntity

3、linux命令执行线程，这个线程执行linux命令并返回执行结果

 package com.mu.mujup.governor.base.tomcatOper;

 import java.io.IOException;
 import java.io.InputStream;

 import ch.ethz.ssh2.Session;

 /**
  * @author  jing.zhang
  * @date 创建时间：2016年6月27日 上午8:52:02
  * @version 1.0
  * @description
  */
 public class TomcatThread extends Thread{
     Object thread;
     String cmds;
     Session sess;
     Result result;
     private final String charset = "UTF-8";
     public TomcatThread(Object thread,String cmds,Session sess){
         this.thread = thread;
         this.cmds = cmds;
         this.sess = sess;
     }
     private void test(Object thread,String str){
         Result result = new Result();
         try{
             long start = System.currentTimeMillis();
             sess.execCommand(cmds);
             System.out.println("时长是=="+(System.currentTimeMillis()-start));
             InputStream stdout = sess.getStdout();
             InputStream stderr = sess.getStderr();
             result.setStdOut(processStream(stdout, charset));
             result.setStdErr(processStream(stderr, charset));
             result.setStatus(sess.getState());
             this.result = result;
             synchronized (thread) {
                 thread.notify();
             }
         }catch(IOException e){
             this.result = null;
         }

     }

     private String processStream(InputStream in, String charset)
             throws IOException {
         byte[] buf = new byte[1024];
         StringBuilder sb = new StringBuilder();
         while (in.read(buf) != -1) {
             sb.append(new String(buf, charset));
         }
         return sb.toString();
     }

     public Result getRunback(){
         return this.result;
     }

     public void run() {
         test(thread,cmds);
     }
 }

TomcatThread

4、执行入口类（主线程），在方法exec处另起TomcatThread线程执行命令，并让主线程等待相应时间，主线程等待时间到了就结束子线程，

并用getRunback()获取子线程执行结果。如果超时返回为null。

 package com.mu.mujup.governor.base.tomcatOper;

 import java.io.IOException;
 import java.io.InputStream;

 import ch.ethz.ssh2.Connection;
 import ch.ethz.ssh2.Session;

 import com.eos.system.annotation.Bizlet;

 /**
  *
  * @author  jing.zhang
  * @date 创建时间：2016年6月15日 下午4:31:16
  * @version 1.0
  * @description gonernor远程控制tomcat类
  */

 @Bizlet("")
 public class TomcatOperater {
     //    private String hostName;
     //    private String userName;
     //    private String password;
     private final String charset = "UTF-8";

     private final String CHECK_TOMCAT_CMD = "curl -o /root/null -s -m 10 --connect-timeout 60 -w %{http_code} ";

     public TomcatOperater() {

     }

     //    public TomcatOperater(String hostName, String userName, String password) {
     //        this.hostName = hostName;
     //        this.userName = userName;
     //        this.password = password;
     //    }

     /*
      *
      * @parameter
      * @return
      * @description 验证用户，是否接入服务器成功
      */
     //    private boolean login() throws IOException {
     //        conn = new Connection(hostName);
     //        conn.connect();
     //        return conn.authenticateWithPassword(userName, password);
     //    }

     /*
      *
      * @parameter
      * @return
      * @description 执行命令获得封装的Result对象
      */
     private Result exec(Connection conn, String cmds ,long time) {
         Result result = new Result();
         try {
             Session sess = conn.openSession();
 //            sess.execCommand(cmds);
 //            InputStream stdout = sess.getStdout();
 //            InputStream stderr = sess.getStderr();
 //            result.setStdOut(processStream(stdout, charset));
 //            result.setStdErr(processStream(stderr, charset));
 //            result.setStatus(sess.getState());

             TomcatThread test = new TomcatThread(this,cmds,sess);
             test.start();
             synchronized (this) {
                 this.wait(time);
             }
             result =  test.getRunback();
             test.interrupt();
             sess.close();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {

             //conn.close();
         }
         return result;
     }

     /*
      *
      * @parameter
      * @return
      * @description 检查tomcat状态 000-关闭  200-启动
      */
     private boolean isStart(Connection conn, String hostName)
             throws IOException {
         String result = null;
         InputStream in = null;
         //'http://172.31.69.130:8080'
         String url = "'http://" + hostName + ":8080'";
         String cmds = CHECK_TOMCAT_CMD + url;
         Session session = conn.openSession();
         session.execCommand(cmds);
         in = session.getStdout();
         result = processStream(in, charset).trim();
         session.close();
         return "200".equals(result) ? true : false;
     }

     /*
      *
      * @parameter
      * @return
      * @description 将流转化成字符串
      */
     private String processStream(InputStream in, String charset)
             throws IOException {
         byte[] buf = new byte[1024];
         StringBuilder sb = new StringBuilder();
         while (in.read(buf) != -1) {
             sb.append(new String(buf, charset));
         }
         return sb.toString();
     }

     @Bizlet("启动tomcat")
     public BackEntity startTomcat(String osUsername ,String osPassword,String tmcStartBatch ,String ip,String adminPort) throws IOException {
         BackEntity backEntity = new BackEntity();

         //测试开始
         ip = "172.31.69.130";
         osUsername = "root";
         osPassword = "root123";
         adminPort = "8080";
         tmcStartBatch = "/root/apache-tomcat-7.0.69/bin/startup.sh";
         //测试结束
         Connection conn = new Connection(ip);
         conn.connect();
         boolean loginFlag = conn.authenticateWithPassword(osUsername, osPassword);
         long time = 1000;
         if (loginFlag) {
             if (!isStart(conn, ip)) {
                 Result result = exec(conn, tmcStartBatch,time);
                 if(result!=null){
                     if (result.getStdErr().trim().equals("")) {
                         backEntity.setErrMessage("success");
                     } else {
                         backEntity.setErrMessage(result.getStdErr());
                     }
                 }else{
                     backEntity.setErrMessage("启动超时");
                 }
             } else {
                 backEntity.setErrMessage("success");
             }
         } else {
             backEntity.setErrMessage("服务器连接异常");
         }
         conn.close();
         return backEntity;
     }

     @Bizlet("关闭tomcat")
     public BackEntity stopTomcat(String osUsername ,String osPassword,String tmcStopBatch ,String ip,String adminPort) throws IOException {
         BackEntity backEntity = new BackEntity();

         //测试开始
         ip = "172.31.69.130";
         osUsername = "root";
         osPassword = "root123";
         adminPort = "8080";
         tmcStopBatch = "/root/apache-tomcat-7.0.69/bin/startup.sh";
         //测试结束

         Connection conn = new Connection(ip);
         conn.connect();
         boolean loginFlag = conn.authenticateWithPassword(osUsername, osPassword);
         long time = 10000000;//脚本执行超时时间
         if (loginFlag) {
             if (!isStart(conn, ip)) {
                 Result result = exec(conn, tmcStopBatch,time);
                 if(result!=null){
                     if (result.getStdErr().trim().equals("")) {
                         backEntity.setErrMessage("success");
                     } else {
                         backEntity.setErrMessage(result.getStdErr());
                     }
                 }else{
                     backEntity.setErrMessage("关闭超时");
                 }
             } else {
                 backEntity.setErrMessage("success");
             }
         } else {
             backEntity.setErrMessage("服务器连接异常");
         }
         conn.close();
         return backEntity;
     }

     @Bizlet("判断ip，用户名，密码,启动脚本是否为空")
     public BackEntity validateNull(String osUsername ,String osPassword,String tmcStartBatch ,String ip,String adminPort) {
         System.out.println("开始。。。。。。。。");
         BackEntity backEntity = new BackEntity();
         if(isNotEnputy(tmcStartBatch)&&isNotEnputy(ip)&&isNotEnputy(osPassword)&&isNotEnputy(osUsername)&&isNotEnputy(adminPort)){
             backEntity.setStatus(0);
         }else{
             backEntity.setStatus(1);
         }
         return backEntity;
     }

     private boolean isNotEnputy(String str){
         if(str==null||str.equals("")){
             return false;
         }
         return true;
     }
 }

TomcatOperater