1.使用普通的JNI去访问本地方法

1.1 简单的Java类提供native方法用于输出HelloWorld

创建一个简单的java类com.wanna.jni.JavaHelloWorld：

package com.wanna.jni;

public class JavaHelloWorld {
    public native void showHelloWorld();
}

定义一个简单的native方法，功能只需要简单的输出一下HelloWorld就行。

1.2 编写C文件对native方法进行实现并编译成为库文件

• 1.使用cd src/main/java/com/wanna/jni切换到src/main/java/com/wanna/jni/路径下。
• 2.使用javac -h /Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/src/jni/JavaHelloWorld JavaHelloWorld.java编译得到JavaHelloWorld.class文件和com_wanna_jni_JavaHelloWorld.h文件。

需要说明的是javac -h之后的第一个参数指明将目标文件生成到当前目录下，可以根据情况改为自己的路径，第二个参数为.java文件说在的路径。

在执行完上面两个步骤之后可以得到下面这样的一个com_wanna_jni_JavaHelloWorld.h文件，它是C/C++中的一个头文件。

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_wanna_jni_JavaHelloWorld */

#ifndef _Included_com_wanna_jni_JavaHelloWorld
#define _Included_com_wanna_jni_JavaHelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_wanna_jni_JavaHelloWorld
 * Method:    showHelloWorld
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_wanna_jni_JavaHelloWorld_showHelloWorld
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

我们要做的，就是创建一个com_wanna_jni_JavaHelloWorld.c文件，去实现头文件中定义的方法。我们就在当前路径下创建，并且导入.h头文件

#include "com_wanna_jni_JavaHelloWorld.h"
#include "stdio.h"

JNIEXPORT void JNICALL Java_com_wanna_jni_JavaHelloWorld_showHelloWorld(JNIEnv * env, jobject o)
{
    printf("HelloWorld...\n");
}

• 1.使用gcc -Ijdk/include -Ijdk/include/darwin -c com_wanna_jni_JavaHelloWorld.c去进行生成可重定位目标文件(com_wanna_jni_JavaHelloWorld.o)。
• 2.使用gcc -dynamiclib -o lib_java_hello_world.dylib com_wanna_jni_JavaHelloWorld.o生成动态链接库文件lib_java_hello_world.dylib。

需要进行说明的是：命令中的jdk/include需要换成自己的对应jdk下的include目录，比如/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/build/macosx-x86_64-normal-server-fastdebug/jdk/include)

1.3 在java中加载库文件并进行测试

public class JavaHelloWorld {

    public static final String JNI_BASE_PATH = "/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/src/jni";
    public static final String LIB_PATH = JNI_BASE_PATH + "/" + "JavaHelloWorld/lib_java_hello_world.dylib";

    public native void showHelloWorld();

    static {
        System.load(LIB_PATH);
    }

    public static void main(String[] args) {
        new JavaHelloWorld().showHelloWorld();
    }
}

在静态代码块中使用System.load方法加载刚刚使用gcc生成的库文件，然后去运行java代码，得到如下运行结果：

HelloWorld...

1.4 如何让写JNI对应的C语言代码拥有代码提示

将C代码全部放到构建好的JDK源码目录下，并使用Clion打开JDK源码的目录。

image.png

我们就可以看到，导入之后其实就拥有相关的提示啦，已经可以看到env对象的相关方法。

1.5 使用JNI实现一个mini的Java线程

在原来的JavaHelloWorld类上增加如下这些方法

public class JavaHelloWorld {

    public static final String JNI_BASE_PATH = "/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/src/jni";
    public static final String LIB_PATH = JNI_BASE_PATH + "/" + "JavaHelloWorld/lib_java_hello_world.dylib";

    public native void showHelloWorld();

    public void run() {
        System.out.println("Hello Thread...");
    }

    public void start() {
        this.start0();
    }

    public native void start0();

    static {
        System.load(LIB_PATH);
    }

    public static void main(String[] args) {
        new JavaHelloWorld().start();
    }
}

使用javac -h ...命令重新生成一遍头文件com_wanna_jni_JavaHelloWorld.h。

下面在com_wanna_jni_JavaHelloWorld.c去实现这个start0方法

