1. Toy模板网首页
  2. > Toy博客

使用 ProcessBuilder API 优化你的流程

9月前 作者：程序猿阿朗 分类：Toy博客 阅读(53) 违法举报

这篇具有很好参考价值的文章主要介绍了使用 ProcessBuilder API 优化你的流程。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

ProcessBuilder 介绍

Java 的 Process API 为开发者提供了执行操作系统命令的强大功能，但是某些 API 方法可能让你有些疑惑，没关系，这篇文章将详细介绍如何使用 ProcessBuilder API 来方便的操作系统命令。

ProcessBuilder 入门示例

我们通过演示如何调用 java -version 命令输出 JDK 版本号，来演示 ProcessBuilder 的入门用法。

package com.wdbyte.os.process;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.apache.commons.io.IOUtils;

/**
 * Process 输出Java 版本号
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest1 {

    public static void main(String[] args) throws IOException, InterruptedException {
        // 构建执行命令
        ProcessBuilder processBuilder = new ProcessBuilder("java","-version");
        // 重定向 ERROR 流(有些 JDK 版本 Java 命令通过 ERROR 流输出)
        processBuilder.redirectErrorStream(true);
        // 运行命令 java -version
        Process process = processBuilder.start();
        // 获取PID，这是一个 Java 9 方法
        long pid = process.pid();
        // 一次性获取运行结果
        String result = IOUtils.toString(process.getInputStream());
        // 等到运行结束
        int exitCode = process.waitFor();

        System.out.println("pid:" + pid);
        System.out.println("result:" + result);
        System.out.println("exitCode:" + exitCode);
    }
}

在这段代码中，首先使用 ProcessBuilder 对象包装了要执行的命令 java -version，紧接着重定向 了要执行的进程的 ERROR 输出流(有些 JDK 版本 Java 命令通过 ERROR 流输出)。最后通过 start 方法执行命令，得到一个用于进程管理的 Process 对象，可以获取其 pid 和输出结果。

注意 IOUtils.toString(process.getInputStream());

这里使用了 commons-io 中的工具类把 InputStream 转为字符串。

commons-io Maven 依赖：

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.12.0</version>
</dependency>

运行得到输出：

pid:80885
result:java version "1.8.0_151"
Java(TM) SE Runtime Environment (build 1.8.0_151-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)

exitCode:0

ProcessBuilder 环境变量

在下面这个示例中，演示如何获取当前环境变量，以及如何修改环境变量并传入子进程中。

输出当前环境变量。

ProcessBuilder processBuilder = new ProcessBuilder();
Map<String, String> environment = processBuilder.environment();
environment.forEach((k, v) -> System.out.println(k + ":" + v));
processBuilder.environment().put("my_website","www.wdbyte.com");

这会打印出当前所有环境变量。

JAVA_HOME:/Library/Java/JavaVirtualMachines/jdk1.8.0_151.jdk/Contents/Home
COMMAND_MODE:unix2003
JAVA_MAIN_CLASS_81717:com.wdbyte.os.process.ProcessBuilderTest2
LOGNAME:darcy
.....

添加一个环境变量。

processBuilder.environment().put("my_website","www.wdbyte.com");

打印出刚才添加的环境变量。

// Linux 或 MacOS 下 ，Windows 下无此命令
processBuilder.command("/bin/bash", "-c", "echo $my_website");
Process process = processBuilder.start();

long pid = process.pid();
String result = IOUtils.toString(process.getInputStream());
int exitCode = process.waitFor();

System.out.println("pid:" + pid);
System.out.println("result:" + result);
System.out.println("exitCode:" + exitCode);

这会输出：

pid:81719
result:www.wdbyte.com
exitCode:0

ProcessBuilder 工作目录

使用 directory 方法可以修改子进程默认的工作目录，下面的示例中修改进程工作目录为 process 文件夹。

package com.wdbyte.os.process;

import java.io.File;
import java.io.IOException;

import org.apache.commons.io.IOUtils;

/**
 * 修改工作目录
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest3 {

    private static String BASE_DIR = "/Users/darcy/git/JavaNotes/core-java-modules/core-java-os/src/main/java/com/wdbyte/os/process";

    public static void main(String[] args) throws IOException, InterruptedException {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.directory(new File(BASE_DIR));
        // /bin/bash 命令只在 linux or macos 下有效
        processBuilder.command("/bin/bash", "-c", "pwd");
        Process process = processBuilder.start();

        long pid = process.pid();
        String result = IOUtils.toString(process.getInputStream());
        int exitCode = process.waitFor();

        System.out.println("pid:" + pid);
        System.out.println("result:" + result);
        System.out.println("exitCode:" + exitCode);
    }
}

输出：

pid:82456
result:/Users/darcy/git/JavaNotes/core-java-modules/core-java-os/src/main/java/com/wdbyte/os/process
exitCode:0

ProcessBuilder I/O

在上面的示例中，都是把运行的新进程的输出通过 getInputStream 的方式读取到当前进程，然后输出，这种方式很不方便。日志输出常见的方式是输出到指定日志文件，ProcessBuilder 对此也有很好的支持。

输出到文件

使用 redirectOutput 可以指定日志输出的文件，这个方法会自动创建日志文件。下面的例子在指定目录下执行 ls-l 命令列出目录下的所有文件。

package com.wdbyte.os.process;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

/**
 * 输出日志到指定文件
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest4 {
    private static String BASE_DIR = "/Users/darcy/git/JavaNotes/core-java-modules/core-java-os/src/main/java/com/wdbyte/os/process";

    public static void main(String[] args) throws IOException, InterruptedException {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.directory(new File(BASE_DIR));
        processBuilder.command("/bin/bash", "-c", "ls -l");

        File logFile = new File(BASE_DIR + "/process_log.txt");
        // 输出到日志文件
        processBuilder.redirectOutput(logFile);
        // 追加日志到文件
        // processBuilder.redirectOutput(ProcessBuilder.Redirect.appendTo(logFile));
        // 是否输出ERROR日志到文件
        processBuilder.redirectErrorStream(true);

        Process process = processBuilder.start();
        long pid = process.pid();
        int exitCode = process.waitFor();
        System.out.println("pid:" + pid);
        System.out.println("exitCode:" + exitCode);

        // 读取日志文件
        Files.lines(logFile.toPath()).forEach(System.out::println);
    }
}

输出日志：

pid:30609
exitCode:0
total 96
-rw-r--r--  1 darcy  staff   749 Jun  6 22:34 ExecDemo.java
-rw-r--r--  1 darcy  staff   445 Jun  7 14:59 ExecDemo2.java
-rw-r--r--  1 darcy  staff  2011 Jun  7 15:33 ProcessBuilder10.java
-rw-r--r--  1 darcy  staff  1807 Jun  6 22:54 ProcessBuilderTest1.java
-rw-r--r--  1 darcy  staff  1054 Jun  6 23:01 ProcessBuilderTest2.java
-rw-r--r--  1 darcy  staff   963 Jun  6 23:05 ProcessBuilderTest3.java
-rw-r--r--  1 darcy  staff  1295 Jun  7 17:02 ProcessBuilderTest4.java
-rw-r--r--  1 darcy  staff  1250 Jun  6 22:34 ProcessBuilderTest5.java
-rw-r--r--  1 darcy  staff   929 Jun  6 22:34 ProcessBuilderTest6.java
-rw-r--r--  1 darcy  staff   911 Jun  6 22:34 ProcessBuilderTest7.java
-rw-r--r--  1 darcy  staff  1305 Jun  6 22:34 ProcessBuilderTest8.java
-rw-r--r--  1 darcy  staff  1278 Jun  7 14:59 ProcessBuilderTest9.java
-rw-r--r--  1 darcy  staff     0 Jun  7 17:03 process_log.txt

如果想要追加日志到指定文件，应该使用：

processBuilder.redirectOutput(ProcessBuilder.Redirect.appendTo(logFile));

使用 processBuilder 也可以指定 INFO 和 ERROR 日志到不同的文件。

ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.directory(new File(BASE_DIR));
// 执行命令 xxx，命令不存在，会报 ERROR 日志
processBuilder.command("/bin/bash", "-c", "xxx");

File infoLogFile = new File(BASE_DIR + "/process_log_info.txt");
File errorLogFile = new File(BASE_DIR + "/process_log_error.txt");
// 日志输出到文件
processBuilder.redirectOutput(infoLogFile);
processBuilder.redirectError(errorLogFile);
Process process = processBuilder.start();

// 读取 ERROR 日志
Files.lines(errorLogFile.toPath()).forEach(System.out::println);

运行输出：

/bin/bash: xxx: command not found

输出到当前进程

在这个示例中，将看到 inheritIO() 方法的作用。当我们想将子进程的 I/O 重定向到当前进程的标准 I/O 时，可以使用这个方法：

package com.wdbyte.os.process;

import java.io.File;
import java.io.IOException;

/**
 * 子线程 I/O 重定向到当前线程
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest6 {
    public static void main(String[] args) throws IOException, InterruptedException {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.directory(new File("./"));
        processBuilder.command("/bin/bash", "-c", "ls -l");
        // 把子线程 I/O 输出重定向当前进程
        processBuilder.inheritIO();
        Process process = processBuilder.start();
        int exitCode = process.waitFor();
        System.out.println("exitCode:" + exitCode);
    }
}

这会输出：

total 2904
-rw-r--r--   1 darcy  staff     5822 May  2 22:33 ArrayList.uml
-rw-r--r--   1 darcy  staff    16555 May 16 16:07 README.md
-rw-r--r--   1 darcy  staff      333 May  4 19:30 core-java-20.iml
drwxr-xr-x  16 darcy  staff      512 Jun  2 22:03 core-java-modules
exitCode:0

在这个示例中，通过使用inheritIO()方法，我们在 IDE 的控制台中看到了一个简单命令结果的输出。

ProcessBuilder 管道操作

从 Java 9 开始，ProcessBuilder 引入了管道概念，可以把一个进程的输出作为另一个进程的输入再次操作。

public static List<Process> startPipeline(List<ProcessBuilder> builders)

使用这个方法我们可以进行如这样的常见操作：ls -l | wc -l

ls -l | wc -l ：列出文件目录，然后统计输出的行数。

下面演示如何使用 startPipeline.

package com.wdbyte.os.process;

import java.io.File;
import java.io.IOException;
import java.lang.ProcessBuilder.Redirect;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.List;

/**
 * Java 9 中新增的管道操作
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest8 {
    private static String BASE_DIR = "/Users/darcy/git/JavaNotes/core-java-modules/core-java-os/src/main/java/com/wdbyte/os/process";

    public static void main(String[] args) throws IOException, InterruptedException {
        ProcessBuilder ls = new ProcessBuilder("/bin/bash", "-c", "ls -l");
        ProcessBuilder wc = new ProcessBuilder("wc", "-l");
        // 追加日志到文件
        File pipeLineLogFile = getFile(BASE_DIR + "/pipe_line_log.txt");
        wc.redirectOutput(Redirect.appendTo(pipeLineLogFile));

        List<Process> processes = ProcessBuilder.startPipeline(Arrays.asList(ls, wc));
        Process process = processes.get(processes.size() - 1);

        System.out.println("pid:" + process.pid());
        System.out.println("exitCode:" + process.waitFor());

        Files.lines(pipeLineLogFile.toPath()).forEach(System.out::println);
    }

    public static File getFile(String filePath) throws IOException {
        File logFile = new File(filePath);
        if (!logFile.exists()) {
            logFile.createNewFile();
        }
        return logFile;
    }
}

这会输出：

pid:33518
exitCode:0
      21

ProcessBuilder 超时与终止

进程有时不能按照自己想要的情况运行，需要对进程进行管理，常见的操作是超时控制以及进程退出。下面通过一个例子来演示如何操作。

先编译一个用于测试的 Java 类 ExecDemo.java，此类每隔一秒输出一个数字，共输出10个数字，预计需要10s输出完毕。

下面是代码部分：

import java.io.IOException;

/**
 * @author https://www.wdbyte.com
 */
