Java 之JNI基础篇(三)

文章目录

      • 从源码开始
        • JNI访问Java成员变量
        • 访问Java成员变量小结
        • 在JNI本地代码中创建Java对象和反调Java方法
        • Java类型签名与方法签名总结
        • JNI字符串与对象数组的操作

从源码开始

上一篇博客讲了Java代码如何调用本地C代码,这一篇则主要讲C代码如何访问Java的变量和方法,那么我们继续从JDK源码入手,从源码中学习,学会JNI真正的使用方式和使用场景,而不是想当然的写几个简单的demo,那样是没有意义的,知道API和会用API并不是一回事,源码的JNI使用方式是高效的经得起考验的,如果我们仅仅只是看了几个demo,查了一下文档就去写JNI,那样很可能就是在给自己埋坑。

好了,进入主题,看到我们今天的主角,使用Java的zip压缩与解压,之所以从这里入手,是因为此处的代码逻辑比较简单,且正真实现压缩与解压的是本地C库,所以非常适合学习JNI,以及Java与C的大数据量交互。
打开openjdk的Java源码/jdk/src/share/classes/java/util/zip/Deflater.java
Java 之JNI基础篇(三)_第1张图片

可以看到,在该类的开头就做了一个介绍,并贴心的给出了一段demo,实际上这个demo太过于简单,真实的代码中并不是这样用,我们这里就以此demo做个小测试,简单改造一下

try {
		// Encode a String into bytes
		String inputString = "Beautiful is better than ugly.Explicit is better than implicit.";

		byte[] input = inputString.getBytes();
		System.out.println("原始长度:"+input.length);

		// Compress the bytes
		byte[] output = new byte[100];
		Deflater compresser = new Deflater();
		compresser.setInput(input);
		compresser.finish();
		int compressedDataLength = compresser.deflate(output);
		compresser.end();
		System.out.println("压缩之后:"+compressedDataLength);

		// Decompress the bytes
		Inflater decompresser = new Inflater();
		decompresser.setInput(output, 0, compressedDataLength);
		byte[] result = new byte[100];
		int resultLength = decompresser.inflate(result);
		decompresser.end();
		System.out.println("解压长度:"+resultLength);
		// Decode the bytes into a String
		String outputString = new String(result, 0, resultLength);
		System.out.println(outputString);
	} catch (Exception ex) {
		ex.printStackTrace();
	} 

这一段程序主要做了两件事,先压缩字节,再解压恢复,这里压缩使用Deflater 类,而解压则用到Inflater 类,从名字也很好理解。大家可以运行上述代码,看看一行字符串,压缩之后减少了多少字节。

首先将上述程序分开来看,先看压缩部分,主要干事的代码如下

Deflater compresser = new Deflater();
compresser.setInput(input);
compresser.finish();
int compressedDataLength = compresser.deflate(output);
compresser.end();

源码其实不是很多,这里仅摘取相关部分

private final ZStreamRef zsRef;
private byte[] buf = new byte[0];
private int off, len;
private int level, strategy;
private boolean setParams;
private boolean finish, finished;

...

    static {
        /* Zip library is loaded from System.initializeSystemClass */
        initIDs();
    }

    /**
     * Sets input data for compression. This should be called whenever
     * needsInput() returns true indicating that more input data is required.
     * @param b the input data bytes
     * @param off the start offset of the data
     * @param len the length of the data
     * @see Deflater#needsInput
     */
    public void setInput(byte[] b, int off, int len) {
        if (b== null) {
            throw new NullPointerException();
        }
        if (off < 0 || len < 0 || off > b.length - len) {
            throw new ArrayIndexOutOfBoundsException();
        }
        synchronized (zsRef) {
            this.buf = b;
            this.off = off;
            this.len = len;
        }
    }

    /**
     * Sets input data for compression. This should be called whenever
     * needsInput() returns true indicating that more input data is required.
     * @param b the input data bytes
     * @see Deflater#needsInput
     */
    public void setInput(byte[] b) {
        setInput(b, 0, b.length);
    }

...

	/**
     * When called, indicates that compression should end with the current
     * contents of the input buffer.
     */
    public void finish() {
        synchronized (zsRef) {
            finish = true;
        }
    }