#include "com_wanna_jni_JavaHelloWorld.h"
#include "stdio.h"
#include "stdlib.h"
#include <unistd.h>
#include "pthread.h"

// gcc -I/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/build/macosx-x86_64-normal-server-fastdebug/jdk/include -I/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/build/macosx-x86_64-normal-server-fastdebug/jdk/include/darwin -c com_wanna_jni_JavaHelloWorld.c
// gcc -dynamiclib -o lib_java_hello_world.dylib com_wanna_jni_JavaHelloWorld.o
JNIEXPORT void JNICALL Java_com_wanna_jni_JavaHelloWorld_showHelloWorld(JNIEnv *env, jobject o) {
    printf("HelloWorld...\n");
}

pthread_t tid;  // 定义线程的tid
#define INITIALIZED 0
#define RUNNABLE 1

int status;     // INITIALIZED/RUNNABLE
JavaVM *javaVM; // 创建JavaVM对象

int java_start(void *args) {
    JNIEnv *env = NULL;  // 初始化JNI环境对象为NULL
    (*javaVM)->AttachCurrentThread(javaVM, (void **) &env, NULL); //通过JavaVM对象初始化env对象
    jclass clazz;                                      //Class对象
    jobject obj;                                        //存放Thread类对象
    jmethodID initMethod, runMethod;                                //构造器方法和run方法

    // 找到对应的java的Class对象
    clazz = (*env)->FindClass(env, "com/wanna/jni/JavaHelloWorld");

    if (clazz == NULL) // 如果类没找到
    {
        printf("class is not found\n");
        return -1;
    }
    // 找到类的构造器方法
    initMethod = (*env)->GetMethodID(env, clazz, "<init>", "()V");
    if (initMethod == NULL) {
        printf("constructor method is not found\n");
        return -1;
    }

    // 利用无参数构造器创建对象
    obj = (*env)->NewObject(env, clazz, initMethod);
    if (obj == NULL) // 如果创建对象失败
    {
        printf("create object error\n");
        return -1;
    }
    // 找到对象的run方法
    runMethod = (*env)->GetMethodID(env, clazz, "run", "()V");
    if (runMethod == NULL) {
        printf("run method has not found\n");
        return -1;
    }
    while (status == INITIALIZED) // 如果还是初始化状态，那么就...一直执行run方法，在这阻塞起来
    {
        printf("thread state is INITIALIZED,status:%d\n", status);
        sleep(1); // 睡眠1秒
    }
    (*env)->CallVoidMethod(env, obj, runMethod, NULL); // 执行线程类的run方法
    return 0;
}

// JVM启动时调用，把jvm对象返回出去，告诉VM此C组件使用那一个JNI版本。
// 如果你的*.so档没有提供JNI_OnLoad()函数，VM会默认该*.so档是使用最老的JNI 1.1版本。
// 由于新版的JNI做了许多扩充，如果需要使用JNI的新版功能，
// 例如JNI 1.4的java.nio.ByteBuffer,就必须由JNI_OnLoad()函数来告知VM。
// 由于VM执行到System.loadLibrary()函数时，就会立即先呼叫JNI_OnLoad()
JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    javaVM = vm;
    return JNI_VERSION_1_8; // 要使用到JDK1.8的JNI
}

// env是虚拟机环境，o对应this指针
JNIEXPORT void JNICALL Java_com_wanna_jni_JavaHelloWorld_start0(JNIEnv *env, jobject o) {
    // 使用posix规范定义的pthread_create去运行线程，要执行的函数指针是java_start函数

    pthread_create(&tid, NULL, (void *) java_start, NULL);
    sleep(5);   // 在这睡眠5秒之后把线程唤醒
    status = RUNNABLE; // 把状态改为RUNNABLE状态
    printf("this is start0 running...\n");
}

重新编译出库文件，并运行main方法，最终得到的执行结果为

thread state is INITIALIZED,status:0
thread state is INITIALIZED,status:0
thread state is INITIALIZED,status:0
thread state is INITIALIZED,status:0
thread state is INITIALIZED,status:0
this is start0 running...
Hello Thread...

