NDK实战（二）—— JNI原理（下）

最新推荐文章于 2024-11-21 16:15:58 发布
原创 最新推荐文章于 2024-11-21 16:15:58 发布 · 502 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析JNI原理，详细介绍了JNI方法的注册流程，从JVM_NativeLoad到JNI_OnLoad，再到Native方法的具体注册实现。通过一个动态注册的native方法实例，阐述了Java中方法定义、JNI中方法映射、gMethod定义、注册方法的编写以及在JNI_OnLoad中的调用过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JNI原理（下）

一、注册JNI方法

接着上一篇，进入 JVM_NativeLoad 方法

JNIEXPORT jstring JVM_NativeLoad(JNIEnv* env,
                                 jstring javaFilename,
                                 jobject javaLoader,
                                 jstring javaLibrarySearchPath) {
    ...

  std::string error_msg;
  {
    art::JavaVMExt* vm =
    art::Runtime::Current()->GetJavaVM();
    bool success = vm->LoadNativeLibrary(env,
                                         filename.c_str(),
                                         javaLoader,
                                         javaLibrarySearchPath,
                                         &error_msg);
    ...
}

该方法主要做了一件事：

调用Java虚拟机加载nativeLibrary

进入JavaVMExt中查看 LoadNativeLibrary 方法

bool JavaVMExt::LoadNativeLibrary(JNIEnv* env,
                                  const std::string& path,
                                  jobject class_loader,
                                  jstring library_path,
                                  std::string* error_msg) {
  ...
  SharedLibrary* library;
  ...
  void* handle = android::OpenNativeLibrary(env,
                                            runtime_->GetTargetSdkVersion(),
                                            path_str,
                                            class_loader,
                                            library_path,
                                            &needs_native_bridge,
                                            error_msg);

  ...
  
  bool created_library = false;
  {
  //通过创建一个 Android 的 Handle 并用其创建一个 SharedLibrary
    std::unique_ptr<SharedLibrary> new_library(
        new SharedLibrary(env,
                          self,
                          path,
                          handle,
                          needs_native_bridge,
                          class_loader,
                          class_loader_allocator));

    MutexLock mu(self, *Locks::jni_libraries_lock_);
    library = libraries_->Get(path);//通过路径获取library库
    if (library == nullptr) { 
      library = new_library.release();
      libraries_->Put(path, library);//将库放入 library 集合中，具体个数为动态链接库的个数
      created_library = true;
    }
  }
  ...
  //重点：
   void* sym = library->FindSymbol("JNI_OnLoad", nullptr);
   if (sym == nullptr) {
    VLOG(jni) << "[No JNI_OnLoad found in \"" << path << "\"]";
    was_successful = true;
  } else {
    
    ScopedLocalRef<jobject> old_class_loader(env, env->NewLocalRef(self->GetClassLoaderOverride()));
    self->SetClassLoaderOverride(class_loader);

    VLOG(jni) << "[Calling JNI_OnLoad in \"" << path << "\"]";
    typedef int (*JNI_OnLoadFn)(JavaVM*, void*);
   
    //在我们要加载so库中查找JNI_OnLoad方法，如果没有系统就认为是静态注册方式进行的，直接返回true，代表so库加载成功。
    //如果找到JNI_OnLoad就会调用JNI_OnLoad方法，JNI_OnLoad方法中一般存放的是方法注册的函数。
    //所以如果采用动态注册就必须要实现JNI_OnLoad方法，否则调用java中声明的native方法时会抛出异常。
    
    JNI_OnLoadFn jni_on_load = reinterpret_cast<JNI_OnLoadFn>(sym);

    
    int version = (*jni_on_load)(this, nullptr);

    if (runtime_->GetTargetSdkVersion() != 0 && runtime_->GetTargetSdkVersion() <= 21) {
      // Make sure that sigchain owns SIGSEGV.
      EnsureFrontOfChain(SIGSEGV);
    }

    self->SetClassLoaderOverride(old_class_loader.get());

    //对 version 进行判断
    if (version == JNI_ERR) {
      StringAppendF(error_msg, "JNI_ERR returned from JNI_OnLoad in \"%s\"", path.c_str());
    } else if (JavaVMExt::IsBadJniVersion(version)) {
      StringAppendF(error_msg, "Bad JNI version returned from JNI_OnLoad in \"%s\": %d",
                    path.c_str(), version);
    } else {
      was_successful = true;
    }
}

bool JavaVMExt::IsBadJniVersion(int version) {
  // We don't support JNI_VERSION_1_1. These are the only other valid versions.
  return version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4 && version != JNI_VERSION_1_6;
}

该方法主要就是：

  1. 创建 Android 中的 Handle，并用 Handle 再创建一个 SharedLibrary ，并将其放入一个 SharedLibrary 的集合中
  2. 通过 SharedLibrary 的 FindSymbol(“JNI_OnLoad”, nullptr) 找到 JNI_Onload 方法并赋值给 void* 类型的 sym
  3. 将 sym 强转为 JNI_OnLoadFn 的方法指针（JNI_OnLoadFn 是 (JavaVM*, void*) 的方法别名）
  4. 通过 JNI_OnLoadFn 获取一个 int 类型的变量 version
  5. 对 version 进行判断，若 version 等于 JNI_ERR(-1) 或不等于 JNI_VERSION_1_2、JNI_VERSION_1_4、JNI_VERSION_1_6 中的任意一个，即为错误的。

二、Native方法的注册流程

打开Android源码中的MediaPlayer类，其中有

 private native final void native_setup(Object mediaplayer_this);

其具体实现为 android_media_MediaPlayer.cpp 中的

static void
android_media_MediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)

类中还有一个 gMethod

static const JNINativeMethod gMethods[] = {
    ...
    
    {"native_setup",        "(Ljava/lang/Object;)V",            (void *)android_media_MediaPlayer_native_setup},
   
    ...
};

三个参数分别对应着

  • Java中的方法
  • Java中方法参数及返回值签名
  • JNI中的方法

接下去寻找 gMethod 的调用，发现其被用于 register_android_media_MediaPlayer 方法中进行注册

#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))

static int register_android_media_MediaPlayer(JNIEnv *env)
{
    return AndroidRuntime::registerNativeMethods(env,
                "android/media/MediaPlayer", gMethods, NELEM(gMethods));
}

register_android_media_MediaPlayer 的调用是在
JNI_OnLoad 中

jint JNI_OnLoad(JavaVM* vm, void* /* reserved */)
{
    JNIEnv* env = NULL;
    jint result = -1;

    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        ALOGE("ERROR: GetEnv failed\n");
        goto bail;
    }
    assert(env != NULL);

    //在此调用
    if (register_android_media_MediaPlayer(env) < 0) {
        ALOGE("ERROR: MediaPlayer native registration failed\n");
        goto bail;
    }

    ...
    
    //此处的返回值与上文所说的三个正确返回值相对应
    result = JNI_VERSION_1_4;

bail:
    return result;
}

