JNI的实现原理

用户1269200

发布于 2018-10-08 16:09:32

1.8K0

发布于 2018-10-08 16:09:32

文章被收录于专栏：刘望舒刘望舒

作者：ladder_builder https://www.jianshu.com/p/0b7976fbf81b

JNI是Java Native Interface的缩写，它为java提供了调用C和C++代码的能力。java.lang包下的很多类都用到了native方法，比如Class、String、Thread、System，可以说JNI是java语言的基础。了解了JNI的实现原理，可以让我们对java虚拟机有更深的认识。本文主要从源码的角度，分析java虚拟机是如何实现对JNI的支持的。

1. native方法的调用

首先来看一下虚拟机是如何调用一个native方法的。

//dalvik2/vm/interp/Stack.cpp
Object* dvmInvokeMethod(Object* obj, const Method* method,
    ArrayObject* argList, ArrayObject* params, ClassObject* returnType,
    bool noAccessCheck)
{
 //省略次要流程 ...
  if (dvmIsNativeMethod(method)) {
        TRACE_METHOD_ENTER(self, method);
        (*method->nativeFunc)((u4*)self->interpSave.curFrame, &retval,
                              method, self);
        TRACE_METHOD_EXIT(self, method);
    } else {
        dvmInterpret(self, method, &retval);
    }

上面的代码就是dalvik虚拟机调用一个方法的实现，它发现如果这是一个native方法，则使用Method对象中的nativeFunc函数指针对象调用。那么nativeFunc函数指针指向哪个函数呢？

2. nativeFunc函数指针的赋值

nativeFunc主要有两种情况

默认情况下，nativeFunc会指向一个解析方法；也可以通过JNIEnv提供的注册方法，手动建立native方法与实现方法的关系，此时nativeFunc就指向了实现方法。

2.1 本地方法解析resolveNativeMethod

// dalvik2/vm/oo/Class.cpp
findClassNoInit
  loadClassFromDex
     loadClassFromDex0
      loadMethodFromDex

static void loadMethodFromDex(ClassObject* clazz, const DexMethod* pDexMethod, Method* meth) {
  ...
  if (dvmIsNativeMethod(meth)) {
    meth->nativeFunc = dvmResolveNativeMethod;
    meth->jniArgInfo = computeJniArgInfo(&meth->prototype);
  }
}

第一次从dex中加载类时，会加载类中的所有方法，对于native方法，会将nativeFunc赋值为dvmResolveNativeMethod，dvmResolveNativeMethod方法如下：

// dalvik2/vm/Native.cpp
void dvmResolveNativeMethod(const u4* args, JValue* pResult,
    const Method* method, Thread* self) {
  ClassObject* clazz = method->clazz;

   //对于静态方法，要确保所属的class已经初始化
  if (dvmIsStaticMethod(method)) {
    if (!dvmIsClassInitialized(clazz) && !dvmInitClass(clazz)) {
      assert(dvmCheckException(dvmThreadSelf()));
      return;
    }
  } else {
    assert(dvmIsClassInitialized(clazz) ||
      dvmIsClassInitializing(clazz));
  }
  //在内部本地方法表中查询
  DalvikNativeFunc infunc = dvmLookupInternalNativeMethod(method);
  if (infunc != NULL) {
    DalvikBridgeFunc dfunc = (DalvikBridgeFunc) infunc;
    dvmSetNativeFunc((Method*) method, dfunc, NULL);
    dfunc(args, pResult, method, self);
    return;
  }
  //在动态链接库表中查询
  void* func = lookupSharedLibMethod(method);
  if (func != NULL) {
    /* found it, point it at the JNI bridge and then call it */
    dvmUseJNIBridge((Method*) method, func);
    (*method->nativeFunc)(args, pResult, method, self);
    return;
  }
}

主要流程如下：

如果是静态方法，首先确保所属的class已经初始化
在内部静态方法表中查询
在动态链接库中查询

这个方法很巧妙，第一次调用native方法时，由于不知道其具体实现，所以就用resolveNativeMethod去查找，等找到后，就将nativeFunc替换为找到的函数，这样下次再用的时候就省去了查找的过程。

2.1.1 内部本地方法的查询 内部本地方法表是一个集合，这个集合里包含了java语言和虚拟机本身用到的native方法，如下所示：

// dalvik2/vm/native/InternalNative.cpp
static DalvikNativeClass gDvmNativeMethodSet[] = {
    { "Ljava/lang/Object;",               dvm_java_lang_Object, 0 },
    { "Ljava/lang/Class;",                dvm_java_lang_Class, 0 },
    ...
    { "Ljava/lang/String;",               dvm_java_lang_String, 0 },
    { "Ljava/lang/System;",               dvm_java_lang_System, 0 },
    { "Ljava/lang/Throwable;",            dvm_java_lang_Throwable, 0 },
    { "Ljava/lang/VMClassLoader;",        dvm_java_lang_VMClassLoader, 0 },
    { "Ljava/lang/VMThread;",             dvm_java_lang_VMThread, 0 },
    { "Ldalvik/system/DexFile;",          dvm_dalvik_system_DexFile, 0 },
    { "Ldalvik/system/VMRuntime;",        dvm_dalvik_system_VMRuntime, 0 },
    { "Ldalvik/system/Zygote;",           dvm_dalvik_system_Zygote, 0 },
    { "Ldalvik/system/VMStack;",          dvm_dalvik_system_VMStack, 0 },
    ...
    { NULL, NULL, 0 },
};

DalvikNativeClass结构的定义如下：

// dalvik2/vm/Native.h
struct DalvikNativeClass {
    const char* classDescriptor; //类描述符
    const DalvikNativeMethod* methodInfo; //native方法数组
    u4          classDescriptorHash;   // 类描述符的hash值
};

类描述符的hash值，会在虚拟机启动的时候进行计算，使用hash值的目的，是为了加快查找过程。 methodInfo是一个以NULL结尾的本地方法数组。DalvikNativeMethod定义如下：

struct DalvikNativeMethod {
    const char* name; //方法名
    const char* signature; // 方法签名
    DalvikNativeFunc  fnPtr; //native函数
};

上面的dvm_java_lang_String就是String类中用到的所有native方法的数组，具体如下：

// dalvik2/vm/native/String.cpp
const DalvikNativeMethod dvm_java_lang_String[] = {
    { "charAt",      "(I)C",                  String_charAt },
    { "compareTo",   "(Ljava/lang/String;)I", String_compareTo },
    { "equals",      "(Ljava/lang/Object;)Z", String_equals },
    { "fastIndexOf", "(II)I",                 String_fastIndexOf },
    { "intern",      "()Ljava/lang/String;",  String_intern },
    { "isEmpty",     "()Z",                   String_isEmpty },
    { "length",      "()I",                   String_length },
    { NULL, NULL, NULL },
};

2.1.2 动态链接库的查询 如果没有在内部本地方法表中找到对应的native方法，则要继续在动态链接库中查找。这个动态链接库就是通过System.loadLibrary加载的so，虚拟机会将所有的so存入一个表中，下面看看具体的代码。

// dalvik2/vm/Native.cpp
static void* lookupSharedLibMethod(const Method* method)
{
    return (void*) dvmHashForeach(gDvm.nativeLibs, findMethodInLib,
        (void*) method);
}

gDvm.nativeLibs是一个HashTable，其中存的是动态链接库的信息。其中的数据是通过System.loadLibrary添加进去的，java层的调用关系如下：

System.loadLibrary
  Runtime.loadLibrary0
    Runtime.doLoad()
      Rumtime.nativeLoad(name, loader, librarySearchPath)

Runtime.nativeLoad是个native方法，对应的native方法如下：

// dalvik2/vm/native/java_lang_Runtime.cpp
static void Dalvik_java_lang_Runtime_nativeLoad(const u4* args,
    JValue* pResult) {
    StringObject* fileNameObj = (StringObject*) args[0];
    Object* classLoader = (Object*) args[1];
    StringObject* ldLibraryPathObj = (StringObject*) args[2];
    ...
    bool success = dvmLoadNativeCode(fileName, classLoader, &reason);
}

// dalvik2/vm/Native.cpp
bool dvmLoadNativeCode(const char* pathName, Object* classLoader,
        char** detail) {
  SharedLib* pEntry;
  void* handle;
  bool verbose;
  ...
  //先检查是否已经加载过
  pEntry = findSharedLibEntry(pathName);
  if (pEntry != NULL) {
    // 检查classLoader是否相同，如果不同会报错，同一个so只能由一个classLoader加载
    if (pEntry->classLoader != classLoader) {
           ALOGW("Shared lib '%s' already opened by CL %p; can't open in %p",
                pathName, pEntry->classLoader, classLoader);
          return false;
    }
    if (verbose) {
         ALOGD("Shared lib '%s' already loaded in same CL %p",
                pathName, classLoader);
    }
    if (!checkOnLoadResult(pEntry))
        return false;
    return true;
  }
  // 打开so文件
  handle = dlopen(pathName, RTLD_LAZY);
  // 创建一个新的ShareLib对象
  SharedLib* pNewEntry;
  pNewEntry = (SharedLib*) calloc(1, sizeof(SharedLib));
  pNewEntry->pathName = strdup(pathName);
  pNewEntry->handle = handle;
  pNewEntry->classLoader = classLoader;
  // 将新的ShareLib加到hash表中
  SharedLib* pActualEntry = addSharedLibEntry(pNewEntry);
  if (pNewEntry != pActualEntry) {
        ALOGI("WOW: we lost a race to add a shared lib (%s CL=%p)",
            pathName, classLoader);
      freeSharedLibEntry(pNewEntry);
      return checkOnLoadResult(pActualEntry);
   } else {
      vonLoad = dlsym(handle, "JNI_OnLoad");
      if (vonLoad == NULL) {
            ALOGD("No JNI_OnLoad found in %s %p, skipping init",
                pathName, classLoader);
      } else {
          OnLoadFunc func = (OnLoadFunc)vonLoad;
          Object* prevOverride = self->classLoaderOverride;
          self->classLoaderOverride = classLoader;
          //调用JNI_OnLoad方法
          version = (*func)(gDvmJni.jniVm, NULL);
      }
    }
  }
}

