zoukankan      html  css  js  c++  java

  • 【Jsch】使用SSH协议连接到远程Shell执行脚本


    如果大家熟悉Linux的话，一定对ssh,sftp,scp等命令非常熟悉，ssh是一个安全协议，用来在不同系统或者服务器之间进行安全连接，SSH 在连接和传送的过程中会加密所有的数据。
    但是SSH一般是基于客户端的或者Linux命令行的，比如客户端的工具:OpenSSH,putty,SSH Tectia；
    在linux上大家可以通过ssh username@host连接到所要想连接的主机。
    但是如果在J2EE中，如何实现SSH呢？进而可以实现SCP,SFTP的功能呢？下面介绍的JSCH就可以实现下边的功能。
    JSCH是一个纯粹的用java实现SSH功能的java  library;
    maven依赖
    1. <dependency>
    2.     <groupId>com.jcraft</groupId>
    3.     <artifactId>jsch</artifactId>
    4.     <version>0.1.44</version>
    5. </dependency>

    关键类介绍

    • JSch:  作为中心配置点，以及Session的工厂；
     This class serves as a central configuration point, and as a factory for Session objects configured with these settings.
    1. Use getSession to start a new Session.
    2. Use one of the addIdentity methods for public-key authentication.
    3. Use setKnownHosts to enable checking of host keys.
    4. See setConfig for a list of configuration options.

    • Session：表示到远程SSH服务器的一个连接，可以包含多个Channels；
     A Session represents a connection to a SSH server.One session can contain multiple Channels of various types
    A session is opened with connect() and closed with disconnect().

    • Channel :  与Session相关联的通道，有多种不同类型；
    The abstract base class for the different types of channel which may be associated with a Session.
    1. shell - ChannelShell ：A channel connected to a remote shell (本次使用的Channel)
    2. exec - ChannelExec ：A channel connected to a remotely executing program
    3. direct-tcpip - ChannelDirectTCPIP： A Channel which allows forwarding a pair of local streams to/from a TCP-connection to a server on the remote side
    4. sftp - ChannelSftp ：A Channel connected to an sftp server (as a subsystem of the ssh server).
    5. subsystem - ChannelSubsystem ：A channel connected to a subsystem of the server process

    使用步骤

    使用Jsch进行SSH连接的具体步骤如下:
    • 步骤1： 使用Jsch获取Session: jsch.getSession()
    • 步骤2： 设置Session的password和属性等: setPassword()/setConfig();
    • 步骤3： 设置SocketFactory（可以不进行设置,使用默认的TCP socket）;
    • 步骤4： 打开Session连接：connect();
    • 步骤5： 打开并连接Channel：openChannel()/connect();
    • 步骤6： 获取Channel的inputStream和outputStream，执行指定cmd或其他；
    1.   getInputStream():  All data arriving in SSH_MSG_CHANNEL_DATA messages from the remote side can be read from this stream
    2.   getOutputStream():  All data written to this stream will be sent in SSH_MSG_CHANNEL_DATA messages to the remote side.
    • 步骤7： 关闭各种资源：输入输出流/Session/Channel等；

    创建Session，并打开Session连接

    步骤1~步骤4：程序如下

    使用SSH协议，连接到Linux，执行指定命令，并获取结果

    步骤5~步骤6：程序如下
    执行Shell命令，并获取执行结果

    测试程序




    完整程序

    JSCHUtil.java

    1. package com.sssppp.Communication;
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    6. import java.net.InetAddress;
    7. import java.net.InetSocketAddress;
    8. import java.net.Socket;
    9. import java.net.UnknownHostException;
    10. import java.util.Properties;
    12. import com.jcraft.jsch.JSch;
    13. import com.jcraft.jsch.JSchException;
    14. import com.jcraft.jsch.Session;
    15. import com.jcraft.jsch.SocketFactory;
    17. /**
    18.  * 相关链接： JSCH api：http://epaul.github.io/jsch-documentation/javadoc/ Example:
    19.  * http://www.jcraft.com/jsch/examples/
    20.  * 
    21.  * @author xxxx
    22.  * 
    23.  */
    24. public class JSCHUtil {
    25.   private static JSch jsch = new JSch();
    27.   /**
    28.    * 创建Session，并打开Session连接
    29.    * 
    30.    * @param dstIp
    31.    * @param dstPort
    32.    * @param localIp
    33.    * @param localPort
    34.    * @param userName
    35.    * @param password
    36.    * @param timeOut
    37.    * @return
    38.    * @throws JSchException
    39.    */
    40.   public static Session createSession(String dstIp, int dstPort,
    41.       final String localIp, final int localPort, String userName,
    42.       String password, final int timeOut) throws JSchException {
    43.     //jsch.setKnownHosts("/home/foo/.ssh/known_hosts");
    44.     
    45.     // A Session represents a connection to a SSH server
    46.     Session session = jsch.getSession(userName, dstIp, dstPort);
    47.     session.setPassword(password);
    48.     
    49.     Properties sshConfig = new Properties();
    50.     sshConfig.put("StrictHostKeyChecking", "no");//To skip host-key check
    51.     session.setConfig(sshConfig);
    53.     // this socket factory is used to create a socket to the target host,
    54.     // and also create the streams of this socket used by us
    55.     session.setSocketFactory(new SocketFactory() {
    56.       @Override
    57.       public OutputStream getOutputStream(Socket socket)
    58.           throws IOException {
    59.         return socket.getOutputStream();
    60.       }
    62.       @Override
    63.       public InputStream getInputStream(Socket socket) throws IOException {
    64.         return socket.getInputStream();
    65.       }
    67.       @Override
    68.       public Socket createSocket(String host, int port)
    69.           throws IOException, UnknownHostException {
    70.         Socket socket = new Socket();
    71.         if (localIp != null) {
    72.           socket.bind(new InetSocketAddress(InetAddress
    73.               .getByName(localIp), localPort));
    74.         }
    75.         socket.connect(
    76.             new InetSocketAddress(InetAddress.getByName(host), port),
    77.             timeOut);
    78.         return socket;
    79.       }
    80.     });
    82.     session.connect(timeOut);
    83.     return session;
    84.   }
    85. }

    SSHCommUtil.java

    1. package com.sssppp.Communication;
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    7. import com.jcraft.jsch.Channel;
    8. import com.jcraft.jsch.JSchException;
    9. import com.jcraft.jsch.Session;
    11. public class SSHCommUtil {
    13.   /**
    14.    * 测试程序
    15.    * @param args
    16.    */
    17.   public static void main(String[] args) {
    18.     String ip = "10.180.137.241";
    19.     int port = 22;
    20.     String localIp = null;
    21.     int localPort = 0;
    22.     int timeOut = 3000;
    23.     String userName = "xxx";
    24.     String password = "xxx";
    25.     String[] cmds = new String[] { "ifconfig | grep eth0
",
    26.         "cat /etc/redhat-release
" };
    27.     String[] result = null;
    28.     try {
    29.       result = execShellCmdBySSH(ip, port, localIp, localPort, timeOut,
    30.           userName, password, cmds);
    31.     } catch (Exception e) {
    32.       e.printStackTrace();
    33.     }
    35.     if (result != null) {
    36.       for (String string : result) {
    37.         System.out.println(string);
    38.         System.out.println("-------------------");
    39.       }
    40.     }
    42.   }
    44.   /**
    45.    * 使用SSH协议，连接到Linux Shell，执行脚本命令，并获取结果
    46.    * 
    47.    * @param dstIp
    48.    * @param dstport
    49.    *            default :22
    50.    * @param localIp
    51.    * @param localPort
    52.    * @param timeOut
    53.    * @param userName
    54.    * @param password
    55.    * @param cmds
    56.    * @return
    57.    * @throws Exception
    58.    */
    59.   public static String[] execShellCmdBySSH(String dstIp, int dstport,
    60.       String localIp, int localPort, int timeOut, String userName,
    61.       String password, String... cmds) throws Exception {
    62.     Session session = null;
    63.     Channel channel = null;
    64.     InputStream is = null;
    65.     OutputStream os = null;
    66.     try {
    67.       session = JSCHUtil.createSession(dstIp, dstport, localIp,
    68.           localPort, userName, password, timeOut);
    69.       channel = session.openChannel("shell");
    70.     
    71.       // Enable agent-forwarding.
    72.       // ((ChannelShell)channel).setAgentForwarding(true);
    74.       // Choose the pty-type "vt102".
    75.       // ((ChannelShell)channel).setPtyType("vt102");
    77.       // Set environment variable "LANG" as "ja_JP.eucJP".
    78.       // ((ChannelShell)channel).setEnv("LANG", "ja_JP.eucJP");
    80.       channel.connect();
    81.       is = channel.getInputStream();
    82.       os = channel.getOutputStream();
    83.       String[] result = new String[cmds.length];
    84.       for (int i = 0; i < cmds.length; i++) {
    85.         result[i] = sendCommand(is, os, cmds[i]);
    86.       }
    87.       return result;
    88.     } catch (JSchException e) {
    89.       if (e.getMessage().contains("Auth fail")) {
    90.         throw new Exception("Auth error");
    91.       } else {
    92.         throw new Exception("Connect error");
    93.       }
    94.     } catch (Exception e) {
    95.       throw e;
    96.     } finally {
    97.       try {
    98.         is.close();
    99.       } catch (IOException e) {
    100.       }
    101.       try {
    102.         os.close();
    103.       } catch (IOException e) {
    104.       }
    106.       channel.disconnect();
    107.       session.disconnect();
    108.     }
    109.   }
    110.   
    111.   /**
    112.    * 执行Shell命令，并获取执行结果
    113.    * 
    114.    * @param is
    115.    * @param os
    116.    * @param cmd
    117.    * @return
    118.    * @throws IOException
    119.    */
    120.   private static String sendCommand(InputStream is, OutputStream os,
    121.       String cmd) throws IOException {
    122.     os.write(cmd.getBytes());
    123.     os.flush();
    125.     StringBuffer sb = new StringBuffer();
    126.     int beat = 0;
    127.     while (true) {
    128.       if (beat > 3) {
    129.         break;
    130.       }
    132.       if (is.available() > 0) {
    133.         byte[] b = new byte[is.available()];
    134.         is.read(b);
    135.         sb.append(new String(b));
    136.         beat = 0;
    137.       } else {
    138.         if (sb.length() > 0) {
    139.           beat++;
    140.         }
    142.         try {
    143.           Thread.sleep(sb.toString().trim().length() == 0 ? 1000
    144.               : 300);
    145.         } catch (InterruptedException e) {
    146.         }
    147.       }
    148.     }
    149.     return sb.toString();
    150.   }
    151. }
  • 相关阅读:
    C语言 弹跳小球
    selenium 相关操作
    aiohttp 多任务异步协程
    39 数据库索引
    36 数据库 库表行增删改查 枚举 集合
    07 线程池回调函数
    06 gevent版真正的协程
    05 greenlet版协程
    03 线程池
    04 生成器版协程
  • 原文地址：https://www.cnblogs.com/ssslinppp/p/6244653.html
Copyright © 2011-2022 走看看