NDK | 带你梳理 JNI 函数注册的方式和时机

前言

调用 Java 类中定义的 native 方法时，虚拟机会调用对应的 JNI 函数，而这些 JNI 函数需要先注册才能使用；
在这篇文章里，我将带你梳理 JNI 函数注册的方式和时机。另外，文末的应试建议也不要错过哦，如果能帮上忙，请务必点赞加关注，这真的对我非常重要。

提示： 有的资料将 注册 JNI 函数 描述为 链接 JNI 函数 / 链接本地方法，其实是一个意思。

1. 静态注册

1.1 静态注册的命名规则

静态注册采用的是 基于约定 方式，即：对于一个 native 方法，与之对应的 JNI 函数的命名规则如下：

短名称（short name）

1、前缀 Java_；

2、类的全限定名（带下划线分隔符_）；

3、方法名；

长名称（long name）

由于存在方法重载的情况，而上面说的短名称规则是无法区分方法重载的。因此，有重载方法的时候，还需要在短名称后追加参数描述符。

4、追加两个下划线（__）和参数描述符

举个例子，MediaPlayer#native_init()对应的 JNI 函数为android_media_MediaPlayer_native_init()

android.media.MediaPlayer.java

public class MediaPlayer extends PlayerBase implements ... {
    private static native final void native_init();
}
复制代码

android_media_MediaPlayer.cpp

static void
android_media_MediaPlayer_native_init(JNIEnv *env)
{
    jclass clazz;
    clazz = env->FindClass("android/media/MediaPlayer");
    fields.context = env->GetFieldID(clazz, "mNativeContext", "J");
    ...
}
复制代码

提示： 使用javap命令可以生成符合命名约定的头文件。

1.2 静态注册查找源码分析

静态注册查找的源码应该在这里：

提示： 为什么要说应该？因为丑丑也没有找到调用这个方法的源码，也没有查阅到对应的资料，所以不是很确定。

java_vm_ext.cc

共享库列表
std::unique_ptr<Libraries> libraries_;

（已简化）
void* FindNativeMethod(Thread* self, ArtMethod* m, std::string& detail) {

    1、获取 native 方法对应的短名称与长名称
    std::string jni_short_name(m->JniShortName());
    std::string jni_long_name(m->JniLongName());

    2、在已经加载的 so 库中搜索
    void* native_code = FindNativeMethodInternal(self,
                                                 declaring_class_loader_allocator,
                                                 shorty,
                                                 jni_short_name,
                                                 jni_long_name);
    return native_code;
}

-> 2、在已经加载的 so 库中搜索（已简化）
void* FindNativeMethodInternal(Thread* self,
                               void* declaring_class_loader_allocator,
                               const char* shorty,
                               const std::string& jni_short_name,
                               const std::string& jni_long_name) {
    for (const auto& lib : libraries_) {
        SharedLibrary* const library = lib.second;

        2.1 检查是否为相同 ClassLoader
        if (library->GetClassLoaderAllocator() != declaring_class_loader_allocator) {
            continue;
        }

        2.2 先搜索短名称
        const char* arg_shorty = library->NeedsNativeBridge() ? shorty : nullptr;
        void* fn = dlsym(library, jni_short_name)

        2.3 再搜索长名称
        if (fn == nullptr) {
            fn = dlsym(library, jni_long_name)
        }
        if (fn != nullptr) {
            return fn;
        }
    }
    return nullptr;
}
复制代码

art_method.cc

-> 1、获取 native 方法对应的短名称与长名称

短名称
std::string ArtMethod::JniShortName() {
    return GetJniShortName(GetDeclaringClassDescriptor(), GetName());
}

长名称
std::string ArtMethod::JniLongName() {
    std::string long_name;
    long_name += JniShortName();
    long_name += "__";

    std::string signature(GetSignature().ToString());
    signature.erase(0, 1);
    signature.erase(signature.begin() + signature.find(')'), signature.end());

    long_name += MangleForJni(signature);

    return long_name;
}
复制代码

descriptors_names.cc

std::string GetJniShortName(const std::string& class_descriptor, const std::string& method) {
    略
}
复制代码

上面的代码已经非常简化了，主要关注以下几点：

1、获取 native 方法对应的短名称与长名称；
2、在已经加载的 so 库libraries_中搜索，关于加载 so 库的流程在我之前写过的一篇文章里讲过：《NDK | 说说 so 库从加载到卸载的全过程》。加载后的共享库就是存储在libraries_表中。

2.1 检查是否为相同 ClassLoader
2.2 先搜索短名称
2.3 再搜索长名称

2. 动态注册

2.1 RegisterNatives(...) 函数

除了基于约定的静态注册外，还可以调用RegisterNatives(...)来注册 native 方法与关联的 JNI 函数。一般来说，会在JNI_Onload(...)函数中执行，例如：

android_media_MediaPlayer.cpp

