java JNI的两种实现方法：javah vs JNI_OnLoad

Java JNI有两种方法，一种是通过javah,获取一组带签名函数，然后实现这些函数。这种方法很常用，也是官方推荐的方法，本文不再详述，重点说明一下JNI_OnLoad方法。

当在系统中调用System.loadLibrary函数时，该函数会找到对应的动态库，然后首先试图找到"JNI_OnLoad"函数，如果该函数存在，则调用它。

JNI_OnLoad可以和JNIEnv的registerNatives函数结合起来，实现动态的函数替换。

下面用一个简单的例子来说明

java类声明
创建目录mj/jnitest，并新建两个文件MyObject.java和JniTest.java

MyObject.java

1. package mj.jnitest;
   
2. 
   
3. class MyObject {  
   
4. 
   
5.    static {   
   
6. 
   
7.       System.loadLibrary("jni");  //这是加载使用javah规定风格实现的库
   
8. 
   
9. }
   
10. 
    
11. //下面定义两个native函数
    
12. 
    
13. public native void func1();
    
14. 
    
15. public native void func2();
    
16. 
    
17. }

复制代码

JniTest.java

1. package mj.jnitest;
   
2. 
   
3. class JniTest {
   
4. 
   
5.      // static {  //这是一种静态的加载方式，可以完全工作；但是下面我们要用更灵活的方式进行
   
6. 
   
7.               //  System.loadLibrary("jni2");
   
8. 
   
9.     // }
   
10. 
    
11. public static void main(String[] args)  {   
    
12. 
    
13.             MyObject obj = new MyObject();   
    
14. 
    
15.            //在fun2函数替换之前，先进行一次调用，会调研jni1中的函数
    
16. 
    
17.            obj.func1();   
    
18. 
    
19.            obj.func2();   
    
20. 
    
21.             //用JNI_OnLoad进行主动注册
    
22. 
    
23.            System.loadLibrary("jni2");   
    
24. 
    
25.            obj.func1();   
    
26. 
    
27.            obj.func2(); //func2已经被jni2中的函数替换
    
28. 
    
29.     }
    
30. 
    
31. };

复制代码

在JniTest.java中，有两个动态库jni1和jni2会被同时加载。jni1在MyObject类被链接时被加载；jni2则在MyObject的实例obj运行时被加载。首先看看他的输出结果：

$ java mj.jnitest.JniTest

--- func1 called in version 1

--- func2 called in version 1

--- func1 called in version 1

--- func2 called in version 2

从结果看出，前两行调用obj.func1和obj.func2，都是jni1中的函数，所以打印的是version 1;

而加载了jni2后，obj.func1函数仍旧是jni1中的，而func2就变成了jni2中的了。

下面看下jni1和jni2的源代码

jni1的源代码mj_jnitest_MyObject.c

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #include "mj_jnitest_MyObject.h"
   
5. 
   
6. /*
   
7. * Class:     mj_jnitest_MyObject
   
8. * Method:    func1
   
9. * Signature: ()V
   
10. */
    
11. JNIEXPORT void JNICALL Java_mj_jnitest_MyObject_func1
    
12.   (JNIEnv *env, jobject jobj)
    
13. {
    
14. printf("--- func1 called in version 1\n");
    
15. }
    
16. 
    
17. /*
    
18. * Class:     mj_jnitest_MyObject
    
19. * Method:    func2
    
20. * Signature: ()V
    
21. */
    
22. JNIEXPORT void JNICALL Java_mj_jnitest_MyObject_func2
    
23.   (JNIEnv *env, jobject jobj)
    
24. {
    
25. printf("--- func2 called in version 1\n");
    
26. }
    

复制代码

斜体部分正是打印的内容

jni2的源代码jni2.c(部分)
include <stdlib.h>

1. #include <jni.h>
   
2. 
   
3. static void JNICALL func2
   
4.   (JNIEnv *env, jobject jobj)
   
5. {
   
6. printf("--- func2 called in version 2\n");
   
7. }

复制代码

....

JNI_OnLoad的使用方法
先看一下jni2.c的完整源代码，并注意注释

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #include <jni.h> //jni的主要头文件
   
5. 
   
6. static void JNICALL func2  //函数名字可以随便取，不过参数一定要和javah生成的函数的参数一致，包括返回值
   