...

    /**
     * Compression flush mode used to achieve best compression result.
     *
     * @see Deflater#deflate(byte[], int, int, int)
     * @since 1.7
     */
    public static final int NO_FLUSH = 0;
    
    public int deflate(byte[] b) {
        return deflate(b, 0, b.length, NO_FLUSH);
    }

    public int deflate(byte[] b, int off, int len, int flush) {
        if (b == null) {
            throw new NullPointerException();
        }
        if (off < 0 || len < 0 || off > b.length - len) {
            throw new ArrayIndexOutOfBoundsException();
        }
        synchronized (zsRef) {
            ensureOpen();
            if (flush == NO_FLUSH || flush == SYNC_FLUSH ||
                flush == FULL_FLUSH)
                return deflateBytes(zsRef.address(), b, off, len, flush);
            throw new IllegalArgumentException();
        }
    }

...

    private static native void initIDs();
    private native static long init(int level, int strategy, boolean nowrap);
    private native static void setDictionary(long addr, byte[] b, int off, int len);
    private native int deflateBytes(long addr, byte[] b, int off, int len,
                                    int flush);
    private native static int getAdler(long addr);
    private native static long getBytesRead(long addr);
    private native static long getBytesWritten(long addr);
    private native static void reset(long addr);
    private native static void end(long addr);

简单浏览一下代码就知道,前几行代码其实都是一些准备工作,真正做压缩的是deflate方法,而对应的其实是native修饰的deflateBytes方法。

我们打开/jdk/src/share/native/java/util/zip/Deflater.c 源码 ,按照Java层的代码调用顺序看

JNI访问Java成员变量

  • Java静态代码块
static {
       initIDs();
}

本地实现

JNIEXPORT void JNICALL
Java_java_util_zip_Deflater_initIDs(JNIEnv *env, jclass cls)
{
    levelID = (*env)->GetFieldID(env, cls, "level", "I");
    strategyID = (*env)->GetFieldID(env, cls, "strategy", "I");
    setParamsID = (*env)->GetFieldID(env, cls, "setParams", "Z");
    finishID = (*env)->GetFieldID(env, cls, "finish", "Z");
    finishedID = (*env)->GetFieldID(env, cls, "finished", "Z");
    bufID = (*env)->GetFieldID(env, cls, "buf", "[B");
    offID = (*env)->GetFieldID(env, cls, "off", "I");
    lenID = (*env)->GetFieldID(env, cls, "len", "I");
}

这个初始化方法是干什么的呢?我们从最直观的角度就能判断,这个方法应该是在获取类的成员变量,因为这个方法里出现了Deflater类的成员变量level、strategy、finish等等,再看到函数名GetFieldID,如果非常熟悉Java反射机制的话,那么对于Java的Field域是再熟悉不过了,这一段代码就跟Java反射获取类成员是高度相似的,唯一的不同是,这里获取的Field的ID

在JNI官方文档中查询GetFieldID
Java 之JNI基础篇(三)_第2张图片

通过阅读文档,我们可以知道,本地方法访问Java实例变量,有两个步骤。 首先,调用GetFieldID函数获取字段的ID,第二步,在以上示例代码中则是调用GetObjectClass函数来访问实例变量。

看到函数原型

jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig); 

前三个参数都很好理解,由于Java中initIDs方法是static方法,所有这里第二个参数传的是jclass类型,主要是最后一个参数不好理解,该参数实际上是一个Field描述符,或者理解为一种类型签名,实际上它是一个字符串,8种基本类型和引用类型都有对应的类型签名,先看一下八种基本类型,最后再做一下总结

Z  boolean  
B  byte  
C  char  
S  short  
I  int  
J  long  
F  float  
D  double  

其中带"["的表示数组,如示例中bufID = (*env)->GetFieldID(env, cls, "buf", "[B");

回到Deflater.c 源码,在函数的外层定义了这些全局静态变量,由此很好理解在Java静态代码块所做的事情,实际上就是在类加载的时候,将类成员的FieldId保存到本地代码的全局静态变量中,这样做的目的就是提高效率,以免本地代码访问类成员时频繁获取FieldId

static jfieldID levelID;
static jfieldID strategyID;
static jfieldID setParamsID;
static jfieldID finishID;
static jfieldID finishedID;
static jfieldID bufID, offID, lenID;
  • 真正处理压缩的方法

在Deflater类的构造方法中也做了一些事情,主要是对native层的zlib库的一些准备,关于zlib库如何使用就不在本文讨论范围了,实际上也就是函数的调用,看一下zlib库的示例很好理解,接下来看到关键代码

