paquete com.learn.service;
importar com.jcraft.jsch. *;
importar java.io.BufferedReader;
importar java.io.IOException;
importar java.io.InputStream;
importar java.io.InputStreamReader;
importar java.util.HashMap ;
import java.util.Map;
/ **
* Llamar de forma remota comandos de shell de Linux
* @author yuyihao 2019.10.12
* /
public class LinuxStateForShell {
public static final String CPU_MEM_SHELL = "top -b -n 1"; // usuario de comando liunx Obtener información del sistema
public static final String FILES_SHELL = "df -hl"; // Ver el uso del disco
public static final String [] COMMANDS = {CPU_MEM_SHELL, FILES_SHELL}; // Matriz de comandos
/ **
* Hay algunos caracteres de escape en java, como " \ n "es un carácter de nueva línea, algunos operadores que JDK viene con System.getProperty (" line.separator ");
* Este es también un carácter de nueva línea, la función y " \ n "son Consistentemente, este método puede distinguir los saltos de línea entre los entornos Windows y Linux.
* Durante el desarrollo y no en el mismo entorno, puede usar System.getProperty ("line.separator"); para controlar el salto de línea
* /
public static final String LINE_SEPARATOR = System.getProperty ("line.separator");
sesión estática privada session;
/ **
* Conectarse al HOST especificado
* @return isConnect
* @throws JSchException JSchException
* /
private static boolean connect (String user, String passwd, String host) {
JSch jsch = new JSch ();
try {
session = jsch .getSession (usuario, host, 22);
session.setPassword (contraseña);
java.util.Properties config = new java.util.Properties ();
config.put ("StrictHostKeyChecking", "no");
session.setConfig (config);
session.connect ();
} catch (JSchException e) {
e.printStackTrace ();
* @param comandos ejecutan Script
* @param nombre de usuario de usuario para conexión remota
* @param passwd contraseña para conexión remota
* @param host IP de host para conexión remota
* @return información de retorno de comando final
System.out.println ("¡error de conexión!");
falso retorno;
}
devuelve verdadero;
}
/ **
* 远程 连接 Linux 服务器 执行 相关 的 命令
* /
public static Map <String, String> runDistanceShell (comandos String [], String usuario, String passwd, String host) lanza IOException {
if (! connect (user, passwd, host)) {
return null;
}
Map <String, String> map = new HashMap <> ();
StringBuilder stringBuffer;
Lector BufferedReader = nulo;
Canal canal = nulo;
intente {
para (comando String: comandos) {
stringBuffer = new StringBuilder ();
canal = session.openChannel ("exec");
(Canal (ChannelExec)) .setCommand (comando);
channel.setInputStream (nulo);
((ChannelExec) channel) .setErrStream (System.err);
channel.connect ();
InputStream in = channel.getInputStream ();
reader = new BufferedReader (nuevo InputStreamReader (in));
String buf ;
while ((buf = reader.readLine ())! = null) {
// Descartar la información del proceso PID
if (buf.contains ("PID")) {
break;
}
stringBuffer.append (buf.trim ()). append (LINE_SEPARATOR);
}
// Cada comando almacena sus propios datos de retorno para el procesamiento posterior de los datos de retorno
map.put (command, stringBuffer.toString ());
}
} catch (IOException | JSchException e) {
e.printStackTrace ();
} finalmente {
try {
if (reader! = null) {
reader.close ();
}
} catch (IOException e) {
e.printStackTrace ();
}
if (channel! = Null) {
channel.disconnect ();
}
session.disconnect ();
}
return map;
}
/ **
* Procesando la información devuelta por el shell
* Procesamiento específico El proceso está sujeto al formato de datos devuelto por el servidor
* Diferentes versiones de Linux devuelven información en diferentes formatos
* @param result shell devuelve información
* @return información final procesada
* /
private static String disposeResultMessage (Map <String, String> resultado) {
StringBuilder buffer = new StringBuilder ();
para (comando String : COMMANDS) {
String commandResult = result.get (command);
if (null == commandResult) continue;
if (command.equals (CPU_MEM_SHELL)) {
String [] strings = commandResult.split (LINE_SEPARATOR);
// Dividir lo devuelto resultado por nueva línea
para (String line: strings) {
line = line.toUpperCase (); // Transferir a mayúsculas
// Procesando CPU Cpu (s): 10.8% us, 0.9% sy, 0.0% ni, 87.6% id, 0.7% wa, 0.0% hi, 0.0% si, 0.0% st
if (line.startsWith ("CPU (S ): ")) {
String cpuStr =" CPU compartida de usuario: ";
prueba {
cpuStr + = line.split (": ") [1] .split (", ") [0] .replace (" US "," ");
} catch (Exception e) {
e.printStackTrace ();
cpuStr + =" Error durante el cálculo ";
}
buffer.append (cpuStr) .append (LINE_SEPARATOR);
// Memoria de procesamiento Mem: 66100704k total, 65323404k usado, 777300k gratis,Búferes 89940k
} else if (line.startsWith ("MEM")) {
String memStr = "Uso de memoria:";
intente {
memStr + = line.split (":") [1]
.replace ("TOTAL", "Total")
.replace ("USED", "Used")
.replace ("FREE", "Free")
.replace ("BUFFERS", "Cache");
} catch (Exception e) {
e.printStackTrace ();
memStr + = "Error durante el cálculo";
buffer.append (memStr) .append (LINE_SEPARATOR);
continue;
}
buffer.append (memStr) .append (LINE_SEPARATOR);
}
}
} else if (command.equals (FILES_SHELL)) {
// Procesar estado del disco del sistema
buffer.append ("Estado del disco del sistema:");
probar {
buffer .append (disposeFilesSystem (commandResult)). append (LINE_SEPARATOR);
} catch (Exception e) {
e.printStackTrace ();
buffer.append ("error de cálculo" ) .append (LINE_SEPARATOR);
}
}
}
return buffer.toString ( );
}
// Procesando el estado del disco del sistema
/ **
* @param commandResult Procesando el resultado de la ejecución del shell del estado del disco del sistema
* @return Procesando el resultado
* /
/ **
* Resultado final del procesamiento
* Tasa de uso del usuario de la CPU: 0.2%
* Uso de la memoria Situación: 1020344K total, 160248K usados, 860096K libres, 14176K caché
* Estado del disco del sistema: tamaño 7.66G, usado 2.93G, libre 4.73G
* /
private static String disposeFilesSystem (String commandResult) {
String [] strings = commandResult.split (LINE_SEPARATOR);
// Cadena final PATTERN_TEMPLATE = "([a-zA-Z0-9% _ /] *) \\ s";
Doble tamaño = 0d;
Doble usado = 0d;
for (int i = 1; i <strings.length; i ++) {// No es necesario el título de la primera línea
Cadena [] fila = cadenas [i] .split ("\\ s +");
tamaño + = disposeUnit (fila [1]); // tamaño de la segunda columna
usada + = disposeUnit (fila [2]); // primeras Tres columnas usadas
}
return new StringBuilder (). append ("tamaño"). append (Math.round (tamaño * 100) / 100d) .append ("G, usado"). append (Math.round (usado * 100) / 100d) .append ("G, inactivo")
.append (Math.round ((tamaño usado) * 100) / 100d) .append ("G"). ToString ();
}
/ **
* Conversión de unidad de procesamiento
* K / KB / M / T finalmente se convierte a G. Procesando
* @param s cadena de datos con unidad
* @return valor procesado en unidad G
* /
private static Double disposeUnit (String s) {
try {
s = s.toUpperCase () ;
String lastIndex = s.substring (s.length () - 1);
String num = s.substring (0, s.length () - 1);
Double parseInt = Double.parseDouble (num);
if (lastIndex.equals ("G")) {
return parseInt;
} else if (lastIndex.equals ("T")) {
return parseInt * 1024;
} else if (lastIndex.equals ("M")) {
return parseInt / 1024;
} else if (lastIndex.equals ("K") || lastIndex.equals ("KB")) {
return parseInt / (1024 * 1024);
}
} catch (NumberFormatException e) {
e.printStackTrace ();
}
return 0d;
}
public static void main (String [] args) lanza IOException {
Map <String, String> result = runDistanceShell (COMMANDS, "root", "root123", "192.168.56.101");
System.out.println (disposeResultMessage (result));
}
} ¡
Di cosas importantes tres veces! Los datos devueltos por los comandos ejecutados por diferentes versiones de Linux son diferentes, los problemas específicos deben ser analizados en detalle.
La versión de Linx utilizada en este ejemplo:
top -b -n 1 datos después de la ejecución
df -hl datos después de la ejecución