public class ExecDemo {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("开始处理数据...");
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println(i);
        }
        System.out.println("数据处理完毕");
    }
}

再编写一个 ProcessBuilder 来执行 ExceDemo，但是在执行 3 秒后就判断是否运行完成，如果没有则杀死进程。

package com.wdbyte.os.process;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * 运行一个 Java 程序
 * 等待一定时间后检查状态，未结束则直接杀死进程。
 *
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest9 {
    private static String BASE_DIR = "/Users/darcy/git/JavaNotes/core-java-modules/core-java-os/src/main/java/com/wdbyte/os/process";

    public static void main(String[] args) throws IOException, InterruptedException {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.directory(new File(BASE_DIR));
        processBuilder.command("java", "ExecDemo.java");
        // 把子线程 I/O 输出重定向当前进程
        processBuilder.inheritIO();
        Process process = processBuilder.start();
        // 等待一定时间
        boolean waitFor = process.waitFor(3, TimeUnit.SECONDS);
        System.out.println("waitFor:" + waitFor);
        // 若未退出，杀死子进程
        if (!waitFor) {
            process.destroyForcibly();
            process.waitFor();
            System.out.println("杀死进程:" + process);
        }

    }
}

这会输出：

开始处理数据...
0
1
waitFor:false
杀死进程:Process[pid=35084, exitValue=137]

