ProcessBuilder脚本运行

ProcessBuilder脚本运行
ProcessBuilder是一个Java类，它用于构建和启动操作系统进程。它提供了一组方法来指定要执行的命令、参数、工作目录、环境变量等信息，然后使用start()方法启动进程。
ProcessBuilder可以方便地将命令、参数和工作目录组合成一个进程，并且可以设置环境变量和输入输出流。它还提供了一些方便的方法来捕获进程的输出和错误输出，以及等待进程完成。
ProcessBuilder常用于需要执行外部命令或程序的应用程序中，例如需要运行shell脚本、调用外部工具或其他应用程序等。使用ProcessBuilder可以更加方便地管理和控制这些外部进程。
ProcessBuilder 类提供了一种创建和管理进程的方法。它允许您指定命令行参数、工作目录、环境变量等。
以下是 ProcessBuilder 的一些常用参数：

1. command：命令及其参数的数组，例如 new String[]{“ls”, “-l”}。
2. directory：进程的工作目录，例如new File(“/home/user”)。 environment：进程的环境变量，例如 new HashMap<String,
   String>()。
3. redirectErrorStream：是否将标准错误流重定向到标准输出流，例如 true。
4. redirectInput：是否将标准输入流重定向到一个文件，例如 new FileInputStream(“/dev/null”)。
5. redirectOutput：是否将标准输出流重定向到一个文件，例如 new FileOutputStream(“/tmp/output.txt”)。
   您可以使用这些参数来创建和管理进程。例如，以下代码将在当前工作目录下运行 ls -l 命令，并将输出重定向到一个文件：

ProcessBuilder pb = new ProcessBuilder(
pb.directory(new File("."));
pb.redirectOutput(new FileOutputStream("/tmp/output.txt"));
Process p = pb.start();

这将在当前工作目录下运行 ls -l 命令，并将输出重定向到 /tmp/output.txt 文件。

package com.cmb.ts01.scan;
import com.google.common.collect.Lists;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.tomcat.util.http.fileupload.FileUtils;
import org.springframework.util.CollectionUtils;
import java.io.*;
import java.text.MessageFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * @author
 * @date 2024/1/25 9:49
 */
public class ScanUtil {
    private final static String CACHE_FILE = "cache\\cacheTemp.tmp";
    private final static String CACHE_FILE_PATH = "cache\\";
    @Data
    @NoArgsConstructor
    static class ScanParam {
        private List<String> keyList;
        private String appPath;
        private String jarPath;
        private boolean rescanSwitch = true;
        private boolean cleanSwitch = true;
    }

    public static void main(String[] args) {
        List<String> keyList = Lists.newArrayList("iText", "jpmml", "Neo4j", "nextcloud", "ownCloud", "JDbC", "jmx",
                "pdfHTML", "plupload", "PM2", "Tailormap", "voltdb");
        ScanParam scanParam = new ScanParam();
        scanParam.setKeyList(keyList);
        scanParam.setAppPath("AppPath");
        scanParam.setJarPath("JarPath");
        ScanParam scanParam2 = new ScanParam();
      
        for (Map.Entry<String, Set<String>> entry : resultMap.entrySet()) {
            System.out.println(MessageFormat.format("应用：{0}命中：", entry.getKey()));
            System.out.println(entry.getValue());
        }
    }
    private static Map<String, Set<String>> executor(List<ScanParam> scanParams) {
        Map<String, Set<String>> resultMap = new HashMap<>();
        for (ScanParam scanParam : scanParams) {
            try {
                Set<String> singleResult = executorSingle(scanParam);
                if (!CollectionUtils.isEmpty(singleResult)) {
                    resultMap.put(scanParam.getAppPath(), singleResult);
                }
            } catch (Exception e) {
                System.out.println(e);
            }
        }
        return resultMap;
    }

    private static Set<String> executorSingle(ScanParam scanParam) {
        System.out.println(MessageFormat.format("----------{0}----------", scanParam.appPath));
        Set<String> matchSet = new HashSet<>();
        // 1、获取扫描关键词
        List<String> scanKeyList = scanParam.getKeyList();
        // 2、确定是否重新扫描生成jar包list
        // 3、执行CMD命令
        boolean jarReady = copyDependency(scanParam);​
        // 4、根据关键词匹配jar
            commend.add("cmd.exe");
            commend.add("/c");
//            commend.add("cd");
//            commend.add("/d");
//            commend.add(APP_LOCAL_DIRECTORY);
//            commend.add("&&");
//            commend.add("dir");
//            commend.add("&&");
            commend.add("mvn");
            commend.add("dependency:copy-dependencies");
            StringBuilder directory = new StringBuilder("-DoutputDirectory=");
            directory.append(scanParam.getJarPath());
            commend.add(directory.toString());
            ProcessBuilder builder = new ProcessBuilder();
            builder.command(commend);
            builder.redirectErrorStream(true);
            builder.redirectOutput(tempFile);
            builder.directory(new File(scanParam.getAppPath()));
            Process process = builder.start();
            int i = process.waitFor();
            printCmdLog();
            if (i == 0) {
                return true;
            } else {
                return false;
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    private static File createCacheTempFile() throws IOException {
        File file = new File(CACHE_FILE_PATH);
        // 新建一个存储结果的缓存文件
        File tmpFile = new File(CACHE_FILE);
        if (!file.exists()) {
            file.mkdirs();
        }
        if (!tmpFile.exists()) {
            tmpFile.createNewFile();
        }
        return tmpFile;
    }
    private static void printCmdLog() {
        StringBuilder stringBuilder = new StringBuilder();
        String result;
        BufferedReader bufferedReader;
        try (InputStream inputStream = new FileInputStream(CACHE_FILE);) {
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "GBK"));
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                stringBuilder.append(line + "\n");
            }
            bufferedReader.close();
            result = stringBuilder.toString();
            System.out.println(result);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}