上面的主要流程就是

检查是否已经加载过该so，如果是还需要判断加载so的classLoader是否相同，不同的话也会报错.
如果没有加载过，则使用dlopen打开so，然后创建一个ShareLib加入到gDvm.nativeLibs哈希表中。
如果so中有JNI_OnLoad方法，则执行该方法。我们可以在该方法中做一些初始化工作，还可以手动建立java类中的native方法和so中的native方法的对应关系。

findMethodInLib的主要流程是，首先根据规则，生成对应的native方法名，然后使用dlsym查找so中是否有该方法。 java层的native方法和so中的对应关系为：Java_类全名_方法名。

2.2 手动注册native方法

上面提到System.loadLibrary加载so时，会执行其中的JNI_OnLoad方法，我们可以在该方法中手动注册native方法。

static jint RegisterNatives(JNIEnv* env, jclass jclazz,
    const JNINativeMethod* methods, jint nMethods)
{
    ScopedJniThreadState ts(env);

    ClassObject* clazz = (ClassObject*) dvmDecodeIndirectRef(ts.self(), jclazz);

    if (gDvm.verboseJni) {
        ALOGI("[Registering JNI native methods for class %s]",
            clazz->descriptor);
    }

    for (int i = 0; i < nMethods; i++) {
        if (!dvmRegisterJNIMethod(clazz, methods[i].name,
                methods[i].signature, methods[i].fnPtr))
        {
            return JNI_ERR;
        }
    }
    return JNI_OK;
}

针对每个JNINativeMethod，调用dvmRegiseterJNIMethod，该方法会修改Method对象的nativeFunc指针，从而建立和native实现方法的对应关系。