Android：JNI实战，理论详解、Java与Jni数据调用

已于 2024-01-24 10:42:51 修改
阅读量1.2k 收藏 16
点赞数 20
分类专栏： Android 文章标签： android 数据结构
于 2024-01-22 21:02:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geyichongchujianghu/article/details/135711436
版权

一.概述

上一篇博文《Android：JNI实战，加载三方库、编译C/C++》讲解了如何搭建一个可以加载和链接第三方库、编译C/C++文件的Jni Demo App。

这篇博文在这个Jni Demo App的基础上，从实战出发详细讲解 Jni 开发语法。

接下来，先用一小节将Jni开发比较重要的理论知识点过一下，然后进行代码实战演练。

二.理论

2.1 JavaVM 和 JNIEnv

JavaVM 和 JNIEnv 是定义在 jni.h 头文件中最关键的两个结构体：

  • JavaVM： 代表 Java 虚拟机，每个 Java进程有且仅有一个全局的 JavaVM 对象，JavaVM 可以跨线程共享；
  • JNIEnv： 代表 Java运行环境，每个 Java线程都有各自独立的 JNIEnv 对象，JNIEnv 不可以跨线程共享。

JavaVM 和 JNIEnv 的类型定义在 C 和 C++ 中略有不同，但本质上是相同的，内部由一系列指向虚拟机内部的函数指针组成。

struct _JNIEnv;
struct _JavaVM;
typedef const struct JNINativeInterface* C_JNIEnv;

#if defined(__cplusplus)
 typedef _JNIEnv JNIEnv;
 typedef _JavaVM JavaVM;
#else
 typedef const struct JNINativeInterface* JNIEnv;
 typedef const struct JNIInvokeInterface* JavaVM;
#endif

结构体详细定义可翻阅 Jni.h 头文件，在此不作代码列举

2.2.Jni 基础数据类型：

Jni 的数据类型都在 jni.h 头文件中定义，包括基础数据类型（int 等）和引用数据类型（Object、Class、数组等）

(1).C/C++基础数据类型：
/* Primitive types that match up with Java equivalents. */
typedef uint8_t  jboolean; /* unsigned 8 bits */
typedef int8_t   jbyte;    /* signed 8 bits */
typedef uint16_t jchar;    /* unsigned 16 bits */
typedef int16_t  jshort;   /* signed 16 bits */
typedef int32_t  jint;     /* signed 32 bits */
typedef int64_t  jlong;    /* signed 64 bits */
typedef float    jfloat;   /* 32-bit IEEE 754 */
typedef double   jdouble;  /* 64-bit IEEE 754 */

/* "cardinal indices and sizes" */
typedef jint     jsize;
(2).C++引用数据类型：
#ifdef __cplusplus
/*
 * Reference types, in C++
 */
class _jobject {};
class _jclass : public _jobject {};
class _jstring : public _jobject {};
class _jarray : public _jobject {};
class _jobjectArray : public _jarray {};
class _jbooleanArray : public _jarray {};
class _jbyteArray : public _jarray {};
class _jcharArray : public _jarray {};
class _jshortArray : public _jarray {};
class _jintArray : public _jarray {};
class _jlongArray : public _jarray {};
class _jfloatArray : public _jarray {};
class _jdoubleArray : public _jarray {};
class _jthrowable : public _jobject {};

typedef _jobject*       jobject;
typedef _jclass*        jclass;
typedef _jstring*       jstring;
typedef _jarray*        jarray;
typedef _jobjectArray*  jobjectArray;
typedef _jbooleanArray* jbooleanArray;
typedef _jbyteArray*    jbyteArray;
typedef _jcharArray*    jcharArray;
typedef _jshortArray*   jshortArray;
typedef _jintArray*     jintArray;
typedef _jlongArray*    jlongArray;
typedef _jfloatArray*   jfloatArray;
typedef _jdoubleArray*  jdoubleArray;
typedef _jthrowable*    jthrowable;
typedef _jobject*       jweak;
(3).C引用数据类型：
/*
 * Reference types, in C.
 */
