Java 提供了几种方式与非 Java 代码进行交互（比如调用本地库或执行外部程序），其中包括 JNA、JNI、ProcessBuilder 和 Runtime.getRuntime().exec()。下面是对每种方式的详细解释。
1. JNA (Java Native Access)
简介
JNA 是 Java 与本地代码进行交互的一种高层次 API，它允许 Java 程序调用本地动态链接库（DLL 或 .so 文件）中的函数，而无需编写 JNI（Java Native Interface）代码。JNA 大大简化了与本地代码的交互，因为它自动处理了参数的转换、调用约定等复杂细节。
使用场景
- 需要调用现有的本地库（如 C/C++ 编写的 DLL 或
.so）。 - 不需要手动编写复杂的 JNI 代码。
- 性能要求没有 JNI 那么高。
工作原理
JNA 使用动态代理模式，将 Java 方法映射到本地库函数。它依赖于 com.sun.jna.Native 类来加载本地库，并通过接口定义与本地库中的函数进行交互。
示例代码
假设有一个名为 mydll.dll 的 C 函数：
// mydll.c
int add(int a, int b) {
return a + b;
}
在 Java 中通过 JNA 调用它：
import com.sun.jna.Library;
import com.sun.jna.Native;
public class MyDllCaller {
// 定义与DLL函数的接口
public interface MyDll extends Library {
MyDll INSTANCE = (MyDll) Native.load("mydll", MyDll.class);
int add(int a, int b);
}
public static void main(String[] args) {
int result = MyDll.INSTANCE.add(3, 4);
System.out.println("Result: " + result); // 输出 7
}
}
优点
- 简单易用，减少了手动处理本地库调用的复杂性。
- 无需生成本地代码，直接通过接口与动态库交互。
- 支持跨平台使用，动态加载库。
缺点
- 性能相对比 JNI 稍低。
- 不支持复杂的指针操作和本地数据结构的深度操作。
------------------------------------------------------------------------------------------------------------------------------
2. JNI (Java Native Interface)
简介
Java中传参并调用C++程序_java 调用c++ 传递参数-CSDN博客
JNI 是 Java 与本地代码（如 C/C++）交互的低层次接口。它允许 Java 直接调用 C/C++ 函数，或者将 C/C++ 代码嵌入到 Java 应用中。与 JNA 不同，JNI 需要编写本地代码，并且通过 JNI 的 API 来与 Java 进行交互。
使用场景
- 对性能有严格要求，需要与本地代码进行高效交互。
- 需要访问 Java 环境中的复杂数据结构，或需要在 C/C++ 中对 Java 对象进行操作。
- 需要与不使用动态库的本地代码进行深度集成。
工作原理
- 编写 Java 代码声明本地方法。
- 使用
javah生成 C/C++ 头文件。 - 编写与 Java 本地方法匹配的 C/C++ 实现。
- 使用 JNI API 与 JVM 进行交互。
示例代码
Java 代码：
public class MyJNI {
// 声明本地方法
public native int add(int a, int b);
static {
// 加载本地库
System.loadLibrary("myjni");
}
public static void main(String[] args) {
MyJNI jni = new MyJNI();
int result = jni.add(3, 4);
System.out.println("Result: " + result); // 输出 7
}
}
C/C++ 实现：
#include <jni.h>
#include "MyJNI.h" // 生成的头文件
JNIEXPORT jint JNICALL Java_MyJNI_add(JNIEnv *env, jobject obj, jint a, jint b) {
return a + b;
}
优点
- 高性能，适合需要频繁调用本地代码的场景。
- 灵活，可以访问和操作 Java 对象。
- 完全控制，可以处理复杂的指针操作和数据结构。
缺点
- 编写和维护 JNI 代码相对复杂，需要理解 JNI 的 API 以及 Java 和本地代码之间的内存管理。
- 跨平台支持复杂，不同平台需要不同的本地库。
- 调试难度大。
3. ProcessBuilder
简介
ProcessBuilder 是 Java 中用于创建和管理操作系统进程的类。它允许 Java 程序启动外部进程（如可执行文件、脚本等），并与该进程进行交互（如传递输入、读取输出、检查退出状态）。
使用场景
- 需要从 Java 中运行外部程序（如
.exe或脚本）。 - 与外部工具或服务进行交互。
- 对进程的启动、输入输出管理有较高的需求。
工作原理
ProcessBuilder 创建一个新的进程，并允许通过流（InputStream/OutputStream）与进程进行交互。
示例代码
import java.io.*;
public class ProcessBuilderExample {
public static void main(String[] args) {
try {
// 使用 ProcessBuilder 运行命令
ProcessBuilder builder = new ProcessBuilder("ping", "google.com");
// 启动进程
Process process = builder.start();
// 读取进程的输出
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
// 等待进程结束
int exitCode = process.waitFor();
System.out.println("Exit code: " + exitCode);
} catch (Exception e) {
e.printStackTrace();
}
}
}
优点
- 提供了对进程的详细控制，包括重定向输入输出流。
- 支持异步进程的管理（通过
Process.waitFor()等方法）。 - 简单易用，可以启动任何外部程序或脚本。
缺点
- 对外部程序的依赖性强，外部程序的路径和可用性可能会有问题。
- 进程之间的数据传输主要依赖于流，处理复杂的交互时可能会变得笨重。
- 不适合高频调用外部程序的场景，启动进程的开销较大。
4. Runtime.getRuntime().exec()
简介
Runtime.getRuntime().exec() 是 ProcessBuilder 的旧版本 API，也用于从 Java 程序中执行外部命令或程序。它可以启动外部进程并返回 Process 对象，用于与进程交互。
使用场景
- 需要从 Java 中简单地运行一个外部命令或程序。
- 不需要对进程有复杂的控制和管理要求。
工作原理
通过调用 Runtime.getRuntime() 获取当前 JVM 的运行时对象，然后调用其 exec() 方法启动外部进程。
示例代码
import java.io.*;
public class RuntimeExecExample {
public static void main(String[] args) {
try {
// 执行外部命令
Process process = Runtime.getRuntime().exec("ping google.com");
// 读取输出
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
// 等待进程结束
int exitCode = process.waitFor();
System.out.println("Exit code: " + exitCode);
} catch (Exception e) {
e.printStackTrace();
}
}
}
优点
- 简单直接，可以快速执行命令。
- 支持与操作系统的简单交互。
缺点
- 功能不如
ProcessBuilder强大，无法对输入输出重定向和环境变量进行详细控制。 - 对于复杂的进程管理需求不够灵活。
