JNA的基本上用法

引言

本人作为一个java程序员也难免在日常的开发过程中需要调用其他开发的库。那么JNA就是一种调用方式。具体的底层原理我只知道使用的反射。我简单了解了一下如何使用。

JNA简单介绍

JNA(Java Native Access)框架是SUN公司主导开发的开源java框架，是建立在JNI的基础上的一个框架，JNA框架提供了一组java工具类用于在运行期间动态访问动态链接库（native library：如Window的dll、Linux的so），实现在java语言中调用C/C++语言封装的接口，java开发人员只需要在一个java接口中描述目标native library的函数与结构，JNA将自动实现Java接口到native function的映射，而不需要编写任何Native/JNI代码，大大降低了Java调用动态链接库的开发难度。相比于JNI的方式，JNA大大简化了调用本地方法的过程，使用很方便，基本上不需要脱离Java环境就可以完成。

上面说了一大堆，我使用简洁的语言描述一下就是：

其实我们调用其他编程语言的库时，对于我们而言需要在意的就是哪个库、库在哪、哪个方法、方法参数和返回值这四个要素。这其实和我们使用接口编程是一样的道理，我们使用接口也是只需要在乎接口名、接口在哪、抽象方法、参数和返回值，他们二者是高度相似的。所以有人开发出了JNA方式。

让接口名映射到库，让抽象方法映射到库中的方法，让抽象方法中的参数和返回值映射到库方法的参数和返回值。这样我们把库当作接口类去用就好了。

众所周知从Java 8开始，接口中还可以有静态方法和默认方法。在Java 9中，接口还可以有私有方法。所以我们无需实例化就可以使用。

换言之复杂的映射都被JNA做了，作为普通的程序员使用这套方法就好了。

那么废话不多说看看如何使用

JNA 的优势

1. 无需编写 C/C++ 代码：与 JNI 不同，JNA 不需要编写本地代码
2. 简单易用：直接通过 Java 接口映射本地函数
3. 跨平台：同一套 Java 代码可以在不同操作系统上运行
4. 动态调用：运行时动态绑定本地库

JNA使用注意点

在看例子之前我们还需要明白的两几个问题

第一个问题库在哪？

确定库文件的位置：通常SDK会提供库文件，可能放在某个目录下，比如lib、lib64等。

C标准库是操作系统的一部分，通常放在系统的标准库路径中（如Windows的系统目录，Linux的/lib、/usr/lib等）。Java的Native.load()方法会按照系统的库搜索路径来查找这些库。因此，对于系统库，我们只需要指定库的名称，而不需要完整路径。

库搜索路径：JNA在加载库时，会遵循操作系统的库搜索路径。例如，在Linux中，会查找LD_LIBRARY_PATH环境变量指定的路径；在Windows中，会查找PATH环境变量指定的路径。如果自定义库不在这些路径中，那么我们就需要指定完整路径。创建JNA工程

自定义库：如果你自己编译的库不在系统库路径中，那么你就需要指定完整路径，或者将库所在目录添加到系统的库搜索路径中。

第二个问题是库叫什么

同样的c语言的库，在windows、Linux、mac中库名称是不一样的：如果是 Windows，则使用 "msvcrt"（Microsoft C Runtime Library）作为库名。否则（如 Linux、Mac OS X 等），使用 "c" 作为库名。

确定库的名称：在Linux中，库名称通常以lib开头，例如libhcnetsdk.so，但在加载时可以省略前缀和后缀，也可以使用完整路径。

常见库名后缀总结

按操作系统分类

后缀	来源系统	全称	说明
.dll	Windows	Dynamic Link Library	Windows主要的动态库格式
.lib	Windows	Library	静态库或DLL的导入库
.so	Linux/Unix	Shared Object	Linux/Unix动态库标准格式
.a	Linux/Unix	Archive	静态库(源自ar归档工具)
.dylib	macOS	Dynamic Library	macOS原生动态库格式
.framework	macOS	Framework	包含库+头文件+资源的包

Java调用C语言库

创建项目

创建一个JNA工程我喜欢使用MAVEN，那么我创建一个maven的项目。这创建一个maven谁都会对吧。

添加依赖

<dependency>
    <groupId>net.java.dev.jna</groupId>
    <artifactId>jna</artifactId>
    <version>5.13.0</version>
</dependency>

定义接口映射

package com.fds.demo.Jnatest.interface01;

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;

// 定义接口继承 Library
public interface CLibrary extends Library {
    // 加载 C 标准库
    CLibrary INSTANCE = (CLibrary) Native.load(
            Platform.isWindows() ? "msvcrt" : "c", CLibrary.class);

    // 映射 C 的 printf 函数
    /**
     * 映射 C 的 printf 函数
     * @param format 格式字符串，与 C 的 printf 格式相同
     * @param args 可变参数，对应格式字符串中的占位符
     * @return 成功打印的字符数
     */
    int printf(String format, Object... args);

    // 映射 C 的 strlen 函数
    long strlen(String str);
}

调用

public class JNAExample {
    public static void main(String[] args) {
        // 调用 C 的 printf
        CLibrary.INSTANCE.printf("Hello from C! %s\n", "Java");
        
        // 调用 C 的 strlen
        String test = "Hello World";
        long length = CLibrary.INSTANCE.strlen(test);
        System.out.println("Length: " + length);
    }
}

执行结果如下：

这时发生了一个神奇的现象输出的顺序反了，这个代码为什么执行顺序乱了，应该是先输出Hello from C! Java。后输出Length: 11

实际发生的情况：

• CLibrary.INSTANCE.printf() 被调用
• 字符串被写入 C 的 stdout 缓冲区
• 缓冲区可能没有立即刷新
• System.out.println() 被调用
• Java 立即刷新自己的缓冲区并输出
• 此时 C 的缓冲区可能还在等待刷新
• 最终 C 的缓冲区在某个不确定的时间点刷新