typedef void*           jobject;
typedef jobject         jclass;
typedef jobject         jstring;
typedef jobject         jarray;
typedef jarray          jobjectArray;
typedef jarray          jbooleanArray;
typedef jarray          jbyteArray;
typedef jarray          jcharArray;
typedef jarray          jshortArray;
typedef jarray          jintArray;
typedef jarray          jlongArray;
typedef jarray          jfloatArray;
typedef jarray          jdoubleArray;
typedef jobject         jthrowable;
typedef jobject         jweak;
(4).与Java数据类型映射表：
Java 类型JNI 类型描述长度（字节）
booleanjbooleanunsigned char1
bytejbytesigned char1
charjcharunsigned short2
shortjshortsigned short2
intjint、jsizesigned int4
longjlongsigned long8
floatjfloatsigned float4
doublejdoublesigned double8
ClassjclassClass 类对象1
Stringjstrting字符串对象/
Objectjobject对象/
Throwablejthrowable异常对象/
boolean[]jbooleanArray布尔数组/
byte[]jbyteArraybyte 数组/
char[]jcharArraychar 数组/
short[]jshortArrayshort 数组/
int[]jinitArrayint 数组/
long[]jlongArraylong 数组/
float[]jfloatArrayfloat 数组/
double[]jdoubleArraydouble 数组/

2.3 JNI 访问 Java 字段 (成员变量)

Jni 访问 Java 字段的流程分为 2 步：

  • 1.通过 jclass 获取字段 ID。例：Fid = env->GetFieldId(clz, "name", "Ljava/lang/String;");
  • 2.通过字段 ID 访问字段。例：Jstr = env->GetObjectField(thiz, Fid);

Java 字段分为静态字段和非静态字段，相关方法如下：

  • GetFieldId：获取非静态字段 ID
  • GetStaticFieldId：获取静态字段 ID
  • GetField：获取类型为 Type 的非静态字段（例如 GetIntField）
  • SetField：设置类型为 Type 的非静态字段（例如 SetIntField）
  • GetStaticField：获取类型为 Type 的静态字段（例如 GetStaticIntField）
  • SetStaticField：设置类型为 Type 的静态字段（例如 SetStaticIntField）

2.4 Jni 调用 Java 方法

Jni 访问 Java 方法与访问 Java 字段类似，访问流程分为 2 步：

  • 1、通过 jclass 获取「方法 ID」。例：Mid = env->GetMethodID(jclass, "helloJava", "()V");
  • 2、通过方法 ID 调用方法。例：env->CallVoidMethod(thiz, Mid);

Java 方法分为静态方法和非静态方法，相关方法如下：

  • GetMethodId：获取非静态方法 ID
  • GetStaticMethodId：获取静态方法 ID
  • CallMethod：调用返回类型为 Type 的非静态方法（例如 GetVoidMethod）
  • CallStaticMethod：调用返回类型为 Type 的静态方法（例如 CallStaticVoidMethod）
  • CallNonvirtualMethod：调用返回类型为 Type 的父类方法（例如 CallNonvirtualVoidMethod）

2.5 描述符：

Jni在调用Java 字段(成员变量)或函数时，需要用描述符对变量、函数参数 、函数返回值的类型进行签名描述。

字段描述符：描述字段(成员变量)的类型。

JVM 对每种基础数据类型定义了固定的描述符，而引用类型则是以 L 开头的形式：

Java 类型描述符
booleanZ
byteB
charC
shortS
intI
longJ
floagF
doubleD
voidV
引用类型以 L 开头 ; 结尾，中间是 / 分隔的包名和类名。例如 String 的字段描述符为 Ljava/lang/String;

方法描述符： 描述方法的返回值类型和参数表类型

参数类型用一对圆括号括起来，按照参数声明顺序列举参数类型，返回值出现在括号后面。

例如方法 void fun() 的名称为 fun，方法描述符为 ()V

三.实战

上一篇博文中Jni Demo App的代码结构图

3.1 Java调用Jni 

(1).Java从Jni 获取一个String

这也是AndroidStudio默认创建的Native C++ Demo里的

jnidemo.cpp

Jni函数名前缀要与Java声明Native函数所在文件的包名+文件名对应