JNIEXPORT jint JNICALL
Java_java_util_zip_Deflater_deflateBytes(JNIEnv *env, jobject this, jlong addr,
                                         jarray b, jint off, jint len, jint flush)
{
    z_stream *strm = jlong_to_ptr(addr);
    
    /* 通过之前加载的FieldId 获取类成员变量*/
    jarray this_buf = (*env)->GetObjectField(env, this, bufID);
    jint this_off = (*env)->GetIntField(env, this, offID);
    jint this_len = (*env)->GetIntField(env, this, lenID);
    jbyte *in_buf;
    jbyte *out_buf;
    int res;
    if ((*env)->GetBooleanField(env, this, setParamsID)) {
        int level = (*env)->GetIntField(env, this, levelID);
        int strategy = (*env)->GetIntField(env, this, strategyID);

		/* 获取待压缩的字节数组*/
        in_buf = (*env)->GetPrimitiveArrayCritical(env, this_buf, 0);
        if (in_buf == NULL) {
            // Throw OOME only when length is not zero
            if (this_len != 0)
                JNU_ThrowOutOfMemoryError(env, 0);
            return 0;
        }

		/* 获取压缩后输出的字节数组*/
        out_buf = (*env)->GetPrimitiveArrayCritical(env, b, 0);
        if (out_buf == NULL) {
            (*env)->ReleasePrimitiveArrayCritical(env, this_buf, in_buf, 0);
            if (len != 0)
                JNU_ThrowOutOfMemoryError(env, 0);
            return 0;
        }

		/* 调用zlib库做压缩之前,需要做的一些准备工作*/
        strm->next_in = (Bytef *) (in_buf + this_off);
        strm->next_out = (Bytef *) (out_buf + off);
        strm->avail_in = this_len;
        strm->avail_out = len;

		/* C库中,真正做压缩的方法,调用完成后返回一个结果值,用以判断是否成功*/
        res = deflateParams(strm, level, strategy);
        /* 释放资源*/
        (*env)->ReleasePrimitiveArrayCritical(env, b, out_buf, 0);
        (*env)->ReleasePrimitiveArrayCritical(env, this_buf, in_buf, 0);

        switch (res) {
        case Z_OK:
            (*env)->SetBooleanField(env, this, setParamsID, JNI_FALSE);
            this_off += this_len - strm->avail_in;
            (*env)->SetIntField(env, this, offID, this_off);
            (*env)->SetIntField(env, this, lenID, strm->avail_in);
            return len - strm->avail_out;
        case Z_BUF_ERROR:
            (*env)->SetBooleanField(env, this, setParamsID, JNI_FALSE);
            return 0;
        default:
            JNU_ThrowInternalError(env, strm->msg);
            return 0;
        }
    } else {
        /* 此处省略另一种策略下的压缩逻辑,实际上这个else中的逻辑与if中的类似,只是具体调用的方法不同*/
    }
}

从这段源码中,可以学会大数据量数组的传递,以及在本地方法中访问Java变量并修改,特别关键的一点是可以学习标准的JNI编写套路,这里Java层的数组并不是直接通过参数传递到本地代码中的,而是先将字节数组的引用保存到成员变量中,在本地代码中去获取这个类成员变量,从而获取到该数组的指针,前面的博客已经详细说明过,GetPrimitiveArrayCritical并不一定获取到原始数组的指针,也可能是副本的指针,所以一定要调用ReleasePrimitiveArrayCritical进行缓冲区释放,回写数组。

访问Java成员变量小结

从这个源码示例进行引申,将JNI官方文档中,对于Java实例变量与静态变量做一个归纳总结

  • 获取实例变量的FieldID

函数原型

jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig); 
  • 通过FieldID获取实例变量值
    根据8种基本类型和引用类型,分别对应不同的函数

函数原型

NativeType Get<type>Field(JNIEnv *env, jobject obj, jfieldID fieldID); 

Java 之JNI基础篇(三)_第3张图片

  • 修改实例变量的值

函数原型

void Set<type>Field(JNIEnv *env, jobject obj, jfieldID fieldID,NativeType value); 

Java 之JNI基础篇(三)_第4张图片

除了实例变量,还有用static修饰的静态变量,看看静态变量如何访问

  • 获取静态变量的FieldID
    可以看到,和获取实例变量的使用是一样的,只是函数名不同

