通过ssh访问linux文件

深碍√TFBOYSˉ_ 2022-05-20 10:24 294阅读 0赞 
  1.    使用java代码链接Linux服务器，无非使用SSH借用用户名密码进行链接，ganymed jar包提供了ssh的连接方式，下面我们借助Ambari开源项目代码，使用实例获得hadoop的一些配置文件并使用xml工具类进行解析。
  3.    pom文件内容，引入ganymed和文本处理类commons-lang3：
  5. <?xml version="1.0" encoding="UTF-8"?>
  6. <project xmlns="http://maven.apache.org/POM/4.0.0"
  7.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  8.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  9.     <parent>
  10.         <artifactId>java</artifactId>
  11.         <groupId>com.study.java</groupId>
  12.         <version>1.0-SNAPSHOT</version>
  13.     </parent>
  14.     <modelVersion>4.0.0</modelVersion>
  16.     <artifactId>utils</artifactId>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.         <ganymed-ssh2.version>262</ganymed-ssh2.version>
  20.         <apache-commons.version>3.5</apache-commons.version>
  21.     </properties>
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>ch.ethz.ganymed</groupId>
  26.             <artifactId>ganymed-ssh2</artifactId>
  27.             <version>${ganymed-ssh2.version}</version>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.apache.commons</groupId>
  31.             <artifactId>commons-lang3</artifactId>
  32.             <version>${apache-commons.version}</version>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>dom4j</groupId>
  36.             <artifactId>dom4j</artifactId>
  37.             <version>1.6.1</version>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>junit</groupId>
  41.             <artifactId>junit</artifactId>
  42.             <version>4.12</version>
  43.             <scope>test</scope>
  44.         </dependency>
  45.     </dependencies>
  47. </project>
  49.  CommandUtils类，getProcess获得进程信息和cat获得xml文件内容：
  51. public class CommandUtils {
  53.   private static DecimalFormat dFormat =new DecimalFormat("#.0");
  55.   /**
  56.    * 获得进程信息，从进程中得到服务部署地址
  57.    * @param conn
  58.    * @param processName
  59.    * @param pwd
  60.    * @return
  61.    */
  62.   public static String getProcess(Connection conn , String processName , String pwd ){
  63.     String head = processName.substring(0,1);
  64.     String end = processName.substring(1);
  65.     String shellString = String.format( CtrCommond.LinuxCmd.PID , pwd,head,end);
  66.     return  CtrCommond.doCommond(conn,shellString );
  67.   }
  69.   /**
  70.    * 使用cat获得到文件内容信息
  71.    * @param conn
  72.    * @param configDir
  73.    * @param pwd
  74.    * @return
  75.    */
  76.   public static String catConfig(Connection conn , String configDir , String pwd ){
  78.     String shellString = String.format( CtrCommond.LinuxCmd.Cat , pwd,configDir);
  79.     return  CtrCommond.doCommond(conn,shellString );
  80.   }
  82. }
  84. CtrCommond类用于linux连接和docommand执行命令：
  86. /**
  87.  * Created by whp on 2017/12/28.
  88.  */
  89. public class CtrCommond {
  91.   private static final Logger LOG = LoggerFactory.getLogger(CtrCommond.class);
  93.   private static final String id_rsa_path =null;
  94.   /**
  95.    * 获取服务器链接
  96.    */
  97.   public static Connection getConn(String hostName, String userName, int sshPort, String passWord) {
  98.     try {
  99.       Connection conn = new Connection(hostName, sshPort);
  100.       //连接到主机
  101.       conn.connect();
  102.       //使用用户名和密码校验
  103.       boolean isconn = conn.authenticateWithPassword(userName, passWord);
  105.       if (!isconn) {
  106.         LOG.info("用户名称或者是密码不正确");
  107.       } else {
  108.         return conn;
  109.       }
  110.     } catch (IOException e) {
  111.       LOG.error("获取服务器链接出现异常：" + e.toString());
  112.       return null;
  113.     }
  114.     return null;
  115.   }
  117.   public static Connection getConn(String hostName, String userName, int sshPort,
  118.                                    char[] pemPrivateKey, String password) {
  119.     try {
  120.       Connection conn = new Connection(hostName, sshPort);
  121.       //连接到主机
  122.       conn.connect();
  123.       //使用PublicKey校验
  124.       boolean isconn = conn.authenticateWithPublicKey(userName, pemPrivateKey, password);
  125.       if (!isconn) {
  126.         LOG.info("用户名称或者是密码不正确");
  127.       } else {
  128.         return conn;
  129.       }
  130.     } catch (IOException e) {
  131.       LOG.error("获取服务器链接出现异常：" + e.toString());
  132.       return null;
  133.     }
  134.     return null;
  135.   }
  137.   public static Connection getConn(String hostName, String userName, int sshPort,
  138.                                    File pemFile, String password) {
  139.     try {
  140.       Connection conn = new Connection(hostName, sshPort);
  141.       //连接到主机
  142.       conn.connect();
  143.       boolean isconn = conn.authenticateWithPublicKey(userName, pemFile, password);
  144.       if (!isconn) {
  145.         LOG.info("用户名称或者是密码不正确");
  146.       } else {
  147.         return conn;
  148.       }
  149.     } catch (IOException e) {
  150.       LOG.error("获取服务器链接出现异常：" + e.toString());
  151.       return null;
  152.     }
  153.     return null;
  154.   }
  156.   /**
  157.    * 远程执行命令
  158.    */
  159.   public static String doCommond(Connection conn, String cmd) {
  160.     String result = "";
  161.     try {
  162.       if (conn == null) {
  163.         LOG.info("请先链接服务器");
  164.       } else {
  165.         Session sess = conn.openSession();
  166.         sess.execCommand(cmd);
  167.         InputStream stdout = new StreamGobbler(sess.getStdout());
  168.         BufferedReader stdoutReader = new BufferedReader(new InputStreamReader(stdout));
  169.         while (true) {
  170.           String line = stdoutReader.readLine();
  171.           if (line == null) {
  172.             break;
  173.           }
  174.           result += line + StaticKeys.SPLIT_BR;
  175.         }
  176.         //连接的Session和Connection对象都需要关闭
  177.         stdoutReader.close();
  178.         sess.close();
  179.       }
  180.     } catch (IOException e) {
  181.       LOG.error("执行linux命令错误：" + e.toString());
  182.     }
  183.     if (result.endsWith(StaticKeys.SPLIT_BR)) {
  184.       result = result.substring(0, result.length() - StaticKeys.SPLIT_BR.length());
  185.     }
  187.     if (!StringUtils.isEmpty(result)) {
  188.       if (cmd.contains("DEV") || cmd.contains("iostat")) {
  189.         if (result.contains("</br></br>")) {
  190.           result = result.substring(result.lastIndexOf("</br></br>") + 10);
  191.         }
  192.       }
  193.       if (cmd.contains("mpstat")) {
  194.         if (result.contains("</br></br>")) {
  195.           result = result.substring(result.lastIndexOf("</br></br>") + 10);
  196.           int s = result.indexOf("</br>") + 5;
  197.           s = result.indexOf("</br>", s);
  198.           result = result.substring(0, s);
  199.         }
  200.       }
  201.     }
  202.     return result;
  203.   }
  205.   public class LinuxCmd {
  207.     /**
  208.      * 根据进程名称查询进程
  209.      */
  210.     public static final String PID = "echo %s | sudo -S ps aux | grep -i [%s]%s ";
  213.     public static final String Cat = "echo %s | sudo -S cat %s ";
  215.     public static final String VIEW_MEM = "free -m";//查看内存状态
  217.     public static final String SYSTEM_RELEASE = "cat /etc/system-release";//查看系统版本
  219.     public static final String UNAME_A = "uname -a";//查看系统详细信息
  221.     public static final String DF_HL = "df -k | grep '^\\/dev/' | awk '{print $2,$3,$4}'";//查看磁盘空间
  223.     //物理cpu个数
  224.     public static final String WULI_CPU_NUM = "cat /proc/cpuinfo| grep \"physical id\"| sort| uniq| wc -l";
  226.     //每个cpu的核数
  227.     public static final String WULI_CPU_CORE_NUM = "cat /proc/cpuinfo| grep \"cpu cores\"| uniq";
  229.     //cpu型号信息
  230.     public static final String CPU_XINGHAO = "cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c";
  232.     //cpu使用情况
  233.     public static final String VMSTAT = "top -b -n 1 | sed -n '3p'";
  235.     //查看服务器网络吞吐率
  236.     public static final String SAR_DEV_1 = "sar -n DEV 1 3";
  238.     //查看磁盘IO使用情况
  239.     public static final String DISK_IO = "iostat -xkz 1 1";
  241.     //tcp状态
  242.     public static final String SAR_TCP_1 = "sar -n TCP 1 3";
  244.     //查看系统负载状态
  245.     public static final String UPTIME = "uptime";
  247.     //根据PID查看进程状态
  248.     public static final String dd = "ps aux|head -1;ps aux|grep {pid}";
  250.     public static final String rpcinfo = "rpcinfo -p";//看rpc服务开放
  252.     public static final String lsmod = "lsmod";//检查系统内核模块
  254.     public static final String passwd_update_time = "ls -l /etc/passwd";//查看passwd文件修改时间
  256.     public static final String crontab = "cat /etc/crontab";//查看计划任务
  258.     public static final String promisc = "ip link | grep promisc";//检查网络：ip link | grep PROMISC（正常网卡不该在promisc模式，可能存在sniffer）
  260.     public static final String date = "date \"+%Y-%m-%d %H:%M:%S\"";
  261.     public static final String ntp = "ntpdate ";
  263.     public static final String reboot = "reboot ";
  265.     public static final String shutdown = "shutdown -h now ";
  266.   }
  268. }
  270.  PathUtils类，对于访问路径进行格式化：
  272. /**
  273.  * @author whp 18-7-16
  274.  */
  275. public class PathUtils {
  277.     /**
  278.      * 进程配置转换
  279.      * @param process
  280.      * @param serviceType
  281.      * @return
  282.      */
  283.     public static String parse(String process  , String serviceType) {
  284.         String homeDir ="";
  285.         if(process!=null ) {
  286.             String []javaConfig =  process.split(" ");
  287.             for(String config : javaConfig ) {
  288.                 if(config.contains("-Dhadoop.home.dir") && serviceType.equals("hadoop")) {
  289.                     String []dir = config.split("=");
  290.                     homeDir = dir[1];
  291.                     break;
  292.                 }else if(config.contains("-Dhbase.home.dir") && serviceType.equals("hbase")) {
  293.                     String []dir = config.split("=");
  294.                     homeDir = dir[1];
  295.                     break;
  296.                 }else if( serviceType.equals("hive")) {
  297.                     if(config.contains("-D") || config.contains("-X"))
  298.                         continue;
  299.                     String pattern = "(.*)\\/lib\\/.*$";
  300.                     Pattern r = Pattern.compile(pattern);
  301.                     Matcher m = r.matcher(config);
  302.                     if(m.find()){
  303.                         homeDir= m.group(1);
  304.                         break;
  305.                     }
  306.                 }
  307.             }
  308.         }
  309.         return homeDir;
  310.     }
  311. }
  313. /**
  314.  */
  315. public class StaticKeys {
  317.     public static String SPLIT_BR = "</br>";//换行标识
  319.     public static String SPLIT_KG = " ";//空格
  321.     public static String SPLIT_DH = ",";//逗号
  323.     public static String SPLIT_MH = ":";//逗号
  325.     public static String SPLIT_SXG = "//";//双反斜杠
  327.     public static String SPLIT_LINE = "\n";//换行标识
  329.     public static String MAC ="";//本机mac地址
  331. }
  333.    xml格式化类，xml格式化借助于java提供的dom4j，使用document将xml转化为element对象，然后遍历elements将其转化为list，并将element的name作为key值进行保存。
  335. public class XmlMapUtils {
  336.   public static void main(String[] args) throws DocumentException, IOException {
  337. //        String textFromFile = FileUtils.readFileToString(new File("D:/workspace/workspace_3.7/xml2map/src/xml2json/sample.xml"),"UTF-8");
  338. //        Map<String, Object> map = xml2map(textFromFile, false);
  339. //        // long begin = System.currentTimeMillis();
  340. //        // for(int i=0; i<1000; i++){
  341. //        // map = (Map<String, Object>) xml2mapWithAttr(doc.getRootElement());
  342. //        // }
  343. //        // System.out.println("耗时:"+(System.currentTimeMillis()-begin));
  344. //        JSON json = JSONObject.fromObject(map);
  345. //        System.out.println(json.toString(1)); // 格式化输出
  346.     Map<String,Object> map = new HashMap<String, Object>();
  347.     map.put("q", "");
  348.     map.put("w", "");
  349.     map.put("e", "");
  350.     Document doc = map2xml(map, "root");
  351.     //Document doc = map2xml(map); //map中含有根节点的键
  352.     System.out.println(formatXml(doc));
  353.   }
  355.   /**
  356.    * xml转map 不带属性
  357.    * @param xmlStr
  358.    * @param needRootKey 是否需要在返回的map里加根节点键
  359.    * @return
  360.    * @throws DocumentException
  361.    */
  362.   public static Map xml2map(String xmlStr, boolean needRootKey) throws DocumentException {
  363.     xmlStr = xmlStr.replace("</br>","");
  364.     Document doc = DocumentHelper.parseText(xmlStr);
  365.     Element root = doc.getRootElement();
  366.     Map<String, Object> map = (Map<String, Object>) xml2map(root);
  367.     if(root.elements().size()==0 && root.attributes().size()==0){
  368.       return map;
  369.     }
  370.     if(needRootKey){
  371.       //在返回的map里加根节点键（如果需要）
  372.       Map<String, Object> rootMap = new HashMap<String, Object>();
  373.       rootMap.put(root.getName(), map);
  374.       return rootMap;
  375.     }
  376.     return map;
  377.   }
  379.   /**
  380.    * xml转map 带属性
  381.    * @param xmlStr
  382.    * @param needRootKey 是否需要在返回的map里加根节点键
  383.    * @return
  384.    * @throws DocumentException
  385.    */
  386.   public static Map xml2mapWithAttr(String xmlStr, boolean needRootKey) throws DocumentException {
  387.     Document doc = DocumentHelper.parseText(xmlStr);
  388.     Element root = doc.getRootElement();
  389.     Map<String, Object> map = (Map<String, Object>) xml2mapWithAttr(root);
  390.     if(root.elements().size()==0 && root.attributes().size()==0){
  391.       return map; //根节点只有一个文本内容
  392.     }
  393.     if(needRootKey){
  394.       //在返回的map里加根节点键（如果需要）
  395.       Map<String, Object> rootMap = new HashMap<String, Object>();
  396.       rootMap.put(root.getName(), map);
  397.       return rootMap;
  398.     }
  399.     return map;
  400.   }
  402.   /**
  403.    * xml转map 不带属性
  404.    * @param e
  405.    * @return
  406.    */
  407.   private static Map xml2map(Element e) {
  408.     Map map = new LinkedHashMap();
  409.     List list = e.elements();
  410.     if (list.size() > 0) {
  411.       for (int i = 0; i < list.size(); i++) {
  412.         Element iter = (Element) list.get(i);
  413.         List mapList = new ArrayList();
  415.         if (iter.elements().size() > 0) {
  416.           Map m = xml2map(iter);
  417.           if (map.get(iter.getName()) != null) {
  418.             Object obj = map.get(iter.getName());
  419.             if (!(obj instanceof List)) {
  420.               mapList = new ArrayList();
  421.               mapList.add(obj);
  422.               mapList.add(m);
  423.             }
  424.             if (obj instanceof List) {
  425.               mapList = (List) obj;
  426.               mapList.add(m);
  427.             }
  428.             map.put(iter.getName(), mapList);
  429.           } else
  430.             map.put(iter.getName(), m);
  431.         } else {
  432.           if (map.get(iter.getName()) != null) {
  433.             Object obj = map.get(iter.getName());
  434.             if (!(obj instanceof List)) {
  435.               mapList = new ArrayList();
  436.               mapList.add(obj);
  437.               mapList.add(iter.getText());
  438.             }
  439.             if (obj instanceof List) {
  440.               mapList = (List) obj;
  441.               mapList.add(iter.getText());
  442.             }
  443.             map.put(iter.getName(), mapList);
  444.           } else
  445.             map.put(iter.getName(), iter.getText());
  446.         }
  447.       }
  448.     } else
  449.       map.put(e.getName(), e.getText());
  450.     return map;
  451.   }
  453.   /**
  454.    * xml转map 带属性
  455.    * @param
  456.    * @return
  457.    */
  458.   private static Map xml2mapWithAttr(Element element) {
  459.     Map<String, Object> map = new LinkedHashMap<String, Object>();
  461.     List<Element> list = element.elements();
  462.     List<Attribute> listAttr0 = element.attributes(); // 当前节点的所有属性的list
  463.     for (Attribute attr : listAttr0) {
  464.       map.put("@" + attr.getName(), attr.getValue());
  465.     }
  466.     if (list.size() > 0) {
  468.       for (int i = 0; i < list.size(); i++) {
  469.         Element iter = list.get(i);
  470.         List mapList = new ArrayList();
  472.         if (iter.elements().size() > 0) {
  473.           Map m = xml2mapWithAttr(iter);
  474.           if (map.get(iter.getName()) != null) {
  475.             Object obj = map.get(iter.getName());
  476.             if (!(obj instanceof List)) {
  477.               mapList = new ArrayList();
  478.               mapList.add(obj);
  479.               mapList.add(m);
  480.             }
  481.             if (obj instanceof List) {
  482.               mapList = (List) obj;
  483.               mapList.add(m);
  484.             }
  485.             map.put(iter.getName(), mapList);
  486.           } else
  487.             map.put(iter.getName(), m);
  488.         } else {
  490.           List<Attribute> listAttr = iter.attributes(); // 当前节点的所有属性的list
  491.           Map<String, Object> attrMap = null;
  492.           boolean hasAttributes = false;
  493.           if (listAttr.size() > 0) {
  494.             hasAttributes = true;
  495.             attrMap = new LinkedHashMap<String, Object>();
  496.             for (Attribute attr : listAttr) {
  497.               attrMap.put("@" + attr.getName(), attr.getValue());
  498.             }
  499.           }
  501.           if (map.get(iter.getName()) != null) {
  502.             Object obj = map.get(iter.getName());
  503.             if (!(obj instanceof List)) {
  504.               mapList = new ArrayList();
  505.               mapList.add(obj);
  506.               // mapList.add(iter.getText());
  507.               if (hasAttributes) {
  508.                 attrMap.put("#text", iter.getText());
  509.                 mapList.add(attrMap);
  510.               } else {
  511.                 mapList.add(iter.getText());
  512.               }
  513.             }
  514.             if (obj instanceof List) {
  515.               mapList = (List) obj;
  516.               // mapList.add(iter.getText());
  517.               if (hasAttributes) {
  518.                 attrMap.put("#text", iter.getText());
  519.                 mapList.add(attrMap);
  520.               } else {
  521.                 mapList.add(iter.getText());
  522.               }
  523.             }
  524.             map.put(iter.getName(), mapList);
  525.           } else {
  526.             // map.put(iter.getName(), iter.getText());
  527.             if (hasAttributes) {
  528.               attrMap.put("#text", iter.getText());
  529.               map.put(iter.getName(), attrMap);
  530.             } else {
  531.               map.put(iter.getName(), iter.getText());
  532.             }
  533.           }
  534.         }
  535.       }
  536.     } else {
  537.       // 根节点的
  538.       if (listAttr0.size() > 0) {
  539.         map.put("#text", element.getText());
  540.       } else {
  541.         map.put(element.getName(), element.getText());
  542.       }
  543.     }
  544.     return map;
  545.   }
  547.   /**
  548.    * map转xml map中没有根节点的键
  549.    * @param map
  550.    * @param rootName
  551.    * @throws DocumentException
  552.    * @throws IOException
  553.    */
  554.   public static Document map2xml(Map<String, Object> map, String rootName) throws DocumentException, IOException  {
  555.     Document doc = DocumentHelper.createDocument();
  556.     Element root = DocumentHelper.createElement(rootName);
  557.     doc.add(root);
  558.     map2xml(map, root);
  559.     //System.out.println(doc.asXML());
  560.     //System.out.println(formatXml(doc));
  561.     return doc;
  562.   }
  564.   /**
  565.    * map转xml map中含有根节点的键
  566.    * @param map
  567.    * @throws DocumentException
  568.    * @throws IOException
  569.    */
  570.   public static Document map2xml(Map<String, Object> map) throws DocumentException, IOException  {
  571.     Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
  572.     if(entries.hasNext()){ //获取第一个键创建根节点
  573.       Map.Entry<String, Object> entry = entries.next();
  574.       Document doc = DocumentHelper.createDocument();
  575.       Element root = DocumentHelper.createElement(entry.getKey());
  576.       doc.add(root);
  577.       map2xml((Map)entry.getValue(), root);
  578.       //System.out.println(doc.asXML());
  579.       //System.out.println(formatXml(doc));
  580.       return doc;
  581.     }
  582.     return null;
  583.   }
  585.   /**
  586.    * map转xml
  587.    * @param map
  588.    * @param body xml元素
  589.    * @return
  590.    */
  591.   private static Element map2xml(Map<String, Object> map, Element body) {
  592.     Iterator<Map.Entry<String, Object>> entries = map.entrySet().iterator();
  593.     while (entries.hasNext()) {
  594.       Map.Entry<String, Object> entry = entries.next();
  595.       String key = entry.getKey();
  596.       Object value = entry.getValue();
  597.       if(key.startsWith("@")){    //属性
  598.         body.addAttribute(key.substring(1, key.length()), value.toString());
  599.       } else if(key.equals("#text")){    //有属性时的文本
  600.         body.setText(value.toString());
  601.       } else {
  602.         if(value instanceof List ){
  603.           List list = (List)value;
  604.           Object obj;
  605.           for(int i=0; i<list.size(); i++){
  606.             obj = list.get(i);
  607.             //list里是map或String，不会存在list里直接是list的，
  608.             if(obj instanceof Map){
  609.               Element subElement = body.addElement(key);
  610.               map2xml((Map)list.get(i), subElement);
  611.             } else {
  612.               body.addElement(key).setText((String)list.get(i));
  613.             }
  614.           }
  615.         } else if(value instanceof Map ){
  616.           Element subElement = body.addElement(key);
  617.           map2xml((Map)value, subElement);
  618.         } else {
  619.           body.addElement(key).setText(value.toString());
  620.         }
  621.       }
  622.       //System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
  623.     }
  624.     return body;
  625.   }
  627.   /**
  628.    * 格式化输出xml
  629.    * @param xmlStr
  630.    * @return
  631.    * @throws DocumentException
  632.    * @throws IOException
  633.    */
  634.   public static String formatXml(String xmlStr) throws DocumentException, IOException {
  635.     Document document = DocumentHelper.parseText(xmlStr);
  636.     return formatXml(document);
  637.   }
  639.   /**
  640.    * 格式化输出xml
  641.    * @param document
  642.    * @return
  643.    * @throws DocumentException
  644.    * @throws IOException
  645.    */
  646.   public static String formatXml(Document document) throws DocumentException, IOException  {
  647.     // 格式化输出格式
  648.     OutputFormat format = OutputFormat.createPrettyPrint();
  649.     //format.setEncoding("UTF-8");
  650.     StringWriter writer = new StringWriter();
  651.     // 格式化输出流
  652.     XMLWriter xmlWriter = new XMLWriter(writer, format);
  653.     document.getRootElement().asXML();
  654.     // 将document写入到输出流
  655.     xmlWriter.write(document);
  656.     xmlWriter.close();
  657.     return writer.toString();
  658.   }
  660. }
  662. test测试类：
  664. public class LinuxCommondTest {
  665.     private final String HOST="192.168.1.221";
  666.     private final int PORT=22;
  667.     private final String USER_NAME="root";
  668.     private final String PASSWORD="123qwe";
  669.     private final String PROCESS_NAME="namenode";
  671.     @Test
  672.     public void testLoadXML(){
  673.         Connection conn= CtrCommond.getConn(HOST,USER_NAME,PORT,PASSWORD);
  674.         String process= CommandUtils.getProcess(conn,PROCESS_NAME,PASSWORD);
  675.         System.out.println("===process=="+process);
  676.         String homeDir= PathUtils.parse(process,"hadoop");
  677.         System.out.println("===homDir=="+homeDir);
  678.         String []hadoopDefaultConfig = {"hdfs-site.xml","core-site.xml","yarn-site.xml","mapred-site.xml"};
  679.         for(String defaultConfig : hadoopDefaultConfig) {
  680.             String configDir = homeDir + "/etc/hadoop/" + defaultConfig;
  681.             String xmlFile = CommandUtils.catConfig(conn, configDir, PASSWORD);
  682.             System.out.println(xmlFile);
  683.         }
  684.     }
  685. }
  687. 文章涉及到xml转化，ssh访问linux系统，command执行linux命令的代码编写，详细工程请参考本人github项目：

https://github.com/whpHarper/java下面utils子工程。

发表评论

表情：
评论列表 （有 0 条评论，294人围观）

还没有评论，来说两句吧...

相关阅读