1.Java执行cmd

public void executeCMD() {
    try {
        Runtime mt = Runtime.getRuntime();
        String cmd = "ping 127.0.0.1";
        Process pro = mt.exec(cmd);
        InputStream ers= pro.getErrorStream();
        pro.waitFor();
    } catch (IOException ioe) {
        ioe.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

2.Java执行Bat

1.绝对路径

// An highlighted block
public void executeBat() {
    try {
        Runtime run = Runtime.getRuntime();
        String cmd = "E:\\Re-Architecture\\test.bat"
        Process pro = run.exec(cmd);
        InputStream ers= pro.getErrorStream();
        pro.waitFor();
    } catch (IOException ioe) {
        ioe.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

2.要跨盘符

// An highlighted block
public void executeCMD() {
    try {
        Runtime run = Runtime.getRuntime();
        Process pro =run.exec("cest.bat",null,new File("E:\\Re-Architecture\\"));
        InputStream ers= pro.getErrorStream();
        pro.waitFor();
    } catch (IOException ioe) {
        ioe.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

3.Java执行exe

// An highlighted block
public void executeExe() {
    try {
        Runtime run = Runtime.getRuntime();
        Process pro =run.exec("cmd /c E:\\Re-Architecture\\test.exe"));
        InputStream ers= pro.getErrorStream();
        pro.waitFor();
    } catch (IOException ioe) {
        ioe.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

4.Java执行快捷图标

// An highlighted block
public void executeBat() {
    try {
        Runtime mt = Runtime.getRuntime();
        String cmd = "rundll32 SHELL32.DLL,ShellExec_RunDLL "+"E:\\ImportMetapediaCMD\\noUAC.CreateMetapedia.lnk";
        Process pro = mt.exec(cmd);
        InputStream ers= pro.getErrorStream();
        pro.waitFor();
    } catch (IOException ioe) {
        ioe.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

5.查看log

// An highlighted block
public class RuntimeTest {
    public static void main(String[] args) {
        RuntimeTest s = new RuntimeTest();
        s.test();
    }
    public void test(){
        Runtime run =Runtime.getRuntime();
        try {
            Process p = run.exec("ping 127.0.0.1");
            InputStream ins= p.getInputStream();
            InputStream ers= p.getErrorStream();
            new Thread(new inputStreamThread(ins)).start();
            p.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    class inputStreamThread implements Runnable{
        private InputStream ins = null;
        private BufferedReader bfr = null;
        public inputStreamThread(InputStream ins){
            this.ins = ins;
            this.bfr = new BufferedReader(new InputStreamReader(ins));
        }
        @Override
        public void run() {
            String line = null;
            byte[] b = new byte[100];
            int num = 0;
            try {
                while((num=ins.read(b))!=-1){
                    System.out.println(new String(b,"gb2312"));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6.报警

1.java.io.IOException: Cannot run program “****”: CreateProcess error=2

// 语法错误，即命令不能被正确识别
run.exec("%comspec% /c \ceshi\ceshi.bat");
//正确语法
run.exec(new String[]{"cmd","/c","%comspec% /c \ceshi\ceshi.bat"},null,null);

2.java.lang.IllegalArgumentException: Executable name has embedded quote,split the arguments

// 可能是命令中有空格识别异常，可以试着把空格转成带引号的空格
run.exec("c:\\ceshi file\\ceshi.bat".replace(" ","" ""))

3.bat命令在CMD窗口中可以正常执行，但通过java的Runtime执行就会阻塞，八成可能是命令执行中开了新窗口，但老窗口没关导致的

// An highlighted block
run.exec(new String[]{"cmd","/k","ceshi.bat"},null,new File("d:\\ceshi\\"));
要把“/k”换成“/c”
run.exec(new String[]{"cmd","/c","ceshi.bat"},null,new File("d:\\ceshi\\"));

java执行cmd命令

起因：项目需要实现jar包上传到远程私服仓库nexus，查询得有两种方法实现：1.调用nexus rest api 进行发行http请求，这个目前在研究；2.调用maven中的命令将本地仓库中的jar包推送到远程仓库；第二种方法虽然简单，但是扩展性不强，需要部署的服务器上有maven环境，并且在linux和Windows上若都要部署则需要进行系统适配。但不论如何，还是打算学习java执性cmd命令及打开其他程序的操作。本文参考了:https://www.jb51.net/article/80829.htm，https://www.cnblogs.com/zhufu9426/p/7928570.html

Java调用cmd命令，并输出显示信息:

	/**
     * execute cmd in current directory
     * then get the inputStream and print on console
     * the Most commonly used 
     * @throws InterruptedException
     */
    @Test
    public void executeDirCMD() throws InterruptedException {
        try {
            Runtime rt = Runtime.getRuntime();
//            Process pr = rt.exec("cmd /c dir");
//            Process pr = rt.exec("D:/APP/Evernote/Evernote.exe");//open evernote program
            Process pr = rt.exec("D:/APP/Tim/Bin/QQScLauncher.exe");//open tim program
            BufferedReader input = new BufferedReader(new InputStreamReader(pr.getInputStream(),"GBK"));
            String line = null;
            while ((line = input.readLine())!=null){
                System.out.println(line);
            }
            int exitValue = pr.waitFor();
            System.out.println("Exited with error code "+exitValue);
        } catch (IOException e) {
            System.out.println(e.toString());
            e.printStackTrace();
        }
    }

Java启动本机应用程序EXE的三种方式:

1.利用cmd方式 
    @Test
    public void executeApplicationByCMD(){
        String command = "D:/APP/Tim/Bin/QQScLauncher.exe";
        Runtime rt = Runtime.getRuntime();
        try {
            Process pr = rt.exec(command);
            BufferedReader br = new BufferedReader(new InputStreamReader(pr.getInputStream(), "UTF-8"));
            String line = null;
            StringBuilder build = new StringBuilder();
            while ((line = br.readLine()) != null) {
                build.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2.利用ProcessBuilder调用cmd方式
/** 
 * 启动应用程序 
 * 
 * @param programName 
 * @return 
 * @throws IOException 
 */ 
public static void startProgram(String programPath) throws IOException { 
 log.info("启动应用程序：" + programPath); 
 if (StringUtils.isNotBlank(programPath)) { 
  try { 
   String programName = programPath.substring(programPath.lastIndexOf("/") + 1, programPath.lastIndexOf(".")); 
   List<String> list = new ArrayList<String>(); 
   list.add("cmd.exe"); 
   list.add("/c"); 
   list.add("start"); 
   list.add("\"" + programName + "\""); 
   list.add("\"" + programPath + "\""); 
   ProcessBuilder pBuilder = new ProcessBuilder(list); 
   pBuilder.start(); 
  } catch (Exception e) { 
   e.printStackTrace(); 
   log.error("应用程序：" + programPath + "不存在！"); 
  } 
 } 
} 

3.使用Desktop启动应用程序 
    /**
     * execute By Desktop
     */
    @Test
    public void executeByDesktop(){
        String programPath ="D:/APP/Tim/Bin/QQScLauncher.exe";
        try {
            Runtime.getRuntime().exec("notepad");
            Desktop.getDesktop().open(new File(programPath));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

如果多次执行可能出现卡死现象，请参考：https://www.cnblogs.com/wang-liang-blogs/p/11022869.html

执行原理

常用命令详解

cmd /c dir 是执行完dir命令后关闭命令窗口。 
cmd /k dir 是执行完dir命令后不关闭命令窗口。 

cmd /c start dir 会打开一个新窗口后执行dir指令，原窗口会关闭。 
cmd /k start dir 会打开一个新窗口后执行dir指令，原窗口不会关闭。 
注：增加了start，就会打开新窗口，可以用cmd /?查看帮助信息。

例：cmd /c copy d:\\test.txt e:将d盘的test文件复制到e盘，直接copy是识别不了为cmd命令的，所以在前面添加cmd /c来启动一个控制台应用程序；而如果是运行一个可执行程序，则直接将将command改为“F:\\apache-tomcat-6.0.20.exe”这样既可。

扩展资料

1.Java实现命令行中的进度条功能：参考：https://www.csdn.net/gather_23/NtjaMgxsMzY1LWJsb2cO0O0O.html

常常需要进行的系统适配

判断目前运行的是windows还是linux，可以使用：
		Properties properties = System.getProperties();
        String property = properties.getProperty("os.name");
        System.out.println(property);
获取到运行的系统名，进行判断则可以使用：
	/**
	 * 系统枚举类
	 *
	 * @author libowan
	 */
	public enum OSType {
	    LINUX,
	    WINDOWS,
	    OTHERS;
	}
	/**
     * get current <code>OSType</code>
     * @return OSType
     */
    public static OSType getCurrentOSType(){
        String s = System.getProperty("os.name").toLowerCase();
        if (s.contains("linux")) return OSType.LINUX;
        if (s.contains("windows")) return OSType.WINDOWS;
        return OSType.OTHERS;
    }

前言

Java应用程序主要是通过Runtime和Process两个类来执行cmd命令。
Runtime.exec方法创建本机进程并返回Process子类的实例，该实例可用于控制进程并获取有关它的信息。
Process类提供了从进程执行输入，执行输出到进程，等待进程完成，检查进程的退出状态以及销毁（杀死）进程的方法。
具体有哪些方法请查看相关文档：https://docs.oracle.com/javase/8/docs/api/

Runtime类

Runtime类位于java.lang包下，继承Object类。
每个Java应用程序都有且只有一个Runtime类实例，它允许应用程序与运行应用程序的环境进行交互。 可以从getRuntime方法获取当前运行时。
从类的实现方式来看，明显是个单例模式，只能通过getRuntime()来获取当前类的实例。

/**
 * Every Java application has a single instance of class
 * <code>Runtime</code> that allows the application to interface with
 * the environment in which the application is running. The current
 * runtime can be obtained from the <code>getRuntime</code> method.
 * <p>
 * An application cannot create its own instance of this class.
 */
 public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

    ......
}

public static Runtime getRuntime()方法
返回与当前Java应用程序关联的运行时对象。 类Runtime的大多数方法都是实例方法，必须根据当前运行时对象进行调用。

public Process exec(String command) throws IOException方法
在单独的进程中执行指定的字符串命令。
这是一种方便的方法。 调用exec（command）形式的行为与调用exec（command，null，null）完全相同。

public Process exec(String[] cmdarray, String[] envp, File dir) throws IOException方法
在具有指定环境和工作目录的单独进程中执行指定的命令和参数。

给定一个字符串数组cmdarray，表示命令行的标记，以及一个字符串envp数组，表示“环境变量”设置，此方法创建一个执行指定命令的新进程。
此方法会检查cmdarray是否为有效的操作系统命令。命令是否有效取决于程序运行所在的操作系统，但至少该命令必须是非空字符串的非空列表。
如果envp为null，则子进程将继承当前进程的环境设置。
在某些操作系统上启动进程可能需要一组最小的系统相关环境变量。因此，子进程可以继承除指定环境中的其他环境变量设置。
ProcessBuilder.start()现在是使用已修改环境启动进程的首选方法。
新子进程的工作目录由dir指定。如果dir为null，则子进程将继承当前进程的当前工作目录。
如果存在安全管理器，则调用其checkExec方法，并将数组cmdarray的第一个组件作为其参数。这可能会导致抛出SecurityException。
启动操作系统进程高度依赖于程序运行所在的操作系统。在许多可能出现如下错误：

• 找不到操作系统程序文件。
• 访问程序文件被拒绝。
• 工作目录不存在。

在这种情况下，程序将会抛出异常。异常的确切性质取决于操作系统，但它始终是IOException的子类。

Process类

Process类同样位于java.lang包下，继承Object类。
ProcessBuilder.start()和Runtime.exec方法创建本机进程并返回Process子类的实例，该实例可用于控制进程并获取有关它的信息。 Process类提供了从进程执行输入，执行输出到进程，等待进程完成，检查进程的退出状态以及销毁（杀死）进程的方法。
创建进程的方法可能不适用于某些本机平台上的特殊进程，例如本机窗口进程，守护程序进程，Microsoft Windows上的Win16 / DOS进程或shell脚本。
默认情况下，创建的子进程没有自己的终端或控制台。它的所有标准I/O（即stdin，stdout，stderr）操作将被重定向到父进程，在那里可以通过使用方法getOutputStream()，getInputStream()和getErrorStream()获得的流来访问它们。父进程使用这些流向子进程提供输入并从子进程获取输出。由于某些本机平台仅为标准输入和输出流提供有限的缓冲区大小，因此无法及时写入输入流或读取子进程的输出流可能导致子进程阻塞甚至死锁。
如果需要，还可以使用ProcessBuilder类的方法重定向子进程I/O.
当没有对Process对象的更多引用时，子进程不会被终止，而是子进程继续异步执行。
不要求Process对象表示的进程相对于拥有Process对象的Java进程异步或并发执行。

public boolean waitFor(long timeout, TimeUnit unit) throws InterruptedException方法
如果需要，使当前线程等待，直到此Process对象表示的子进程终止，或者指定的等待时间。
如果子进程已经终止，则此方法立即返回值true。 如果进程尚未终止且超时值小于或等于零，则此方法立即返回值false。
此方法的默认实现轮询exitValue的值以检查进程是否已终止。 强烈建议采用更高效的实现方式来覆盖此类的方法。

具体使用

public class cmdTask implements Runnable {
    private String command;

    public cmdTask (String command) {
        this.command = comand;
     }

    @Override
    public void run() {
        Process process = null;
        int exitVal = 0;
        try {
            process = Runtime.getRuntime().exec(command);
            // Runtime.exec()创建的子进程公用父进程的流，不同平台上，父进程的stream buffer可能被打满导致子进程阻塞，从而永远无法返回。
            //针对这种情况，我们只需要将子进程的stream重定向出来即可。
            new RedirCmdStreamThread(process.getInputStream(), "INFO").start();
            new RedirCmdStreamThread(process.getErrorStream(),"ERR").start();

            exitVal = process.waitFor();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
        
        if (exitVal != 0){
            throw new RuntimeException("cmd任务执行失败");
        }
    }

    class RedirCmdStreamThread extends Thread {
        InputStream is;
        String printType;

        RedirCmdStreamThread(InputStream is, String printType) {
            this.is = is;
            this.printType = printType;
        }

        public void run() {
            try {
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader br = new BufferedReader(isr);
                String line = null;
                while ( (line = br.readLine()) != null) {
                    System.out.println(printType + ">" + line);
                }

            } catch (IOException ioe)
            {
                ioe.printStackTrace();
            }
        }
    }
}

参考文献

深入研究java.lang.Runtime类
java Runtime.exec方法详解！
Java 调用外部命令使用 waitFor() 方法阻塞或锁死