声明：转载而来
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实现方法的对应关系。

总结
本文分析了native方法的注册与调用流程。
native方法既可以手动注册，也可以按规则动态解析。
手动注册，需要在JNI_OnLoad中使用JNIEnv提供的RegisterNatives接口注册。
动态解析只在第一次调用时进行。

作者：ladder_builder
链接：https://www.jianshu.com/p/0b7976fbf81b
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。粗体内容