java连接linux服务器执行shell命令（框架分析+推荐）
java连接linux服务器执行shell命令（框架分析+推荐）
一、分类+连接方式
- 程序打成jar包，在本地服务器上执行shell命令。这种使用MyRuntimeUtil工具类
- java程序远程linux服务器有两个框架分别是：jsch与ganymed-ssh2框架。推荐使用jsch框架因为ganymed-ssh2框架不支持麒麟服务器的连接原因是openssl版本过高，ganymed-ssh框架不维护了所以不支持。
二、执行本地的shell命令
<dependency>
<groupId>cn.hutoolgroupId>
<artifactId>hutool-allartifactId>
<version>5.7.21version>
dependency>
工具类
package com.dameng.util;
import cn.hutool.core.exceptions.UtilException;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.text.StrBuilder;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.StaticLog;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.management.ManagementFactory;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* @author xgt(小光头)
* @version 1.0
* @date 2022-3-3 22:40
*/
public class MyRuntimeUtil {
/**
* 执行系统命令，使用系统默认编码
*
* @param cmds 命令列表，每个元素代表一条命令
* @return 执行结果
* @throws IORuntimeException IO异常
*/
public static String execForStr(String... cmds) throws IORuntimeException {
return execForStr(CharsetUtil.systemCharset(), cmds);
}
/**
* 执行系统命令，使用系统默认编码
*
* @param charset 编码
* @param cmds 命令列表，每个元素代表一条命令
* @return 执行结果
* @throws IORuntimeException IO异常
* @since 3.1.2
*/
public static String execForStr(Charset charset, String... cmds) throws IORuntimeException {
return getResult(exec(cmds), charset);
}
public static String execForErrStr(Charset charset,String cmd) throws IORuntimeException {
return getResultErr(exec(cmd), charset);
}
/**
* 执行系统命令，使用系统默认编码
*
*/
public static String execForStr(Charset charset, String cmds) throws IORuntimeException {
return getResult(exec(cmds), charset);
}
/**
* 执行系统命令，使用系统默认编码
*
* @param cmds 命令列表，每个元素代表一条命令
* @return 执行结果，按行区分
* @throws IORuntimeException IO异常
*/
public static List<String> execForLines(String... cmds) throws IORuntimeException {
return execForLines(CharsetUtil.systemCharset(), cmds);
}
/**
* 执行系统命令，使用系统默认编码
*
* @param charset 编码
* @param cmds 命令列表，每个元素代表一条命令
* @return 执行结果，按行区分
* @throws IORuntimeException IO异常
* @since 3.1.2
*/
public static List<String> execForLines(Charset charset, String... cmds) throws IORuntimeException {
return getResultLines(exec(cmds), charset);
}
/**
* 执行命令<br>
* 命令带参数时参数可作为其中一个参数，也可以将命令和参数组合为一个字符串传入
*
* @param cmds 命令
* @return {@link Process}
*/
public static Process exec(String... cmds) {
Process process;
try {
process = new ProcessBuilder(handleCmds(cmds)).redirectErrorStream(true).start();
} catch (IOException e) {
throw new IORuntimeException(e);
}
return process;
}
/**
* 执行命令<br>
* 命令带参数时参数可作为其中一个参数，也可以将命令和参数组合为一个字符串传入
*
* @param cmd 命令
* @return {@link Process}
*/
public static Process exec(String cmd) {
Process process;
try {
// 得到Java进程的相关Runtime运行对象
Runtime runtime = Runtime.getRuntime();
if(cmd.indexOf("|")>0){
String[] cmdArr = {"sh","-c",cmd};
process = runtime.exec(cmdArr);
}else{
process = runtime.exec(cmd);
}
} catch (IOException e) {
throw new IORuntimeException(e);
}
return process;
}
/**
* 执行命令<br>
* 命令带参数时参数可作为其中一个参数，也可以将命令和参数组合为一个字符串传入
*
* @param envp 环境变量参数，传入形式为key=value，null表示继承系统环境变量
* @param cmds 命令
* @return {@link Process}
* @since 4.1.6
*/
public static Process exec(String[] envp, String... cmds) {
return exec(envp, null, cmds);
}
/**
* 执行命令<br>
* 命令带参数时参数可作为其中一个参数，也可以将命令和参数组合为一个字符串传入
*
* @param envp 环境变量参数，传入形式为key=value，null表示继承系统环境变量
* @param dir 执行命令所在目录（用于相对路径命令执行），null表示使用当前进程执行的目录
* @param cmds 命令
* @return {@link Process}
* @since 4.1.6
*/
public static Process exec(String[] envp, File dir, String... cmds) {
try {
return Runtime.getRuntime().exec(handleCmds(cmds), envp, dir);
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
// -------------------------------------------------------------------------------------------------- result
/**
* 获取命令执行结果，使用系统默认编码，获取后销毁进程
*
* @param process {@link Process} 进程
* @return 命令执行结果列表
*/
public static List<String> getResultLines(Process process) {
return getResultLines(process, CharsetUtil.systemCharset());
}
/**
* 获取命令执行结果，使用系统默认编码，获取后销毁进程
*
* @param process {@link Process} 进程
* @param charset 编码
* @return 命令执行结果列表
* @since 3.1.2
*/
public static List<String> getResultLines(Process process, Charset charset) {
InputStream in = null;
try {
in = process.getInputStream();
return IoUtil.readLines(in, charset, new ArrayList<>());
} finally {
IoUtil.close(in);
destroy(process);
}
}
/**
* 获取命令执行结果，使用系统默认编码，，获取后销毁进程
*
* @param process {@link Process} 进程
* @return 命令执行结果列表
* @since 3.1.2
*/
public static String getResult(Process process) {
return getResult(process, CharsetUtil.systemCharset());
}
/**
* 获取命令执行结果，获取后销毁进程
*
* @param process {@link Process} 进程
* @param charset 编码
* @return 命令执行结果列表
* @since 3.1.2
*/
public static String getResult(Process process, Charset charset) {
InputStream in = null;
InputStream errorStream = null;
try {
in = process.getInputStream();
errorStream = process.getErrorStream();
String errorResult = IoUtil.read(errorStream, charset);
if(StrUtil.isNotBlank(errorResult)){
StaticLog.warn("Shell command execution error, because {}",errorResult);
}
return IoUtil.read(in, charset);
} finally {
IoUtil.close(in);
IoUtil.close(errorStream);
destroy(process);
}
}
/**
* 获取错误的执行结果，获取后销毁进程
*
* @param process {@link Process} 进程
* @param charset 编码
* @return 命令执行结果列表
* @since 3.1.2
*/
public static String getResultErr(Process process, Charset charset) {
InputStream in = null;
InputStream errorStream = null;
try {
in = process.getInputStream();
errorStream = process.getErrorStream();
// System.out.println("252"+IoUtil.read(errorStream, charset));
return IoUtil.read(errorStream, charset);
} finally {
IoUtil.close(in);
IoUtil.close(errorStream);
destroy(process);
}
}
/**
* 获取命令执行异常结果，使用系统默认编码，，获取后销毁进程
*
* @param process {@link Process} 进程
* @return 命令执行结果列表
* @since 4.1.21
*/
public static String getErrorResult(Process process) {
return getErrorResult(process, CharsetUtil.systemCharset());
}
/**
* 获取命令执行异常结果，获取后销毁进程
*
* @param process {@link Process} 进程
* @param charset 编码
* @return 命令执行结果列表
* @since 4.1.21
*/
public static String getErrorResult(Process process, Charset charset) {
InputStream in = null;
try {
in = process.getErrorStream();
return IoUtil.read(in, charset);
} finally {
IoUtil.close(in);
destroy(process);
}
}
/**
* 销毁进程
*
* @param process 进程
* @since 3.1.2
*/
public static void destroy(Process process) {
if (null != process) {
process.destroy();
}
}
/**
* 增加一个JVM关闭后的钩子，用于在JVM关闭时执行某些操作
*
* @param hook 钩子
* @since 4.0.5
*/
public static void addShutdownHook(Runnable hook) {
Runtime.getRuntime().addShutdownHook((hook instanceof Thread) ? (Thread) hook : new Thread(hook));
}
/**
* 获得JVM可用的处理器数量（一般为CPU核心数）
*
* @return 可用的处理器数量
* @since 5.3.0
*/
public static int getProcessorCount() {
return Runtime.getRuntime().availableProcessors();
}
/**
* 获得JVM中剩余的内存数，单位byte
*
* @return JVM中剩余的内存数，单位byte
* @since 5.3.0
*/
public static long getFreeMemory() {
return Runtime.getRuntime().freeMemory();
}
/**
* 获得JVM已经从系统中获取到的总共的内存数，单位byte
*
* @return JVM中剩余的内存数，单位byte
* @since 5.3.0
*/
public static long getTotalMemory() {
return Runtime.getRuntime().totalMemory();
}
/**
* 获得JVM中可以从系统中获取的最大的内存数，单位byte，以-Xmx参数为准
*
* @return JVM中剩余的内存数，单位byte
* @since 5.3.0
*/
public static long getMaxMemory() {
return Runtime.getRuntime().maxMemory();
}
/**
* 获得JVM最大可用内存，计算方法为：<br>
* 最大内存-总内存+剩余内存
*
* @return 最大可用内存
*/
public static long getUsableMemory() {
return getMaxMemory() - getTotalMemory() + getFreeMemory();
}
/**
* 获取当前进程ID，首先获取进程名称，读取@前的ID值，如果不存在，则读取进程名的hash值
*
* @return 进程ID
* @throws UtilException 进程名称为空
* @since 5.7.3
*/
public static int getPid() throws UtilException {
final String processName = ManagementFactory.getRuntimeMXBean().getName();
if (StrUtil.isBlank(processName)) {
throw new UtilException("Process name is blank!");
}
final int atIndex = processName.indexOf('@');
if (atIndex > 0) {
return Integer.parseInt(processName.substring(0, atIndex));
} else {
return processName.hashCode();
}
}
/**
* 处理命令，多行命令原样返回，单行命令拆分处理
*
* @param cmds 命令
* @return 处理后的命令
*/
private static String[] handleCmds(String... cmds) {
if (ArrayUtil.isEmpty(cmds)) {
throw new NullPointerException("Command is empty !");
}
// 单条命令的情况
if (1 == cmds.length) {
final String cmd = cmds[0];
if (StrUtil.isBlank(cmd)) {
throw new NullPointerException("Command is blank !");
}
cmds = cmdSplit(cmd);
}
return cmds;
}
/**
* 命令分割，使用空格分割，考虑双引号和单引号的情况
*
* @param cmd 命令，如 git commit -m 'test commit'
* @return 分割后的命令
*/
private static String[] cmdSplit(String cmd) {
final List<String> cmds = new ArrayList<>();
final int length = cmd.length();
final Stack<Character> stack = new Stack<>();
boolean inWrap = false;
final StrBuilder cache = StrUtil.strBuilder();
char c;
for (int i = 0; i < length; i++) {
c = cmd.charAt(i);
switch (c) {
case CharUtil.SINGLE_QUOTE:
case CharUtil.DOUBLE_QUOTES:
if (inWrap) {
if (c == stack.peek()) {
//结束包装
stack.pop();
inWrap = false;
}
cache.append(c);
} else {
stack.push(c);
cache.append(c);
inWrap = true;
}
break;
case CharUtil.SPACE:
if (inWrap) {
// 处于包装内
cache.append(c);
} else {
cmds.add(cache.toString());
cache.reset();
}
break;
default:
cache.append(c);
break;
}
}
if (cache.hasContent()) {
cmds.add(cache.toString());
}
return cmds.toArray(new String[0]);
}
}
使用方法
package java.nio.charset;
Charset charset = Charset.forName("UTF-8");
MyRuntimeUtil.execForStr(charset,"ls");
三、Jsch远程连接执行
<dependency>
<groupId>cn.hutoolgroupId>
<artifactId>hutool-allartifactId>
<version>5.7.21version>
dependency>
<dependency>
<groupId>com.jcraftgroupId>
<artifactId>jschartifactId>
<version>0.1.55version>
dependency>
工具类
package com.dameng.util;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.ssh.JschUtil;
import com.jcraft.jsch.*;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Properties;
/**
* 执行Shell工具类
*
* @author JustryDeng
* @date 2019/4/29 16:29
*/
public class ExecuteShellUtil {
/** 未调用初始化方法 错误提示信息 */
private static final String DONOT_INIT_ERROR_MSG = "please invoke init(...) first!";
private static Session session;
private ExecuteShellUtil() {
}
/**
* 获取ExecuteShellUtil类实例对象
*
* @return 实例
* @date 2019/4/29 16:58
*/
public static ExecuteShellUtil getInstance() {
return new ExecuteShellUtil();
}
/**
* 初始化
*
* @param ip
* 远程Linux地址
* @param port
* 端口
* @param username
* 用户名
* @param password
* 密码
* @throws JSchException
* JSch异常
* @date 2019/3/15 12:41
*/
public void init(String ip, Integer port, String username, String password) throws JSchException {
JSch jsch = new JSch();
// jsch.getSession(username, ip, port);
session = jsch.getSession(username, ip, port);
session.setPassword(password);
Properties sshConfig = new Properties();
sshConfig.put("StrictHostKeyChecking", "no");
session.setConfig(sshConfig);
session.connect(1200 * 1000);
}
/**
* 执行一条命令,探活使用
*/
public static String execCmd(Session session,String command) throws Exception {
// if (session == null || channel == null || channelExec == null) {
// throw new Exception(DONOT_INIT_ERROR_MSG);
// }
// 打开执行shell指令的通道
Channel channel = session.openChannel("exec");
ChannelExec channelExec = (ChannelExec) channel;
channelExec.setCommand("source /etc/profile && source ~/.bash_profile && source ~/.bashrc && adb devices && locale charmap");
channelExec.setCommand(command);
channel.setInputStream(null);
channelExec.setErrStream(System.err);
// channel.setXForwarding();
channel.connect();
StringBuilder sb = new StringBuilder(16);
try (InputStream in = channelExec.getInputStream();
InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader reader = new BufferedReader(isr)) {
String buffer;
while ((buffer = reader.readLine()) != null) {
sb.append("\n").append(buffer);
}
//2023-02-21 关闭流
IoUtil.close(reader);
IoUtil.close(isr);
IoUtil.close(in);
return sb.toString();
}finally {
if (channelExec.isConnected()) {
channelExec.disconnect();
}
if (channel.isConnected()) {
channel.disconnect();
}
}
}
/**
* 执行一条命令
*/
public String execCmd(String command) throws Exception {
// if (session == null || channel == null || channelExec == null) {
// throw new Exception(DONOT_INIT_ERROR_MSG);
// }
// 打开执行shell指令的通道
Channel channel = session.openChannel("exec");
ChannelExec channelExec = (ChannelExec) channel;
channelExec.setCommand("source /etc/profile && source ~/.bash_profile && source ~/.bashrc && adb devices && locale charmap");
channelExec.setCommand(command);
channel.setInputStream(null);
channelExec.setErrStream(System.err);
// channel.setXForwarding();
channel.connect();
StringBuilder sb = new StringBuilder(16);
try (InputStream in = channelExec.getInputStream();
InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader reader = new BufferedReader(isr)) {
String buffer;
while ((buffer = reader.readLine()) != null) {
sb.append("\n").append(buffer);
}
//2023-02-21 关闭流
IoUtil.close(reader);
IoUtil.close(isr);
IoUtil.close(in);
return sb.toString();
}finally {
if (channelExec != null && channelExec.isConnected()) {
channelExec.disconnect();
}
if ( channel != null && channel.isConnected()) {
channel.disconnect();
}
}
}
/**
* 执行一条命令 获取错误流中的内容
*/
public String execCmdErrContent(String command) throws Exception {
// if (session == null || channel == null || channelExec == null) {
// throw new Exception(DONOT_INIT_ERROR_MSG);
// }
// 打开执行shell指令的通道
Channel channel = session.openChannel("exec");
ChannelExec channelExec = (ChannelExec) channel;
channelExec.setCommand(command);
channel.setInputStream(null);
ByteArrayOutputStream err = new ByteArrayOutputStream();
channelExec.setErrStream(err);
channel.connect();
StringBuilder sb = new StringBuilder(16);
try (InputStream in = channelExec.getErrStream();
InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader reader = new BufferedReader(isr)) {
String buffer;
while ((buffer = reader.readLine()) != null) {
sb.append("\n").append(buffer);
}
//2023-02-21 关闭流
IoUtil.close(reader);
IoUtil.close(isr);
IoUtil.close(in);
IoUtil.close(err);
if(StrUtil.contains(sb.toString(), "没有那个文件或目录")){
return "";
}else{
return sb.toString();
}
}finally {
if (channelExec != null && channelExec.isConnected()) {
channelExec.disconnect();
}
if ( channel != null && channel.isConnected()) {
channel.disconnect();
}
}
}
public static void closeConnect() {
if (session != null && session.isConnected()) {
session.disconnect();
}
}
}
使用方法
package com.dameng;
import cn.hutool.core.text.StrSplitter;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.ssh.JschUtil;
import com.dameng.util.ExecuteShellUtil;
import com.dameng.util.ShellCmdUtil;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import org.junit.Test;
import java.math.BigDecimal;
import java.util.List;
/**
* Unit test for simple App.
*/
public class JschUtilTest
{
/**
* Jsch方式4830
*/
@Test
public void shouldAnswerWithTrue() {
long currentTimeMillis = System.currentTimeMillis();
ExecuteShellUtil instance = ExecuteShellUtil.getInstance();
try {
//instance.init("192.168.60.179", 22, "root","password123.1");
// String ls = instance.execCmd("top -p 21475 -n 1 -b");
String ls = instance.execCmd("cat /opt/dmdbms/log/dm_DW1_01B_202203.log | grep -v 'INFO'");
List<String> lineFreedList = StrSplitter.splitByRegex(StrUtil.trimToEmpty(ls), "\n", -1, true, true);
for (String s : lineFreedList) {
List<String> stringList = StrSplitter.split(StrUtil.trimToEmpty(s), "=", -1, true, true);
System.out.println(stringList);
}
System.out.println(ls);
//
// // 计算内存使用率（已使用内存/总内存）
// String freeStr = instance.execCmd("free | sed -n '2p'");
// List freeInfoList = StrSplitter.splitByRegex(StrUtil.trimToEmpty(freeStr), "\\s+", -1, true, true);
// String allMemory = freeInfoList.get(1);
// String usedMemory = freeInfoList.get(2);
// double f1 = new BigDecimal(Float.valueOf(usedMemory) / Float.valueOf(allMemory)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue() * 100;
//
//
//
//
// System.out.println(ls);
// long currentTimeMillis1 = System.currentTimeMillis();
// System.out.println("Jsch方式"+(currentTimeMillis1-currentTimeMillis));
} catch (Exception e) {
System.out.println("error info");
e.printStackTrace();
}
}
}
四、ganymed-ssh2远程连接执行
<dependency>
<groupId>cn.hutoolgroupId>
<artifactId>hutool-allartifactId>
<version>5.7.21version>
dependency>
<dependency>
<groupId>ch.ethz.ganymedgroupId>
<artifactId>ganymed-ssh2artifactId>
<version>262version>
dependency>
工具类
package com.dameng.util;
import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.ConnectionInfo;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.StaticLog;
import com.dameng.core.exception.MyGanymedException;
import com.dameng.core.exception.MyHostConnectException;
import com.dameng.core.exception.MyResolutionException;
import com.dameng.domain.OsInfo;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.List;
/**
* @author xgt(小光头)
* @version 1.0
* @date 2022-2-26 15:36
*/
public class MyGanymedSingleUtil {
private MyGanymedSingleUtil() {
}
private static Connection connect;
private static MyGanymedSingleUtil myGanymedSingleUtil;
public static MyGanymedSingleUtil getInstance() {
if(myGanymedSingleUtil == null){
myGanymedSingleUtil =new MyGanymedSingleUtil();
}
return myGanymedSingleUtil;
}
/**
* 连接到服务器
* @param sshHost 主机
* @param sshPort 端口
* @return {@link Connection}
*/
public Connection connect(String sshHost, int sshPort) {
connect = new Connection(sshHost, sshPort);
try {
connect.connect();
} catch (IOException e) {
throw new IORuntimeException(e);
}
return connect;
}
/**
* 打开远程会话
*
* @param sshHost 主机
* @param sshPort 端口
* @param sshUser 用户名，如果为null，默认root
* @param sshPass 密码
* @return {@link Session}
*/
public void openConnect(String sshHost, int sshPort, String sshUser, String sshPass) throws MyHostConnectException {
// 默认root用户
if (StrUtil.isEmpty(sshUser)) {
sshUser = "root";
}
connect = connect(sshHost, sshPort);
try {
connect.authenticateWithPassword(sshUser, sshPass);
ConnectionInfo connectionInfo = connect.getConnectionInfo();
// session = connect.openSession();
} catch (IOException e) {
throw new MyHostConnectException(e);
}
}
/**
* 执行Shell命令（使用EXEC方式）
*
* 此方法单次发送一个命令到服务端，不读取环境变量，执行结束后自动关闭Session，不会产生阻塞。
*
*
* @param cmd 命令
* @param charset 发送和读取内容的编码
* @return 执行返回结果
*/
public String exec(String cmd, String charset) throws Exception {
final String result;
final String stderrStr;
ByteArrayOutputStream errStream = new ByteArrayOutputStream();
Session session = null;
try {
session = connect.openSession();
Charset charset1 = Charset.forName(charset);
session.execCommand(cmd, charset1.name());
result = IoUtil.read(new StreamGobbler(session.getStdout()), charset1);
//打印错误的流输出
IoUtil.copy(new StreamGobbler(session.getStderr()), errStream);
stderrStr = new String(errStream.toByteArray(),charset);
} finally {
session.close();
}
if(!StrUtil.isEmpty(stderrStr)){
throw new MyGanymedException(stderrStr);
}
return result;
}
/**
* 执行Shell命令
*
* 此方法单次发送一个命令到服务端，自动读取环境变量，执行结束后自动关闭Session，不会产生阻塞。
*
*
* @param cmd 命令
* @param charset 发送和读取内容的编码
* @param errStream 错误信息输出到的位置
* @return 执行返回结果
*/
public String execByShell(String cmd, Charset charset, OutputStream errStream) {
final String result;
Session session = null;
try {
//这个方法有问题
session.requestDumbPTY();
IoUtil.write(session.getStdin(), charset, true, cmd);
result = IoUtil.read(new StreamGobbler(session.getStdout()), charset);
if(null != errStream){
// 错误输出
IoUtil.copy(new StreamGobbler(session.getStdout()), errStream);
}
} catch (IOException e) {
throw new IORuntimeException(e);
} finally {
close(session);
}
return result;
}
/**
* 关闭会话
*
*/
public void close(Session session) {
if(session!=null){
session.close();
}
}
/**
* 关闭会话
*
*/
public void closeConnect() {
if(connect!=null){
connect.close();
}
}
}
使用方式
package com.dameng;
import ch.ethz.ssh2.Session;
import cn.hutool.extra.ssh.GanymedUtil;
import cn.hutool.extra.ssh.JschUtil;
import com.dameng.util.ExecuteShellUtil;
import com.dameng.util.MyGanymedUtil;
import org.junit.Test;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
/**
* Unit test for simple App.
*/
public class GanymedUtilTest
{
private static String DEFAULTCHART = "UTF-8";
/**
* Rigorous Test :-)
*/
@Test
public void shouldAnswerWithTrue() {
long currentTimeMillis = System.currentTimeMillis();
// Session session = JschUtil.getSession("192.168.60.177", 22, "root", "root");
Session session = MyGanymedUtil.openSession("192.168.60.177", 22, "root", "root");
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Charset charset = Charset.forName("UTF-8");
String ls = MyGanymedUtil.exec(session, "awk -F: '/model name/ {name=$2} END {print name}' /proc/cpuinfo | sed 's/^[ \\t]*//;s/[ \\t]*$//'", charset, byteArrayOutputStream);
String str = new String(byteArrayOutputStream.toByteArray(),charset);
System.out.println(ls);
System.out.println("error="+str);
long currentTimeMillis1 = System.currentTimeMillis();
System.out.println("Ganymed方式"+(currentTimeMillis1-currentTimeMillis));
}
}
问题总结
1. dd命令进行磁盘测速方法获取不到值
经过分析发现执行结果都在工具类的错误流中，并非在正常流中，自己打印一下错误流就发现了。
- 本地的shell命令的话参考一下工具类的MyRuntimeUtil.execForErrStr(charset,cmd)这个方法。
- jsch框架的话参考一下工具类的jschInstance.execCmdErrContent(cmd)这个方法。
2. 执行ll命令报错
采用框架中的方法调用，是不带用户的环境变量的所以ll命令会报错，ll命令是ls -l命令封装后的结果。所以需要使用ls -l命令。
3.执行top命令报错
不支持top这种不断刷新交互式的命令。加参数获取一次性结果。
top -b -n 1 |head -n 4 | grep 'sy' | grep 'us' | awk '{print $2}'