extern "C" {

JNIEXPORT jstring JNICALL
Java_com_android_demo_jni_JNIDEMO_JavaGetStringFromJNI(JNIEnv *env, jobject instance) {
	string hello = "Hello from C++";
	return env->NewStringUTF(hello.c_str());
}

}

JNIDEMO.java

public class JNIDEMO {

    //Java从Jni获取String
    public native String JavaGetStringFromJNI();

}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

        String jniStr = mJniDemo.JavaGetStringFromJNI();
        Log.v(TAG, "jniStr:" + jniStr);

   }
}

日志打印：

(2).Java传一个Int[]到Jni，Jni直接处理Int[]数据

jnidemo.cpp

extern "C" {

/***** java传递一个Int[]到Jni, Jni赋值后再返回给Java *****/
JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JavaJniTransIntArray(JNIEnv *env, jobject instance,
                                                       jintArray javaArr) {
    //获取Java数组长度
    int lenght = env->GetArrayLength(javaArr);

    //GetIntArrayElements() 函数作用就是将 jintArray 转为 int* 指针;  将本地指针指向含有Java端数组的内存地址
    //依赖Jvm的具体实现,可能是锁住Java端的那段数组不被回收(增加引用计数)，也可能所Jvm在堆上对该数组的一份拷贝,速度和效率比GetIntArrayRegion方法要高很多
    int *arrp = env->GetIntArrayElements(javaArr, 0);

    //对数组元素进行处理
    for (int i = 0; i < lenght; i++) {
        *(arrp + i) += i;
    }

    //将C数组种的元素拷贝到Java数组中
    env->SetIntArrayRegion(javaArr, 0, lenght, arrp);

    //如果需要，可以返回数组
    //return javaArr;
}

}

JNIDEMO.java

public class JNIDEMO {

    //Java传一个Int[]到Jni进行数据处理
    public native void JavaJniTransIntArray(int[] arrInt);

}

JniActivity.java

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

        //Java传一个int[]到Jni，Jni对int[]元素进行修改
        int[] arrInt = new int[10];
        Log.v(TAG, "BeforCallJni  arrInt[]:" + Arrays.toString(arrInt));
        mJniDemo.JavaJniTransIntArray(arrInt);
        Log.v(TAG, "AfterCallJni  arrInt[]:" + Arrays.toString(arrInt));

   }
}

日志打印：

可以看到在调用Jni函数之前，数组元素都是初始值0，经过Jni处理之后数值就改变了

(3).Java传一个byte[]到Jni，Jni直接处理byte[]数据

jnidemo.cpp

extern "C" {

JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JavaJniTransByteArray1(JNIEnv *env, jobject instance,
                                                         jbyteArray javaArr) {
    //获取Java数组长度
    int lenght = env->GetArrayLength(javaArr);

    //将 jbyteArray 转为 int* 指针，使用本地指针指向含有Java端数组的内存地址
    //依赖Jvm的具体实现,可能是锁住Java端的那段数组不被回收(增加引用计数)，也可能所Jvm在堆上对该数组的一份拷贝,速度和效率比GetIntArrayRegion方法要高很多
    jbyte *arrp = env->GetByteArrayElements(javaArr, 0);
    //另外两种方式
    //signed char jbp1[lenght];
    //signed char *jbp2 = env->GetByteArrayElements(javaArr, 0);

    //对数组元素进行处理
    for (int i = 0; i < lenght; i++) {
        *(arrp + i) += i;
    }

    //将C数组中的元素拷贝到Java数组中
    env->SetByteArrayRegion(javaArr, 0, lenght, arrp);

    //如果需要，可以返回数组
    //return javaArr;
}

}

JNIDEMO.java

public class JNIDEMO {

    //Java传一个byte[]到Jni，Jni对byte[]数据处理
    public native void JavaJniTransByteArray1(byte[] arrByte);

}

JniActivity.java

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

        //Java传一个byte[]到Jni，Jni对int[]元素进行修改
        byte[] arrbyte1 = new byte[10];
        Log.v(TAG, "BeforCallJni  arrbyte1[]:" + Arrays.toString(arrbyte1));
        mJniDemo.JavaJniTransByteArray1(arrbyte1);
        Log.v(TAG, "AfterCallJni  arrbyte1[]:" + Arrays.toString(arrbyte1));

   }
}

