JavaVM 和 JNIEnv

JNI 定义了两个关键数据结构，即JavaVM和JNIEnv。两者本质上都是指向函数表的二级指针。在 C++ 版本中，它们是一些类，这些类具有指向函数表的指针，并具有每个通过该函数表间接调用的 JNI 函数的成员函数。

1. JavaVM

JavaVM是虚拟机在JNI中的表示，一个JVM中只有一个JavaVM对象，这个对象是线程共享的。

通过JNIEnv我们可以获取一个Java虚拟机对象，其函数如下：

/**
 * 获取Java虚拟机对象
 * @param env JNIEnv对象
 * @param vm 用来存放获得的虚拟机的指针的指针
 * @return 成功返回0，失败返回其他
 */
jint GetJavaVM(JNIEnv *env, JavaVM **vm);

在加载动态链接库的时候，JVM会调用JNI_OnLoad(JavaVM* jvm, void* reserved)（如果定义了该函数），第一个参数会传入JavaVM指针。可以在该函数中保存JavaVM指针来供全局使用。

JavaVM *javaVM = NULL;

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    javaVM = vm;
    ...
}

2. JNIEnv

JNIEnv类型是一个指向全部JNI方法的指针，JNIEnv 提供了大部分 JNI 函数。JNIEnv只在创建它的线程有效，不能跨线程传递，不能再线程之间共享 JNIEnv。

所有的本地接口函数都会以 JNIEnv 作为第一个参数。不管是静态注册的本地C/C++函数接口，还是动态注册的本地函数接口，函数的第一个参数都是JNIEnv。

静态注册的函数实例

JNIEXPORT jstring JNICALL Java_cc_ccbu_jnitest_Test_textFromJni
  (JNIEnv *, jobject) {
    return env->NewStringUTF("text from jni");
}

动态注册的函数实例

jstring textFromJni(JNIEnv* env, jobject thiz) {
    return env->NewStringUTF("text from jni");
}

static JNINativeMethod gMethods[] = {
        {"textFromJni", "()Ljava/lang/String;", (void*)textFromJni}
};

int registerMethod(JNIEnv *env) {
    jclass test = env->FindClass("cc/ccbu/jnitest/Test");
    return env->RegisterNatives(test, gMethods, sizeof(gMethods)/ sizeof(gMethods[0]));
}

如果一段代码无法通过其他方法获取自己的 JNIEnv，可以通过全局有效的 JavaVM，然后使用 GetEnv 来获取当前线程的 JNIEnv（如果该线程包含一个 JNIEnv）。

JNIEnv* env = NULL;
if (javaVM->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK) {
    return JNI_ERR;
}

GetEnv函数定义如下：

/**
 * 获取当前线程JNIEnv
 * @param env 用来存放获取JNIEnv对象的指针的指针
 * @param version JNI版本
 * @return 成功返回0，失败返回其他
 */
jint GetEnv(void** env, jint version)

对于本地库中创建的线程，需要使用AttachCurrentThread来附加到 JavaVM来获取一个可用的JNIEnv。线程退出或不再需要使用JNIEnv时，必须通过调用DetachCurrentThread来解除连接。具体的会在线程篇进行详细说明。

3. 两种代码格式

JavaVM 和 JNIEnv 在 C 语言环境下和 C++ 环境下调用是有区别的，以NewStringUTF函数为例：'

C语言调用格式为：

(*env)->NewStringUTF(env, “Hellow World!”);

C++调用格式为：

env->NewStringUTF(“Hellow World!”);

建议使用 C++ 格式，这也是大部分代码使用的形式。但C++ 格式其实只是封装了 C 格式，使得调用更加简介方便。

4.具体定义

JavaVM 和 JNIEnv 在 <jni.h> 中的定义如下

#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;
typedef const struct JNIInvokeInterface* JavaVM;
#endif

这里分了 C 和 C++。如果是 C++ 环境下，JNIEnv 和 JavaVM则只是对 _JNIEnv 和 _JavaVM 的一个重命名；如果是 C 环境下，则是指向 JNINativeInterface 结构体和 JNIInvokeInterface 结构体的指针。JNINativeInterface 和 JNIInvokeInterface的具体定义如下：

struct JNINativeInterface {
    void*       reserved0;
    void*       reserved1;
    void*       reserved2;
    void*       reserved3;

    jint        (*GetVersion)(JNIEnv *);

    jclass      (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,
                        jsize);
    jclass      (*FindClass)(JNIEnv*, const char*);
    
    ... //此次省略大量函数指针定义
    
}

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*);
};

JNINativeInterface包含了很多的函数指针，JNI中常用的函数基本都在这个结构体中进行了定义。JNIInvokeInterface相对比较简单。C++环境下的封装_JNIEnv 和 _JavaVM具体定义如下：

struct _JNIEnv {
    /* do not rename this; it does not seem to be entirely opaque */
    const struct JNINativeInterface* functions;

#if defined(__cplusplus)

    jint GetVersion()
    { return functions->GetVersion(this); }

    jclass DefineClass(const char *name, jobject loader, const jbyte* buf,
        jsize bufLen)
    { return functions->DefineClass(this, name, loader, buf, bufLen); }

    jclass FindClass(const char* name)
    { return functions->FindClass(this, name); }
    
    ...//此次省略大量函数定义
    
#endif /*__cplusplus*/
};

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 /*__cplusplus*/
};

由此可见，C++环境下只是对C语言环境下的结构体进行了简单的封装，使的调用习惯符合C++的调用风格。但由于C和C++环境下代码格式不一样，具体是哪种格式取决于引用的文件是C文件还是C++文件。