函数原型

jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig); 
  • 通过FieldID获取静态变量值
    获取静态变量值和获取实例变量值稍有一点不同,可以看该函数的第二参数不是jobject类型,而是jclass类型,这说明该函数调用的时候需要一个字节码对象,而不是类的实例对象

函数原型

NativeType GetStatic<type>Field(JNIEnv *env, jclass clazz,jfieldID fieldID); 

Java 之JNI基础篇(三)_第5张图片

  • 修改静态变量的值

函数原型

void SetStatic<type>Field(JNIEnv *env, jclass clazz, jfieldID fieldID, NativeType value); 

Java 之JNI基础篇(三)_第6张图片

在JNI本地代码中创建Java对象和反调Java方法

由于Java的JNI接口被设计出来,主要是用于提升Java性能,复用已有的C/C++库,所以在JDK中没有很好的示例学习在本地代码中创建Java对象和反调Java方法,然而这样的情况在Android NDK开发中则大为不同,JNI成为了本地运行环境和Java层的重要桥梁,因而JNI在Android平台被发扬光大了。在后续的Android NDK相关博客中再从源码角度学习,这里先从官方文档示例入手学习

首先我们回顾一下Java反射机制,在我的Java入门基础博客里曾有写过

所谓反射,简单说就是通过一个class文件对象来使用该class文件中的构造方法,成员变量,成员方法。获取Class类对象通常有三种方法

//1.Object类中的getClass()方法
Person p = new Person();
Class c1 = p.getClass();
 
//2.通过数据类型的一个静态的class属性
Class c2= Person.class;
 
//3.通过Class类的一个静态方法forName()
Class c3 = Class.forName("com.test.Person");

在Java中,通常得到了Class对象就可以反射构造方法从而创建一个该类的实例对象,看到文档给出的示例

jstring MyNewString(JNIEnv *env, jchar *chars, jint len)
{
	jclass stringClass;
	jmethodID cid;
	jcharArray elemArr;
	jstring result;

	/*获取jclass对象*/
	stringClass = (*env)->FindClass(env, "java/lang/String");
	if (stringClass == NULL) {
	    return NULL; 
	}
	
	/*获取 String(char[]) 构造函数的MethodID*/
	cid = (*env)->GetMethodID(env, stringClass,"", "([C)V");
	
	if (cid == NULL) {
	    return NULL;
	}
	
	/*创建一个char[]数组作为String类的内容 */
	elemArr = (*env)->NewCharArray(env, len);
	
	if (elemArr == NULL) {
	    return NULL; 
	}
	(*env)->SetCharArrayRegion(env, elemArr, 0, len, chars);
	
	/*创建一个java.lang.String对象 */
	result = (*env)->NewObject(env, stringClass, cid, elemArr);
	
	/* 释放本地引用*/
	(*env)->DeleteLocalRef(env, elemArr);
	(*env)->DeleteLocalRef(env, stringClass);
	return result;
}

从这个示例中可以看出,本地代码创建对象的步骤和Java反射其实是一致的

  1. 获得字节码文件对象,即获得Class对象
  2. 获得类的成员属性、方法或者构造函数
  3. 调用构造函数创建对象

我们通过查询文档,学习示例中的相关方法

  • 获取jclass对象
    FindClass函数类似Java中的forName方法,传入完整包名类名,注意中间使用"/"分隔符,该方法加载的是CLASSPATH路径下的类

函数原型

jclass FindClass(JNIEnv *env, const char *name);

除了该函数外,还有另一个函数也可以用来或许jclass对象,这一点和Java的getClass()方法也是高度相似的,都是通过一个实例对象获取自身的class对象

jclass GetObjectClass(JNIEnv *env, jobject obj); 
  • 获取MethodID
    与获取FieldID一样,调用Java的方法,也需要先得到MethodID

函数原型

jmethodID GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig); 

该函数的使用与GetFieldID是一样的,最后两个参数传入方法名和方法签名,需要注意的一点是,如果获取的是构造方法,那么方法名统一使用"",这里还有一个知识点就是方法签名的使用,我们在最后做一个总结

  • 调用构造方法创建对象

函数原型

jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID,...); 

可以看到这个函数后面是不定参,传入的正是Java构造方法中需要的参数。处理NewObject函数用来创建对象,还有另外两个函数可用,只是传参的形式稍有不同,一个是传入jvalue数组,另一个则传入va_list 类型

