JNI: 连接Java世界的JavaVM和JNIEnv

在 不使用IDE做一次JNI开发 一文中，我们做了一次从 Java 层到 Native 层的开发。那么，我们能不能反过来，完成一次从 Native 层到 Java 层的开发呢？当然能，不过过程可没那么简单，而掌握 JavaVM 和 JNIEnv 这两个结构体就是关键，这两个结构体就是通往 Java 世界的大门，重要性不言而喻。

JavaVM

JavaVM 这个结构体指针在简单的 JNI 开发中很少使用到，它是虚拟机的代表，从 JDK 1.2 开始，一个进程只允许创建一个虚拟机。

当 Java 层访问 Nativce 层的时候会自动在 JNI 层创建一个 JavaVM 指针，而我们在 JNI 层通常所使用的都是从 JavaVM 中获取的 JNIEnv 指针。那么现在我们来看下 JavaVM 这个结构体

struct _JavaVM {
    const struct JNIInvokeInterface* functions;

#if defined(__cplusplus)
    jint DestroyJavaVM()
    { return functions->DestroyJavaVM(this); }
    jint AttachCurrentThread(JNIEnv** p_env, void* thr_args)
    { return functions->AttachCurrentThread(this, p_env, thr_args); }
    jint DetachCurrentThread()
    { return functions->DetachCurrentThread(this); }
    jint GetEnv(void** env, jint version)
    { return functions->GetEnv(this, env, version); }
    jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)
    { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }
#endif
};

本文分析的代码都是C++版本，因为C++版本的JNI使用起来方便些。

可以看到所有方法都是由结构体 JNIInvokeInterface 实现的，那么来看下这个结构体吧

/* * JNI invocation interface. */
struct JNIInvokeInterface {
    void*       reserved0;
    void*       reserved1;
    void*       reserved2;

    jint        (*DestroyJavaVM)(JavaVM*);
    jint        (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*);
    jint        (*DetachCurrentThread)(JavaVM*);
    jint        (*GetEnv)(JavaVM*, void**, jint);
    jint        (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);
};

非常简单，前三个指针作为保留使用，后五个指针为函数指针，从函数指针的名字可以推测出函数的用途，其中 DestoryJavaVM 函数是用来销毁虚拟机的, getEnv 函数是用来获取 JNIEnv 指针的。后面会举例解释这几个函数用途。

创建JavaVM

从 Java 层到 Native 层的开发的时候，我们并不需要手动创建 JavaVM 对象，因此虚拟机自动帮我们完成了这些工作。然而，如果从 Native 层到 Java 层开发的时候，我们就需要手动创建 JavaVM 对象，创建的函数原型如下

#inlcude <jni.h>

jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args);

JNI_CreateJavaVM 函数不属于任何结构体，方法声明在 jni.h 头文件中。

参数解释

1. p_vm: 是一个指向 JavaVM * 的指针，函数成功返回时会给 JavaVM *指针赋值。
2. p_env: 是一个指向 JNIEnv * 的指针，函数成功返回时会给 JNIEnv * 指针赋值。
3. vm_args: 是一个指向 JavaVMInitArgs 的指针，是初始化虚拟机的参数。

如果函数执行成功，返回 JNI_OK(值为0)，如果失败返回负值。

基本上可以这样理解 JNI_CreateJavaVM() 函数，它就是为了给 JavaVM *指针 和 JNIEnv *指针赋值。我们得到这两个指针便可以操纵”万物”，这里的”万物”指的是 Java 世界的”万物”。

使用 JavaVM

那么我们如何使用这个函数呢？这个还是有点小复杂的，需要对 Java虚拟机 有比较深的认知。那么我们只能找个例子来学习，找哪个例子呢？在 Android 源码中，Zygote 进程开启 Java 世界就是一个绝佳的例子。

Zygote 进程启动入口为 App_main.cpp 的 main() 函数

int main(int argc, char* const argv[]) {
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
}

代码是简化的，只是为了学习JNI而已。

main()函数最终会调用 AppRuntime 类的 start() 函数，AppRuntime 还是定义在 App_main.cpp 文件中，它是 AndroidRuntime 的子类，并且 start() 方法是由 AndroidRuntime 类实现的。

那么，现在看下 AndroidRuntime.cpp 的 start() 函数实现

JavaVM* AndroidRuntime::mJavaVM = NULL;

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    // 1. 创建虚拟机
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    
    // 2. 注册函数
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
    
    // 3. 调用ZygoteInit.java的main()方法
    env->CallStaticVoidMethod(startClass, startMeth, strArray);
    
    // 4. 从JavaVM中分离当前线程
    if (mJavaVM->DetachCurrentThread() != JNI_OK)
        ALOGW("Warning: unable to detach main thread\n");
    // 5. 销毁JavaVM
    if (mJavaVM->DestroyJavaVM() != 0)
        ALOGW("Warning: VM did not shut down cleanly\n");
}

第一步创建虚拟机就是调用了 JNI_CreateJavaVM() 函数，函数成功返回后，就可以得到赋值的 JavaVM *指针和JNIEnv *指针，也就是代码中的全局变量mJavaVM 和 局部变量env。这里，需要注意下为何 mJavaVM 是全局变量，而 env 是局部变量？这个后面讲 JNIEnv 的时候会解释。

