Cara menggunakan kelas Proses dalam Java 9 untuk mengawal pelaksanaan proses luaran

Cara menggunakan kelas Proses untuk mengawal pelaksanaan proses luaran dalam Java 9

Ikhtisar:
Di Java, dengan menggunakan kelas Proses, kita boleh berinteraksi dengan proses luaran dengan mudah. Java 9 memperkenalkan beberapa ciri baharu, termasuk pendekatan yang lebih selamat dan fleksibel apabila berurusan dengan proses luaran. Artikel ini akan menerangkan cara menggunakan kelas Proses dalam Java 9 dan menunjukkan penggunaannya dengan contoh kod.

1. Buat proses luaran
   Dalam Java 9, mencipta proses luaran adalah sangat mudah. Pertama, kita perlu mencipta objek ProcessBuilder menggunakan kelas ProcessBuilder dan menentukan arahan proses luaran untuk dimulakan. Kami kemudiannya boleh memulakan proses luaran menggunakan kaedah start(). Berikut ialah contoh kod untuk mencipta proses luaran:

import java.io.IOException;
public class ExternalProcessExample {
    public static void main(String[] args) {
        ProcessBuilder processBuilder = new ProcessBuilder("notepad.exe");
        try {
            Process process = processBuilder.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dalam contoh di atas, kami mencipta objek ProcessBuilder dan menentukan arahan proses luaran untuk dimulakan sebagai 'notepad.exe'. Kemudian, kami menggunakan kaedah start() untuk memulakan proses luaran.

2. Mengawal pelaksanaan proses luaran
   Sebaik sahaja kami memulakan proses luaran, kami boleh menggunakan kelas Proses untuk mengawal pelaksanaannya. Kelas Proses menyediakan beberapa kaedah untuk membantu kami memantau status proses luaran, mendapatkan aliran input/output dan berinteraksi dengan proses.

2.1 Memantau status keluar proses
Kita boleh menggunakan kaedah waitFor() untuk menunggu keluarnya proses luaran dan mendapatkan status keluarnya. Kod sampel adalah seperti berikut:

try {
    int exitValue = process.waitFor();
    System.out.println("Process exited with value: " + exitValue);
} catch (InterruptedException e) {
    e.printStackTrace();
}

Dalam contoh di atas, kami menggunakan kaedah waitFor() untuk menunggu keluar dari proses luaran dan menyimpan status keluar dalam pembolehubah exitValue.

2.2 Dapatkan aliran input/output proses luaran
Kadangkala, kita perlu mendapatkan aliran input/output proses luaran untuk berinteraksi dengan proses tersebut. Kelas Proses menyediakan kaedah getInputStream(), getOutputStream() dan getErrorStream() untuk mendapatkan aliran yang sepadan.

try {
    // 获取进程输入流并发送数据
    OutputStream outputStream = process.getOutputStream();
    outputStream.write("Hello".getBytes());
    
    // 获取进程输出流并读取数据
    InputStream inputStream = process.getInputStream();
    byte[] buffer = new byte[1024];
    int length = inputStream.read(buffer);
    String output = new String(buffer, 0, length);
    System.out.println("Process output: " + output);
    
    // 获取进程错误流并读取错误信息
    InputStream errorStream = process.getErrorStream();
    byte[] errorBuffer = new byte[1024];
    int errorLength = errorStream.read(errorBuffer);
    String errorMessage = new String(errorBuffer, 0, errorLength);
    System.out.println("Process error: " + errorMessage);
} catch (IOException e) {
    e.printStackTrace();
}

Dalam contoh di atas, kami menggunakan kaedah getInputStream() untuk mendapatkan aliran input proses, dan kaedah getOutputStream() untuk mendapatkan aliran keluaran proses dan kaedah getErrorStream() untuk mendapatkan aliran ralat proses tersebut. Kami kemudiannya boleh menggunakan aliran ini untuk menghantar data ke proses, membaca output proses dan membaca maklumat ralat proses.

3. Kemusnahan dan gangguan proses luaran
   Kadangkala, kita perlu memusnahkan proses luaran secara manual. Kita boleh menggunakan kaedah destroy() untuk memusnahkan proses tersebut. Kod sampel adalah seperti berikut:

process.destroy();

Selain itu, kita juga boleh menggunakan kaedah destroyForcibly() untuk memaksa pemusnahan proses walaupun proses tidak bertindak balas. Kod sampel adalah seperti berikut:

process.destroyForcibly();

Kadang-kadang, atas sebab tertentu, kita perlu mengganggu operasi menunggu proses luaran untuk keluar. Kita boleh menggunakan kaedah interrupt() untuk mengganggu operasi. Kod sampel adalah seperti berikut:

Thread currentThread = Thread.currentThread();
currentThread.interrupt();

4. Keselamatan dan sekatan pada proses luaran
   Dalam Java 9, adalah mungkin untuk menyediakan dan menyekat pelaksanaan proses luaran menggunakan kaedah baharu kelas ProcessBuilder. Gunakan kaedah arahan(String...) untuk menentukan dengan lebih tepat perintah proses luaran yang akan dilaksanakan. Selain itu, aliran keluaran ralat boleh diubah hala menggunakan kaedah redirectError(ProcessBuilder.Redirect).

ProcessBuilder processBuilder = new ProcessBuilder()
    .command("ping", "www.google.com")
    .redirectError(ProcessBuilder.Redirect.INHERIT);

Dalam contoh di atas, kami menggunakan kaedah arahan(String...) untuk menentukan arahan proses luaran sebagai 'ping www.google.com'. Kami juga menggunakan kaedah redirectError(ProcessBuilder.Redirect) untuk mengubah hala aliran keluaran ralat ke aliran keluaran standard.

Ringkasan:
Di Java 9, menggunakan kelas Proses untuk mengawal pelaksanaan proses luaran telah menjadi lebih selamat dan fleksibel. Kita boleh menggunakan kelas ProcessBuilder untuk mencipta dan memulakan proses luaran, dan menggunakan kelas Proses untuk memantau status proses, mendapatkan aliran input/output dan berinteraksi dengan proses. Selain itu, Java 9 juga menyediakan beberapa kaedah baharu untuk menetapkan dan mengehadkan pelaksanaan proses luaran.

Rujukan:

1. Java 9 Process API Javadoc: https://docs.oracle.com/javase/9/docs/api/java/lang/Process.html
2. Java 9 ProcessBuilder API Javadoc: https:// / /docs.oracle.com/javase/9/docs/api/java/lang/ProcessBuilder.html

Atas ialah kandungan terperinci Cara menggunakan kelas Proses dalam Java 9 untuk mengawal pelaksanaan proses luaran. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!