实战:第十篇:使用Java代码获取Linux系统执行命令后的结果

本文涉及的产品
Redis 开源版,标准版 2GB
推荐场景:
搭建游戏排行榜
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
云数据库 Tair(兼容Redis),内存型 2GB
简介: 实战:第十篇:使用Java代码获取Linux系统执行命令后的结果

需求一:使用Java代码获取Linux系统执行命令后的结果




需求二:获取xml节点数据


解答:

import java.io.*;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.tree.DefaultAttribute;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import xsf.data.*;
/**
 * SSH工具类
 * @author
 * 2013-4-7
 */
public class TestGetData {
    public static void main(String args[]){
    }
    public static Map getXml(String url){
        Map<String, String> hashMap = new HashMap<>();
        //创建解析器
        SAXReader saxreader = new SAXReader();
        //读取文档
        Document doc = null;
        try {
            doc = saxreader.read(new File(url));
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        //获取根
        Element root = doc.getRootElement();
        //获取子节点
        List<Element> list = root.elements();
        for (Element element : list) {
            String name = element.getName();
            if("System".equals(name)){
                Element dbConnection = element.element("DataBase").element("DBConnection");
                String removeAbandoned = dbConnection.attributeValue("removeAbandoned");
                hashMap.put("removeAbandoned",removeAbandoned != "" && removeAbandoned != null ? removeAbandoned : "");
                String removeAbandonedTimeout = dbConnection.attributeValue("removeAbandonedTimeout");
                hashMap.put("removeAbandonedTimeout",removeAbandonedTimeout != "" && removeAbandonedTimeout != null ? removeAbandonedTimeout : "");
                String logAbandoned = dbConnection.attributeValue("logAbandoned");
                hashMap.put("logAbandoned",logAbandoned != "" && logAbandoned != null ? logAbandoned : "");
            }
            if("Service".equals(name)){
                Element connector = element.element("Connector");
                hashMap.put("port",connector.attributeValue("port"));
                hashMap.put("protocol",connector.attributeValue("protocol"));
                hashMap.put("maxThreads",connector.attributeValue("maxThreads"));
                hashMap.put("connectionTimeout",connector.attributeValue("connectionTimeout"));
            }
            if("ConnectionSettings".equals(name)){
                List<Element> settings = element.elements("Settings");
                for (Element setting : settings) {
                    String attributeValue = setting.attributeValue("Id");
                    if("XUGUConnection".equals(attributeValue)){
                        List<Element> elements = setting.elements("Add");
                        for (Element attr : elements) {
                            List<Object> attributes = attr.attributes();
                            DefaultAttribute value = (DefaultAttribute) attributes.get(0);
                            String valueValue = value.getValue();
                            DefaultAttribute data = (DefaultAttribute) attributes.get(1);
                            String dataValue = data.getValue();
                            if("removeAbandoned".equals(valueValue)){
                                hashMap.put("removeAbandoned",dataValue);
                            }
                            if("removeAbandonedTimeout".equals(valueValue)){
                                hashMap.put("removeAbandonedTimeout",dataValue);
                            }
                            if("logAbandoned".equals(valueValue)){
                                hashMap.put("logAbandoned",dataValue);
                            }
                        }
                    }
                }
            }
        }
        return hashMap;
    }
//
//
//    static ThreadPoolTaskExecutor threadPoolTaskExecutor;
//
//    static {
//        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
//        threadPoolTaskExecutor.setCorePoolSize(5);
//        threadPoolTaskExecutor.setMaxPoolSize(10);
//        threadPoolTaskExecutor.setQueueCapacity(100);
//        threadPoolTaskExecutor.initialize();
//    }
//
//    /**
//     * 获取数据
//     */
//    public static List<Map> getData(){
//        List<Map> list = new ArrayList<>();
//        if(!"Linux".equals(OSinfo.getOSname())){
//            final CountDownLatch latch = new CountDownLatch(5);
//            threadPoolTaskExecutor.submit(new Runnable() {
//                @Override
//                public void run() {
//                    TestGetData.getJVM();
//                    latch.countDown();
//                }
//            });
//            threadPoolTaskExecutor.submit(new Runnable() {
//                @Override
//                public void run() {
//                    Map linux = TestGetData.getOpenFiles("192.168.134.100", "root", "root", 22, "ulimit -a");
//                    list.add(linux);
//                    latch.countDown();
//                }
//            });
//            threadPoolTaskExecutor.submit(new Runnable() {
//                @Override
//                public void run() {
//                    Map mysql = TestGetData.getMysql("192.168.134.100", "root", "root", 22, "cat /etc/my.cnf");
//                    list.add(mysql);
//                    latch.countDown();
//                }
//            });
//            threadPoolTaskExecutor.submit(new Runnable() {
//                @Override
//                public void run() {
//                    Map redis = TestGetData.getRedis("192.168.134.100", "root", "root", 22, "cat redis.conf", "/usr/local/redis/bin/redis-cli info clients");
//                    list.add(redis);
//                    latch.countDown();
//                }
//            });
//            threadPoolTaskExecutor.submit(new Runnable() {
//                @Override
//                public void run() {
                    Map tomcat = TestGetData.getXml("G:\\Tomcat\\PersonalTomcat\\OrdinaryTomcat\\apache-tomcat-9.0.27\\conf\\server.xml");
                    list.add(tomcat);
//                    latch.countDown();
//                }
//            });
//        }
//        return list;
//    }
//
//
//
//    /**
//     * 远程 执行命令并返回结果调用过程 是同步的(执行完23才会返回)
//     * @param host  主机名
//     * @param user  用户名
//     * @param psw 密码
//     * @param port  端口
//     * @param command 命令
//     * @return
//     */
//    public static Map exec(String host,String user,String psw,int port,String command){
//        String result="";
//        Session session =null;
//        ChannelExec openChannel =null;
//        Map<String, String> map = new HashMap<>();
//        try {
//            JSch jsch=new JSch();
//            session = jsch.getSession(user, host, port);
//            java.util.Properties config = new java.util.Properties();
//            config.put("StrictHostKeyChecking", "no");
//            session.setConfig(config);
//            session.setPassword(psw);
//            session.connect();
//            openChannel = (ChannelExec) session.openChannel("exec");
//            openChannel.setCommand(command);
//            openChannel.connect();
//            InputStream in = openChannel.getInputStream();
//            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
//            String buf = null;
//            while ((buf = reader.readLine()) != null) {
//                String data = new String(buf.getBytes("UTF-8"),"UTF-8");
//                result+= data +"\r\n";
//                if(buf.contains("open files")){
//                    map.put("openFiles",data);
//                }
//                if(buf.contains("soft nofile")){
//                    map.put("softNofile",data);
//                }
//                if(buf.contains("hard nofile")){
//                    map.put("hardNofile",data);
//                }
//                if(buf.contains("max_connections")){
//                    map.put("maxConnections",data);
//                }
//                if(buf.contains("innodb_buffer_pool_size")){
//                    map.put("innodbBufferPoolSize",data);
//                }
//                if(buf.contains("timeout")){
//                    map.put("timeout",data);
//                }
//                if(buf.contains("connected_clients")){
//                    map.put("connectedClients",data);
//                }
//            }
//        } catch (JSchException | IOException e) {
//            result+=e.getMessage();
//        }finally{
//            if(openChannel!=null&&!openChannel.isClosed()){
//                openChannel.disconnect();
//            }
//            if(session!=null&&session.isConnected()){
//                session.disconnect();
//            }
//        }
//        map.put("all",result);
//        return map;
//    }
//
//    public static void getJVM(){
//        MemoryMXBean memorymbean = ManagementFactory.getMemoryMXBean();
//        System.out.println("堆内存信息: " + memorymbean.getHeapMemoryUsage());
//        System.out.println("方法区内存信息: " + memorymbean.getNonHeapMemoryUsage());
//
//        List<String> inputArgs = ManagementFactory.getRuntimeMXBean().getInputArguments();
//        System.out.println("\n#####################运行时设置的JVM参数#######################");
//        System.out.println(inputArgs);
//
//        System.out.println("\n#####################运行时内存情况#######################");
//        long totle = Runtime.getRuntime().totalMemory();
//        System.out.println("总的内存量 [" + totle + "]");
//        long free = Runtime.getRuntime().freeMemory();
//        System.out.println("空闲的内存量 [" + free + "]");
//        long max = Runtime.getRuntime().maxMemory();
//        System.out.println("最大的内存量 [" + max + "]");
//    }
//
//
//
//    public static Map getRedis(String host,String user,String psw,int port,String conf,String info){
//        Map map = exec(host, user, psw, port, conf);//"cat redis.conf"
//        Map<String, String> hashMap = new HashMap<>();
//        if(!CollectionUtils.isEmpty(map)){
//            String timeoutStr = (String) map.get("timeout");
//            if(!StringUtils.isEmpty(timeoutStr)){
//                hashMap.put("timeout ",timeoutStr);
//            }else {
//                hashMap.put("timeout ","0");
//            }
//        }
//        Map clients = exec(host, user, psw, port, info);//"/usr/local/redis/bin/redis-cli info clients"
//        String connectedClients  = getInt(((String)clients.get("connectedClients")));
//        hashMap.put("connectedClients",connectedClients);
//        return hashMap;
//    }
//
//    /**
//     * 获取mysql参数
//     * @return
//     */
//    public static Map getMysql(String host,String user,String psw,int port,String command){
//        Map map = exec(host, user, psw, port, command);//"cat /etc/my.cnf"
//        Map<String, String> hashMap = new HashMap<>();
//        if(!CollectionUtils.isEmpty(map)){
//            String maxConnections = getInt(((String)map.get("maxConnections")));
//            if(StringUtils.isEmpty(maxConnections)){
//                maxConnections = "0";
//                hashMap.put("maxConnections",maxConnections);
//            }
//            String innodbBufferPoolSize = getInt((String)map.get("innodbBufferPoolSize"));
//            if(StringUtils.isEmpty(innodbBufferPoolSize)){
//                innodbBufferPoolSize = "0";
//                hashMap.put("innodbBufferPoolSize",innodbBufferPoolSize);
//            }
//        }
//        return hashMap;
//    }
//
//    /**
//     * 获取打开的最大文件数
//     * @return
//     */
//    public static Map getOpenFiles(String host,String user,String psw,int port,String ulimit){
//        Map<String, String> hashMap = new HashMap<>();
//        Map map = exec(host, user, psw, port, ulimit);//ulimit -a
//        String openFiles = (String) map.get("openFiles");
//        hashMap.put("openFiles",openFiles);
//        return hashMap;
//    }
//
//    /**
//     * 获取nofile
//     * @param host
//     * @param user
//     * @param psw
//     * @param port
//     * @param noFile
//     * @return
//     */
//    public static Map getNofile(String host,String user,String psw,int port,String noFile){
//        Map<String, String> hashMap = new HashMap<>();
//        Map exec = exec(host, user, psw, port, noFile);//"cat /etc/security/limits.conf"
//        String hardNofile = getInt((String)exec.get("hardNofile"));
//        hashMap.put("hardNofile",hardNofile);
//        String softNofile = getInt((String)exec.get("softNofile"));
//        hashMap.put("softNofile",softNofile);
//        return hashMap;
//    }
//
//    /**
//     * 获取数字
//     * @param str
//     * @return
//     */
//    private static String getInt(String str){
//        String regEx="[^0-9]";
//        Pattern p = Pattern.compile(regEx);
//        Matcher m = p.matcher(str);
//        return m.replaceAll("").trim();
//    }
}

pom.xml

<!--远程连接linux建立SSH连接-->
<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.46</version>
</dependency>
相关实践学习
DataV Board用户界面概览
本实验带领用户熟悉DataV Board这款可视化产品的用户界面
阿里云实时数仓实战 - 项目介绍及架构设计
课程简介 1)学习搭建一个数据仓库的过程,理解数据在整个数仓架构的从采集、存储、计算、输出、展示的整个业务流程。 2)整个数仓体系完全搭建在阿里云架构上,理解并学会运用各个服务组件,了解各个组件之间如何配合联动。 3&nbsp;)前置知识要求 &nbsp; 课程大纲 第一章&nbsp;了解数据仓库概念 初步了解数据仓库是干什么的 第二章&nbsp;按照企业开发的标准去搭建一个数据仓库 数据仓库的需求是什么 架构 怎么选型怎么购买服务器 第三章&nbsp;数据生成模块 用户形成数据的一个准备 按照企业的标准,准备了十一张用户行为表 方便使用 第四章&nbsp;采集模块的搭建 购买阿里云服务器 安装 JDK 安装 Flume 第五章&nbsp;用户行为数据仓库 严格按照企业的标准开发 第六章&nbsp;搭建业务数仓理论基础和对表的分类同步 第七章&nbsp;业务数仓的搭建&nbsp; 业务行为数仓效果图&nbsp;&nbsp;
目录
打赏
0
0
0
0
74
分享
相关文章
|
1月前
|
Linux缓存管理:如何安全地清理系统缓存
在Linux系统中,内存管理至关重要。本文详细介绍了如何安全地清理系统缓存,特别是通过使用`/proc/sys/vm/drop_caches`接口。内容包括清理缓存的原因、步骤、注意事项和最佳实践,帮助你在必要时优化系统性能。
202 78
Linux系统查看操作系统版本信息、CPU信息、模块信息
在Linux系统中,常用命令可帮助用户查看操作系统版本、CPU信息和模块信息
62 23
基于Java的Hadoop文件处理系统:高效分布式数据解析与存储
本文介绍了如何借鉴Hadoop的设计思想,使用Java实现其核心功能MapReduce,解决海量数据处理问题。通过类比图书馆管理系统,详细解释了Hadoop的两大组件:HDFS(分布式文件系统)和MapReduce(分布式计算模型)。具体实现了单词统计任务,并扩展支持CSV和JSON格式的数据解析。为了提升性能,引入了Combiner减少中间数据传输,以及自定义Partitioner解决数据倾斜问题。最后总结了Hadoop在大数据处理中的重要性,鼓励Java开发者学习Hadoop以拓展技术边界。
34 7
Kali Linux系统Metasploit框架利用 HTA 文件进行渗透测试实验
本指南介绍如何利用 HTA 文件和 Metasploit 框架进行渗透测试。通过创建反向 shell、生成 HTA 文件、设置 HTTP 服务器和发送文件,最终实现对目标系统的控制。适用于教育目的,需合法授权。
75 9
Kali Linux系统Metasploit框架利用 HTA 文件进行渗透测试实验
|
1月前
|
Linux 10 个“who”命令示例
Linux 10 个“who”命令示例
84 14
Linux 10 个“who”命令示例
|
1月前
|
Linux 各发行版安装 ping 命令指南
如何在不同 Linux 发行版(Ubuntu/Debian、CentOS/RHEL/Fedora、Arch Linux、openSUSE、Alpine Linux)上安装 `ping` 命令,详细列出各发行版的安装步骤和验证方法,帮助系统管理员和网络工程师快速排查网络问题。
164 20
|
28天前
|
linux查看目录下的文件夹命令,find查找某个目录,但是不包括这个目录本身?
通过本文的介绍,您应该对如何在 Linux 系统中查看目录下的文件夹以及使用 `find` 命令查找特定目录内容并排除该目录本身有了清晰的理解。掌握这些命令和技巧,可以大大提高日常文件管理和查找操作的效率。 在实际应用中,灵活使用这些命令和参数,可以帮助您快速定位和管理文件和目录,满足各种复杂的文件系统操作需求。
81 8
嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
在嵌入式Linux系统编程中,`times`和 `clock`函数是获取进程时间的两个重要工具。`times`函数提供了更详细的进程和子进程时间信息,而 `clock`函数则提供了更简单的处理器时间获取方法。根据具体需求选择合适的函数,可以更有效地进行性能分析和资源管理。通过本文的介绍,希望能帮助您更好地理解和使用这两个函数,提高嵌入式系统编程的效率和效果。
109 13
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等