日志打印：

(4).Java传一个byte[]到Jni，Jni拷贝数据到native byte[]，处理数据后再返回native byte[]给Java

jnidemo.cpp

extern "C" {

JNIEXPORT jbyteArray JNICALL
Java_com_android_demo_jni_JNIDEMO_JavaJniTransByteArray2(JNIEnv *env, jobject instance,
                                                         jbyteArray javaArr) {
    //获取Java数组长度
    int lenght = env->GetArrayLength(javaArr);

    //新建一个jni byte指针，指向一块 byte数据内存
    jbyte *jbp = (jbyte *) malloc(lenght * sizeof(jbyte));

    //直接将Java端的数组拷贝到本地jni内存中
    env->GetByteArrayRegion(javaArr, 0, lenght, jbp);

    //对数组元素进行处理
    for (int i = 0; i < lenght; i++) {
        *(jbp + i) += i;
    }

    //新建一个jni byte数组
    jbyteArray arrjb = env->NewByteArray(lenght);

    //将jni byte指针所指内存中的元素拷贝到生成的C数组中，然后返回
    env->SetByteArrayRegion(arrjb, 0, lenght, jbp);

    //如果需要，可以返回数组
    return arrjb;
}

}

JNIDEMO.java

public class JNIDEMO {

    //Java传一个byte[]到Jni，Jni拷贝数据到native byte[]，处理数据后再返回native byte[]给Java
    public native byte[] JavaJniTransByteArray2(byte[] arrByte);

}

JniActivity.java

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

        byte[] arrbyte2 = new byte[10];
        byte[] arrbyte3 = new byte[10];

        Log.v(TAG, "BeforCallJni  arrbyte2[]:" + Arrays.toString(arrbyte2));
        Log.v(TAG, "BeforCallJni  arrbyte3[]:" + Arrays.toString(arrbyte3));

        arrbyte3 = mJniDemo.JavaJniTransByteArray2(arrbyte2);

        Log.v(TAG, "AfterCallJni  arrbyte2[]:" + Arrays.toString(arrbyte2));
        Log.v(TAG, "BeforCallJni  arrbyte3[]:" + Arrays.toString(arrbyte3));

   }
}

日志打印：

新建了两个byte[]，arrbyte2[] 和 arrbyte3[] 。

arrbyte2[] 作为参数传递到Jni，arrbyte3[] 用于被Jni返回的Native byte[]赋值

可以看到，arrbyte2[] ，arrbyte3[] 在调用JavaJniTransByteArray2()之前，都是初始值0，在调用之后，由于arrbyte2[]在Jni中其元素并没有被改变，所以打印出来仍然都是0，而arrbyte3[]元素值则是Jni返回的Native byte[]的元素值。

(5).Java调用Jni启动一个线程

jnidemo.h

extern "C" {

bool running = false;

void *JniThreadStartByJava(void *arg);

}

jnidemo.cpp

extern "C" {

/***** java 启动一个 jni 线程 *****/
JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JavaStartJNIThread(JNIEnv *env, jobject instance) {
    pthread_t myThread;
    int res = pthread_create(&myThread, NULL, JniThreadStartByJava, NULL);
    if (res != 0) {
        LOGW("JniThreadStartByJava create failed!");
        return;
    }
}

void *JniThreadStartByJava(void *arg) {
    LOGW("JniThreadStartByJava create success!");

    while (running) {
        //do the thread thing...
    }
    return NULL;
}

}

JNIDEMO.java

public class JNIDEMO {

    //Java启动一个Jni线程
    public native void JavaStartJNIThread();
}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

        //java启动一个jni线程
        mJniDemo.JavaStartJNIThread();

   }
}

日志打印：

可以看到，在 Java 成功的创建和启动 Jni 中的一个线程

3.2 Jni调用Java

(1).Jni调用Java非静态成员变量

jnidemo.cpp