这里其实有个问题，那就是使用IDEA去点击运行的话，运行结果老是不太对，直接使用java命令跑起来则没问题，不知道为什么！

2. 使用JNA框架去进行本地方法的访问

2.1 使用maven/gradle导入jar包

下面是maven引入方式

<dependency>
    <groupId>com.sun.jna</groupId>
    <artifactId>jna</artifactId>
    <version>3.0.9</version>
</dependency>

下面是gradle的引入方式

implementation group: 'com.sun.jna', name: 'jna', version: '3.0.9'

2.2 编写C文件执行编译并打包为动态链接库

#include "stdio.h"

int add(int x, int y) {
    return x + y;
}

和之前JNI的方式类似，使用如下命令完成共享库的打包：

gcc -c Jna.c
gcc -dynamiclib -o libjna.dylib Jna.o

2.3 回到java层面进行测试

在java层面编写一个Lib接口

public interface Lib extends Library {

    Lib lib = (Lib) Native.loadLibrary("/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/src/jni/Jna/libjna.dylib", Lib.class);

    int add(int x, int y);
}

使用如下的代码去进行简单的测试，最终得到运行结果为3。

    System.out.println(Lib.lib.add(1, 2));

2.4 对比JNA和传统的JNI

我们发现相对于传统JNI，使用JNA的方式有如下好处：

• 1.可以不用遵循函数命名规范，JNI中的函数命名必须是Java_类名_方法名，而在JNA中则不需要，可以更加随心所欲。
• 2.在传统的JNI中，需要在java类上去定义相关的native方法，JNA则不需要，JNA通过反射直接对JNI进行封装，更加方便用户的使用。

2.5 更多数据类型的映射关系

Java数据类型	C数据类型	原生表现
boolean	int	32位整数
byte	char	8位整数
char	wchar_t	平台依赖
short	short	16位整数
int	int	32位整数
long	long long/int64	64位整数
float	float	32位浮点数
double	double	64位浮点数
PointerType	pointer	32或者64位指针
String	char*	\0结尾的数组
WString	wchar_t*	\0结尾的数组
String[]	char**	\0结尾的数组的数组
WString[]	wchar_t**	\0结尾的数组的数组
Structure	struct/struct*	结构体或者结构体指针
NativeLong	long	平台原生
Structure[]	struct[]	结构体数组
...	...	...

需要注意的是：

• 1.尽量使用基本、简单的数据类型；尽量少跨平台、跨语言传递数据！
• 2.如果有复杂的数据类型需要在Java和原生函数中传递，那么我们就必须在Java中模拟大量复杂的原生类型。这将大大增加实现的难度，甚至无法实现。
• 3.如果在Java和原生函数间存在大量的数据传递，那么一方面，性能会有很大的损失。更为重要的是，Java调用原生函数时，会把数据固定在内存中，这样原生函数才可以访问这些Java数据。这些数据，JVM的GC不能管理，会造成内存碎片。

2.6 java数据类型和C中结构体数据类型的映射关系

我们都知道在Java层面是没有结构体一说的，那么如果我在C语言中有如下的结构体和函数定义，在java层面我们应该如何去映射？

struct User {
    long id;
    char *name;
    int age;
};

void printUser(struct User *user) {
    printf("user id:%ld, user name:%s, user age:%d", user->id, user->name, user->age);
}

其实JNA的jar包为我们提供了很方便的映射方法，特意为我们提供了结构体等相关的类进行操作。

public class UserStructure extends Structure {
    public NativeLong id;
    public String name;
    public int age;
}

在Lib接口中我们也增加下面的方法

void printUser(UserStructure user);

我们继续编写简单的测试代码进行测试

    UserStructure user = new UserStructure();
        user.id = new NativeLong(1234);
        user.name = "wanna";
        user.age = 22;
        Lib.lib.printUser(user);

得到下面的运行结果user id:1234, user name:wanna, user age:22，符合我们的预期。

为什么我们的结构体类要使用public属性，而不是使用Getter和Setter？貌似JNA框架做出来就只设计了public的？应该是要和结构体一致吧，直接字段访问。

3. 新版JDK中提出新的访问本地方案

事先说明：下面的运行环境基于JDK17

