首页 > 代码库 > JNI学习笔记

JNI学习笔记

1为什么使用JNI?

JNI 的强大特性使我们在使用 JAVA 平台的同时,还可以重用原来的本地代码。作为虚拟机 实现的一部分,JNI 允许 JAVA 和本地代码间的双向交互。
请记住,一旦使用 JNI,JAVA 程序就丧失了 JAVA 平台的两个优点:
1、 程序不再跨平台。要想跨平台,必须在不同的系统环境下重新编译本地语言部分。
2、 程序不再是绝对安全的,本地代码的不当使用可能导致整个程序崩溃。 一个通用规则是,你应该让本地方法集中在少数几个类当中。这样就降低了 JAVA 和 C 之间的耦合性。

当你开始着手准备一个使用 JNI 的项目时,请确认是否还有替代方案。像上一节所提到的, 应用程序使用 JNI 会带来一些副作用。下面给出几个方案,可以避免使用 JNI 的时候,达到 与本地代码进行交互的效果:
1、JAVA 程序和本地程序使用 TCP/IP 或者 IPC 进行交互。
2、 当用 JAVA 程序连接本地数据库时,使用 JDBC 提供的 API。
3、JAVA 程序可以使用分布式对象技术,如 JAVAIDLAPI。

这些方案的共同点是,JAVA 和 C 处于不同的线程,或者不同的机器上。这样,当本地程序 崩溃时,不会影响到 JAVA 程序。 下面这些场合中,同一进程内 JNI 的使用无法避免:
1、 程序当中用到了 JAVA API 不提供的特殊系统环境才会有的特征。而跨进程操作又不现 实。
2、 你可能想访问一些己有的本地库,但又不想付出跨进程调用时的代价,如效率,内存, 数据传递方面。
3、JAVA 程序当中的一部分代码对效率要求非常高,如算法计算,图形渲染等。
总之,只有当你必须在同一进程中调用本地代码时,再使用 JNI。
Android应用框架层JNI部分源码主要位于frameworks/base/目录下。按照模块组织,不同的模块将被编译为不同的共享库,分别为上层提供不同的服务。这些共享库最终会被放置在目标系统的/system/lib目录下。

注意:NDK与JNI的区别: NDK是为便于开发基于JNI的应用而提供的一套开发和编译工具集;而JNI则是一套编程接口,可以运用在应用层,也可以运用在应用框架层,以实现Java代码与本地代码的互操作。

2.JNI步骤

JNI编程模型的结构十分清晰,可以概括为以下三个步骤:

步骤1 Java层声明Native方法。

步骤2 JNI层实现Java层声明的Native方法,在JNI层可以调用底层库或者回调Java层方法。这部分将被编译为动态库(SO文件)供系统加载。

步骤3 加载JNI层代码编译后生成的共享库。

如何创建一个支持JNI的项目:https://developer.android.com/studio/projects/add-native-code.html

创建后的目录如下:
技术分享

3.CMake

一款外部构建工具,可与 Gradle 搭配使用来构建原生库。简单来说用来将.cpp文件或.c等文件编译生成.so文件的工具,其配置文件就是上述目录图中的CMakeLists.txt。以前用的是ndk-build,但是已经弃用,其配置文件是Android.mk。

CMakeLists.txt的基本配置:
1. cmake_minimum_required(参数):设置cmake的版本以决定你将使用到cmake的feature。
2. add_library(so_file_name [STATIC | SHARED | MODULE] sources):第一个参数是创建的so文件的名字,第二个参数是配置so文件的用途,第三个参数是该so文件包含的c/c++源代码文件。举个例子:

add_library(native_lib
            SHARED
            src/main/cpp/test.cpp
            src/main/cpp/test2.cpp)

这个配置的意思是,CMake会创建一个名字叫libnative_lib.so文件,so的命名 = lib + 名字 + .so。但是在java层调用System.loadLibrary的时候,还是传入第一个参数即可,在这个例子中只用传入”native_lib”第二个参数的意思是代表该so文件的类型,static代表静态库,shared代表动态库,module在使用dyid的系统有效,若不支持dyid,等同于shared。
后面的参数都代表加入到so文件的c/c++源代码,例如这个例子中test.cpp和test2.cpp都会编译到libnative_lib.so这个文件中,依据需求加入你需要的源代码。
3.find_library:定位NDK的某个库,并将其路径存在某个变量,供其他部分引用。
其他CMake Commands内容,点击这里

4.javah, javap

