精华内容
下载资源
问答
  • 我们可以使用Java来执行本地Shell命令甚至是远程主机上的Shell命令,并获取其标准输出、异常输出、执行结果码。 首先,访问远程主机需要加入一下maven支持: <dependency> <groupId>com.jcraft</...

    我们可以使用Java来执行本地Shell命令甚至是远程主机上的Shell命令,并获取其标准输出、异常输出、执行结果码。

    首先,访问远程主机需要加入一下maven支持:

    <dependency>
        <groupId>com.jcraft</groupId>
        <artifactId>jsch</artifactId>
        <version>0.1.55</version>
    </dependency>
    

    获取命令返回值所用的java bean类:

    public class ShellCmdResult {
        /** 异常输出 */
        private List<String> errorList;
    
        /** 标准输出 */
        private List<String> echoList;
    
        /** 执行结果码 */
        private int result;
    
        public ShellCmdResult() {
            this.echoList = new ArrayList<>();
            this.errorList = new ArrayList<>();
        }
    
        public List<String> getErrorList() {
            return errorList;
        }
    
        public void setErrorList(List<String> errorList) {
            this.errorList = errorList;
        }
    
        public List<String> getEchoList() {
            return echoList;
        }
    
        public void setEchoList(List<String> echoList) {
            this.echoList = echoList;
        }
    
        public int getResult() {
            return result;
        }
    
        public void setResult(int result) {
            this.result = result;
        }
    
        public void addEcho(String echo) {
            this.echoList.add(echo);
        }
    
        public void addError(String error) {
            this.errorList.add(error);
        }
    
        @Override
        public String toString() {
            return "ShellCmdResult{" +
                    "errorList=" + StringUtils.join(errorList, ", ") +
                    "], echoList=[" + StringUtils.join(echoList, ", ") +
                    "], result=" + result +
                    '}';
        }
    }
    

    然后就是逻辑代码了:

    import com.jcraft.jsch.ChannelExec;
    import com.jcraft.jsch.JSch;
    import com.jcraft.jsch.JSchException;
    import com.jcraft.jsch.Session;
    import org.apache.commons.lang3.StringUtils;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.Properties;
    
    public class ShellCmdExecutor {
        private static final int SESSION_TIMEOUT = 10000;
        private static final int CHANNEL_TIMEOUT = 5000;
    
        /**
         * 执行远程主机上的shell命令.
         * 
         * @param host 远程主机名(或IP地址)
         * @param port 远程主机端口号
         * @param user 用户ID(远程主机登陆用)
         * @param password 密码(远程主机登陆用)
         * @param cmd 命令
         * @return ShellCmdResult
         * @throws JSchException
         * @throws IOException
         */
        public static ShellCmdResult exec(String host, int port, String user, String password, String cmd) throws JSchException, IOException {
            JSch jsch = new JSch();
            Session session = null;
            ChannelExec channelExec = null;
            try {
                Properties config = new Properties();
                config.put("StrictHostKeyChecking", "no");
                session = jsch.getSession(user, host, port);
                session.setConfig(config);
                session.setPassword(password);
                session.connect(SESSION_TIMEOUT);
    
                channelExec = (ChannelExec) session.openChannel("exec");
                channelExec.setCommand(cmd);
                channelExec.connect(CHANNEL_TIMEOUT);
    
                try (BufferedReader errorReader = new BufferedReader(new InputStreamReader(channelExec.getErrStream()));
                     BufferedReader echoReader = new BufferedReader(new InputStreamReader(channelExec.getInputStream()))) {
                    ShellCmdResult shellCmdResult = new ShellCmdResult();
                    String line = null;
                    while ((line = echoReader.readLine()) != null) {
                        shellCmdResult.addEcho(line);
                    }
                    while ((line = errorReader.readLine()) != null) {
                        shellCmdResult.addError(line);
                    }
                    int exitStatus = channelExec.getExitStatus();
                    shellCmdResult.setResult(exitStatus);
                    return shellCmdResult;
                }
            } finally {
                if (channelExec != null && channelExec.isConnected()) {
                    channelExec.disconnect();
                }
                if (session != null && session.isConnected()) {
                    session.disconnect();
                }
            }
    
        }
    
        /**
         * 执行本地Shell命令.
         * 
         * @param cmd 命令
         * @return ShellCmdResult
         * @throws IOException
         * @throws InterruptedException
         */
        public static ShellCmdResult exec(String cmd) throws IOException, InterruptedException {
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec(new String[]{"bash", "-c", cmd});
            try (BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
                 BufferedReader echoReader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
                ShellCmdResult shellCmdResult = new ShellCmdResult();
                String line = null;
                while ((line = echoReader.readLine()) != null) {
                    shellCmdResult.addEcho(line);
                }
                while ((line = errorReader.readLine()) != null) {
                    shellCmdResult.addError(line);
                }
                int exitStatus = process.waitFor();
                shellCmdResult.setResult(exitStatus);
                return shellCmdResult;
            }
        }
    }
    

    用法:

    public class Main {
        public static void main(String[] args) throws IOException, JSchException, InterruptedException {
            // 调用远程主机Shell命令
            String host = "192.168.0.142";
            int port = 22;
            String user = "root";
            String password = "12345";
            String cmd = "bash /tmp/test.sh";
            ShellCmdResult shellCmdResult = ShellCmdExecutor.exec(host, port, user, password, cmd);
            System.out.println(shellCmdResult);
    
    		// 调用本地Shell命令
            cmd = "bash /tmp/test.sh";
            shellCmdResult = ShellCmdExecutor.exec(cmd);
            System.out.println(shellCmdResult);
        }
    }
    
    展开全文
  • [java]代码库import java.io.File;.../*** 通过ProcessBuilder执行本地命令。此类用于创建操作系统进程。 获取本机的ip配置信息** 每个进程生成器管理这些进程属性: (1)命令 是一个字符串列表,它表示要调用的外...

    [java]代码库import java.io.File;

    import java.io.IOException;

    import java.io.InputStream;

    import java.util.Map;

    /**

    * 通过ProcessBuilder执行本地命令。此类用于创建操作系统进程。 获取本机的ip配置信息

    *

    * 每个进程生成器管理这些进程属性: (1)命令 是一个字符串列表,它表示要调用的外部程序文件及其参数(如果有) (2)环境 是从变量 到值

    * 的依赖于系统的映射。初始值是当前进程环境的一个副本. (3)工作目录。默认值是当前进程的当前工作目录,通常根据系统属性 user.dir 来命名.

    * (4)redirectErrorStream 属性。最初,此属性为 false, 意思是子进程的标准输出和错误输出被发送给两个独立的流, 这些流可以通过

    * Process.getInputStream() 和 Process.getErrorStream() 方法来访问。 如果将值设置为

    * true,标准错误将与标准输出合并。这使得关联错误消息和相应的输出变得更容易。 在此情况下,合并的数据可从

    * Process.getInputStream() 返回的流读取, 而从 Process.getErrorStream() 返回的流读取将直接到达文件尾。

    */

    public class UsingProcessBuilder {

    /**

    * 获取Windows系统下的网卡的MAC地址

    *

    * @return

    */

    public static String getPhysicalAddress() {

    Process p = null;

    try {

    // 执行ipconfig /all命令

    p = new ProcessBuilder("ipconfig", "/all").start();

    } catch (IOException e) {

    return "";

    }

    byte[] b = new byte[1024];

    int readbytes = -1;

    StringBuffer sb = new StringBuffer();

    // 读取进程输出值

    InputStream in = p.getInputStream();

    try {

    while ((readbytes = in.read(b)) != -1) {

    sb.append(new String(b, 0, readbytes));

    }

    } catch (IOException e1) {

    } finally {

    try {

    in.close();

    } catch (IOException e2) {

    }

    }

    return sb.toString();

    }

    /**

    * 执行自定义的一个命令,该命令放在C:/temp下,并且需要2个环境变量的支持。

    */

    public static boolean executeMyCommand() {

    // 创建系统进程创建器

    ProcessBuilder pb = new ProcessBuilder("myCommand", "myArg1", "myArg2");

    // 获得进程的环境

    Map env = pb.environment();

    // 设置和去除环境变量

    env.put("VAR1", "myValue");

    env.remove("VAR0");

    env.put("VAR2", env.get("VAR1") + ";");

    // 切换工作目录

    pb.directory(new File("C:/temp"));

    try {

    // 得到进程实例

    Process p = pb.start();

    // 等待该进程执行完毕

    if (p.waitFor() != 0) {

    // 如果进程运行结果不为0,表示进程是错误退出的

    // 获得进程实例的错误输出

    InputStream error = p.getErrorStream();

    // do something

    }

    // 获得进程实例的标准输出

    InputStream sdin = p.getInputStream();

    } catch (IOException e) {

    } catch (InterruptedException e) {

    }

    return true;

    }

    public static void main(String[] args) {

    String address = UsingProcessBuilder.getPhysicalAddress();

    System.out.println(address);

    }

    }

    694748ed64b9390909c0d88230893790.png

    展开全文
  • 一.以springboot为例,建立代码1.IExecCommandServer:public interface IExecCommandServer {void execCommand(String cmd);}2.ExecCommandServerImp:@Servicepublic class ExecCommandServerImp implements ...

    一.以springboot为例,建立代码

    1.IExecCommandServer:

    public interface IExecCommandServer {

    void execCommand(String cmd);

    }

    2.ExecCommandServerImp:

    @Service

    public class ExecCommandServerImp implements IExecCommandServer {

    @Override

    public void execCommand(String cmd){

    try{

    Runtime rt = Runtime.getRuntime();

    Process proc = rt.exec(cmd,null,null);

    InputStream stderr = proc.getInputStream();

    InputStreamReader isr = new InputStreamReader(stderr,"GBK");

    BufferedReader br = new BufferedReader(isr);

    String line="";

    while ((line = br.readLine()) != null) {

    System.out.println(line);

    }

    }catch (Exception e){

    e.printStackTrace();

    }

    }

    }

    3.ExecCommandController:

    @CrossOrigin

    @RestController

    @RequestMapping("/linux")

    public class ExecCommandController {

    @Autowired

    private IExecCommandServer execCommandServer;

    @GetMapping("/exec")

    public ResultMap execCommand(String cmd) throws Exception {

    execCommandServer.execCommand(cmd);

    return Result.success("ok");

    }

    }

    二,执行示例

    http://192.168.142.222:8086/linux/exec?cmd=ls /mnt

    日志中输出:

    748fe6ca596052e2f413779bf3df9156.png

    展开全文
  • Java代码调用本地shell命令或shell脚本

    千次阅读 2018-11-12 16:35:21
    1. 概述: java.lang包下有一个Runtime类,是一个封装了JVM进程的...该类有一个方法,exec(),我们就是使用该方法来调用shell命令的。 2. exec方法的说明: Runtime.getRuntime().exec()方法主要用于执行外部的...

    1. 概述:

    java.lang包下有一个Runtime类,是一个封装了JVM进程的类。每一个JAVA程序实际上都是启动了一个JVM进程,那么每一个进程都是对应这一个Runtime实例,其实例是由JVM为其初始化的。该类有一个方法,exec(),我们就是使用该方法来调用shell命令的。

    2. exec方法的说明:

    Runtime.getRuntime().exec()方法主要用于执行外部的程序或命令。
    Runtime.getRuntime().exec共有六个重载方法:
    1.public Process exec(String command)
    在单独的进程中执行指定的字符串命令。
    2.public Process exec(String [] cmdArray)
    在单独的进程中执行指定命令和变量
    3.public Process exec(String command, String [] envp)
    在指定环境的独立进程中执行指定命令和变量
    4.public Process exec(String [] cmdArray, String [] envp)
    在指定环境的独立进程中执行指定的命令和变量
    5.public Process exec(String command,String[] envp,File dir)
    在有指定环境和工作目录的独立进程中执行指定的字符串命令
    6.public Process exec(String[] cmdarray,String[] envp,File dir)
    在指定环境和工作目录的独立进程中执行指定的命令和变量

    参数说明:
    cmdarray - 包含所调用命令及其参数的数组。
    envp - 字符串数组,其中每个元素的环境变量的设置格式为 name=value,如果子进程应该继承当前进程的环境,或该参数为 null。
    dir - 子进程的工作目录;如果子进程应该继承当前进程的工作目录,则该参数为 null。

     

    3. exec(String command)与exec(String[] cmdArray)

    exec(String command)有很大的局限性,不能执行重定向或者管道命令

            String cmd = "lsof -i:8080 >>/home/user/log.log";
            String[] cmds = new String[]{
                    "/bin/bash",
                    "-c",
                    "lsof -i:8080 >> /home/user/log.log"
            };
            BufferedReader br = null;
            try {
                Process p = Runtime.getRuntime().exec(cmd);
                br = new BufferedReader(new InputStreamReader(p.getInputStream()));
                StringBuilder sb = new StringBuilder();
                String line = null;
                while ((line = br.readLine()) != null) {
                    sb.append(line);
                }
                System.out.println("sb:" + sb.toString());
    
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                throw new ServiceLevelException(ExceptionConstants.SYSTEM_EXCEPTION, "test 失败");
            } 

    4. 如何使用exec(String[] cmdArray)

    把整个命令都当成/bin/bash的参数传入

    假设我需要执行/home/user/script ,并且调用这个script脚本的时候需要给他传三个参数,分别是param1,param2,param3.这里就应该这么写:

    	cmds = new String[]{
                    "/bin/sh",
                    "-c",
                    "/home/user/script param1 param2 param3"
            };

    或者:

    	cmds = new String[]{
                    "/home/user/script",
                    "param1",
                    "param2",
                    "param3"
            };

    假设这个脚本还需要sudo权限,user的密码是123456 ,则更复杂一点:

    	cmds = new String[]{
                    "/bin/sh",
                    "-c",
                    "echo 123456| sudo -S /home/user/script param1 param2 param3"
            };

    这里无论 我们在shell界面运行“/home/user/script param1 param2 param3”还是“echo 123456| sudo -S /home/user/script param1 param2 param3”都应该可以运行才对。

     

    参考文章:

    https://www.cnblogs.com/softidea/p/4287519.html

    https://www.linuxidc.com/Linux/2012-07/64526.htm

    http://blog.51cto.com/tianxingzhe/1700098

    https://blog.csdn.net/timo1160139211/article/details/75006938

    展开全文
  • 一。项目需求: 从某一机构获取证书,证书机构提供小工具...解决方案:java调用shell命令,利用spring容器启动即执行方案。 参考博文:http://zohan.iteye.com/blog/1709136 项目结构: 原码: 1。RuntimeUt...
  • Java本地调用shell,cmd命令本地调用cmd命令本地调用Linux命令 本地调用cmd命令 @Test public void testCmd()throws Exception{ String cmd="cmd /c date"; //命令的前面必须要有cmd /c execCmd(cmd); ...
  • java在linux本地执行shell命令

    千次阅读 2019-06-09 03:51:52
    一.以springboot为例,建立代码 1.IExecCommandServer: public interface IExecCommandServer { void execCommand(String cmd); } 2.ExecCommandServerImp: ...public class ExecCommandServerImp implemen...
  • 有时候经常会碰到需要远程调用Linux或者本地调用Linux或者本地调用cmd的一些命令,最近小结了一下这几种用法。 本地调用cmd命令 package com.cn.cmd; import java.io.BufferedReader; import java.io....
  • 2:本地window环境和线上linux环境java执行命令不同,代码中注释有。 3:最重要的是mysqldump插件位置原因,这个浪费了我好多时间。 1:mysqldump 的路径上不要有空格。 2:mysqldump 最好放到C盘(我之前就是...
  • 【转载原因:代码亲测可以远程实现连接服务器,收获颇丰,...有时候经常会碰到需要远程调用Linux或者本地调用Linux或者本地调用cmd的一些命令,最近小结了一下这几种用法 本地调用cmd命令 @Test public void t...
  • http://central.maven.org/maven2/com/jcraft/jsch/0.1.54/jsch-0.1.54.jar
  • 简述shell 命令与 非shell命令区别shell命令不用先adb shell进入界面执行非shell命令必须要 adb shell进入界面执行基础非shell命令1.安装appadb install apk文件的绝对路径2.卸载appadb uninstall 包名3.将设备文件...
  • 由于两个模型都是在终端执行,于是考虑用java代码直接调起终端,然后让终端执行指定的shell命令,测试代码如第二节; 由于模型的启动模型在不同的项目路径下,这种情况下指令需要好几条,有点...
  • sshxcute 就是这样一个框架工具集,它基于 JSCH 构建,允许工程师利用Java 代码通过 SSH 连接远程批量执行 Linux/UNIX 系统上的命令或者脚本,同时加入了判断成功与否,取回输出等多种实用功能。sshxcute 不管是针对...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 239
精华内容 95
关键字:

java本地shell命令

java 订阅