Java调用命令行并返回打印的内容

博主在最近的工作中，收到了这样一个需求。

调用别人以前完成开发的 jar 包或 python 程序，并将原程序在命令行中输出的内容封装为 JSON 对象后通过 RESTful 接口返回。

面对以上的需求，博主给出了以下解决方案。话不多说，上代码。

import lombok.extern.slf4j.Slf4j;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.*;

/**
 * 

 * Java 在执行 Runtime.getRuntime().exec(command)之后，Linux会创建一个进程，
 * 该进程与JVM进程建立三个管道连接，标准输入流、标准输出流、标准错误流。
 * 
 *
 * @author SupremeSir
 * @since 2022/11/27
 */
@Slf4j
public class ShellCommandExecutor {
    /**
     * 创建线程池
     */
    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(2, 4, 20,TimeUnit.MINUTES, new ArrayBlockingQueue<>(10), new ThreadPoolExecutor.CallerRunsPolicy());

    /**
     * @param cmd 命令行内容
     */
    public static ShellExecutorResultBean execShellStrWithResult(String cmd) {
        // 命令行输出的正常信息
        String sysOutInfo = null;
        // 命令行输出的错误信息
        String sysOutError = null;

        // 判断系统环境
        boolean isWindows = System.getProperty("os.name").toLowerCase().startsWith("windows");

        // 组装命令行命令
        String[] cmdArray = {isWindows ? "cmd" : "/bin/sh", isWindows ? "/c" : "-c", cmd};
        String charset = isWindows ? "GBK" : "UTF-8";

        try {
            // 执行命令
            Process process = Runtime.getRuntime().exec(cmdArray);

            // 启动子线程，读取命令行输出的正常信息
            FutureTask<String> sysOutTask = new FutureTask<>(() -> {
                StringBuilder builder = new StringBuilder();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), charset))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        builder.append(line);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return builder.toString();
            });
            THREAD_POOL_EXECUTOR.execute(sysOutTask);

            // 启动子线程，命令行输出的错误信息
            FutureTask<String> sysErrorTask = new FutureTask<>(() -> {
                StringBuilder builder = new StringBuilder();
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getErrorStream(), charset))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        builder.append(line);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return builder.toString();
            });
            THREAD_POOL_EXECUTOR.execute(sysErrorTask);

            log.info("命令行执行进程开始等待");
            process.waitFor();

            // 获取命令行输出信息
            sysOutInfo = sysOutTask.get();
            sysOutError = sysErrorTask.get();

            log.info("命令行执行进程结束等待");

            // 判断命令行进程执行状态
            if (process.isAlive()) {
                process.destroy();
                log.info("线程已销毁：" + process.isAlive());
            } else {
                log.info("线程已销毁：" + process.isAlive());
            }

        } catch (InterruptedException | IOException | ExecutionException e) {
            e.printStackTrace();
        }

        // 组装返回结果
        ShellExecutorResultBean resultBean = new ShellExecutorResultBean();
        resultBean.setSysOutError(sysOutError);
        resultBean.setSysOutInfo(sysOutInfo);

        return resultBean;
    }

    /**
     * 命令行输出结果包装类
     */
    public static class ShellExecutorResultBean{
        /**
         * 命令行输出的正常信息
         */
        private String sysOutInfo;
        /**
         * 命令行输出的错误信息
         */
        private String sysOutError;

        public String getSysOutInfo() {
            return sysOutInfo;
        }

        public void setSysOutInfo(String sysOutInfo) {
            this.sysOutInfo = sysOutInfo;
        }

        public String getSysOutError() {
            return sysOutError;
        }

        public void setSysOutError(String sysOutError) {
            this.sysOutError = sysOutError;
        }

        @Override
        public String toString() {
            return "ShellExecutorResultBean{" +
                    "sysOutInfo='" + sysOutInfo + '\'' +
                    ", sysOutError='" + sysOutError + '\'' +
                    '}';
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

注意：

1. 如果你不需要获取命令行的数据，也最好将命令行的输出信息、错误信息，都通过线程的方式获取一下，这样可以避免因输入流缓冲区灌满而导致的死锁问题。

2. 如果你在 Linux 环境中执行调用，最好使用 /bin/sh 解析 shell 命令，否则可能也会导致线程莫名卡死的状态。

3. 如果你使用的是 XShell 连接工具，同时规避了以上两个问题，但线程还是莫名其妙的卡死了，且收到 “转发 X11 到 Xmanager ” 的提示，则需在当前连接 “属性” 页面中的 “隧道” 选项卡中，取消勾选“转发X11到”这个选项，如下图所示：
   

   4. 如果你的程序不死锁了、线程也不阻塞了、返回结果也拿到了，但是忽然发现，对方输出的内容是纯字符格式，并不能转成 JSON 方便前端使用，那么你可能需要下面这段代码。

   import com.alibaba.fastjson2.JSON;
   import com.alibaba.fastjson2.JSONArray;
   
   public class JsonUtil {
   
       /**
        * 将 [{aaa:123,bbb:456}] 这样的字符串转换为 json 数组
        * @param str 需要转换的字符串
        */
       public static JSONArray str2JSONArray(String str) {
           JSONArray jsonArray = new JSONArray();
           if (str != null) {
               str = str.replace("{", "{\"")
                       .replace(":", "\":\"")
                       .replace(",", "\",\"")
                       .replace("}", "\"}");
               jsonArray = JSON.parseArray(str);
           }
           return jsonArray;
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21

   上面的代码是将字符串转换为了 JSON 数组，如果你需要转换成 JSON 对象，则修改 fastjson2 的转换函数即可，这里就不做演示了。

-------------------------------------- 独处的时光里，藏着你未来的样子。 --------------------------------------