在java层声明好native方法之后,按照一般的习惯是要生成对应的jni层方法,网上最一般的方法也是通过javah来生成。
1. 在jdk1.6及以下,使用对应java文件生成的class文件来生成.h文件
进入到对应的\build\intermediates\classes\debug目录下,打开命令行输入以下命令:

javah -jni com.netesae.jnisample.Prompt

后面一定要输入类的全名,包括包名。然后就会生成.h文件了。
2. 但是在jdk1.7及以上,可以直接使用java文件生成.h文件。
进入\src\main\java目录下,打开命令行,敲入和上面一样的命令,就可以了。

两种方式生成的.h文件名很长,当然你可以改。
在main/下创建cpp文件夹,将该.h文件加入,并创建新的cpp文件或者c文件,include .h文件,实现.h文件的方法即可,这一部分是c++/c的用法就不解释了。

当然如果你是采用Android官网上的方法创建一个支持c++的项目,它会自动帮你生成一个jni的模板,并且发现他其实只有一个cpp文件,并不需要什么.h文件,当然这也是可以的。
那为什么还要javah呢?这是因为jni方法规范,java层的方法要对应的native层的方法,为了保证每个函数的唯一性,所以jni层的方法命名比较长,规则如下:

Java_包名_函数名字

并且包名之间的.号也要用_来代替。因为名字比较长,为了防止程序员写错而导致找不到对应的方法,就用javah。

那么javap是干嘛的,就是用来生成函数签名的,那什么是函数签名呢,后面再解释,现在先看命令。看例子:

public class Prompt {

    static {
        System.loadLibrary("prompt-lib");
    }

    native String getLine(String prompt);

    native String show();
}

进入到Prompt.java所在的目录,敲入以下命令:

D:\git\JNISample\app\src\main\java\com\example\jnisample>javap -s -p -classpath . Prompt
警告: 二进制文件Prompt包含com.example.jnisample.Prompt
Compiled from "Prompt.java"
public class com.example.jnisample.Prompt {
  public com.example.jnisample.Prompt();
    descriptor: ()V

  native java.lang.String getLine(java.lang.String);
    descriptor: (Ljava/lang/String;)Ljava/lang/String;

  native java.lang.String show();
    descriptor: ()Ljava/lang/String;

  static {};
    descriptor: ()V
}

看prompt中的getLine函数,他的参数是String,返回的是String,所以他的函数签名就是(Ljava/lang/String;)Ljava/lang/String;,括号中的是参数签名,括号外面的就是方法返回值签名。这个后面会用到,先记着吧。

4.JNIEnv在c和c++中的区别

一开始看些资料的话,大家可能会有些疑惑,例如我们要调用JNIEnv的同一个函数,会看到有以下两个版本:

(*env)->FindClass(env,"com/example/jnisample/Prompt");

env->FindClass("com/example/jnisample/Prompt");

那这两个有什么区别么?区别就是一个是c++用法,一个是c中的用法,首先先让我们看下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++中,定义_JNIEnv是JNIEnv,其他情况(c)下,定义const struct JNINativeInterface*是JNIEnv。那么_JNIEnv和JNINativeInterface又是什么呢?

struct JNINativeInterface {
   ......很多方法
    jclass      (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,
};


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); }
.....其他方法
};

可以看到JNINativeInterface 其实定义了很多方法,都是对Java的数据进行操作,而_JNIEnv则封装了一个JNINativeInterface的指针,并且声明与JNINativeInterface中一模一样的方法,并且都是通过JNINativeInterface的指针来调方法,其实就是对JNINativeInterface做了一层封装,那么为什么这么做呢?
我的猜想是c++是面向对象的语言,不用在用指针方式来调用,并且_JNIEnv中的每个方法都比JNINativeInterface少一个参数,就是JNIEnv。具体可以自己看jni.h中的实现。

5.extern “C” vs JNIExport JNICall

.cpp文件是c++的语法,.c是c的语法,文件的类型决定了JNIEnv的语法,在上面一小节也提到JNIEnv在c++和c的区别。
网上的资料中,native方法除了要遵守JNI函数规范,还要加上JNIExport和JNICall,这样才能保证这个native函数是可以注册在函数列表中,但我后来试了下,在使用cmake的情况下,并不需要JNIExport和JNICall。
1.c语言情况下,并不需要JNIExport和JNICall。
2.c++语言情况下,也不需要JNIExport和JNICall,但是需要加上extern “C”{},native函数需要放在这个括号中才可以。

解释下extern “C”的意思。extern代表声明的方法和变量为全局变量,和java的static一样,但是和c++的static不一样(有关c++语法自行查找)。”c”则代表{}内的内容以c语言方式编译和连接。
至于c语言下为什么不用JNIExport和JNICall还不是很清楚,尚未找到原因。但猜想可能是在cmake编译so文件的时候,做了什么手脚。

