需求：

项目运营过程中不可避免的需要监控服务器指标，这时，使用 Java 代码远程调用 shell 脚本来获取服务器的一些信息，不失为一种常见的解决方案。

实现思路

使用 Java 代码模拟登录服务器，然后使用 shell 命令操作服务器。

必要说明

  • 本 demo 为 SpringBoot 项目，JDK为1.8.0，IDE为IDEA2020.1。
  • Java 代码调用的 shell 脚本已提前放置在服务器的相应位置。
  • 若在使用 Java 代码调用 shell 脚本时，未传递服务器相关信息(SSHVo)，则默认使用配置文件 ssh.properties 中相应的参数操作服务器。

话不多说，直接上代码。

代码

代码结构

Java代码远程调用shell脚本 - 图1

pom.xml

  1. <!-- Java远程调用shell脚本 -->
  2.         <dependency>
  3.             <groupId>ch.ethz.ganymed</groupId>
  4.             <artifactId>ganymed-ssh2</artifactId>
  5.             <version>262</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>commons-io</groupId>
  9.             <artifactId>commons-io</artifactId>
  10.             <version>2.6</version>
  11.         </dependency>

SSHVo 实体类

  1. package com.demo.entity;
  3. /**
  4.  * @Author: 瞎琢磨先生lyg
  5.  * @Date: 2020/4/4 12:10
  6.  * @Version 1.0
  7.  * Just do it, Just do IT
  8.  */
  9. public class SSHVo {
  11.     private String ipAddr;
  12.     private Integer port;
  13.     private String userName;
  14.     private String password;
  15.     private String cmds;
  17.     public SSHVo() {
  18.     }
  20.     public SSHVo(String ipAddr, Integer port, String userName, String password, String cmds) {
  21.         this.ipAddr = ipAddr;
  22.         this.port = port;
  23.         this.userName = userName;
  24.         this.password = password;
  25.         this.cmds = cmds;
  26.     }
  28.     public String getIpAddr() {
  29.         return ipAddr;
  30.     }
  32.     public void setIpAddr(String ipAddr) {
  33.         this.ipAddr = ipAddr;
  34.     }
  36.     public Integer getPort() {
  37.         return port;
  38.     }
  40.     public void setPort(Integer port) {
  41.         this.port = port;
  42.     }
  44.     public String getUserName() {
  45.         return userName;
  46.     }
  48.     public void setUserName(String userName) {
  49.         this.userName = userName;
  50.     }
  52.     public String getPassword() {
  53.         return password;
  54.     }
  56.     public void setPassword(String password) {
  57.         this.password = password;
  58.     }
  60.     public String getCmds() {
  61.         return cmds;
  62.     }
  64.     public void setCmds(String cmds) {
  65.         this.cmds = cmds;
  66.     }
  68.     @Override
  69.     public String toString() {
  70.         final StringBuilder sb = new StringBuilder("{");
  71.         sb.append("\"ipAddr\":\"")
  72.                 .append(ipAddr).append('\"');
  73.         sb.append(",\"port\":")
  74.                 .append(port);
  75.         sb.append(",\"userName\":\"")
  76.                 .append(userName).append('\"');
  77.         sb.append(",\"password\":\"")
  78.                 .append(password).append('\"');
  79.         sb.append(",\"cmds\":\"")
  80.                 .append(cmds).append('\"');
  81.         sb.append('}');
  82.         return sb.toString();
  83.     }
  84. }

SSH 工具类

