JNI/NDK入门指南之C/C++结构体和Java对象转换方式二
JNI/NDK入门指南之C/C++结构体和Java对象转换方式二
Android JNI/NDK入门指南目录
JNI/NDK入门指南之正确姿势了解JNI和NDK
JNI/NDK入门指南之JavaVM和JNIEnv
JNI/NDK入门指南之JNI数据类型，描述符详解
JNI/NDK入门指南之jobject和jclass
JNI/NDK入门指南之javah和javap的使用和集成
JNI/NDK入门指南之Eclipse集成NDK开发环境并使用
JNI/NDK入门指南之JNI动/静态注册全分析
JNI/NDK入门指南之JNI字符串处理
JNI/NDK入门指南之JNI访问数组
JNI/NDK入门指南之C/C++通过JNI访问Java实例属性和类静态属性
JNI/NDK入门指南之C/C++通过JNI访问Java实例方法和类静态方法
JNI/NDK入门指南之JNI异常处理
JNI/NDK入门指南之JNI多线程回调Java方法
JNI/NDK入门指南之正确姿势了解，使用，管理，缓存JNI引用
JNI/NDK入门指南之调用Java构造方法和父类实例方法
JNI/NDK入门指南之C/C++结构体和Java对象转换方式一
JNI/NDK入门指南之C/C++结构体和Java对象转换方式二
引言
在前面的篇章C/C++结构体和Java对象之间通过Jni相互转换方式一中已经介绍了一种方法，可能有些对Android源码或者Jni比较熟悉的读者会说，在源码里面很少会用到前面的方法，而是通过Jni里面的jfieldID和jmethodID直接操作Java对象来进行相转换。下面开启本篇介绍之旅，方式二介绍。
一.方法介绍
在这里将要使用到是比较传统的方法，借助NDK中jni.h头文件中定义的方法，直接操作通过Jni传递过来的Java层的Object对象，获取object中jfieldID域值然后赋值到C/C++中Struct结构体中这样就完成了Java对象对C/C++结构体的转换。然后对Object中的jfieldID域进行相关的赋值操作，这样就完成了相关的相互的转换。
二.具体步骤
在前面的章节已经介绍了，具体使用什么方法。那么在本章节里面将介绍具体的步骤，那么，下面来开始我们的介绍。
2.1 需要转换的数据
本篇的标题是C/c++结构体和Java对象之间的转换，那么下面介绍我们要相互转换的数，这里只是为了做演示使用，至于数据还可以进行扩展，或者学完此种方法以后读者也可以亲自操作实践一把。
(1) C/C++结构体
//对应om.xxx.object2struct.JavaBean的数据
typedef struct{
bool boolValue; //boolean
char charValue; //char
double doubleValue; //double
int intValue; //int
char arrayValue[4]; //byte[]
int double_dimen_array[2][2]; // int[][]
const char * stringValue;
const char * message; // String
}JNI_JavaBean;
//对应com.xxx.object2struct.JavaBean$InnerClass的域和方法
typedef struct{
jclass clazz;
jfieldID message;
jmethodID constructor;
}InnerClass_t;
//对应com.xxx.object2struct.JavaBean的域和方法
typedef struct {
jclass clazz;
jfieldID boolValue;
jfieldID charValue;
jfieldID doubleValue;
jfieldID intVaule;
jfieldID byteArray;
jfieldID double_dimen_array;
jfieldID stringValue;
jfieldID inner_message;
jmethodID constructor;
}JavaBean_t;
(2) Java类
package com.xxx.object2struct;
public class JavaBean {
public boolean boolValue = false; // boolean类型
public char charValue = 'A'; // char类型
public double doubleValue = 100; // double类型
public int intValue = 100; // 整形
public byte[] array = {
0, 1, 2, 3}; // byte数组
public int[][] mDoubleDimenArray = {
{
10,10},
{
20,20}
}; // 二维数组
public String stringValue = "Hello!";
public InnerClass mInnerClass = new InnerClass(); // 静态内部类
static class InnerClass {
public String mMessage = "Im from Java!";// 字符串
@Override
public String toString() {
return "InnerClass [mMessage=" + mMessage + "]";
}
}
@Override
public String toString() {
return "JavaBean [boolValue=" + boolValue + ", charValue=" + charValue
+ ", doubleValue=" + doubleValue + ", intValue=" + intValue
+ ", array=" + array.toString() + ", mDoubleDimenArray="
+ mDoubleDimenArray.toString() + ", stringValue=" + stringValue
+ ", mInnerClass=" + mInnerClass + "]";
}
}
2.2 具体实现
前面的章节介绍了，需要转换的数据，那么在这个章节将要介绍具体的步骤。
2.2.1 Jni接口的定义
public class JniTransfer {
// 将C/C++结构体转为Java类
public static native JavaBean getJavaBeanFromNative();
//将Java对象转换成C/C++结构体
public static native void transferJavaBeanToNative(JavaBean javaBean);
// 加载jni库
static {
System.loadLibrary("java2native-transfer");
}
}
2.2.2 Java端的实现
这个比较简单，主要就是通过Jni将Java对象传递到Jni层进行相关的转换，然后加以打印。就不加以赘述了，因为确实代码量比较少太简单，我想讲解也没有啥好讲解的。
private void getJavaBeanFromC() {
JavaBean javaBean = JniTransfer.getJavaBeanFromNative();
Log.d("JniTransfer", javaBean.toString());
}
private void javaBeanToStruct() {
JavaBean javaBean = new JavaBean();
JniTransfer.transferJavaBeanToNative(javaBean);
}
2.2.3 Jni端的实现
这个比前面的第一种方法要复杂一点，因为涉及到本地Native方法的注册，相关类信息的注册。下面我们就一个步骤一个步骤的类详细介绍：
2.2.3.1 Jni动态注册
static JNINativeMethod gMethods[] = {
{
"getJavaBeanFromNative", "()Lcom/xxx/object2struct/JavaBean;",(void*)Java_com_xxx_object2struct_JniTransfer_getJavaBeanFromNative },
{
"transferJavaBeanToNative", "(Lcom/xxx/object2struct/JavaBean;)V",(void*)Java_com_xxx_object2struct_JniTransfer_transferJavaBeanToNative },
};
//动态注册Native方法
static int register_native_interface(JNIEnv * env){
jclass clazz;
clazz = env->FindClass(kClassPathName);
if(clazz == NULL)
return JNI_FALSE;
if (env->RegisterNatives(clazz, gMethods, sizeof(gMethods) / sizeof(gMethods[0])) < 0){
return JNI_FALSE;
}
return JNI_TRUE;
}
jint JNI_OnLoad(JavaVM * vm, void * reserved){
JNIEnv * env = NULL;
jint result = -1;
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE(TAG, "ERROR: GetEnv failed\n");
goto bail;
}
assert(env != NULL);
if (register_native_interface(env) < 0) {
LOGE(TAG,"ERROR: native registration failed\n");
goto bail;
}
register_classes(env);
result = JNI_VERSION_1_4;
bail:
return result;
}
2.2.3.2 注册类信息
static JavaBean_t javaBean_t;
static InnerClass_t innerClass_t;
#define ARRAY_LEN(x) ((int) (sizeof(x) / sizeof((x)[0])))
static int dump_JavaBean_Info(JNI_JavaBean * javaBean){
int i =0;
int lenght = 0;
LOGE(TAG, "+++ dump javaBean info start +++\n");
LOGE(TAG, "+++ boolValue : %d +++\n", javaBean->boolValue);
LOGE(TAG, "+++ charValue : %c +++\n", javaBean->charValue);
LOGE(TAG, "+++ doubleVaule : %lf +++\n", javaBean->doubleValue);
LOGE(TAG, "+++ intValue : %d +++\n", javaBean->intValue);
lenght = ARRAY_LEN(javaBean->arrayValue);
for(i = 0; i < lenght; i++)
{
LOGE(TAG, "+++ byte[%d] : %d +++\n", i, javaBean->arrayValue[i]);
}
for(i =0 ; i <2; i++){
for(int j = 0; j <2; j++)
{
LOGE(TAG, "+++ byte[%d] : %d +++\n", i, javaBean->arrayValue[i]);
LOGE(TAG, "+++ double[%d][%d]: %d +++\n", i, j, javaBean->double_dimen_array[i][j]);
}
}
LOGE(TAG, "+++ stringValue : %s +++\n", javaBean->stringValue);
LOGE(TAG, "+++ inner_message : %s +++\n", javaBean->message);
LOGE(TAG, "+++ dump javaBean info end +++\n");
}
static int find_class(JNIEnv * env, const char *className, jclass * classOut)
{
jclass clazz = env->FindClass(className);
if(clazz == NULL)
{
LOGE(TAG,"Can't find %s\n", className);
return -1;
}
*classOut = (jclass) env->NewGlobalRef(clazz); // 这里必须新建一个全局的引用
return 0;
}
static int get_field(JNIEnv * env, jclass clazz, const char *name, const char *sig, jfieldID * field_out)
{
jfieldID filed = env->GetFieldID(clazz, name, sig);
if (filed == NULL) {
LOGE(TAG, "Can't find. filed name: %s, sig: %s", name, sig);
return -1;
}
*field_out = filed;
return 0;
}
static void register_inner_class(JNIEnv * env)
{
int ret = find_class(env, "com/xxx/object2struct/JavaBean$InnerClass", &innerClass_t.clazz);
if(ret != 0)
{
LOGE(TAG,"register_inner_class failed, please check you code!\n");
return;
}
jclass inner_clazz = innerClass_t.clazz;
// 获取构造方法
innerClass_t.constructor = env->GetMethodID(inner_clazz, "" , "()V");
// 获取成员
get_field(env, inner_clazz, "mMessage", "Ljava/lang/String;", &innerClass_t.message);
}
static void register_javaBean_class(JNIEnv * env)
{
int ret = find_class(env, "com/xxx/object2struct/JavaBean", &javaBean_t.clazz);
if(ret != 0)
{
LOGE(TAG,"register_JavaBean_class failed, please check you code!\n");
return;
}
jclass javaBean_clazz = javaBean_t.clazz;
//在Jni中获取构造方法
javaBean_t.constructor = env->GetMethodID(javaBean_clazz, "" , "()V");
//获取成员方法
//Signature: (ZCDI[B[[ILjava/lang/String;)V
get_field(env, javaBean_clazz, "boolValue", "Z", &javaBean_t.boolValue);
get_field(env, javaBean_clazz, "charValue", "C", &javaBean_t.charValue);
get_field(env, javaBean_clazz, "doubleValue", "D", &javaBean_t.doubleValue);
get_field(env, javaBean_clazz, "intValue", "I", &javaBean_t.intVaule);
get_field(env, javaBean_clazz, "array", "[B", &javaBean_t.byteArray);
get_field(env, javaBean_clazz, "mDoubleDimenArray", "[[I", &javaBean_t.double_dimen_array);
get_field(env, javaBean_clazz, "stringValue", "Ljava/lang/String;", &javaBean_t.stringValue);
get_field(env, javaBean_clazz, "mInnerClass", "Lcom/xxx/object2struct/JavaBean$InnerClass;", &javaBean_t.inner_message);
}
static void register_classes(JNIEnv* env)
{
register_javaBean_class(env);
register_inner_class(env);
}
2.2.3.3 Java对象转换成C/C++结构体
/**
java class use jni transfer to c struct
**/
static void javaBean_java_2_c(JNIEnv *env , jobject javaBean_in, JNI_JavaBean * jni_JavaBean_out)
{
if(javaBean_in == NULL)
{
LOGE(TAG,"javaBean_in is NULL, please check you input or code!\n");
return;
}
LOGE(TAG,"Start javaBean_java_2_c fun\n");
//get boolValue
jni_JavaBean_out->boolValue = env->GetBooleanField(javaBean_in, javaBean_t.boolValue);
//get charValue
jni_JavaBean_out->charValue = env->GetCharField(javaBean_in, javaBean_t.charValue);
//get doubleValue
jni_JavaBean_out->doubleValue = env->GetDoubleField(javaBean_in, javaBean_t.doubleValue);
//get intValue
jni_JavaBean_out->intValue = env->GetIntField(javaBean_in, javaBean_t.intVaule);
//get byte array
jbyteArray byteArray = (jbyteArray)env->GetObjectField(javaBean_in, javaBean_t.byteArray);
jbyte * byte_data = env->GetByteArrayElements(byteArray, 0);
jsize length = env->GetArrayLength(byteArray);
LOGE(TAG,"The byteArray len : %d\n", length);
//copy data
memcpy(jni_JavaBean_out->arrayValue, byte_data, length * sizeof(jbyte));
//get double dimen int array
jobjectArray objectArray = (jobjectArray)env->GetObjectField(javaBean_in, javaBean_t.double_dimen_array);
length = env->GetArrayLength(objectArray);
LOGE(TAG,"doublemin int array len : %d\n", length);
for(int i = 0; i < length; i++)
{
jintArray intArray = (jintArray)env->GetObjectArrayElement(objectArray, i);
jint * sub_int = env->GetIntArrayElements(intArray, 0);
jsize sub_len = env->GetArrayLength(intArray); // 获取列数
LOGE(TAG,"sub_len: %d", sub_len);
memcpy(jni_JavaBean_out->double_dimen_array[i], sub_int, sub_len * sizeof(jint));
env->ReleaseIntArrayElements(intArray, sub_int, 0);
}
//get stringValue
LOGE(TAG,"get StringValue\n");
jstring stringValue = (jstring)env->GetObjectField(javaBean_in, javaBean_t.stringValue);
jni_JavaBean_out->stringValue = env->GetStringUTFChars(stringValue, 0);
//get inner class data
LOGE(TAG,"get inner class data\n");
jobject inner_object = env->GetObjectField(javaBean_in, javaBean_t.inner_message);
jstring message = (jstring)env->GetObjectField(inner_object, innerClass_t.message);
jni_JavaBean_out->message = env->GetStringUTFChars(message, 0);
}
2.2.3.4 C/C++结构体转换为Java对象
/**
c struct use jni transfer to java class
**/
static jobject javaBean_c_2_java(JNIEnv *env , JNI_JavaBean * jni_JavaBean)
{
if(jni_JavaBean == NULL)
{
LOGE(TAG,"javaBean_c_2_java failed, jni_JavaBean is NULL\n");
return NULL;
}
LOGE(TAG,"javaBean_c_2_java\n");
LOGE(TAG,"innerObject\n");
//1.create InnerClass class
jobject innerObject = env->NewObject(innerClass_t.clazz, innerClass_t.constructor);
jstring message = env->NewStringUTF(jni_JavaBean->message);
env->SetObjectField(innerObject, innerClass_t.message, message);
LOGE(TAG,"javaBeanObject\n");
//2.create JavaBean class
jobject javaBeanObject = env->NewObject(javaBean_t.clazz, javaBean_t.constructor);
//set boolValue
env->SetBooleanField(javaBeanObject, javaBean_t.boolValue, jni_JavaBean->boolValue);
LOGE(TAG,"set charValue\n");
//set charValue
env->SetCharField(javaBeanObject, javaBean_t.charValue, jni_JavaBean->charValue);
LOGE(TAG,"set doubleVaule\n");
//set doubleVaule
env->SetDoubleField(javaBeanObject, javaBean_t.doubleValue, jni_JavaBean->doubleValue);
LOGE(TAG,"set intValue\n");
//set intValue
env->SetIntField(javaBeanObject, javaBean_t.intVaule, jni_JavaBean->intValue);
LOGE(TAG,"set StringValue\n");
//set StringValue
jstring stringValue = env->NewStringUTF(jni_JavaBean->stringValue);
env->SetObjectField(javaBeanObject, javaBean_t.stringValue, stringValue);
LOGE(TAG,"set byte[] array\n");
//set byte[] array
jsize length = ARRAY_LEN(jni_JavaBean->arrayValue);
LOGE(TAG,"The byteArray len : %d\n", length);
jbyteArray byteArray = env->NewByteArray(length);
env->SetByteArrayRegion(byteArray, 0, length, (jbyte *)jni_JavaBean->arrayValue);
env->SetObjectField(javaBeanObject, javaBean_t.byteArray, byteArray);
LOGE(TAG,"set double dimen int array\n");
//set double dimen int array
//设置二维数组的时候需要要一定的技巧性
length = ARRAY_LEN(jni_JavaBean->double_dimen_array);
LOGE(TAG,"The double_dimen_array : %d\n", length);
jclass clazz = env->FindClass("[I");//一维数组的类
jobjectArray double_int_array = env->NewObjectArray(length, clazz, NULL);
for(int i = 0; i < length; i++)
{
jsize sub_len = ARRAY_LEN(jni_JavaBean->double_dimen_array[i]);
LOGE(TAG,"The sub[%d] len: %d\n", i, sub_len);
jintArray intArray = env->NewIntArray(sub_len);
env->SetIntArrayRegion(intArray, 0, sub_len, jni_JavaBean->double_dimen_array[i]);
env->SetObjectArrayElement(double_int_array, i, intArray);
}
env->SetObjectField(javaBeanObject, javaBean_t.double_dimen_array, double_int_array);
//set innerClass
env->SetObjectField(javaBeanObject, javaBean_t.inner_message, innerObject);
return javaBeanObject;
}
2.2.3.5 具体使用
/*
* Class: com_xxx_object2struct_JniTransfer
* Method: getJavaBeanFromNative
* Signature: ()Lcom/xxx/object2struct/JavaBean;
*/
JNIEXPORT jobject JNICALL Java_com_xxx_object2struct_JniTransfer_getJavaBeanFromNative
(JNIEnv * env, jclass clazz)
{
JNI_JavaBean javaBean= {
true,
'c',
1,
2,
{
1, 2, 3, 4},
{
{
5,6},
{
7,8}
},
"Im StringValue",
"Im message",
};
dump_JavaBean_Info(&javaBean);
jobject obj = javaBean_c_2_java(env, &javaBean);
return obj;
}
/*
* Class: com_xxx_object2struct_JniTransfer
* Method: transferJavaBeanToNative
* Signature: (Lcom/xxx/object2struct/JavaBean;)V
*/
JNIEXPORT void JNICALL Java_com_xxx_object2struct_JniTransfer_transferJavaBeanToNative
(JNIEnv * env, jclass clazz, jobject object)
{
JNI_JavaBean jni_JavaBean;
javaBean_java_2_c(env, object, &jni_JavaBean);
dump_JavaBean_Info(&jni_JavaBean);
}
三.成果演示
在前面的章节里面，我们将原理和步骤都已经交代和讲解OK了，那么到了最终的步骤了就是见证奇迹的时刻到了，看下我们的效果。是不是已经OK了.
λ adb logcat -s JniTransfer
--------- beginning of main
--------- beginning of system
12-02 17:13:39.640 27863 27911 E JniTransfer: getJavaBeanFromC
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ dump javaBean info start +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ boolValue : 1 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ charValue : c +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ doubleVaule : 1.000000 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ intValue : 2 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[0] : 1 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[1] : 2 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[2] : 3 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[3] : 4 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[0] : 1 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ double[0][0]: 5 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[0] : 1 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ double[0][1]: 6 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[1] : 2 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ double[1][0]: 7 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ byte[1] : 2 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ double[1][1]: 8 +++
12-02 17:13:39.647 27863 27911 I JniTransfer: +++ stringValue : Im StringValue +++
12-02 17:13:39.648 27863 27911 I JniTransfer: +++ inner_message : Im message +++
12-02 17:13:39.648 27863 27911 I JniTransfer: +++ dump javaBean info end +++
12-02 17:13:39.648 27863 27911 I JniTransfer: javaBean_c_2_java
12-02 17:13:39.648 27863 27911 I JniTransfer: innerObject
12-02 17:13:39.648 27863 27911 I JniTransfer: javaBeanObject
12-02 17:13:39.648 27863 27911 I JniTransfer: set charValue
12-02 17:13:39.648 27863 27911 I JniTransfer: set doubleVaule
12-02 17:13:39.648 27863 27911 I JniTransfer: set intValue
12-02 17:13:39.648 27863 27911 I JniTransfer: set StringValue
12-02 17:13:39.648 27863 27911 I JniTransfer: set byte[] array
12-02 17:13:39.648 27863 27911 I JniTransfer: The byteArray len : 4
12-02 17:13:39.648 27863 27911 I JniTransfer: set double dimen int array
12-02 17:13:39.648 27863 27911 I JniTransfer: The double_dimen_array : 2
12-02 17:13:39.648 27863 27911 I JniTransfer: The sub[0] len: 2
12-02 17:13:39.648 27863 27911 I JniTransfer: The sub[1] len: 2
12-02 17:13:39.649 27863 27911 D JniTransfer: JavaBean [boolValue=true, charValue=c, doubleValue=1.0, intValue=2, array=[B@ec430b3, mDoubleDimenArray=[[I@dd17670, stringValue=Im StringValue, mInnerClass=InnerClass [mMessage=Im message]]
12-02 17:13:39.649 27863 27911 E JniTransfer:
12-02 17:13:39.649 27863 27911 E JniTransfer: javaBeanToStruct
12-02 17:13:39.649 27863 27911 I JniTransfer: Start javaBean_java_2_c fun
12-02 17:13:39.650 27863 27911 I JniTransfer: The byteArray len : 4
12-02 17:13:39.650 27863 27911 I JniTransfer: doublemin int array len : 2
12-02 17:13:39.650 27863 27911 I JniTransfer: sub_len: 2
12-02 17:13:39.650 27863 27911 I JniTransfer: sub_len: 2
12-02 17:13:39.650 27863 27911 I JniTransfer: get StringValue
12-02 17:13:39.650 27863 27911 I JniTransfer: get inner class data
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ dump javaBean info start +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ boolValue : 0 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ charValue : A +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ doubleVaule : 100.000000 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ intValue : 100 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[0] : 0 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[1] : 1 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[2] : 2 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[3] : 3 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[0] : 0 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ double[0][0]: 10 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[0] : 0 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ double[0][1]: 10 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[1] : 1 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ double[1][0]: 20 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ byte[1] : 1 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ double[1][1]: 20 +++
12-02 17:13:39.650 27863 27911 I JniTransfer: +++ stringValue : Hello! +++
12-02 17:13:39.651 27863 27911 I JniTransfer: +++ inner_message : Im from Java! +++
12-02 17:13:39.651 27863 27911 I JniTransfer: +++ dump javaBean info end +++
写在最后
如上就将C/C++结构体和Java对象之间通过Jni相互转换的两种方式介绍完了，这两种都是比较常见的方法，读者朋友们掌握了这两种方法以后，再难的转换无外乎也可以使用这两种方式。最后希望本篇能对实际工作中的你有一定的帮助作用。最后附上实例工程C_Java_Transfer.zip。青山不改绿水长流，各位江湖见！