6.框架层vs应用层

以下内容资料来自JNI在Android系统中所处的位置,可自行往下阅读。

应用框架层:Android定义了一套JNI编程模型,使用函数注册方式弥补了标准JNI编程模型的不足。Android应用框架层JNI部分源码主要位于frameworks/base/目录下。按照模块组织,不同的模块将被编译为不同的共享库,分别为上层提供不同的服务。这些共享库最终会被放置在目标系统的/system/lib目录下。
在Android应用程序开发中,一般是调用应用框架层的android.util.Log.java提供的Java接口来使用日志系统。比如我们会写如下代码输出日志:
Log.d(TAG,"debug log");
这个Java接口其实是通过JNI调用系统运行库(即本地库)并最终调用内核驱动程序Logger把Log写到内核空间中的。在Android中, Log系统十分通用,而且其JNI结构非常简洁,很适合作为JNI入门的例子。所涉及的文件包括:
frameworks/base/core/jni/android_util_Log.cpp(JNI层实现代码)

frameworks/base/core/java/android/util/Log.java(Java层代码)

libnativehelper/include/nativehelper/jni.h(JNI规范的头文件)

libnativehelper/include/nativehelper/JNIHelp.h

libnativehelper/JNIHelp.cpp

frameworks/base/core/jni/AndroidRuntime.cpp

package android.util;  
public final class Log {  
  ……  
  public static int d(String tag, String msg) {  
//使用Native方法打印日志。LOG_ID_MAIN表示日志ID,有4种:main、radio、events、system  
return println_native(LOG_ID_MAIN, DEBUG, tag, msg);  
  }  
  ……  
//声明Native方法isLoggable  
public static native boolean isLoggable(String tag, int level);  
  ……  
  /** @hide */ public static final int LOG_ID_MAIN = 0;  
  /** @hide */ public static final int LOG_ID_RADIO = 1;  
  /** @hide */ public static final int LOG_ID_EVENTS = 2;  
  /** @hide */ public static final int LOG_ID_SYSTEM = 3;  
//声明Native方法println_native  
  /** @hide */ public static native int println_native(int bufID,  
     int priority, String tag, String msg);  
} 

native的实现:

#include "jni.h"  //符合JNI规范的头文件,必须包含进来  
#include "JNIHelp.h"  //Android为更好地支持JNI提供的头文件  
#include "utils/misc.h"  
#include "android_runtime/AndroidRuntime.h"  
/*这里便是Java层声明的isLoggable方法的实现代码。  
 *JNI方法增加了JNIEnv和jobject两个参数,其余参数和返回值只是将Java参数映射成JNI  
 *的数据类型,然后通过调用本地库和JNIEnv提供的JNI函数处理数据,最后返回给Java层*/  