3.1 编写外部C语言代码并打包成为动态链接库

编写如下的C头文件simple_functions.h

#include "stdlib.h"

typedef struct Person {
    long long id;
    char name[10];
    int age;
} Person;

typedef void (*OnEach)(int element);

void forEach(int array[], int length, OnEach on_each);

void DumpPerson(Person *person);

int getCLangVersion();

编写如下的C语言源文件simple_functions.c去进行代码实现

#include "stdio.h"
#include "stdlib.h"
#include "simple_functions.h"

typedef void (*OnEach)(int element);

void forEach(int array[], int length, OnEach on_each) {
    for (int i = 0; i < length; i++) {
        on_each(array[i]);
    }
}

void DumpPerson(Person *person) {
    printf("person id:%lld, person name:%s, person age:%d", person->id, person->name, person->age);
    char *p = person;
    for (int i = 0; i < sizeof(struct Person); i++) {
        printf("%d, ", *p++);
    }
    printf("\n");
}

int getCLangVersion() {
    return __STDC_VERSION__;
}

使用如下的命令，将其打包成为动态链接库libsimplefunctions.dylib。

gcc -c simple_functions.c
gcc -dynamiclib -o libsimplefunctions.dylib simple_functions.o 

3.2 回到java层面去调用本地实现的相关方法

因为这个功能还处于孵化期，因此需要添加如下JVM参数(VM选项)才能使用：

--add-modules jdk.incubator.foreign --enable-native-access ALL-UNNAMED

3.2.1 编写java代码调用本地的getCLangVersion函数

    public static void getCLangVersionInvoke() throws Throwable {
        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
        // 获取getCLangVersion方法的内存地址
        final MemoryAddress getCLangVersion = loaderLookup.lookup("getCLangVersion").get();
        // 第一个参数是指定方法地址，第二个参数指定Java层面的方法类型，第三个参数指定C语言层面的函数描述
        MethodHandle getCLangVersionHandle = CLinker.getInstance().downcallHandle(
                getCLangVersion,
                MethodType.methodType(int.class),
                FunctionDescriptor.of(C_INT)
        );
        System.out.println(getCLangVersionHandle.invoke());
    }

3.2.2 编写java代码调用本地的DumpPerson函数

        public static void dumpPersonInvoke() throws Throwable {
        // 创建一个结构体的内存布局，对应C语言层面的结构体定义
        MemoryLayout personLayout = MemoryLayout.structLayout(
                C_LONG_LONG.withName("id"),
                MemoryLayout.sequenceLayout(10, C_CHAR).withName("name"), // 长度为10的数组
                MemoryLayout.paddingLayout(2L * 8),  // 涉及到内存对齐的问题，这里手动填充2个字节的padding
                C_INT.withName("age")
        );

        // 为Person分配本地内存空间，第一个参数指定内存布局，第二个参数用来指明对象的作用域(可以被GC进行回收)
        MemorySegment person = MemorySegment.allocateNative(personLayout, ResourceScope.newImplicitScope());

        // 第一个参数指定对应的java类型，第二个参数指定字段的名字是id
        VarHandle idHandle = personLayout.varHandle(long.class, MemoryLayout.PathElement.groupElement("id"));
        // 给id属性赋值
        idHandle.set(person, 100000L);

        // 第一个参数指定对应的java当中的类型，第二个参数指定字段的名字是name，第三个参数指定这个字段是一个数组
        VarHandle nameHandle = personLayout.varHandle(
                byte.class,
                MemoryLayout.PathElement.groupElement("name"),
                MemoryLayout.PathElement.sequenceElement()
        );

        // 给name字段去进行赋值
        byte[] bytes = "wanna".getBytes(StandardCharsets.UTF_8);
        for (int i = 0; i < bytes.length; i++) {
            nameHandle.set(person, i, bytes[i]);
        }
        // C中字符串最后是以\0结尾的，这里需要给手动补上
        nameHandle.set(person, bytes.length, (byte) 0);

        // 给年龄设置值
        VarHandle ageHandle = personLayout.varHandle(int.class, MemoryLayout.PathElement.groupElement("age"));
        ageHandle.set(person, 20);

        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
        // 获取DumpPerson方法的内存地址
        final MemoryAddress dumpPerson = loaderLookup.lookup("DumpPerson").get();

        // 第一个参数指定要调用的对象实例，第二个参数指定的是方法在java层面的方法类型，第3个参数指定的是函数在C语言层面的描述
        MethodHandle dumpPersonHandle = CLinker.getInstance().downcallHandle(
                dumpPerson,
                MethodType.methodType(void.class, MemoryAddress.class),  // 指定java层面对应的方法类型
                FunctionDescriptor.ofVoid(C_POINTER) // 指定返回值为void，参数类型为指针类型
        );

        // 调用DumpPerson方法
        dumpPersonHandle.invoke(person.address());
    }