第二步，第三步就是利用获取的 JNIEnv * 来访问 Java 世界。

第四步调用 JavaVM 的 DeatchCurrentThread() 函数，这个函数从命名就可以看出是从虚拟机分离当前线程。此时，我们应该想到了 JavaVM 的另外一个函数 AttachCurrentThread()，这个函数是把当前线程附着到虚拟机中。然而我们并没有调用附着的操作，怎么就直接出现 DeatchCurrentThread() 函数呢？ 那是因为 JNI_CreateJavaVM() 直接把当前线程附着到了虚拟机中。这个在后面讲 JNIEnv 也会有解释。

第五步调用 JavaVM 的 DestroyJavaVM() 函数，销毁虚拟机，

JNIEnv

在 _JavaVM 结构体中有一个函数 getEnv()，与之相对应的函数原型如下

jint GetEnv(JavaVM *vm, void **env, jint version);

参数说明

1. vm: 虚拟机对象。
2. env: 一个指向 JNIEnv 结构的指针的指针。
3. version: JNI版本，根据jdk的版本，目前有四种值，分别为 JNI_VERSION_1_1, JNI_VERSION_1_2, JNI_VERSION_1_4, JNI_VERSION_1_6。

这个函数执行结果有几种情况:

1. 如果当前线程没有附着到虚拟机中，也就是没有调用 JavaVM 的 AttachCurrentThread() 函数，那么就会设置 *env 的值为 NULL，并且返回 JNI_EDETACHED (值为-2)。
2. 如果参数version锁指定的版本不支持，那么就会设置 *env 的值为 NULL，并且返回 JNI_EVERSION(值为-3)。
3. 除去上面的两种异常情况，就会给 *env 设置正确的值，并且返回 JNI_OK(值为0)。

JNIEnv使用限制

函数执行结果的第一种情况来可以说明几个问题

1. JNIEnv * env 是与线程相关，因此多个线程之间不能共享同一个 env。
2. 如果在Native层新建一个线程，要获取 JNIEnv * env，那么必须做到如下两点
   • 线程必须调用 JavaVM 的 AttachCurrentThread() 函数。
   • 必须全局保存 JavaVM * mJavaVm，那么就可以在线程中通过调用 JavaVM 的 getEnv() 函数来获取 JNIEnv * env的值。

我们还记得 JNI_CreateJavaVM() 函数也设置 *env 的值吗？那么它肯定也会执行 AttachCurrentThread() 函数把当前线程附着到虚拟机中。这也就是解释了为何在没有明显调用 AttachCurrentThread() 的情况下，可以执行 JavaVM 的 DetachCurrentThread() 函数。

JNIEnv作用

GetEnv() 函数从命名可以看出是给 JNIEnv *env 赋值的，那么这个 JNIEnv 又有什么作用呢？来看下结构体声明吧

struct _JNIEnv {
    const struct JNINativeInterface* functions;

    jclass FindClass(const char* name) { return functions->FindClass(this, name); }
    
    jobject NewGlobalRef(jobject obj) { return functions->NewGlobalRef(this, obj); }
    
    jmethodID GetMethodID(jclass clazz, const char* name, const char* sig) { return functions->GetMethodID(this, clazz, name, sig); }
    
    // ... 省略无数个函数
}    

从声明可以看出，_JNIEnv 和 _JavaVM 玩了一样的套路，函数的都是交由另外一个指针实现，而这里就是交给 JNINativeInterface 结构体指针，从结构体命名可以大致猜下意思，它应该是定义了JNI函数调用的接口，究竟是不是呢，看下结构体声明

/* * Table of interface function pointers. */
struct JNINativeInterface {
    void*       reserved0;
    void*       reserved1;
    void*       reserved2;
    void*       reserved3;
    
    jclass      (*FindClass)(JNIEnv*, const char*);
    jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
    
    // 调用返回值为int类型的Java方法
    jint        (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);
    
    // 获取Java对象某个变量的值
    jboolean    (*GetBooleanField)(JNIEnv*, jobject, jfieldID);
    // 设置Java对象某个变量的值
    void        (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean);
    
    // 创建一个Java的String对象
    jstring     (*NewStringUTF)(JNIEnv*, const char*);
    
    // ... 省略无数个操作Java的方法
}    

从函数的作用来看，原来这个结构体是操作 Java 层的入口，从这里就可见 JNIEnv * 指针的作用了，而这个指针正是本地函数的第一个参数，例如在不使用IDE做一次JNI开发 一文中实现的一个本地函数如下

extern "C" JNIEXPORT jstring JNICALL Java_com_bxll_jnidemo_Hello_helloFromJNI (JNIEnv * env, jclass clazz) {
    const char * str_hello = "Hello from C++";
    return env->NewStringUTF(str_hello);
}

注意看第一个参数JNIEnv * env，这是自动虚拟机自动帮我们传入的，意思就是告诉你，可以利用这个指针来操作 Java 层。

总结

通过对 _JavaVM 和 _JNIEnv 结构的了解，我们就知道利用这两个结构体指针是可以打通 Java 世界的，而具体操纵 Java 世界的是 JNIEnv * 指针，那么具体如何操作 Java 世界”万物”呢，后面文章会一一详述。

参考

Oracle官网的Invocation API

docs.oracle.com/javase/7/do…