static jboolean android_util_Log_isLoggable(JNIEnv* env, jobject clazz,  
   jstring tag, jint level)  
{  
  ……  
  //这里调用了JNI函数  
const char* chars = env->GetStringUTFChars(tag, NULL);  
jboolean result = false;  
if ((strlen(chars)+sizeof(LOG_NAMESPACE)) > PROPERTY_KEY_MAX) {  
 ……  
} else {  
  //这里调用了本地库函数  
  result = isLoggable(chars, level);  
}  
env->ReleaseStringUTFChars(tag, chars);//调用JNI函数  
return result;  
}  
//以下是Java层声明的println_Native方法的实现代码  
static jint android_util_Log_println_native(JNIEnv* env, jobject clazz,  
   jint bufID, jint priority, jstring tagObj, jstring msgObj)  
{  
const char* tag = NULL;  
const char* msg = NULL;  
……//省略异常处理代码  
if (tagObj != NULL)  
   tag = env->GetStringUTFChars(tagObj, NULL);//调用JNI函数  
msg = env->GetStringUTFChars(msgObj, NULL);  
//调用本地库提供的方法  
int res = __android_log_buf_write(bufID,(android_LogPriority)priority, tag, msg);  
if (tag != NULL)  
   env->ReleaseStringUTFChars(tagObj, tag);//调用JNI函数释放资源  
   env->ReleaseStringUTFChars(msgObj, msg);//调用JNI函数释放资源  
return res; 

JNI层已经实现了Java层声明的Native方法。可这两个方法又是如何联系在一起的呢?我们接着分析android_util_Log.cpp的源码。定位到以下部分:

static JNINativeMethod gMethods[] = {  
   { "isLoggable",  "(Ljava/lang/String;I)Z",  
      (void*) android_util_Log_isLoggable },  
   { "println_native",  "(IILjava/lang/String;Ljava/lang/String;)I",  

      (void*) android_util_Log_println_native },  
};

这里定义了一个数组gMethods,用来存储JNINativeMethod类型的数据。

可以在jni.h文件中找到JNINativeMethod的定义:

typedef  struct {  
   const char* name;   //Java层声明的Native函数的函数名  
   const char* signature;  //Java函数的签名,依据JNI的签名规则  
   void* fnPtr;   //函数指针,指向JNI层的实现方法  
} JNINativeMethod; 

可见,JNINativeMethod是一个结构体类型,保存了声明函数和实现函数的一一对应关系。

下面分析gMethods[0]中存储的对应信息:

{ "isLoggable", "(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable }  
Java层声明的Native函数名为isLoggable。  
Java层声明的Native函数的签名为(Ljava/lang/String;I)Z。  
JNI层实现方法的指针为(void*) android_util_Log_isLoggable。 

这里就可以用到刚刚说到的javap工具,用来生成函数签名。
至此,我们给出了Java层方法和JNI层方法的对应关系。可如何告诉虚拟机这种对应关系呢?

继续分析android_util_Log.cpp源码。定位到以下部分:

int register_android_util_Log(JNIEnv* env)  
{  

jclass clazz = env->FindClass("android/util/Log");  
   levels.debug = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz,  

      "DEBUG", "I"));  
……  
return AndroidRuntime::registerNativeMethods(env, "android/util/Log",  
       gMethods, NELEM(gMethods));  

具体细看AndroidRuntime::registerNativeMethods,发现最终调用的是JNIEnv的RegisterNatives方法,其作用是向clazz参数指定的类注册本地方法。这样,虚拟机就得到了Java层和JNI层之间的对应关系,就可以实现Java和C/C++代码的互操作了。
register_android_util_Log函数是在哪里调用的?
这个问题涉及JNI部分代码在系统启动过程中是如何加载的,这已经超出了本章的知识范围,我们将在启动篇详细介绍这个过程。在这里,读者只需要知道这个函数是在系统启动过程中通过AndroidRuntime.cpp的register_jni_procs方法执行的,进而调用到register_android_util_Log将这种函数映射关系注册给Dalvik虚拟机的。
注意 使用JNI有两种方式:一种是遵守JNI规范的函数命名规范,建立声明函数和实现函数之间的对应关系;另一种是就是Log系统中采用的函数注册方式。应用层多采用第一种方式,应用框架层多采用第二种方式。

那么应用层可以使用上述函数注册方式来么,不用遵守JNI函数规范?答案是可以的。
看以下的例子:

package com.example.jnisample;
public class Prompt {

    static {
        System.loadLibrary("prompt-lib");
    }

    native String getLine(String prompt);
}
#include <jni.h>
#include <stdio.h>

jstring
Prompt_getLine(JNIEnv *env, jobject thiz, jstring params) {
    return params;
}

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

/*虚拟机执行System.loadLibrary("native-lib")后,进入libnative-lib.so后  
 *会首先执行这个方法,所以我们在这里做注册的动作*/  
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    jint result = -1;
    if (vm->GetEnv((void **) &env, JNI_VERSION_1_4)) {
        return result;
    }
    jclass clazz = env->FindClass("com/example/jnisample/Prompt");
    if (clazz == NULL) {
        return result;
    }
    if (env->RegisterNatives(clazz, gMethods, sizeof(gMethods) / sizeof(gMethods[0])) >= 0) {
        result = JNI_VERSION_1_4;
    }
    return result;
}

上述例子是仿自android_media_MediaPlayer.cpp。

6.获取当前线程的JNIEnv

不论进程中有多少个线程,JavaVM只有一份,所以在任何地方都可以使用它。可以通过调用JavaVM的attachCurrentThread来得到这个线程的JNIEnv,注意要调用detachCurrentThread来释放对应的资源。

参考资料:
http://book.51cto.com/art/201305/395846.htm
http://androidxref.com/4.2_r1/xref/frameworks/base/media/jni/
https://developer.android.com/studio/projects/add-native-code.html
https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html

<script type="text/javascript"> $(function () { $(‘pre.prettyprint code‘).each(function () { var lines = $(this).text().split(‘\n‘).length; var $numbering = $(‘
    ‘).addClass(‘pre-numbering‘).hide(); $(this).addClass(‘has-numbering‘).parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($(‘
  • ‘).text(i)); }; $numbering.fadeIn(1700); }); }); </script>

    JNI学习笔记