extern "C" {

/**** jni访问java非静态成员变量 ****/
/* 1.使用 GetObjectClass、 FindClass获取调用对象的类
*  2.使用 GetFieldID 获取字段的ID。这里需要传入字段类型的签名描述。
*  3.使用 GetIntField、 GetObjectField等方法，获取字段的值。
*  4.使用 SetIntField、 SetObjectField等方法，设置字段的值。
*  注意：即使字段是 private也照样可以正常访问。*/
JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JniCallJavaNoStaticField(JNIEnv *env, jobject instance) {
    //获取jclass
    jclass j_class = env->GetObjectClass(instance);
    //获取jfieldID
    jfieldID j_fid = env->GetFieldID(j_class, "mNoStaticField", "I");
    //获取java成员变量int值
    jint j_int = env->GetIntField(instance, j_fid);
    //noStaticField==0
    LOGI("noStaticField==%d", j_int);
    //Set<Type>Field 修改noStaticKeyValue的值改为111
    env->SetIntField(instance, j_fid, 111);
}

}

JNIDEMO.java

public class JNIDEMO {

    //非静态成员变量
    public int mNoStaticField;

    //Jni调用Java非静态成员变量
    public native void JniCallJavaNoStaticField();

}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

	  //jni调用Java非静态成员变量
	  Log.v(TAG, "BeforCallJni   mJni.mNoStaticField:" + mJniDemo.mNoStaticField);
	  mJniDemo.JniCallJavaNoStaticField();
	  Log.v(TAG, "AfterCallJni   mJni.mNoStaticField:" + mJniDemo.mNoStaticField);

   }
}

日志打印：

可以看到，在Jni中对Java的非静态成员变量的值进行了改变

(2).Jni调用Java静态成员变量

jnidemo.cpp

Jni函数名前缀要与Java声明Native函数所在文件的包名+文件名对应

extern "C" {

/**** jni访问java静态成员变量 ****/
/* 1.使用 GetObjectClass、 FindClass获取调用对象的类
*  2.使用 GetStaticFieldID 获取字段的ID。这里需要传入字段类型的签名描述。
*  3.使用 GetStaticIntField、 GetStaticObjectField 等方法，获取字段的值。
*  4.使用 SetStaticIntField、 SetStaticObjectField 等方法，设置字段的值。
*  注意：即使字段是 private也照样可以正常访问。*/
JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JniCallJavaStaticField(JNIEnv *env, jobject instance) {
    //获取jclass
    jclass j_class = env->GetObjectClass(instance);
    //获取jfieldID
    jfieldID j_fid = env->GetStaticFieldID(j_class, "mStaticField", "I");
    //获取java成员变量int值
    jint j_int = env->GetStaticIntField(j_class, j_fid);
    //noStaticField==0
    LOGI("StaticField==%d", j_int);

    //Set<Type>Field 修改noStaticKeyValue的值改为666
    env->SetStaticIntField(j_class, j_fid, 222);
}

}

JNIDEMO.java

public class JNIDEMO {

    //静态成员变量
    public static int mStaticField;

    //Jni调用Java静态成员变量
    public native void JniCallJavaStaticField();

}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

      //Jni调用Java静态成员变量
      Log.v(TAG, "BeforCallJni   mJni.mStaticField:" + mJniDemo.mStaticField);
      mJniDemo.JniCallJavaStaticField();
      Log.v(TAG, "AfterCallJni   mJni.mStaticField:" + mJniDemo.mStaticField);

   }
}

日志打印：

可以看到，在Jni中对Java的静态成员变量的值进行了改变

(3).Jni调用Java非静态成员方法

jnidemo.cpp

Jni函数名前缀要与Java声明Native函数所在文件的包名+文件名对应

extern "C" {

/**** jni调用java非静态成员方法 ****/
/* 1.使用 GetObjectClass、 FindClass获取调用对象的类
*  2.使用 GetMethodID获取方法的ID。这里需要传入方法的签名描述。
*  3.使用 CallVoidMethod执行无返回值的方法
*  4.使用 CallIntMethod、 CallBooleanMethod、CallStringMethod等执行有返回值的方法。
*  注意：即使字段是 private也照样可以正常访问。*/
JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JniCallJavaNoStaticMethod(JNIEnv *env, jobject instance) {
    //回调JNI.java中的noParamMethod
    jclass clazz = env->FindClass("com/android/demo/jni/JNIDEMO");
    if (clazz == NULL) {
        printf("find class Error");
        return;
    }
    jmethodID method = env->GetMethodID(clazz, "noStaticMethod", "(I)I");
    if (method == NULL) {
        printf("find method Error");
        return;
    }
    env->CallIntMethod(instance, method, 333);
}

}

