1、Linux环境

代码：

public class ProcessLinux {
    public static void main(String[] args) {
    	// dmidecode -s bios-version表示获取bios版本
    	// 可以根据实际情况进行修改
        String result = executeLinuxCmd("dmidecode -s bios-version");
        System.out.println(result);
    }

    public static String executeLinuxCmd(String cmd) {
        try {
            StringBuilder sb = new StringBuilder();
            Process process = Runtime.getRuntime().exec(cmd);
            BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = br.readLine()) != null) {
                sb.append(line).append("\n");
            }
            return sb.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试：
我们测试在Linux运行dmidecode -s bios-version命令，该命令会输出bios的版本情况，单独将ProcessLinux上传到服务器，通过javac进行编译执行；

注意：ProcessLinux类中不要出现package路径

2、Windows环境

代码：

public class ProcessWindows {
    public static void main(String[] args) {
    	// wmic bios get serialnumber表示获取bios版本
    	// cmd.exe /c 固定写法，表示执行cmd后关闭cmd窗口
    	// 可以根据实际情况进行修改
        String result = executeWindowsCmd("cmd.exe /c wmic bios get serialnumber");
        System.out.println(result);
    }

    public static String executeWindowsCmd(String cmd) {
        try {
            StringBuilder result = new StringBuilder();
            Runtime rt = Runtime.getRuntime();
            Process p = rt.exec(cmd);
            BufferedReader input = new BufferedReader(new InputStreamReader(
                    p.getInputStream()));
            String line;
            while ((line = input.readLine()) != null) {
                result.append(line);
            }
            input.close();
            return result.toString();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }
}

测试：

3、通用环境

该方法更加适用于，命令比较复杂、执行时间较长、返回内容较多的情况
代码：

public class ProcessUtil {
    private static final Logger LOG = LoggerFactory.getLogger(ProcessUtil.class);

    public static void main(String[] args) {
        // 比如执行`java -version`命令
        List<String> command = new ArrayList<>();
        command.add("java");
        command.add("-version");
        execute(command);
    }

    /**
     * 通过终端命令执行子进程
     * <p>
     * 注意：这种方式会在瞬间大量消耗CPU和内存等系统资源，所以需要对流进行处理
     *
     * @param command 接收一个命令数组，一个空格一个元素
     * @return String
     */
    public static String execute(List<String> command) {
        // 打印命令
        String cmd = String.join(" ", command);
        LOG.debug("执行命令：" + cmd);
        StringBuffer inputStringBuffer = new StringBuffer();
        StringBuffer errorStringBuffer = new StringBuffer();
        try {
            ProcessBuilder builder = new ProcessBuilder(command);
            Process process = builder.start();

            // 处理InputStream
            new Thread() {
                @Override
                public void run() {
                    InputStream input = null;
                    InputStreamReader reader = null;
                    BufferedReader buffer = null;
                    try {
                        input = process.getInputStream();
                        reader = new InputStreamReader(input);
                        buffer = new BufferedReader(reader);
                        String inputLine = "";
                        while ((inputLine = buffer.readLine()) != null) {
                            LOG.debug(inputLine);
                            inputStringBuffer.append(inputLine);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            if (buffer != null) {
                                buffer.close();
                            }
                            if (reader != null) {
                                reader.close();
                            }
                            if (input != null) {
                                input.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                }
            }.start();

            // 处理ErrorStream
            new Thread() {
                @Override
                public void run() {
                    InputStream input = null;
                    InputStreamReader reader = null;
                    BufferedReader buffer = null;
                    try {
                        input = process.getErrorStream();
                        reader = new InputStreamReader(input);
                        buffer = new BufferedReader(reader);
                        String errorLine = "";
                        while ((errorLine = buffer.readLine()) != null) {
                            LOG.debug(errorLine);
                            errorStringBuffer.append(errorLine);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            if (buffer != null) {
                                buffer.close();
                            }
                            if (reader != null) {
                                reader.close();
                            }
                            if (input != null) {
                                input.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();

            // 这里进程阻塞，将等待外部转换成功后，才往下执行
            process.waitFor();

            /**
             * 只会存在一个输入流返回
             */
            if (StringUtils.isNotBlank(inputStringBuffer)) {
                return inputStringBuffer.toString();
            }
            if (StringUtils.isNotBlank(errorStringBuffer)) {
                return errorStringBuffer.toString();
            }
        } catch (InterruptedException | IOException e) {
            e.printStackTrace();
            return null;
        }
        return null;
    }
}

测试：
我们执行一个java -version进行测试：