###JNI数据类型
#####JNI的数据类型包含两种: 基本类型和引用类型
####基本类型 基本类型主要有jboolean, jchar, jint等, 它们和Java中的数据类型对应关系如下表所示:
Java类型 | JNI类型 | 描述 |
---|---|---|
boolean | jboolean | 无符号8位整型 |
byte | byte | 无符号8位整型 |
char | jchar | 无符号16位整型 |
short | jshort | 有符号16位整型 |
int | jint | 32位整型 |
long | jlong | 64位整型 |
float | jfloat | 32位浮点型 |
double | jdouble | 64位浮点型 |
void | void | 无类型 |
####引用类型(对象) JNI中的引用类型主要有类, 对象和数组. 它们和Java中的引用类型的对应关系如下表所示:
Java类型 | JNI类型 | 描述 |
---|---|---|
Object | jobject | Object类型 |
Class | jclass | Class类型 |
String | jstring | String类型 |
Object[] | jobjectArray | 对象数组 |
boolean[] | jbooleanArray | boolean数组 |
byte[] | jbyteArray | byte数组 |
char[] | jcharArray | char数组 |
short[] | jshortArray | short数组 |
int[] | jintArray | int数组 |
long[] | jlongArray | long数组 |
float[] | jfloatArray | float数组 |
double[] | jdoubleArray | double数组 |
Throwable | jthrowable | Throwable |
####native函数参数说明
每个native函数,都至少有两个参数(JNIEnv*,jclass或者jobject)。
1)当native方法为静态方法时: jclass 代表native方法所属类的class对象(JniTest.class)。
2)当native方法为非静态方法时: jobject 代表native方法所属的对象。
native函数的头文件可以自己写。
####关于属性与方法的签名
数据类型 | 签名 |
---|---|
boolean | Z |
byte | B |
char | C |
short | S |
int | I |
long | J |
float | F |
double | D |
ully-qualified-class | Lfully-qualified-class; |
type[] | [type |
method type | (arg-types)ret-type |
#####注意:
-
类描述符开头的 'L' 与结尾的 ';' 必须要有
-
数组描述符,开头的 '[' 必须要有
-
方法描述符规则: "(各参数描述符)返回值描述符",其中参数描述符间没有任何分隔符号
从上表可以看出, 基本数据类型的签名基本都是单词的首字母大写, 但是boolean和long除外因为B已经被byte占用, 而long也被Java类签名的占用.
对象和数组的签名稍微复杂一些.
对象的签名就是对象所属的类签名, 比如String对象, 它的签名为Ljava/lang/String; .
数组的签名为[+类型签名, 例如byte数组. 其类型为byte, 而byte的签名为B, 所以byte数组的签名就是[B.同理可以得到如下的签名对应关系:
char[] [C
float[] [F
double[] [D
long[] [J
String[] [Ljava/lang/String;
Object[] [Ljava/lang/Object;
复制代码
方法签名具体方法: 获取方法的签名比较麻烦一些,通过下面的方法也可以拿到属性的签名。 打开命令行,输入javap,出现以下信息:
上述信息告诉我们,通过以下命令就可以拿到指定类的所有属性、方法的签名了,很方便有木有?!
javap -s -p 完整类名
复制代码
我们通过cd命令,来到编译生成的class字节码文件目录(注意:非src目录。 eclipse 编译生成的class字节码文件在bin文件夹中, 而用idea编译器 编译生成的class字节码文件在out\production下),然后输入命令:
D:\IdeaProjects\jni1\out\production\jni1>javap -s -p com.haocai.jni.JniTest
复制代码
得到以下信息:
Compiled from "JniTest.java"
public class com.haocai.jni.JniTest {
public java.lang.String key;
descriptor: Ljava/lang/String;
public static int count;
descriptor: I
public com.haocai.jni.JniTest();
descriptor: ()V
public static native java.lang.String getStringFromC();
descriptor: ()Ljava/lang/String;
public native java.lang.String getString2FromC(int);
descriptor: (I)Ljava/lang/String;
public native java.lang.String accessField();
descriptor: ()Ljava/lang/String;
public native void accessStaticField();
descriptor: ()V
public native void accessMethod();
descriptor: ()V
public native void accessStaticMethod();
descriptor: ()V
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
public int genRandomInt(int);
descriptor: (I)I
public static java.lang.String getUUID();
descriptor: ()Ljava/lang/String;
static {};
descriptor: ()V
}
复制代码
#####其中,descriptor:对应的值就是我们需要的签名了,注意签名中末尾的分号 ";" 不能省略。
###C/C++访问Java的属性、方法
在JNI调用中,肯定会涉及到本地方法操作Java类中数据和方法。在Java1.0中“原始的”Java到C的绑定中,程序员可以直接访问对象数据域。然而,直接方法要求虚拟机暴露他们的内部数据布局,基于这个原因,JNI要求程序员通过特殊的JNI函数来获取和设置数据以及调用java方法。
######有以下几种情况:
1.访问Java类的非静态属性。 2.访问Java类的静态属性。 3.访问Java类的非静态方法。 4.访问Java类的静态方法。 5.间接访问Java类的父类的方法。 6.访问Java类的构造方法。
####一、访问Java的非静态属性 Java声明如下:
public String name = "kpioneer";
//访问非静态属性name,修改它的值
//accessField 自定义的一个方法
public native void accessField();
复制代码
C代码如下:
//把java中的变量name中值kpioneer 变为kpioneer Goodman
JNIEXPORT jstring JNICALL Java_com_haocai_jni_JniTest_accessField
(JNIEnv *env, jobject jobject) {
//Jclass
//jobj是t对象
jclass cls = (*env)->GetObjectClass(env, jobject);
//jfieldID
//属性名称,属性签名
jfieldID fid = (*env)->GetFieldID(env, cls, "name", "Ljava/lang/String;");
//类似于反射
//拿到jniTest(jobject) 中name的值
/*
Get<Type>Field:
GetFloatField
GetIntField
GetLongField
...
*/
jstring jstr = (*env)->GetObjectField(env, jobject, fid);
printf("jstr:%#x\n", &jstr);
//printf("jstr:%#x\n", &jstr);
//jstring -> C 字符串
boolean isCopy =NULL;
//函数内部复制了,isCopy 为JNI_TRUE,没有复制JNI_FALSE
char *c_str = (*env)->GetStringUTFChars(env, jstr, &isCopy );
//意义:isCopy为JNI_FALSE,c_str和jstr都指向同一个字符串,不能修改java字符串
char text[20] = " Goodman";
strcat(c_str, text);//拼接函数
//再把C字符串 ->jstring
jstring new_str = (*env)->NewStringUTF(env, c_str);
printf("jstr:%#x\n", &new_str);
//修改name
/*
Set<Type>Field:
SetFloatField
SetIntField
SetLongField
...
*/
(*env)->SetObjectField(env, jobject, fid, new_str);
//最后释放资源,通知垃圾回收器来回收
//良好的习惯就是,每次GetStringUTFChars,结束的时候都有一个ReleaseStringUTFChars与之呼应
(*env)->ReleaseStringUTFChars(env, jstr, c_str);
return new_str;
}
复制代码
最后在Java中测试:
public static void main(String[] args) {
JniTest jniTest = new JniTest();
System.out.println("name修改前:"+jniTest.name);
jniTest.accessField();
System.out.println("name修改后:"+jniTest.name);
}
结果输出:
name修改前:kpioneer
name修改后:kpioneer Goodman
jstr:0x27cf238 //调用的C也打印输出
jstr:0x27cf2a8
复制代码
####二、访问Java的静态属性 Java声明如下:
public static int count = 9;
public native void accessStaticField();
复制代码
C代码如下:
//访问静态属性
JNIEXPORT void JNICALL Java_com_haocai_jni_JniTest_accessStaticField
(JNIEnv *env, jobject jobj) {
//jclass
jclass cls = (*env)->GetObjectClass(env, jobj);
//jfieldID
jfieldID fid =(*env)->GetStaticFieldID(env, cls, "count", "I");
//GetStatic<Type>Field
jint count = (*env)->GetStaticIntField(env, cls, fid);
count++;
//修改
//SetStatic<Type>Field
(*env)->SetStaticIntField(env, cls, fid, count);
}
复制代码
最后在Java中测试:
public static void main(String[] args) {
JniTest jniTest= new JniTest();
System.out.println("count修改前:"+count);
jniTest.accessStaticField();
System.out.println("count修改后:"+count);
}
结果输出:
count修改前:9
count修改后:10
复制代码
####三、访问Java的非静态方法 Java声明如下:
//产生指定范围的随机数
public int genRandomInt(int max){
System.out.println("genRandomInt 执行了..");
return new Random().nextInt(max);
}
复制代码
C代码如下:
JNIEXPORT void JNICALL Java_com_haocai_jni_JniTest_accessMethod
(JNIEnv *env, jobject jobj) {
//Jclass
jclass cls = (*env)->GetObjectClass(env, jobj);
//JmethodID
jfieldID mFid = (*env)->GetMethodID(env, cls, "genRandomInt", "(I)I");
//调用
//Call<Type>Method
jint random = (*env)->CallIntMethod(env, jobj, mFid, 200);
printf("random num:%ld",random);
}
复制代码
最后在Java中测试:
public static void main(String[] args) {
JniTest jniTest= new JniTest();
jniTest.accessMethod();
}
结果输出:
genRandomInt 执行了..
random num:109
复制代码
####四、访问Java的静态方法 Java声明如下:
public static String getUUID(){
return UUID.randomUUID().toString();
}
复制代码
C代码如下:
//访问Java静态方法
JNIEXPORT void JNICALL Java_com_haocai_jni_JniTest_accessStaticMethod
(JNIEnv *env, jobject jobj) {
//Jclass
jclass cls = (*env)->GetObjectClass(env, jobj);
//JmethodID
jfieldID mFid = (*env)->GetStaticMethodID(env, cls, "getUUID", "()Ljava/lang/String;");
//调用
//CallStatic<Type>Method
jstring uuid = (*env)->CallStaticObjectMethod(env, jobj, mFid);
//随机文件名称 uuid.txt
//jstring -> char*
//isCopy JNI_FALSE,代表java和c操作的是同一个字符串
char *uuid_str = (*env)->GetStringUTFChars(env, uuid, NULL);
//拼接
char filename[100];
sprintf(filename, "D://%s.txt", uuid_str);
FILE *fp = fopen(filename, "w");
fputs("i love kpioneer", fp);
fclose(fp);
}
复制代码
最后在Java中测试:
public static void main(String[] args) {
JniTest jniTest = new JniTest();
jniTest.accessStaticMethod();.
}
复制代码
######最终在D盘目录下生成名为2fbf3e41-741b-4899-8e4e-a6a80a23a0b2(UUID随机生成) 的txt文件
####五、访问Java类的构造方法 Java声明如下:
public native long accessConstructor();
复制代码
C代码如下:
//访问Java类的构造方法
//使用java.util.Date产生一个当前的事件戳
JNIEXPORT jlong JNICALL Java_com_haocai_jni_JniTest_accesssConstructor
(JNIEnv *env, jobject jobj) {
jclass cls = (*env)->FindClass(env, "java/util/Date");
//jmethodID
jmethodID constructor_mid= (*env)->GetMethodID(env, cls,"<init>","()V");
//实例化一个Date对象(可以在constructor_mid后加参)
jobject date_obj = (*env)->NewObject(env, cls, constructor_mid);
//调用getTime方法
jmethodID mid = (*env)->GetMethodID(env, cls, "getTime", "()J");
jlong time = (*env)->CallLongMethod(env, date_obj, mid);
printf("time:%lld\n",time);
return time;
}
复制代码
最后在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 = jniTest.accessConstructor();
System.out.println(time);
}
结果输出:
1509688828013
1509688828013
time:1509688828013
复制代码
####六、间接访问Java类的父类的方法 Java代码如下: 父类:
public class Human {
public void sayHi(){
System.out.println("人类打招乎(父类)");
}
}
复制代码
子类:
public class Man extends Human {
@Override
public void sayHi() {
System.out.println("男人打招乎");
}
}
复制代码
在TestJni类中有Human方法声明:
public Human human = new Man();
public native void accessNonvirtualMethod();
复制代码
如果是直接使用human .sayHi()的话,其实访问的是子类Man的方法 但是通过底层C的方式可以间接访问到父类Human的方法,跳过子类的实现,甚至你可以直接哪个父类(如果父类有多个的话),这是Java做不到的。
下面是C代码实现,无非就是属性和方法的访问:
//调用父类的方法
JNIEXPORT void JNICALL Java_com_haocai_jni_JniTest_accessNonvirtualMethod
(JNIEnv *env, jobject jobj) {
jclass cls = (*env)->GetObjectClass(env, jobj);
//获取man属性(对象)
jfieldID fid = (*env)->GetFieldID(env, cls, "human", "Lcom/haocai/jni/Human;");
//获取
jobject human_obj = (*env)->GetObjectField(env, jobj, fid);
//执行sayHi方法
jclass human_cls = (*env)->FindClass(env, "com/haocai/jni/Human");
jmethodID mid = (*env)->GetMethodID(env, human_cls, "sayHi", "()V");
//执行Java相关的子类方法
(*env)->CallObjectMethod(env, human_obj, mid);
//执行Java相关的父类方法
(*env)->CallNonvirtualObjectMethod(env, human_obj, human_cls, 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 jniTest = new JniTest();
jniTest.human.sayHi();
jniTest.accessNonvirtualMethod();
}
结果输出:
男人打招乎
男人打招乎
人类打招乎(父类)
复制代码
####实际案例---用JNI方法和属性访问解决中文编码乱码问题 中文乱码
char *cOutStr = "李四";
string jstr = (*env)->NewStringUTF(env, cOutStr);
return jstr; 直接返回会有中文乱码问题
复制代码
######原因分析,调用NewStringUTF的时候,产生的是UTF-16的字符串,但是我们需要的时候UTF-8字符串。
#####如果使用C语言方法解决中文编码问题,代码行数多(几百行+),且容易产生问题。所以直接通过Java 中的String(byte bytes[],String charsetName)构造方法来进行字符集变换,解决该问题。
Java声明如下:
public native String chineseChars(String str);
复制代码
C代码如下:
JNIEXPORT jstring JNICALL Java_com_haocai_jni_JniTest_chineseChars
(JNIEnv *env, jobject jobj,jstring in) {
//输出
char *cStr = (*env)->GetStringUTFChars(env, in, JNI_FALSE);
printf("C %s\n", cStr);
//c -> jstring
char *cOutStr = "李四";
//jstring jstr = (*env)->NewStringUTF(env, cOutStr);
//return jstr; 直接返回会有中文乱码问题
//解决中文乱码问题
//执行java 中String(byte bytes[],String charsetName);
//1.jmethodID
//2.byte数组
//3.字符编码
jstring str_cls = (*env)->FindClass(env, "java/lang/String");
//构造方法用<init>
jmethodID construvtor_mid = (*env)->GetMethodID(env, str_cls, "<init>", "([BLjava/lang/String;)V");
//jbyte-> char
//jbyteArray -> char[]
jbyteArray bytes = (*env)->NewByteArray(env, strlen(cOutStr));
//byte数组赋值
//从0到strlen(cOutStr),从头到尾
(*env)->SetByteArrayRegion(env,bytes,0,strlen(cOutStr), cOutStr);
//字符编码jstring
jstring charsetName = (*env)->NewStringUTF(env, "GB2312");
//调用构造函数,返回编码之后的jstring
return (*env)->NewObject(env,str_cls, construvtor_mid,bytes, charsetName);
}
复制代码
最后在Java中测试:
public static void main(String[] args) {
JniTest jniTest = new JniTest();
String outStr = jniTest.chineseChars("张三");
System.out.println("中文输出:"+outStr);
}
结果输出:
中文输出:李四
C 张三
复制代码
####总结
- #####1.C/C++完成的功能并不是所有代码一定要C/C++语句写,有时候C/C++可以调用现成的Java方法或属性解决问题,能起到事半功倍的作用。
- #####2.属性、方法的访问的使用是和Java的反射相类似。
特别感谢: 动脑学院Jason