SSH 连接、登录、操作服务器工具类

  1. package com.demo.tool;
  3. import ch.ethz.ssh2.Connection;
  4. import ch.ethz.ssh2.Session;
  5. import com.demo.entity.SSHVo;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.context.annotation.PropertySource;
  8. import org.springframework.stereotype.Component;
  10. import java.io.FileNotFoundException;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13. import java.nio.charset.Charset;
  14. import java.nio.charset.StandardCharsets;
  16. /**
  17.  * @Author: 瞎琢磨先生lyg
  18.  * @Date: 2020/4/4 12:10
  19.  * @Version 1.0
  20.  * Just do it, Just do IT
  21.  */
  22. @Component
  23. @PropertySource(value = {"classpath:config/ssh.properties"})
  24. public class SSHTool {
  26.     private static Charset charset = StandardCharsets.UTF_8;
  28.     private static Connection conn;
  29.     private static String ipAddr;
  30.     private static Integer port;
  31.     private static String userName;
  32.     private static String password;
  33.     private static String cmds;
  35.     @Value("${ipAddr}")
  36.     public void setIpAddr(String ipAddr) {
  37.         SSHTool.ipAddr = ipAddr;
  38.     }
  40.     @Value("${port}")
  41.     public void setPort(Integer port) {
  42.         SSHTool.port = port;
  43.     }
  45.     @Value("${userName}")
  46.     public void setUserName(String userName) {
  47.         SSHTool.userName = userName;
  48.     }
  50.     @Value("${password}")
  51.     public void setPassword(String password) {
  52.         SSHTool.password = password;
  53.     }
  55.     @Value("${cmds}")
  56.     public void setCmds(String cmds) {
  57.         SSHTool.cmds = cmds;
  58.     }
  60.     /**
  61.      * 登录远程Linux主机
  62.      *
  63.      * @return 是否登录成功
  64.      */
  65.     private static boolean login(SSHVo sshVo) {
  67.         try {
  68.             // 连接
  69.             //conn = new Connection(ipAddr, port);
  70.             conn = new Connection(sshVo.getIpAddr(), sshVo.getPort());
  71.             conn.connect();
  72.             // 认证
  73.             return conn.authenticateWithPassword("root", sshVo.getPassword());
  74.         } catch (IOException e) {
  75.             e.printStackTrace();
  76.             return false;
  77.         }
  78.     }
  80.     /**
  81.      * 执行Shell脚本或命令
  82.      *
  83.      * @param sshVo .cmds 命令行序列
  84.      * @return 脚本输出结果
  85.      */
  86.     public static StringBuilder exec(SSHVo sshVo) throws IOException {
  87.         InputStream in = null;
  88.         StringBuilder result = new StringBuilder();
  90.         if (sshVo == null || (sshVo != null && (sshVo.getIpAddr() == null || "".equals(sshVo.getIpAddr())))) {
  91.             sshVo = new SSHVo(ipAddr, port, userName, password, cmds);
  92.         }
  93.         System.out.println(sshVo
  94.         );
  95.         try {
  96.             if (SSHTool.login(sshVo)) {
  97.                 // 打开一个会话
  98.                 Session session = conn.openSession();
  99.                 session.execCommand(sshVo.getCmds());
  100.                 in = session.getStdout();
  101.                 result = SSHTool.processStdout(in, SSHTool.charset);
  102.                 conn.close();
  103.             }
  104.         } finally {
  105.             if (null != in) {
  106.                 in.close();
  107.             }
  108.         }
  109.         return result;
  110.     }
  112.     /**
  113.      * 解析流获取字符串信息
  114.      *
  115.      * @param in      输入流对象
  116.      * @param charset 字符集
  117.      * @return 脚本输出结果
  118.      */
  119.     public static StringBuilder processStdout(InputStream in, Charset charset) throws FileNotFoundException {
  120.         byte[] buf = new byte[1024];
  121.         StringBuilder sb = new StringBuilder();
  122. //        OutputStream os = new FileOutputStream("./data.txt");
  123.         try {
  124.             int length;
  125.             while ((length = in.read(buf)) != -1) {
  126. //                os.write(buf, 0, c);
  127.                 sb.append(new String(buf, 0, length));
  128.             }
  129.         } catch (IOException e) {
  130.             e.printStackTrace();
  131.         }
  132.         return sb;
  133.     }
  134. }

ssh.properties

(注意位置是在 resources/config 目录下)

  1. ipAddr=124.160.108.89
  2. port=22
  3. userName=root
  4. password=root
  5. cmds=sh -x /test/shell.sh

测试类

  1. public static void main(String[] args) throws IOException {
  3.         SSHTool.exec(new SSHVo(
  4.                 "124.160.108.88",
  5.                 22,
  6.                 "root",
  7.                 "root",
  8.                 "mkdir -p /java/shell"));
  10.     }

访问 localhost:8080/shell

Java代码远程调用shell脚本 - 图2

查看服务器，发现服务器上也调用了相应的 shell 脚本，说明 Java 代码调用 shell 脚本执行成功。

[注意事项]

  1. 使用Java代码调用shell脚本杀死当前服务，然后重启。无论尝试多少次，都无法进行重启。而单纯的使用shell实现杀死并重启服务却正常。

原因：Java代码调用shell杀死当前服务后，相当于调用shell脚本的主线程被杀了，子线程调用也就无从说起了。
解决办法：(曲线救国)。使用守护线程启动服务，当Java代码调用shell脚本杀死服务后，守护线程检测到服务被杀死，会自动将服务重启。

  1. 在win系统下编写的shell脚本极有可能无法在linux服务器上正常运行。

原因：就在于编码格式不一致。
解决办法：要么就在 linux 服务器上编写脚本，要么在win电脑上编写完毕后，使用 notepad++ 将其转码成linux的编码格式。
image.png

  1. 使用 shell 脚本调用 MySQL 脚本(eg. user.sql)报错，但是单独将其放在 Navicat 中执行，却一点错误都没有。

原因：SQL 脚本中存在以”#”开头的注释，导致 linux 上无法正常解析。
解决办法：将 SQL 脚本中所有以”#”开头的注释统统替换成”— “的注释(注意：—和待注释的内容之间要用”空格”隔开)。