jobject NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args); 
jobject NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 

接下再看看如何调用Java成员方法,先看的官方示例

class InstanceMethodCall {
	private native void nativeMethod();
	private void callback() {
		System.out.println("In Java");
	}
	public static void main(String args[]) {
		InstanceMethodCall c = new InstanceMethodCall();
		c.nativeMethod();
	}
	static {
		System.loadLibrary("InstanceMethodCall");
	}
}
JNIEXPORT void JNICALL
Java_InstanceMethodCall_nativeMethod(JNIEnv *env, jobject obj)
{
	jclass cls = (*env)->GetObjectClass(env, obj);
	jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "()V");
	if (mid == NULL) {
		return; /* method not found */
	}
	printf("In C\n");
	(*env)->CallVoidMethod(env, obj, mid);
}

与访问成员变量步骤相同,也是两步,首先获得Java方法的MethodID,最后调用JNI函数执行该方法。此示例中,调用的是CallVoidMethod函数,它表示执行一个无返回值的Java方法。我们知道Java方法返回值除了Void类型,还可以是8种基本类型和引用类型,下面看到Call函数的原型

<NativeType> Call<Type>Method(JNIEnv *env,jobject obj, jmethodID methodID, ...);

后面的不定参表示被调用的Java方法需要传入的参数
Java 之JNI基础篇(三)_第7张图片

除了实例方法,Java还有静态方法,静态方法的调用步骤与实例方法也是相同的

  • 获取MethodID
jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz,const char *name, const char *sig); 
  • 根据MethodID执行Java方法
<NativeType> CallStatic<Type>Method(JNIEnv *env, jclass clazz,jmethodIDmethodID, ...);

Java 之JNI基础篇(三)_第8张图片

在本地代码调用Java方法中,最后还有一个点需要注意,即在父类中定义但在子类中已被覆盖的实例方法。在Java中我们直接通过关键字super.来调用,在JNI中也有单独处理,而调用步骤和上面讲的也是相同的,都是先获取MethodID,只是执行Java方法的函数是不同的

