Android NDK开发之旅10 JNI JNI数据类型与方法属性访问

###JNI数据类型

####基本数据 Java基本数据类型与JNI数据类型的映射关系

Java类型->JNI类型->C类型
复制代码

JNI的基本数据类型有（左边是Java，右边是JNI）：

boolean 			jboolean
byte 				jbyte
char 				jchar
short 				jshort
int 				jint
long 				jlong
float 				jfloat
double 				jdouble
void 				void
复制代码

####引用类型(对象)

String 				jstring
Object 				jobject

数组,基本数据类型的数组
byte[]				jByteArray
对象数组
object[](String[]) 	jobjectArray
复制代码

###native函数参数说明

每一个native函数，都至少有两个参数（JNIEnv*,jclass或者jobject)。

1）当native方法为静态方法时： jclass 表明native方法所属类的class对象(JniTest.class)。

2）当native方法为非静态方法时： jobject 表明native方法所属的对象。

######native函数的头文件能够本身写。

###关于属性与方法的签名

####1、属性的签名

属性的签名其实就是属性的类型的简称，对应关系以下：

尤为注意的是，类的签名格式就是：

L完整包名;
复制代码

其中完整包名用 / 代替.

末尾的 ; 不能省略

数组的签名就是：

[类型签名
复制代码

其中，多为数组就用多个[

####2、方法的签名

获取方法的签名比较麻烦一些，经过下面的方法也能够拿到属性的签名。

打开命令行，输入javap，出现如下信息：

上述信息告诉咱们，经过如下命令就能够拿到指定类的全部属性、方法的签名了，很方便有木有？！

javap -s -p 完整类名
复制代码

咱们经过cd命令，来到Java工程的bin目录，而后输入命令：

D:\WebPrj\TestJni\bin>javap -s -p com.test.JniTest
Compiled from "JniTest.java"
public class com.test.JniTest {
  public java.lang.String str;
    descriptor: Ljava/lang/String;
  public static int NUM;
    descriptor: I
  static {};
    descriptor: ()V

  public com.test.JniTest();
    descriptor: ()V

  public static native java.lang.String getStringFromC();
    descriptor: ()Ljava/lang/String;

  public native void accessField();
    descriptor: ()V

  public native void accessStaticField();
    descriptor: ()V

  public int genRandomInt(int);
    descriptor: (I)I

  public native void accessMethod();
    descriptor: ()V

  public native void accessStaticMethod();
    descriptor: ()V

  public static java.lang.String getUUID();
    descriptor: ()Ljava/lang/String;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
}
复制代码

其中，descriptor就是咱们须要的签名了，注意签名中末尾的分号不能省略。

方法签名的规律就是，括号不能够省略：

(参数类型签名)返回值类型签名
复制代码

###C/C++访问Java的属性、方法

有如下几种状况：

1. 访问Java类的非静态属性。
2. 访问Java类的静态属性。
3. 访问Java类的非静态方法。
4. 访问Java类的静态方法。
5. 间接访问Java类的父类的方法。
6. 访问Java类的构造方法。

####1、访问Java的非静态属性

Java方法中，经过调用accessField，利用C修改静态属性

public String str = "Li lu";

//访问非静态属性str，修改它的值
public native void accessField();
复制代码

C代码以下：（头文件能够不写，直接写实现）

JNIEXPORT void JNICALL Java_com_test_JniTest_accessField
(JNIEnv * env, jobject jobj){

	//经过对象拿到Class
	jclass clz = (*env)->GetObjectClass(env, jobj);
	//拿到对应属性的ID
	jfieldID fid = (*env)->GetFieldID(env, clz, "str", "Ljava/lang/String;");
	//经过属性ID拿到属性的值
	jstring jstr = (*env)->GetObjectField(env, jobj, fid);

	//经过Java字符串拿到C字符串，第三个参数是一个出参，用来告诉咱们GetStringUTFChars内部是否复制了一份字符串
	//若是没有复制，那么出参为isCopy，这时候就不能修改字符串的值了，由于Java中常量池中的字符串是不容许修改的（可是jstr能够指向另一个字符串）
	char* cstr = (*env)->GetStringUTFChars(env, jstr, NULL);
	//在C层修改这个属性的值
	char res[20] = "I love you : ";
	strcat(res, cstr);

	//从新生成Java的字符串，而且设置给对应的属性
	jstring jstr_new = (*env)->NewStringUTF(env, res);
	(*env)->SetObjectField(env, jobj, fid, jstr_new);

	//最后释放资源，通知垃圾回收器来回收
	//良好的习惯就是，每次GetStringUTFChars，结束的时候都有一个ReleaseStringUTFChars与之呼应
	(*env)->ReleaseStringUTFChars(env, jstr, cstr);
}
复制代码

最后在Java中测试：

public static void main(String[] args) {

	JniTest test = new JniTest();
	System.out.println(test.str);
	//修改非静态属性str
	test.accessField();
	System.out.println(test.str);
	
}
复制代码

####2、访问Java的静态属性

Java代码以下：

//访问静态属性NUM，修改它的值
public static int NUM = 1;

public native void accessStaticField();
复制代码

C代码以下：

JNIEXPORT void JNICALL Java_com_test_JniTest_accessStaticField
(JNIEnv * env, jobject jobj){
	//与上面相似，只不过是某些方法须要加上Static
	jclass clz = (*env)->GetObjectClass(env, jobj);
	jfieldID fid = (*env)->GetStaticFieldID(env, clz, "NUM", "I");
	jint jInt = (*env)->GetStaticIntField(env, clz, fid);
	jInt++;
	(*env)->SetStaticIntField(env, clz, fid, jInt);
}
复制代码

最后在Java中测试：

public static void main(String[] args) {
	
	JniTest test = new JniTest();
	System.out.println(NUM);
	test.accessStaticField();
	System.out.println(NUM);

}
复制代码

####3、访问Java的非静态方法

Java代码以下，经过调用accessMethod，在底层用C语言调用genRandomInt方法

//产生指定范围的随机数
public int genRandomInt(int max){
	System.out.println("genRandomInt 执行了...max = "+ max);
	return new Random().nextInt(max); 
}

public native void accessMethod();
复制代码

C代码以下：

JNIEXPORT void JNICALL Java_com_test_JniTest_accessMethod
(JNIEnv * env, jobject jobj){
	jclass clz = (*env)->GetObjectClass(env, jobj);
	//拿到方法的ID，最后一个参数是方法的签名
	jmethodID mid = (*env)->GetMethodID(env, clz, "genRandomInt", "(I)I");
	//调用该方法，最后一个是可变参数，就是调用该方法所传入的参数
	//套路是若是返回是：Call返回类型Method
	jint jInt = (*env)->CallIntMethod(env, jobj, mid, 100);
	printf("output from C ： %d", jInt);
}
复制代码

最后在Java中测试：

public static void main(String[] args) {
	
	JniTest test = new JniTest();
	test.accessMethod();

}
复制代码

####4、访问Java的静态方法

Java代码以下，经过调用accessStaticMethod，在底层用C语言调用getUUID方法

public native void accessStaticMethod();

//产生UUID字符串
public static String getUUID(){
	System.out.println("getUUID 执行了...");
	return UUID.randomUUID().toString();
}
复制代码

C代码以下：

JNIEXPORT void JNICALL Java_com_test_JniTest_accessStaticMethod
(JNIEnv * env, jobject jobj){
	jclass clz = (*env)->GetObjectClass(env, jobj);
	jmethodID mid = (*env)->GetStaticMethodID(env, clz, "getUUID", "()Ljava/lang/String;");

	//调用java的静态方法，拿到返回值
	jstring jstr = (*env)->CallStaticObjectMethod(env, clz, mid);

	//把拿到的Java字符串转换为C的字符串
	char* cstr= (*env)->GetStringUTFChars(env, jstr, NULL);

	//后续操做，产生以UUID为文件名的文件
	char fielName[100];
	sprintf(fielName, "D:\\%s.txt", cstr);
	FILE* f = fopen(fielName, "w");
	fputs(cstr, f);
	fclose(f);

	printf("output from C : File had saved", jstr);
}
复制代码

最后在Java中测试：

public static void main(String[] args) {

	JniTest test = new JniTest();
	test.accessStaticMethod();

}
复制代码

####5、间接访问Java类的父类的方法

Java代码以下：

父类：

package com.test;

public class Human {
	protected void speek() {
		System.out.println("Human Speek");
	}	
}
复制代码

子类：

package com.test;

public class Man extends Human {
	@Override
	protected void speek() {
		// 能够经过super关键字来访问父类的方法
		// super.speek();
		System.out.println("Man Speek");
	}
}
复制代码

在TestJni类中有Human属性：

//父类的引用指向子类的对象
Human man= new Man();

public native void accessNonvirtualMethod();
复制代码

若是是直接使用man.speek()的话，访问的是子类Man的方法 可是经过底层C的方式能够间接访问到父类Human的方法，跳过子类的实现，甚至你能够直接哪一个父类（若是父类有多个的话），这是Java作不到的。

下面是C代码实现，无非就是属性和方法的访问：

JNIEXPORT void JNICALL Java_com_test_JniTest_accessNonvirtualMethod
(JNIEnv * env, jobject jobj){
	//先拿到属性man
	jclass clz=(*env)->GetObjectClass(env, jobj);
	jfieldID fid = (*env)->GetFieldID(env, clz, "man", "Lcom/test/Human;");
	jobject man = (*env)->GetObjectField(env, jobj, fid);

	//拿到父类的类，以及speek的方法id
	jclass clz_human = (*env)->FindClass(env, "com/test/Human");
	jmethodID mid = (*env)->GetMethodID(env, clz_human, "speek", "()V");

	//调用本身的speek实现
	(*env)->CallVoidMethod(env, man, mid);
	//调用父类的speek实现
	(*env)->CallNonvirtualVoidMethod(env, man, clz_human, mid);
}
复制代码

1. 当有这个类的对象的时候，使用(*env)->GetObjectClass()，至关于Java中的test.getClass()
2. 当有没有这个类的对象的时候，(*env)->FindClass()，至关于Java中的Class.forName("com.test.TestJni")

这里直接使用CallVoidMethod，虽然传进去的是父类的Method ID，可是访问的让然是子类的实现。

最后，经过CallNonvirtualVoidMethod，访问不覆盖的父类方法（C++使用virtual关键字来覆盖父类的实现），固然你也能够指定哪一个父类（若是有多个父类的话）。

最后在Java中测试：

public static void main(String[] args) {

	JniTest test = new JniTest();
	//这时候是调用子类Man的方法
	test.man.speek();
	//可是经过JNI的方式，能够访问到父类的speek方法
	test.accessNonvirtualMethod();

}
复制代码

####6、访问Java类的构造方法

Java代码以下，经过调用accessConstructor，在底层用C语言调用java.util.Date产生一个当前的时间戳，而且返回。

//调用Date的构造函数
public native long accessConstructor();
复制代码

C代码以下：

JNIEXPORT jlong JNICALL Java_com_test_JniTest_accessConstructor
(JNIEnv * env, jobject jobj){

	jclass clz_date = (*env)->FindClass(env, "java/util/Date");
	//构造方法的函数名的格式是：<init>
	//不能写类名，由于构造方法函数名都同样区分不了，只能经过参数列表（签名）区分
	jmethodID mid_Date = (*env)->GetMethodID(env, clz_date, "<init>", "()V");;

	//调用构造函数
	jobject date = (*env)->NewObject(env, clz_date, mid_Date);

	//注意签名，返回值long的属性签名是J
	jmethodID mid_getTime= (*env)->GetMethodID(env, clz_date, "getTime", "()J");
	//调用getTime方法
	jlong jtime = (*env)->CallLongMethod(env, date, mid_getTime);

	return jtime;
}
复制代码

最后在Java中测试：

public static void main(String[] args) {

	JniTest test = new JniTest();
	//直接在Java中构造Date而后调用getTime
	Date date = new Date();
	System.out.println(date.getTime());
	//经过C语音构造Date而后调用getTime
	long time = test.accessConstructor();
	System.out.println(time);

}
复制代码

####总结

属性、方法的访问的使用是和Java的反射API相似的。

###综合进阶案例——JNI返回中文乱码问题

测试乱码问题：

public native void testChineseIn(String chinese);//传进去
public native String testChineseOut();//取出来会乱码

public static void main(String[] args) {

	//传中文进去，而后转为C字符串，直接在C层输出是没有问题的
	JniTest test = new JniTest();
	test.testChineseIn("我爱你");
	//C层将C字符串转换为JavaString而后输出，就会乱码
	System.out.println(test.testChineseOut());

}
复制代码

C代码以下：

JNIEXPORT void JNICALL Java_com_test_JniTest_testChineseIn
(JNIEnv * env, jobject jobj, jstring chinese){

	char* c_chinese = (*env)->GetStringUTFChars(env, chinese, NULL);
	printf("%s", c_chinese);
}

JNIEXPORT jstring JNICALL Java_com_test_JniTest_testChineseOut
(JNIEnv * env, jobject jobj){

	char* c_str = "我爱你";
	jstring j_str = (*env)->NewStringUTF(env, c_str);
	return j_str;
}
复制代码

结果输出，其中第一条是C返回的乱码，第二条是传进去在C层打印的结果：

ÎҰ®Ä
我爱你
复制代码

######能够看到C执行的速度要比Java快。

#####缘由分析，调用NewStringUTF的时候，产生的是UTF-16的字符串，可是咱们须要的时候UTF-8字符串。

解决办法，经过Java的String类的构造方法来进行字符集变换。

JNIEXPORT jstring JNICALL Java_com_test_JniTest_testChineseOut
(JNIEnv * env, jobject jobj){

	//须要返回的字符串
	char* c_str = "我爱你";
	//jstring j_str = (*env)->NewStringUTF(env, c_str);

	//经过调用构造方法String string = new String(byte[], charsetName);来解决乱码问题

	//0.找到String类
	jclass clz_String =  (*env)->FindClass(env, "java/lang/String");
	jmethodID mid = (*env)->GetMethodID(env, clz_String, "<init>", "([BLjava/lang/String;)V");

	//准备new String的参数：byte数组以及字符集
	//1.建立字节数组，而且将C的字符串拷贝进去
	jbyteArray j_byteArray = (*env)->NewByteArray(env, strlen(c_str));
	(*env)->SetByteArrayRegion(env, j_byteArray, 0, strlen(c_str), c_str);
	//2.建立字符集的参数，这里用Windows的more字符集GB2312
	jstring charsetName = (*env)->NewStringUTF(env, "GB2312");

	//调用
	jstring j_new_str = (*env)->NewObject(env, clz_String, mid, j_byteArray, charsetName);
	return j_new_str;

}
复制代码

若是以为个人文字对你有所帮助的话，欢迎关注个人公众号：

个人群欢迎你们进来探讨各类技术与非技术的话题，有兴趣的朋友们加我私人微信huannan88，我拉你进群交（♂）流（♀）。