7.   (JNIEnv *env, jobject jobj)
   
8. {
   
9. printf("--- func2 called in version 2\n");
   
10. }
    
11. 
    
12. static const JNINativeMethod gMethods[] = { //定义批量注册的数组，是注册的关键部分
    
13. {"func2", "()V", (void*)func2} // func2是在java中声明的native函数名，"()V"是函数的签名，可以通过javah获取。
    
14. };
    
15. 
    
16. JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void *reserved) //这是JNI_OnLoad的声明，必须按照这样的方式声明
    
17. {
    
18. JNIEnv* env = NULL; //注册时在JNIEnv中实现的，所以必须首先获取它
    
19. jint result = -1;
    
20. 
    
21. if((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_4) != JNI_OK) //从JavaVM获取JNIEnv，一般使用1.4的版本
    
22.   return -1;
    
23. 
    
24. jclass clazz;
    
25. static const char* const kClassName="mj/jnitest/MyObject";
    
26. 
    
27. clazz = (*env)->FindClass(env, kClassName); //这里可以找到要注册的类，前提是这个类已经加载到java虚拟机中。 这里说明，动态库和有native方法的类之间，没有任何对应关系。
    
28. 
    
29. if(clazz == NULL)
    
30. {
    
31.   printf("cannot get class:%s\n", kClassName);
    
32.   return -1;
    
33. }
    
34. 
    
35. if((*env)->RegisterNatives(env, clazz,gMethods, sizeof(gMethods)/sizeof(gMethods[0]))!= JNI_OK) //这里就是关键了，把本地函数和一个java类方法关联起来。不管之前是否关联过，一律把之前的替换掉！
    
36. {
    
37.   printf("register native method failed!\n");
    
38.   return -1;
    
39. }
    
40. 
    
41. return JNI_VERSION_1_4; //这里很重要，必须返回版本，否则加载会失败。
    
42. }

复制代码

对他进行编译后，得到一个libjni2.so。

C++用法说明
上面的用法是c语言中的用法，在C++中更简单。

JavaVM和JNIEnv都是经过简单封装的类，可以直接按照如下方式调用