这也是一个java确实调用了C库的证据

JAVA对象映射C语言结构体

在C语言中参数的传递和返回值的接手不可能一直用基础类型，我们肯定会用到结构体。我们抽象的看结构体一定程度上就是没有方法的JAVA类。那么JNA直接把JAVA的类和结构体映射。

接下来将演示一个简单的例子，Java类映射结构体给C库传值。

步骤 1：创建 Java 类继承 Structure

public Point extends Structure

• Structure 是 JNA 提供的基类
• 继承后，JNA 就知道这个类对应 C 的结构体

步骤 2：定义字段

public int x;
public int y;

• 字段必须是 public（JNA 需要直接访问）
• 类型要与 C 结构体对应：

• • int → int
  • char[] → byte[]
  • double → double
  • float → float

步骤 3：构造函数（如果有数组的话）

public Person() {
    name = new byte[50];  // 分配与 C 结构体相同大小的数组
}

• 初始化数组字段的大小
• 大小必须与 C 结构体中的数组大小一致

步骤 4：定义字段顺序

@Override
protected java.util.List<String> getFieldOrder() {
    return java.util.Arrays.asList("x", "y");
}

• 这是最重要的一步！
• 告诉 JNA 字段在内存中的排列顺序
• 顺序必须与 C 结构体完全一致

步骤 5：辅助方法（可选但推荐）

这只是一个最简单的例子。在实际运用中我们可能需要使用java去调用很多第三方的成体系的方法去完成我们业务上的需求。等我研究一波。

完整的例子

但是我们明白一件事情在C语言中是不存在distance_points()这个方法的。那么我们自己去用c语言写一个这个方法，然后把它弄成C语言的库，然后使用JNA去调用。

文件名为：fan.c

// mymath.c
#include <math.h>
#include<stdio.h>

// 自定义距离函数
double distance(double x1, double y1, double x2, double y2) {
    return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
}

// 使用结构体的版本
typedef struct {
    double x;
    double y;
} Point;

double distance_points(Point p1, Point p2) {
    return sqrt(pow(p2.x - p1.x, 2) + pow(p2.y - p1.y, 2));
}

int main(){
    printf("321\n");
    Point a,b;
    a.x=0;
    a.y=0;
    b.x=1;
    b.y=1;
    double fff = distance_points(a,b);
    double ddd = distance(0,0,1,1);
    printf("%lf\n",fff);
    printf("%lf\n",ddd);
    printf("%lf\n",distance(0,0,1,1));
    printf("%lf\n",distance_points(a,b));
}

再一次的强调JAVA调用的是C源码经过编译后的文件。我们在我们文件下面执行如下指令。

gcc -shared -fPIC -o libmylib.dylib fan.c

各部分含义：

1. gcc

• • GNU C Compiler，Linux系统上常用的C语言编译器

1. -shared

• • 告诉编译器生成一个共享库（shared library）而不是可执行文件
  • 共享库可以在运行时被多个程序动态加载和使用
  • 在Windows上对应的是.dll文件，在Linux上是.so文件

1. -fPIC

• • -f：编译器选项标志
  • PIC：Position Independent Code（位置无关代码）
  • 这意味着生成的代码可以在内存的任何位置执行，而不依赖于固定的内存地址
  • 这对于共享库是必需的，因为不同的程序可能会将同一个共享库加载到不同的内存地址

1. -o libmylib.so

• • -o：指定输出文件名
  • libmylib.so：输出文件名称
  • 命名约定：通常共享库以lib开头，.so结尾（在Linux上）
  • 版本号可以添加在后面，如：libmylib.so.1.0

1. mylib.c

• • 输入的C源文件

执行结果如下：

编写接口类

package com.fds.demo.Jnatest.interface01;

import com.fds.demo.Point;
import com.sun.jna.Library;
import com.sun.jna.Native;

// C 库接口
public interface SimpleLibrary extends Library {
    SimpleLibrary INSTANCE = Native.load("/Users/fandongsheng/我爱学习/c++/cpp/fantest/fantest/libmylib.dylib", SimpleLibrary.class);

    // C 函数：计算两点距离
    double distance_points(Point.ByValue p1, Point.ByValue p2);
}

编写映射类

package com.fds.demo;

import com.sun.jna.Structure;

// 最简单的结构体映射
public class Point extends Structure {

    public static class ByValue extends Point implements Structure.ByValue {}
    public static class ByReference extends Point implements Structure.ByReference {}

    public double x;
    public double y;

    @Override
    protected java.util.List<String> getFieldOrder() {
        return java.util.Arrays.asList("x", "y");
    }
}

主函数

package com.fds.demo;

import com.fds.demo.Jnatest.interface01.SimpleLibrary;


public class Main {
    public static void main(String[] args) {
        // 创建两个点
        Point.ByValue p1 = new Point.ByValue();
        p1.x = 0.0;
        p1.y = 0.0;

        Point.ByValue p2 = new Point.ByValue();
        p2.x = 1.0;
        p2.y = 1.0;

        // 调用 C 函数计算距离
        double dist = SimpleLibrary.INSTANCE.distance_points(p1, p2);
        System.out.println("两点距离: " + dist);
    }
}

执行结果如下。

完美！

上面这个例子还有两个需要注意的问题

问题1：当我们需要传递一个对象时，JNA不清楚我们是要传递对象的地址还是实际的值。所以我们需要在映射类中指定两种传递方式。并且在new对象的时候使用这个方式new出对象。如我上面的例子。

问题2:我的在指定C库的时候使用了绝对路径，这在生产环境使用时无疑是在灾难，所以建议把这个文件放到JAVA默认就可以找到的地方。