JNIDEMO.java

public class JNIDEMO {

    //非静态成员方法
    private int noStaticMethod(int number) {
        Log.v(TAG,"noStaticMethod() number: "+number);
        return number;
    }

    //Jni调用Java非静态成员方法
    public native void JniCallJavaNoStaticMethod();

}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

      //Jni调用Java非静态成员方法
      mJniDemo.JniCallJavaNoStaticMethod();

   }

}

日志打印：

可以看到，Jni调用一个带整型参数的Java非静态成员方法，并且在Jni给这个方法传参333

运行后，这个Java非静态成员方法中的Log打印如下：

(4).Jni调用Java静态成员方法

jnidemo.cpp

Jni函数名前缀要与Java声明Native函数所在文件的包名+文件名对应

extern "C" {

/**** jni调用java静态成员方法 ****/
/*1.使用 GetObjectClass、 FindClass获取调用对象的类
* 2.使用 GetStaticMethodID 获取方法的ID。这里需要传入方法的签名描述。
* 3.使用 CallStaticVoidMethod 执行无返回值的方法。
* 4.使用 CallStaticIntMethod、 CallStaticBooleanMethod 等执行有返回值的方法。
* 注意：即使字段是 private也照样可以正常访问。*/
JNIEXPORT void JNICALL
Java_com_android_demo_jni_JNIDEMO_JniCallJavaStaticMethod(JNIEnv *env, jobject instance) {
    //回调JNI.java中的noParamMethod
    jclass clazz = env->FindClass("com/android/demo/jni/JNIDEMO");
    if (clazz == NULL) {
        printf("find class Error");
        return;
    }
    jmethodID method = env->GetStaticMethodID(clazz, "staticMethod", "(I)I");
    if (method == NULL) {
        printf("find method Error");
        return;
    }
    env->CallStaticIntMethod(clazz, method, 444);
}

}

JNIDEMO.java

public class JNIDEMO {

    //静态成员方法
    private static int staticMethod(int number) {
        Log.v(TAG,"staticMethod() number: "+number);
        return number;
    }

    //Jni调用Java静态成员方法
    public native void JniCallJavaStaticMethod();

}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

       //jni调用Java静态成员方法
       mJniDemo.JniCallJavaStaticMethod();

   }

}

日志打印：

可以看到，Jni调用一个带整型参数的Java非静态成员方法，并且在Jni给这个方法传参333

运行后，这个Java非静态成员方法中的Log打印如下：

(5).Jni调用Java类的构造函数

新建一个JNIConstruct.java类，其中包含一个Int和一个String成员变量。

在Jni调用JNIConstruct.java类的构造函数，实现通过Jni调用构造函数传参，给这两个成员变量赋值

JNIConstruct.java

package com.android.demo.jni;

import android.util.Log;

public class JNIConstruct {
    private final String TAG = "JNIConstruct";

    private int paramInt = 0;
    private String paramStr = null;

    public JNIConstruct(int intp, String strp) {
        paramInt = intp;
        paramStr = strp;
    }

    public void printf() {
        Log.v(TAG, "printf()  paramInt:" + paramInt + " paramStr:" + paramStr);
    }

}

jnidemo.cpp

Jni函数名前缀要与Java声明Native函数所在文件的包名+文件名对应