现在，一连串的源码分析就走通了：

  1. LoadNativeLibrary 方法中，SharedLibrary会通过 FindSymbol 调用 JNI_OnLoad
  2. JNI_OnLoad 会将 native 方法进行注册，并返回一个 version
  3. 若 version 为 JNI_VERSION_1_2、JNI_VERSION_1_4、JNI_VERSION_1_6 中的一个则表示注册成功

三、Native 方法注册的具体实现

接着刚刚 register_android_media_MediaPlayer 方法，继续寻找 registerNativeMethods 的实现

int AndroidRuntime::registerNativeMethods(JNIEnv* env,
    const char* className, const JNINativeMethod* gMethods, int numMethods)
{
    return jniRegisterNativeMethods(env, className, gMethods, numMethods);
}

又是一个方法调用，继续找 jniRegisterNativeMethods 的实现，这个方法在 JNIHelp.cpp 中

extern "C" int jniRegisterNativeMethods(C_JNIEnv* env, const char* className,
    const JNINativeMethod* gMethods, int numMethods)
{
    JNIEnv* e = reinterpret_cast<JNIEnv*>(env);

    //findClass 之后 赋值给 c
    scoped_local_ref<jclass> c(env, findClass(env, className));
    ...

    //c.get()就是获取刚刚 findClass 的类
    if ((*env)->RegisterNatives(e, c.get(), gMethods, numMethods) < 0)
    
    ...
    
}

最终注册就是在 RegisterNatives 中

四、手写一个动态注册的 native 方法