在这段代码中，destroyForcibly() 用于杀死进程，但是杀死进程并不是瞬间完成的，所以接着使用 waitFor() 来等待程序真正被杀死退出。

ProcessBuilder 异步处理

很多情况下，在执行一个命令启动一个新线程后，我们不想阻塞等待进程的完成，想要异步化，在进程执行完成后进行通知回调。这时可以使用 CompletableFuture 来实现这个功能。

package com.wdbyte.os.process;

import java.io.File;
import java.io.IOException;
import java.util.concurrent.CompletableFuture;

/**
 * @author https://www.wdbyte.com
 */
public class ProcessBuilderTest10 {
    private static String BASE_DIR = "/Users/darcy/git/JavaNotes/core-java-modules/core-java-os/src/main/java/com/wdbyte/os/process";

    public static void main(String[] args) throws InterruptedException {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.directory(new File(BASE_DIR));
        processBuilder.command("java", "ExecDemo.java");
        // 把子线程 I/O 输出重定向当前进程
        processBuilder.inheritIO();

        // 创建 CompletableFuture 对象
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                // 命令执行
                Process process = processBuilder.start();
                // 任务超时时间
                process.waitFor();
            } catch (IOException e) {
                throw new RuntimeException(e);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return null;
        });

        // 注册回调函数，处理异步等待的结果
        future.thenAccept(result -> {
            System.out.println("进程执行结束");
        });
        System.out.println("主进程等待");
        Thread.sleep(20 * 1000);
    }
}