(vm->GetEnv((void**)&env, JNI_VERSION_1_4)

env->FindClass(kClassName);

env->RegisterNatives(clazz,gMethods, sizeof(gMethods)/sizeof(gMethods[0]))

Dalvik中动态库的原理简要分析

之所以出现这种结果，和jni的机制有关的，通过对Android中的Dalvik的分析，可以印证。

System.loadLibrary，也是一个native方法，它向下调用的过程是：

Dalvik/vm/native/java_lang_Runtime.cpp: Dalvik_java_lang_Runtime_nativeLoad ->

    Dalvik/vm/Native.cpp:dvmLoadNativeCode

dvmLoadNativeCode
打开函数dvmLoadNativeCode,可以找到以下代码

1. bool result = true;
   
2.         void* vonLoad;
   
3.         int version;
   
4. 
   
5.         vonLoad = dlsym(handle, "JNI_OnLoad"); //获取JNI_OnLoad的地址
   
6.         if (vonLoad == NULL) { //这是用javah风格的代码了，推迟解析
   
7.             LOGD("No JNI_OnLoad found in %s %p, skipping init",
   
8.                 pathName, classLoader);
   
9.         } else {
   
10.             /*
    
11.              * Call JNI_OnLoad.  We have to override the current class
    
12.              * loader, which will always be "null" since the stuff at the
    
13.              * top of the stack is around Runtime.loadLibrary().  (See
    
14.              * the comments in the JNI FindClass function.)
    
15.              */
    
16.             OnLoadFunc func = (OnLoadFunc)vonLoad;
    
17.             Object* prevOverride = self->classLoaderOverride;
    
18. 
    
19.             self->classLoaderOverride = classLoader;
    
20.             oldStatus = dvmChangeStatus(self, THREAD_NATIVE);
    
21.             if (gDvm.verboseJni) {
    
22.                 LOGI("[Calling JNI_OnLoad for \"%s\"]", pathName);
    
23.             }
    
24.             version = (*func)(gDvmJni.jniVm, NULL); //调用JNI_OnLoad，并获取返回的版本信息
    
25.             dvmChangeStatus(self, oldStatus);
    
26.             self->classLoaderOverride = prevOverride;
    
27. 
    
28.             if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4 &&
    
29.                 version != JNI_VERSION_1_6) //对版本进行判断，这是为什么要返回正确版本的原因
    
30.             {
    
31.                 LOGW("JNI_OnLoad returned bad version (%d) in %s %p",
    
32.                     version, pathName, classLoader);
    
33.                 /*
    
34.                  * It's unwise to call dlclose() here, but we can mark it
    
35.                  * as bad and ensure that future load attempts will fail.
    
36.                  *
    
37.                  * We don't know how far JNI_OnLoad got, so there could
    
38.                  * be some partially-initialized stuff accessible through
    
39.                  * newly-registered native method calls.  We could try to
    
40.                  * unregister them, but that doesn't seem worthwhile.
    
41.                  */
    
42.                 result = false;
    
43.             } else {
    
44.                 if (gDvm.verboseJni) {
    
45.                     LOGI("[Returned from JNI_OnLoad for \"%s\"]", pathName);
    
46.                 }
    
47.             }
    
48. 
    
49. 上面的代码说明，JNI_OnLoad是一种更加灵活，而且处理及时的机制。
    
50. 
    
51. 用javah风格的代码，则推迟解析，直到需要调用的时候才会解析。这样的函数，是dvmResolveNativeMethod(dalvik/vm/Native.cpp)
    
52. 
    
53. dvmResolveNativeMethod
    
54. dvmResolveNativeMethod是在一种延迟解析机制，它的代码是
    
55. 
    
56. void dvmResolveNativeMethod(const u4* args, JValue* pResult,
    
57.     const Method* method, Thread* self)
    
58. {
    
59.     ClassObject* clazz = method->clazz;
    
60. 
    
61.     /*
    
62.      * If this is a static method, it could be called before the class
    
63.      * has been initialized.
    
64.      */
    
65.     if (dvmIsStaticMethod(method)) {
    
66.         if (!dvmIsClassInitialized(clazz) && !dvmInitClass(clazz)) {
    
67.             assert(dvmCheckException(dvmThreadSelf()));
    
68.             return;
    
69.         }
    
70.     } else {
    
71.         assert(dvmIsClassInitialized(clazz) ||
    
72.                dvmIsClassInitializing(clazz));
    
73.     }
    
74. 
    
75.     /* start with our internal-native methods */
    
76.     DalvikNativeFunc infunc = dvmLookupInternalNativeMethod(method);
    
77.     if (infunc != NULL) {
    
78.         /* resolution always gets the same answer, so no race here */
    
79.         IF_LOGVV() {
    
80.             char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
    
81.             LOGVV("+++ resolved native %s.%s %s, invoking",
    
82.                 clazz->descriptor, method->name, desc);
    
83.             free(desc);
    
84.         }
    
85.         if (dvmIsSynchronizedMethod(method)) {
    
86.             LOGE("ERROR: internal-native can't be declared 'synchronized'");
    
87.             LOGE("Failing on %s.%s", method->clazz->descriptor, method->name);
    
88.             dvmAbort();     // harsh, but this is VM-internal problem
    
89.         }
    
90.         DalvikBridgeFunc dfunc = (DalvikBridgeFunc) infunc;
    
91.         dvmSetNativeFunc((Method*) method, dfunc, NULL);
    
92.         dfunc(args, pResult, method, self);
    
93.         return;
    
94.     }
    
95. 
    
96.     /* now scan any DLLs we have loaded for JNI signatures */
    
97.     void* func = lookupSharedLibMethod(method); //注意到，这里，是获取地址的地方
    
98.     if (func != NULL) {
    
99.         /* found it, point it at the JNI bridge and then call it */
    
100.         dvmUseJNIBridge((Method*) method, func);
     
101.         (*method->nativeFunc)(args, pResult, method, self);
     
102.         return;
     
103.     }
     
104. 
     
105.     IF_LOGW() {
     
106.         char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
     
107.         LOGW("No implementation found for native %s.%s %s",
     
108.             clazz->descriptor, method->name, desc);
     
109.         free(desc);
     
110.     }
     
111. 
     
112.     dvmThrowUnsatisfiedLinkError(method->name);
     
113. }
     

复制代码

lookupSharedLibMethod函数会调用到函数findMethodInLib,当然，不是直接调用，有兴趣的可以参考具体源码。

findMethodInLib是实现解析的：

static int findMethodInLib(void* vlib, void* vmethod)
{
    const SharedLib* pLib = (const SharedLib*) vlib;
    const Method* meth = (const Method*) vmethod;
    char* preMangleCM = NULL;
    char* mangleCM = NULL;
    char* mangleSig = NULL;
    char* mangleCMSig = NULL;
    void* func = NULL;
    int len;

    if (meth->clazz->classLoader != pLib->classLoader) {
        LOGV("+++ not scanning '%s' for '%s' (wrong CL)",
            pLib->pathName, meth->name);
        return 0;
    } else
        LOGV("+++ scanning '%s' for '%s'", pLib->pathName, meth->name);

    /*
     * First, we try it without the signature.
     */
    preMangleCM =
        createJniNameString(meth->clazz->descriptor, meth->name, &len);
    if (preMangleCM == NULL)
        goto bail;

    mangleCM = mangleString(preMangleCM, len); //这里，把java的native方法的名字进行转换，生成和javah一致的名字
    if (mangleCM == NULL)
        goto bail;

    LOGV("+++ calling dlsym(%s)", mangleCM);
    func = dlsym(pLib->handle, mangleCM);
    if (func == NULL) {
        mangleSig =
            createMangledSignature(&meth->prototype);
        if (mangleSig == NULL)
            goto bail;

        mangleCMSig = (char*) malloc(strlen(mangleCM) + strlen(mangleSig) +3);
        if (mangleCMSig == NULL)
            goto bail;

        sprintf(mangleCMSig, "%s__%s", mangleCM, mangleSig);

        LOGV("+++ calling dlsym(%s)", mangleCMSig);
        func = dlsym(pLib->handle, mangleCMSig); //dlsym清晰的表明，这里才是获取符号的地方。
        if (func != NULL) {
            LOGV("Found '%s' with dlsym", mangleCMSig);
        }
    } else {
        LOGV("Found '%s' with dlsym", mangleCM);
    }

bail:
    free(preMangleCM);
    free(mangleCM);
    free(mangleSig);
    free(mangleCMSig);
    return (int) func;
}

实际上，无论是那种方式，从vm的代码中，都可以看出，这些符号可以放在任意的动态库中，只要确保他们调用了System.loadLibrary即可。

JNI_OnLoad函数，可以通过registerNatives，在任意时刻替换。

VM把native函数指针通过JNI Bridge，放到一个Method结构中，这个Method结构，最终会放在struct DvmGlobals gDvm;这个全局变量中。

由于是普通的全局变量，在java独立进程中保存，一旦该全局变量被修改，linux的copy-on-write机制启动，就会形成一个该进行独有的一个gDvm变量，从而和其他进行区分开。



利用JNI_OnLoad替换WebCore模块

在Android的WebViewCore类里，静态加载了

1. static {
   
2.         // Load libwebcore and libchromium_net during static initialization.
   
3.         // This happens in the zygote process so they will be shared read-only
   
4.         // across all app processes.
   
5.         try {
   
6.             System.loadLibrary("webcore");
   
7.             System.loadLibrary("chromium_net");
   
8.         } catch (UnsatisfiedLinkError e) {
   
9.             Log.e(LOGTAG, "Unable to load native support libraries.");
   
10.         }
    
11.     }

复制代码

注意到红字部分的说明，Android通过zygote进程，来孵化每个新启动的进程。

Android为了加快启动速度，把一些重要的类都放在了preloaded-classes中，这个列表，可以在Android源码的frameworks/base/preloaded-classes中找到，

也可以在frameworks.jar包中找到，就在最上层。

而webkit相关的类，也在这个proloaded-classes的列表中。它意味着，在android系统启动时，这些类就都会被加载到系统中。

但是，通过JNI_OnLoad机制，在浏览器的主Activiy中，只要加入

1. static {
   
2. 
   
3.   System.loadLibrary("mxwebcore");
   
4. 
   
5. }

复制代码

VM即可实现用新的方法来替换老的方法。

当然，这是仅对当前进程有效，不影响其他进程。