Java 层调用 Native 层函数的两种方式

示例代码:https://github.com/ITcrazywgy/Blog/tree/master/JNIDemo

概述

Java 层如何调用Native层函数，大家都应该知道使用JNI(Java 本地接口)。

1. 通过在java层声明native方法，然后遵守JNI规范命名Native函数，即可建立Java层native声明函数与Native层实现函数的关联。

2. 另一种就是采用函数注册方式，Android Frameword层多采用这种方式，执行效率更高。

以下详细说明，两种方式的实现。

第一种方式：函数命名规范

在Android Studio 工程中，New Project 新建一个项目，将include c++ support 勾上。

pic1.png

创建出来的工程中，默认会帮你生成一个java调用native函数的示例。

//MainActivity.java
 public class MainActivity extends AppCompatActivity {
    static { System.loadLibrary("native-lib");}
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        final TextView tv = findViewById(R.id.sample_text);
        tv.setText(stringFromJNI());
    }
    public native String stringFromJNI();
}   

// native-lib.cpp
#include <jni.h>
#include <string>
extern "C"
JNIEXPORT jstring JNICALL Java_com_felix_jnidemo_MainActivity_stringFromJNI(JNIEnv *env, jobject /* this */) {
    std::string hello = "hello world from 函数命名规范方式";
    return env->NewStringUTF(hello.c_str());
}

一目了然，java层 stringFromJNI 方法 与 native 层 Java_com_felix_jnidemo_MainActivity_stringFromJNI 方法，存在对应关系。
我们会发现，native层函数方法名的命名规范即是

1. "Java" ，包名，类名 , 方法名 以 "_" 相连
2. 返回值 jstring 对应 java 中的String
3. JNICALL JNIEXPORT 表明是一个 对外暴露的JNI函数调用

特别留意一下 extern "C" ，必须加上。

如果不加上，由于C++编译器编译 cpp 文件会存在 Name Mangling (命名重整)的问题,Java_com_felix_jnidemo_MainActivity_stringFromJNI 会被C++编译器重整为另一个函数名 xxyyzzaabbcc (我随便起的名)，以确保方法的独一无二性。所以java层通过调用 stringFromJNI 时，虚拟机按照默认的命名规范，找不到对应的 native实现函数，从而导致应用崩溃。
而加上 extern "C",则是通知C++编译器按照 C 的编译方式来生成函数名（即函数名保持不变)

第二种方式：函数注册方式

这种方式，写的代码稍微多点，但好处很明显，函数映射关系配置灵活，执行效率要比第一种方式高。

先要明白一个概念：
System.loadLibrary 加载动态库后，进入动态库后，会首先执行 JNI_OnLoad 这个方法，所以我们可以实现这个方法，在这个方法中注册java层与native层的函数对应关系。

具体实现流程

1. 首先在java层中新增一个native 声明函数

  public native String stringFromJNI2();

2. 在native层提供对应的实现方法，这次我们不采用默认的命名方式

  jstring stringFromJNI2(JNIEnv *env, jobject) {
    std::string hello = "hello world from 函数注册方式";
    return env->NewStringUTF(hello.c_str());
}

3.在Native层实现 JNI_OnLoad 方法，在这个方法中注册函数的对应关系

static int registerNativeMethods(JNIEnv *, const char *, JNINativeMethod *, int);
static int registerNatives(JNIEnv *);

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    jint result = -1;
    JNIEnv *env = NULL;
    if (vm->GetEnv((void **) &env, JNI_VERSION_1_4)) {
        goto fail;
    }
    // 在这里注册函数的对应关系
    if (registerNatives(env) != JNI_TRUE) {
        goto fail;
    }
    result = JNI_VERSION_1_4;
    fail:
    return result;
}
static JNINativeMethod gMethods[] = {{"stringFromJNI2", "()Ljava/lang/String;", (void *) stringFromJNI2}};

static int registerNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *gMethods, int numMethods) {
    jclass clazz;
    clazz = env->FindClass(className);
    if (clazz == NULL) {
        return JNI_FALSE;
    }
    // 关键代码，在JNIEnv中 注册函数的对应关系
    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
        return JNI_FALSE;
    }
    return JNI_TRUE;
}

static int registerNatives(JNIEnv *env) {
    if (!registerNativeMethods(env, "com/felix/jnidemo/MainActivity", gMethods, sizeof(gMethods) / sizeof(gMethods[0]))) {
        return JNI_FALSE;
    }
    return JNI_TRUE;
}

上述代码实现中，核心代码就一句

env->RegisterNatives(clazz, gMethods, numMethods)

在这里注册了函数的对应关系,其它的都是围绕这句代码展开的。

//函数对应关系数组
static JNINativeMethod gMethods[] = {{"stringFromJNI2", "()Ljava/lang/String;", (void *) stringFromJNI2}};

JNINativeMethod 是存储映射关系的一个结构体，第一个元素是java的方法名，第二个元素是java方法对应的方法签名，第三个是native实现函数的函数指针。

下面附带一张 JNI类型签名规则表

Java类型	类型签名
boolean	Z
byte	B
char	C
long	J
float	F
double	D
short	S
int	I
类	L全限定类名;
数组	[元素类型签名

两种方式的比较

传统的JNI编程方式，符合JNI规范，但其缺点也明显：

1. 方法名固定，不能灵活配置，稍不注意写错了便会出错，编译时无法发现错误
2. 虚拟机在so库中搜索定位Native实现方法，效率有一定影响，通过注册函数可以回避这个问题