extern "C" {

/***** jni调用java构造方法 *****/
/* 1.使用 FindClass 获取需要构造的类
 * 2.使用 GetMethodID 获取构造方法的ID。方法名为 <init>, 这里需要传入方法的签名描述。
 * 3.使用 NewObject 执行创建对象。*/
JNIEXPORT jobject JNICALL
Java_com_android_demo_jni_JNIDEMO_JniCallJavaConstructMethod(JNIEnv *env, jobject instance) {
    // 1、获取 JNIConstruct 类的 class 引用
    jclass cls_jniCons = env->FindClass("com/android/demo/jni/JNIConstruct");
    if (cls_jniCons == NULL) {
        return NULL;
    }

    // 2、获取 JNIConstruct 的构造方法ID (构造方法的名称统一为：<init>)
    jmethodID med_jniCons = env->GetMethodID(cls_jniCons, "<init>", "(ILjava/lang/String;)V");
    if (med_jniCons == NULL) {
        return NULL; // 没有找到参数为int和String的构造方法
    }

    // 3、创建JNIConstruct对象的实例(调用对象的构造方法并初始化对象), env->NewStringUTF("") 创建一个 String 对象，作为构造方法的第二个 String 类型参数
    jobject obj_jniCons = env->NewObject(cls_jniCons, med_jniCons, 555,
                                         env->NewStringUTF("Jni Construct!"));
    if (obj_jniCons == NULL) {
        return NULL;
    }

    return obj_jniCons;
}

}

JNIDEMO.java

public class JNIDEMO {

    //Jni调用Java类的构造函数
    public native JNIConstruct JniCallJavaConstructMethod();

}

JniActivity.java

通过JNIDEMO实例对象调用声明的Native方法，实现对Jni函数的调用

public class JniActivity{

   private JNIDEMO mJniDemo = new JNIDEMO();

   publice void JavaJniFun(){

       //jni调用Java构造函数
       JNIConstruct jniConstruct = mJniDemo.JniCallJavaConstructMethod();
       jniConstruct.printf();

   }

}

日志打印：

可以看到，Jni调用了JNIConstruct.java的构造函数，并传递两个参数：

  • int paramInt = 555;
  • String paramStr = Jni Construct!;

四.结束语 

Jni 实战开发到此讲解完毕，篇幅有限，无法所有场景都实战涉及，但是万变不离其宗。

掌握了Jni理论基础，实践了多种类型Jni与Java互相调用后，其他都只是在此基础上的扩展了。