3.2.3 编写java代码调用本地的forEach函数

public static void forEachInvoke() throws Throwable {

        // 使用这个类中的onEach方法作为函数指针
        MethodHandle onEachHandle = MethodHandles.lookup()
                .findStatic(TestMain.class, "onEach", MethodType.methodType(void.class, int.class));

        // upcallStub代表从C调用java，这里用来获取到java的onEach方法的内存地址
        MemoryAddress onEachHandleAddress = CLinker.getInstance().upcallStub(
                onEachHandle,
                FunctionDescriptor.ofVoid(C_INT),
                ResourceScope.newImplicitScope()
        );

        int[] originArray = new int[]{5, 4, 3, 2, 1};
        
        // 在C层面去分配内存空间，也就是给array分配内存空间
        MemorySegment array = MemorySegment.allocateNative(Integer.BYTES * originArray.length, ResourceScope.newImplicitScope());
        // 创建一个VarHandle，用来给数组元素进行赋值，需要使用的是顺序布局(sequenceLayout,数组)
        VarHandle arrayHandle = MemoryLayout.sequenceLayout(originArray.length, C_INT).varHandle(int.class, MemoryLayout.PathElement.sequenceElement());
        for (int i = 0; i < originArray.length; i++) {
            arrayHandle.set(array, i, originArray[i]);
        }

        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
        // 获取forEach方法的内存地址
        final MemoryAddress forEach = loaderLookup.lookup("forEach").get();

        // 创建MethodHandle，第一个参数为方法的地址，第二个参数为java层面的方法类型，第三个参数是C层面的函数描述符
        MethodHandle forEachHandle = CLinker.getInstance().downcallHandle(
                forEach,
                MethodType.methodType(void.class, MemoryAddress.class, int.class, MemoryAddress.class),
                FunctionDescriptor.ofVoid(C_POINTER, C_INT, C_POINTER)
        );

        // 执行forEach方法，第一个参数传递的是array的地址，第二个参数传递的是array的大小，第三个参数传递的是函数指针
        forEachHandle.invoke(array.address(), originArray.length, onEachHandleAddress);
    }

    public static void onEach(int element) {
        System.out.println("onEach: " + element);
    }

3.2.4 运行并完成测试

运行main方法

    static {
        System.load("/Users/wanna/Desktop/Code/java/jdksrc/openjdk11s/src/jni/Jdk17NativeLibrary/libsimplefunctions.dylib");
    }

    public static void main(String[] args) throws Throwable {
        getCLangVersionInvoke();
        dumpPersonInvoke();
        forEachInvoke();
    }

得到下面的运行结果：

201112
onEach: 5
onEach: 4
onEach: 3
onEach: 2
onEach: 1
person id:100000, person name:wanna, person age:20
-96, -122, 1, 0, 0, 0, 0, 0, 119, 97, 110, 110, 97, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 

3.2.5 新兴的访问本地的方式特点

• 1.感觉使用起来复杂了不少，需要定义这定义那的，调用3个函数就写了一百多行代码了，而且还得注意很多C语言中的特点。
• 2.支持的功能太灵活了，可以自己根据内存布局构建C层面的结构体什么的，甚至可以传递函数指针，就很智能很离谱。
• 3.目前来说，这种方式使用起来感觉比JNA难用，希望这个孵化中的模块能成功，希望以后能有更好的框架可以出来方便使用。

个人博客：http://wanna1314y.top:8090/