jint JNI_OnLoad(JavaVM* vm, void* /* reserved */) {
    ...
    if (register_android_media_MediaPlayer(env) < 0) {
        ALOGE("ERROR: MediaPlayer native registration failed\n");
        goto bail;
    }
    ...
}

-> 2、调用 AndroidRuntime::registerNativeMethods
static int register_android_media_MediaPlayer(JNIEnv *env) {
    return AndroidRuntime::registerNativeMethods(env,
        "android/media/MediaPlayer", gMethods, NELEM(gMethods));
}

1、native 方法与 JNI 方法的映射关系
static const JNINativeMethod gMethods[] = {
    {
        "nativeSetDataSource",
        "(Landroid/os/IBinder;Ljava/lang/String;[Ljava/lang/String;"
        "[Ljava/lang/String;)V",
        (void *)android_media_MediaPlayer_setDataSourceAndHeaders
    },

    {
        "_setDataSource",
        "(Ljava/io/FileDescriptor;JJ)V",
         (void *)android_media_MediaPlayer_setDataSourceFD}
    },
    ...
}
复制代码

JNIHelp.cpp

-> 调用 AndroidRuntime::registerNativeMethods
-> 最终调用的是：JNIHelp.cpp

extern "C" int jniRegisterNativeMethods(C_JNIEnv* env, const char* className,
        const JNINativeMethod* gMethods, int numMethods) {

    JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
    scoped_local_ref<jclass> c(env, findClass(env, className));
    
    3、关注点：调用 RegisterNatives
    if ((*env)->RegisterNatives(e, c.get(), gMethods, numMethods) < 0) {
        ...
    }
    return 0;
}
复制代码

上面的代码已经非常简化了，主要关注以下几点：

1、gMethods数组表示了 native 方法与 JNI 方法的映射关系
2、调用 AndroidRuntime::registerNativeMethods
3、最终调用的是：RegisterNatives(...)函数

其中，JNINativeMethod 是定义在jni.h中的一个结构体：

typedef struct {
    const char* name; native 方法名
    const char* signature; native 方法的方法描述符
    void* fnPtr; JNI 函数指针
} JNINativeMethod;
复制代码

提示： 这里需要提醒下，很多资料都把 signature 说成是 JNI 这个知识下的概念，事实上它是 JVM 字节码中用于描述方法的字符串，是字节码中的概念。

2.2 优缺点对比

静态注册优点：简单直接，不需要编写注册 JNI 函数的代码，但是修改 Java 代码类名或方法后，需要修改 JNI 函数命名；
动态注册优点：灵活性高，当需要修改类名或方法名时，不需要修改 JNI 函数。

3. 注册 JNI 函数的时机

经过我的总结，注册 JNI 函数的时机主要分为三种，这三种场景都是比较常见的：

1、虚拟机第一次调用 native 方法时

这种时机对应于静态注册，当虚拟机第一次调用该 native 方法时，会先搜索对应的 JNI 函数并注册。

2、Android 虚拟机启动时

在 App 进程启动流程中，在创建虚拟机后会执行一次 JNI 函数注册，源码为：

AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote) {
    ...
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
    }
    ...
}

start -> startReg：
int AndroidRuntime::startReg(JNIEnv* env) {
    androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
    env->PushLocalFrame(200);
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    env->PopLocalFrame(NULL);
    return 0;
}

startReg->register_jni_procs：
static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env) {
    for (size_t i = 0; i < count; i++) {
        执行 JNI 注册
        if (array[i].mProc(env) < 0) {
            return -1;
        }
    }
    return 0;
}


static const RegJNIRec gRegJNI[] = {
    REG_JNI(register_com_android_internal_os_RuntimeInit),
    REG_JNI(register_com_android_internal_os_ZygoteInit_nativeZygoteInit),
    REG_JNI(register_android_os_SystemClock),
    REG_JNI(register_android_util_EventLog),
    ...    
}

struct RegJNIRec {
    int (*mProc)(JNIEnv*);
}
复制代码

可以看到，Android 虚拟机启动时，会调用startReg()。其中会遍历调用gRegJNI数组，这个数组是一系列注册 JNI 函数的函数指针。

3、加载 so 库时

在加载 so 库时，会回调JNI_Onload(..)，因此这是注册 JNI 函数的好时候，例如上面提到的MediaPlayer也是在这个时候注册 JNI 函数。

注册的时机	对应的注册方式
1、虚拟机第一次调用 native 方法时	静态注册
2、Android 虚拟机启动时	动态注册
3、加载 so 库时	动态注册

4. 总结

应试建议

1、应理解注册 JNI 函数的两种方式：静态注册 & 动态注册；

2、应理解静态注册的函数命名约定、动态注册调用的RegisterNatives(...)；

3、应知晓注册 JNI 函数的三个时机。

参考资料

《Android JNI 原理分析》 —— Gityuan 著
《JNI 编程指南》