肖云鹤
关注
  • 20
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android使用jni调用c++/c方法详解
01-20
JniTest是在Android.mk里约束好的，关于Android.mk的编写具体在后面详解。 3、使用javah -jni生成.h文件 编写好jni加载类之后，就要开始生成.h文件了，此文件相当于一个声明文件，起到jni连接c++源
Android Jni的简单使用详解
08-27
在本篇文章中，我们将详细介绍Android Jni的简单使用详解，包括如何使用Jni存储常量值、如何调用native代码等等。 使用Jni存储常量值 在Android开发中，我们经常需要存储一些常量值，例如API密钥、加密密钥等等。...
Android：JNI 与 NDK到底是什么？（含实例教学）
热门推荐
Carson带你学Android
06-14 18万+
前言 在Android开发中，使用 NDK开发的需求正逐渐增大 但很多人却搞不懂 JNI 与 NDK 到底是怎么回事 今天，我将先介绍JNI 与 NDK & 之间的区别，手把手进行 NDK的使用教学，希望你们会喜欢 目录1. JNI介绍1.1 简介 定义：Java Native Interface，即 Java本地接口 作用： 使得Java 与 本地其他类型语言（如C、C++）交互 即在 Ja
Android ——JNI基本了解与使用
qq_35231506的博客
05-16 1598
JNI （Java Native Interface，Java本地接口）是一种编程框架，使得Java虚拟机中的Java程序可以调用本地应用/或库，也可以被其他程序调用。本地程序一般是用其它语言（C、C++或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序。Android NDK开发之JNI基础Android JNI详解JNI入门到精通: 用Java和C/C++打造高性能应用ANDROID STUDIO 创建一个JNI工程创建JNI基础工程并运行JNI基本知识（一）JNI编程原理。
Android JNI QQ 搞怪语音实战 (含完整 Demo)，2024最新Android大厂面试真题大全
最新发布
m0_60453176的博客
03-24 682
光有这些思路和搞懂单个知识的应用是还远远不够的，在Android开源框架设计思想中的知识点还是比较多的，想要搞懂还得学会整理和规划：我们常见的**Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架，**这些都是属于Android开源框架设计思想的。如下图所示：这位阿里P8大佬针对以上知识点，熬夜整理出了一本长达1042页的完整版如何解读开源框架设计思想。
Android调用JNI的实现方法
保温杯拖把风扇的博客
12-09 2292
介绍Android如何调用JNI
Android JNI(三)：Java与Native相互调用
whl0071的专栏
03-29 1391
Android JNI(三)：Java与Native相互调用
JNI 调用
zhexiao
04-04 1347
JNI是Java Native Interface的缩写，通过使用 Java本地接口书写程序，可以确保代码在不同的平台上方便移植。从Java1.1开始，JNI标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。本地代码与 Java 虚拟机之间是通过 JNI 函数实现相互操作的。JNI 函数通过接口指针来获得，本地方法将 JNI 接口指针当作参数来接受。
C++ / JNI - MacOS Java 调用 JNI 保姆级示例
BITDDD小栈
12-28 843
Java 调用 JNI on MacOs 保姆级教程。
Java本地调用JNI使用规范详解.doc
05-09
本文档主要讲述的是Java本地调用JNI使用规范详解；JNI概述;JavaNative Interface的缩写，中文为Java本地调用。从Java1.1开始，JNI即成为Java标准的一部分。 JNI设计的目的是为了允许Java代码与其他语言进行交互。但...
Android jni调试打印char阵列的实例详解
08-29
"Android JNI 调试打印 char 数组的实例详解" Android JNI 调试打印 char 数组的实例详解是 Android 开发中的一种常见需求，特别是在 debug 和测试阶段。在 Android 中，使用 JNI 调用 native 方法时，需要将 char...
本地java项目调用jni
程序课代表的博客
12-22 2346
一、环境搭建 1.jdk环境搭建(这个就不说了) 2.安装MinGW,官网可能下载较慢,这里我提供下载地址 提取码:nbc3 配置下MinGw的环境变量
JNI中调用Java函数
Liuqz2009的专栏
04-08 5352
JNI调用Java函数，主要是在JNI中使用反射调用Java中的函数。 1、Java代码： package com.my.hawk.jni2; import androidx.appcompat.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.T
Android中通过jni调用C++
weixin_42589381的博客
01-12 516
ndk、ndk-build、jni、Java、C++
Android使用android studio配置并运行Jni详细流程
yxw331291779的博客
05-09 4331
以手动不使用cmake方式，配置并运行jni项目的详细流程。结构清晰，按照步骤做，一定能够成功运行，一起来试试吧
Android-JNI的简单使用
HZF
08-30 4535
一、什么是JNI 1、jni的含义 JNI即为java native interface Java本地接口；JNI是用来调用本地方法的技术，用来使Java和C/C++进行通信。 简单来说，Java运行一个程序需要和不同的系统进行交互，在windows里就要和windows底层平台交互，mac里就要和mac的底层平台交互， JVM就是通过大量的JNI技术能够使Java运行在不同的系统平台当中，与不同的系统平台底层进行交互。 2、Java与JNI类型对照表 基本类型对照 引用类型对照 3、什么是动态库 静态
Android之 JNI详解
qq_29848853的博客
03-07 4506
Android JNI详解
android jni 调用
明风的博客
08-13 1209
android JNI是连接android Java部分和C/C++部分的纽带，完整使用JNI需要Java代码和C/C++代码。其中C/C++代码用于生成库文件，Java代码用于引用C /C++库文件以及调用C/C++方法。 android Java部分代码： /*  * Copyright (C) 2008 The Android Open Source Project  *  *
Android NDK开发——Android studio使用JNI调用OpenCV处理图像
知来者逆的博客
12-13 7656
在安卓里面使用OpenCV图像处理库，JNI调用C++示例
android调用jni操作指示灯
05-31
2. 在Android Studio中，创建一个新的Java类，用于调用JNI接口中的函数。在这个类中，你需要： - 加载JNI库 - 调用JNI接口中的函数，实现控制指示灯的功能 3. 在AndroidManifest.xml文件中，添加权限： ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值