1. 在Java中定义一个方法
public static native void diff(String path, String patternPath, int fileNum);
2. 在JNI中定义对应的方法
JNIEXPORT void JNICALL
jni_diff(JNIEnv *env, jclass type, jstring path_,
     jstring patternPath_, jint fileNum) {
    const char *path = (*env)->GetStringUTFChars(env, path_, 0);
    const char *patternPath = (*env)->GetStringUTFChars(env, patternPath_, 0);
    LogI("JNI Begin");

    (*env)->ReleaseStringUTFChars(env, path_, path);
    (*env)->ReleaseStringUTFChars(env, patternPath_, patternPath);
}
3. 定义一个 gMethod
static const JNINativeMethod gMethods[] = {
        {"diff", "(Ljava/lang/String;Ljava/lang/String;I)V", (void *) jni_diff},
};
4. 定义一个注册方法
static int registerNative(JNIEnv *env) {
    LogI("register native start");
    jclass jclz = (*env)->FindClass(env, "yourpackage/className");
    if (jclz == NULL) {
        LogI("class is null");
    }

    if ((*env)->RegisterNatives(env, jclz, gMethods, NELEM(gMethods)) < 0) {
        LogI("register failed");
    };
    LogI("register native success");
    return JNI_TRUE;
}
5. 在JNI_OnLoad中实现注册方法
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    jint result = -1;

    if ((*vm)->GetEnv(vm, (void **) &env, JNI_VERSION_1_4) != JNI_OK) {
        LogI("ERROR: GetEnv failed\n");
        goto bail;
    }
    assert(env != NULL);

    if (registerNative(env) < 0) {
        LogI("ERROR: native registration failed");
        goto bail;
    }

    /* success -- return valid version number */
    result = JNI_VERSION_1_4;
    LogI("register native completed");
    bail:
    return result;
}
6. 运行打印结果
I/TAG: register native start
I/TAG: register native success
I/TAG: register native completed
NDK实战（一）—— JNI原理（上）
冰冻三尺，非一日之寒。
12-22 593
JNI原理（上） 一、编译 CPU只能识别0101这样的二进制文件，C/C++需要经过一层编译转成二进制文件。在Windows平台上会转成xxx.obj文件，在Linux平台会转成xxx.o文件。此由过程编译器完成。 编译规则： - Eclipse ====&gt; GUN ====&gt; Android.mk - Android Studio ====&gt; LLVM ====&gt; CM...
NDK开发之编译原理与语法
awsaawsy的博客
11-29 582
1.编译流程 编译就是将高级语言的代码转化成可执行的二进制目标代码。主要包含四个步骤：预处理、编译、汇编、链接。 预处理：就是对各种预处理命令的处理，主要是宏替换、文件引入、去除空行和注释等。linux系统中预处理命令：gcc -E test.c -o test.i。-E表示gcc在预处理后停止编译、汇编和链接操作。 编译：将预处理后的代码翻译成汇编语言。会先分析后综合，分析就是进行词法、语...
Android NDK 原理
X-Teamer提炼商业万有引力模型, 低成本定制化开发
09-23 5134
本文介绍Android NDK 原理, 熟悉此教程, 需要有JNI的基础, 以及Android 应用程序的入门知识(环境搭建, 工程运行等), 可以查看本站的其它文章. 本文关注Android NDK的原理知识.
Android NDK应用原理
08-22 243
转：http://shihongzhi.com/ndk/ 那么首先看一下Android的系统框架： 最底层是Linux Kernel，然后上面是封装的库及Android runtime。再上面是Application Framework。最顶层的就是App了。 而App开发者最主要的就是专注于App层。但是由于某些原因要使用到NDK编程，所以会涉及到系统开发(中间层)的开...
NDK之静态库与动态库原理及编译流程
weixin_35937808的博客
02-06 647
NDK开发。 静态库与动态库原理，编译流程详解。编译原理和语法详解。 一、编译 编译，就是将高级语言编写的程序转化为二进制代码可执行性目标程序。四个步骤：预处理，编译，汇编，链接 1、预处理(Preprocessing) 预处理解释： 完成宏替换、文件引入，以及去除空行、注释等，为下一步的编译做准备。 也就是对各种预处理命令进行处理，包括头文件的包含、宏定义的扩展、条件编译的选项等。 代码说...
【鸿蒙实战开发】—— NDK构建工程
最新发布
2401_88547687的博客
11-21 1082
HarmonyOS NDK默认使用CMake作为构建系统，随包提供了符合HarmonyOS工具链的基础配置文件 ohos.toolchain.cmake，用于预定义CMake变量来简化开发者配置。从源码构建源码构建也有不同方式：* 可以使用DevEco Studio提供的C++应用模板，用DevEco Studio来编译构建* 也可以使用命令行CMake来编译构建使用预构建库构建本章节将通过具体示例介绍如何在Native工程中使用NDK，以及如何编写CMake脚本来构建NDK工程。
android jni 读写sd卡,Android NDK的使用实例——增量更新实战
weixin_32900811的博客
05-26 567
image1、概述Android很多应用没有使用到NDK开发，但想要开发更高级的应用，NDK的学习是必然之路。NDK的好处不多说，这里也应该说是JNI的好处，其中之一就是可以方便使用到C/C++世界里面的优秀开源库，这里要实战的是增量更新，其中用到的是bsdiff开源代码，而bsdiff又依赖bzip2开源代码。一开始自己做过一些硬件开发，也使用过一些so库，使用的话按照文档指示一般没什么问题，但...
安卓Android源码——史上最强NDK入门项目实战.zip
10-12
本项目实战将带领你逐步完成一个简单的NDK项目，通过实践学习如何创建原生库、定义JNI接口、编译和调试原生代码，以及如何在Java层调用这些接口。通过这个过程，你将深入了解Android NDK的运作机制，为后续的高级...
Android：清晰讲解JNI-与-NDK（含实例教学，Android开发必会技术
m0_66155658的博客
01-11 496
1.2 为什么要有 JNI 背景：实际使用中，Java 需要与 本地代码 进行交互 问题：因为 Java 具备跨平台的特点，所以Java 与 本地代码交互的能力非常弱 解决方案： 采用 JNI特性 增强 Java 与 本地代码交互的能力 1.3 实现步骤 在Java中声明Native方法（即需要调用的本地方法） 编译上述 Java源文件javac（得到 .class文件） 通过 javah 命令导出JNI的头文件（.h文件） 使用 Java需要交互的本地代码 实现在 Java
Android_NDK JNI实现原理和简单实现（D7）
木寸~
04-10 329
Android_NDK JNI实现原理和简单实现 JNI开发一般流程 定义本地native方法 生成.h头文件 添加.h的工程目录依赖添加 实现头文件中的native方法 load动态库 定义java native方法 kotlin external fun signatureParams(params: String): String init { System.loadLibrary("lib_network_sign") } System.load 加载一个具体路径
java jni原理_Android NDK - JNI原理和使用技巧
weixin_33014843的博客
02-12 257
JNI ReferenceJNI Reference一切都是LocalReferenceLocalReference局部引用引起泄漏导致crashjsize size = env->GetArrayLength(messages);//这里如果size太大，一直不销毁局部引用的话，会导致泄漏crashfor (int i = 0; i < size; ++i) {//这里是一个局部引用...
android 进阶解密 第九章 JNI原理
龚礼鹏的博客
07-20 598
一.JNI概述。 JNI：是java与其他语言通信的桥梁。 需要用到JNI技术的地方： 1.需要调用java语言不支持的依赖于操作系统平台特性的一些功能。 2.为了整合一些以前的非java语言开发的系统。 3.为了节省程序的运行时间。必须采用其他语言(比如：c/c++)来提升运行效率。 JNI在android中的运用场景：音视频开发、热修复和插件化、逆向开发、系统源码调用等。 二.N...
java.lang.UnsatisfiedLinkError: JNI_ERR returned from JNI_OnLoad错误的解决
ruizhenggang的博客
07-24 2万+
困扰了我一天的一个问题，显示一个so文件报找不到，后来是图上的错误。让我误以为第一个so文件是读到了的。 先简单讲下个人对android项目引入so文件的原理性的理解，知道了这个原理其实就不难查出问题。 1.首先so文件是一个native方法的实现。我们都知道Android的架构，我们编写的应用程序都是在应用层展示的，那么怎么调用更底层的东西呢，比如说应用框架层。那就要依靠native方法...
jni动态注册
momo_ibeike的博客
08-13 1118
在上一篇jni加载流程中，我们提到了最终调用了Runtime.java的nativeLoad方法，然后通过动态注册调用java_lang_Runtime.cc中的Runtime_nativeLoad方法。我们先接着分析一下加载流程。 Runtime_nativeLoad流程分析 static jstring Runtime_nativeLoad(JNIEnv* env, jclass,
一文让你懂weex
自由麦田
09-11 1682
weex的初始化 weex的初始化一般从app启动的时候进行。weex的初始化主要完成三件事情： 初始化js framework——initFramework(); 注册公共Component和Module——registerModulesAndComponents(); 注册上层DSL框架，如Rax——loadRaxFramework(); initFramewo...
Android NDK 编译原理
Just for fun的专栏
04-08 838
一、gradle gradle是Android Studio指定的自动编译脚本，它有点像 Linux C开发中的 Makefile。下面我来看下 Android Studio 是如何使用 Gradle 的。 在 Android 项目中，包括三个 gradle 文件, 它分分别是： build.gradle是Android 项目的顶级脚本； setting.gradle里记录了 Android 项目里都包括了哪些子项目； app/build.gradle里记录了每个子模块应该如何进行编译。 下.
android app中使用JNI
weixin_33691700的博客
03-02 342
JNI提供了一种机制，使得在Java 代码中可以使用 C/C++ ...
Android WebView硬件加速渲染网页UI的过程分析
热门推荐
老罗的Android之旅
12-19 7万+
Android WebView作为App UI的一部分，当App UI以硬件加速方式渲染时，它也是以硬件加速方式渲染的。Android WebView的UI来自于网页，是通过Chromium渲染的。Chromium渲染网页UI的机制与Android App渲染UI的机制是不一样的。不过，它们会一起协作完成网页UI的渲染。本文接下来就详细分析Android WebView硬件加速渲染网页UI的过程。
掌握Ndk-Jni实战开发技巧与Aes加密案例分析
本文将详细介绍"Ndk-Jni开发实战"的知识点，涵盖Android NDK和Jni的基本概念、开发过程以及一个具体的应用实例——Aes加密demo。 ### NDK（Native Development Kit） Android NDK是一个工具集，允许开发者使用C和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值