NativeType CallNonvirtual<type>Method(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 

Java 之JNI基础篇(三)_第9张图片

Java类型签名与方法签名总结

在前面无论是访问Java成员变量还是调用Java方法,都涉及到一个描述符的东西,也就是签名,它是一个字符串,有固定的写法规则

  • 类型签名
    Java 之JNI基础篇(三)_第10张图片
    Java 之JNI基础篇(三)_第11张图片

可以看到,引用类型必须以L开头,并带上完整包名类名,其包名中的分隔符使用/,而数组则必须以[开头,如果是二维数组,则用[[,三维数组用[[[,最后还有需要特别注意的一点,签名的后面一定要以;结尾

  • 方法签名
    与签名的类型前不同的是,方法签名是有返回值的,其固定格式如下

     (形参列表)返回值类型
    

需要注意的是,形参之间是没有分隔符号的,紧跟在一起
Java 之JNI基础篇(三)_第12张图片

当我们手写方法签名的时候很容易出错,JDK是有提供工具自动生成签名的,就和javah工具一样,生成签名的工具是javap命令,如需生成InstanceMethodCall类的签名,执行如下命令
javap -s -p InstanceMethodCall

JNI字符串与对象数组的操作

在上一篇博客我们谈了基本类型数组的使用,这一篇的最后就补充一下关于字符串和对象类型数组的使用

  • 字符串操作
    先看到文档的示例代码
JNIEXPORT jstring JNICALL
Java_Prompt_getLine(JNIEnv *env, jobject obj, jstring prompt)
{
	char buf[128];
	const jbyte *str;
	str = (*env)->GetStringUTFChars(env, prompt, NULL);
	if (str == NULL) {
		return NULL; /* OutOfMemoryError already thrown */
	}
	printf("%s", str);
	(*env)->ReleaseStringUTFChars(env, prompt, str);
	
	/* We assume here that the user does not type more than 127 characters */
	scanf("%s", buf);
	return (*env)->NewStringUTF(env, buf);
}

实际上在C语言中是没有字符串类型的,字符串就是一个字符数组,因此对于字符串的操作,和数组是非常类似的,但是为了和Java的类型对接起来,JNI对Java的字符串提供了专有的函数操作,我们学习了前面的基本类型数组的操作,对于字符串的操作函数就非常好理解了。

从官方示例中可以看出来,这段代码进行了两种操作,1.获取Java层传下来的字符串,并转换为本地代码中的字符数组;2.在本地代码中创建一个Java字符串对象返回。

const jbyte * GetStringUTFChars(JNIEnv *env,jstring string, jboolean *isCopy);

如果有可能,该函数会返回一个指向Java字符串的UTF-8类型字符数组的指针,最后一个参数,我们在之前讲数组操作时已经讲过,注意传值方式,传入的是一个指针。它我们之前探讨的数组操作一样,也有可能会返回一个副本的指针,因此在最后一定要调用对应的Release函数释放副本,回写改变后的值到Java原始字符串中。

void ReleaseStringUTFChars(JNIEnv *env,jstring string, const char *utf);

与我们之前创建的字符串对象不同,这里没有去获取MethodID然后调用构造方法去创建,而是使用NewStringUTF函数,从UTF-8字符数组构去造一个新的String对象

jstring NewStringUTF(JNIEnv *env, const char *bytes); 

除了这些函数之外,还有一些字符串操作的函数,这些函数基本上与数组操作函数完全对应

JNI Function Description Since
GetStringChars
ReleaseStringChars
以Unicode格式获取或释放指向字符串内容的指针。 可能会返回字符串的副本。 JDK1.1
GetStringUTFChars
ReleaseStringUTFChars
获取或释放指向UTF-8格式的字符串内容的指针。可能返回字符串的副本。 JDK1.1
GetStringLength 返回Unicode字符串中的字符长度。 JDK1.1
GetStringUTFLength 获取 UTF-8 编码字符串的长度,也可以通过标准 C 函数 strlen 获取 JDK1.1
NewString 通过给定的Unicode C字符串创建一个Java String字符串 JDK1.1
NewStringUTF 通过给定的UTF-8编码C字符串创建一个Java String字符串 JDK1.1
GetStringCritical
ReleaseStringCritical
获取Unicode格式的字符串内容的指针。 可能会返回字符串的副本。 与我们之前数组操作一样,在Get / ReleaseStringCritical调用之间不得进行阻塞操作 JDK1.2
GetStringRegion
SetStringRegion
以Unicode格式将字符串的内容复制到预分配的C缓冲区或从预分配的C缓冲区中回写修改的内容到原始字符串中。 JDK1.2
GetStringUTFRegion
SetStringUTFRegion
以UTF-8 格式将字符串的内容复制到预分配的C缓冲区或从预分配的C缓冲区中回写修改的内容到原始字符串中。 JDK1.2
  • 对象数组
jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index); 
void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value); 

示例

JNIEXPORT jobjectArray JNICALL Java_com_test_modifyStringArr(JNIEnv * env, jclass jc,jobjectArray strArray )
{
    jstring jstr;
    jsize len = (*env)->GetArrayLength(env, strArray);
    char **pstr = (char **) malloc(len*sizeof(char *));
             
    int i=0;      
    for (i=0 ; i< len ;i++){
	    jstr = (*env)->GetObjectArrayElement(env, strArray, i);
        *pstr[i] = (char *)(*env)->GetStringUTFChars(env, jstr, 0);                     
    }    
    
    jclass stringClass = (*env)->FindClass(env, "java/lang/String");
    jobjectArray  strArr = (*env)->NewObjectArray(env, len , stringClass, NULL); 
    if( strArr  == NULL){
	    return NULL;
    }   

	 for (i=0 ; i< len ;i++){
		jstring js = (*env)->NewStringUTF(env,*pstr[i])
		(*env)->SetObjectArrayElement(env, strArr , i, iarr,js);
	 }  
     
     free(pstr);
     return strArr ;
}
  • JNI字符串操作乱码问题
    由于编码不统一就会出现乱码问题,本地代码中,中文等使用的是Unicode 编码,而在Java中通常使用UTF-8编码,解决乱码问题需要进行编码转换,在本地代码进行编码转换通常会比较麻烦。一般有两种比较简便的解决方法
    1.调用Java层String的构造方法指定编码表进行转换 String(byte[] data, String charsetName)
    2.使用LibIconv库,在本地代码中进行转换。在NDK开发中已经支持了该库,如需在Windows上使用,可进入官网下载静态或动态库 地址 该库的使用也非常简单

你可能感兴趣的:(#,Android的JNI)