这会输出：

主进程等待
开始处理数据...
0
1
2
3
4
5
6
7
8
9
数据处理完毕
进程执行结束

ProcessBuilder 总结

在这篇文章中，我们详细介绍了 ProcessBuilder 的具体用法，并且给出了常用的操作示例。同时也介绍了 Java 9 开始为 ProcessBuilder 引入的管道操作，最后介绍如何对 Process 进程进行异步处理。

一如既往，文章中代码存放在 Github.com/niumoo/javaNotes.

本文原发于网站：https://www.wdbyte.com/java/os/processbuilder/
我的公众号：ProcessBuilder API 使用教程文章来源地址https://www.toymoban.com/news/detail-481843.html

到了这里，关于使用 ProcessBuilder API 优化你的流程的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 使用开源 MaxKey 与 APISIX 网关保护你的 API

    使用开源 MaxKey 与 APISIX 网关保护你的 API

    Apache APISIX 是 Apache 软件基金会下的云原生 API 网关，它兼具动态、实时、高性能等特点，提供了负载均衡、动态上游、灰度发布（金丝雀发布）、服务熔断、身份认证、可观测性等丰富的流量管理功能。我们可以使用 Apache APISIX 来处理传统的南北向流量，也可以处理服务间的

    2024年02月06日
    浏览(41)

  • 深入探索FastAPI单元测试：使用TestClient轻松测试你的API

    原文：深入探索FastAPI单元测试：使用TestClient轻松测试你的API-51CTO.COM 当使用FastAPI进行单元测试时，一个重要的工具是TestClient类。TestClient类允许我们模拟对FastAPI应用程序的HTTP请求，并测试应用程序的响应。这使我们能够在不启动服务器的情况下对API进行全面的测试。 下面我

    2024年02月03日
    浏览(40)
  • 全面解析 Postman 网页版的使用，提升你的 API 调试技能！

    全面解析 Postman 网页版的使用，提升你的 API 调试技能！

    Postman是一款流行的API开发工具，可以帮助开发者优化工作流程。除了客户端，Postman还支持网页版访问，让用户能够从任何网页浏览器中访问该工具。在本篇文章中，我们将详细介绍如何使用Postman的网页版。 要访问Postman网页版，首先，我们需要进入Postman的官网。 进入网站，

    2024年03月16日
    浏览(47)
  • 使用magic-api ，让你的开发效率蹭蹭提升

    使用magic-api ，让你的开发效率蹭蹭提升

    一个基于Java的接口快速开发框架，通过magic-api提供的UI界面完成编写接口，无需定义Controller、Service、Dao、Mapper、XML、VO等Java对象即可完成常见的HTTP API接口开发 官网：https://ssssssss.org 示例：ssssssss-team/magic-api-example demo:https://magic-api.ssssssss.org 源码:magic-api: magic-api 是一个基于

    2024年02月10日
    浏览(54)
  • 文心一言api接入如何在你的项目里使用文心一言

    文心一言api接入如何在你的项目里使用文心一言

    基于百度文心一言语言大模型的智能文本对话AI机器人API,支持聊天对话、行业咨询、语言学习、代码编写等功能. 重要提示:建议使用https协议,当https协议无法使用时再尝试使用http协议 请求方式: POST 序号 参数 是否必须 说明 1 ques 是 你的问题 2 appKey 是 唯一验证AppKey, 可前往官

    2024年02月09日
    浏览(56)

  • 使用 Webpack 优化前端开发流程

    在现代前端开发中，构建工具的选择和优化流程的设计至关重要。Webpack 是一个功能强大的前端构建工具，能够优化我们的开发流程，提高开发效率和项目性能。本文将介绍如何使用 Webpack 来优化前端开发流程。 代码优化和资源管理也是前端项目中不可忽视的一部分。我们将

    2024年02月15日
    浏览(52)

  • Camunda 7.x 系列【10】使用 Rest API 运行流程实例

    有道无术，术尚可求，有术无道，止于术。 本系列Spring Boot 版本 2.7.9 本系列Camunda 版本 7.19.0 源码地址：https://gitee.com/pearl-organization/camunda-study-demo

    2024年02月13日
    浏览(53)

  • knife4j API文档生成使用流程及详解

    目录 初始化流程 详细注解分析 @Api @ApiOperation @ApiModelProperty @ApiImplicitParam @ApiImplicitParams @ApiIgnore         1：pom文件引入相关依赖 2：创建配置类 3：默认访问域名+端口+doc.html         类上         tags：配置模块的名称         方法上         value：配置业务名称        

    2024年02月05日
    浏览(83)
  • Python使用HTTP代理进行API请求的优化

    Python使用HTTP代理进行API请求的优化

    在Python中，HTTP代理是一种常用的技术，用于控制和修改HTTP请求和响应。通过使用HTTP代理，我们可以更好地控制网络请求的行为，提高安全性、隐私性和效率。下面我们将详细介绍如何在Python中使用HTTP代理进行API请求的优化。 一、减少请求次数 使用HTTP代理可以帮助我们减少

    2024年01月22日
    浏览(55)

  • 「探索API的奇妙世界：理解、使用和优化接口技术」

    引言： 在现代科技的时代，API（应用程序编程接口）已经成为各行业中不可或缺的关键技术。从手机应用到云计算，从社交媒体到物联网，几乎所有的软件都在背后使用着API来实现数据交互和功能扩展。在这篇文章中，我们将深入探索API的奇妙世界，从理解API的基本概念开始

    2024年02月16日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包