Java 之JNI基础篇（三）

最新推荐文章于 2021-05-28 10:45:52 发布

编程之路从0到1

最新推荐文章于 2021-05-28 10:45:52 发布

阅读量862

点赞数 3

分类专栏： # Android的JNI 文章标签： NDK Android JNI 字符串数组

本文链接：https://blog.csdn.net/yingshukun/article/details/79234453

版权

Android的JNI 专栏收录该内容

4 篇文章 3 订阅

订阅专栏

文章目录

- - 从源码开始

从源码开始

上一篇博客讲了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
这里写图片描述

可以看到，在该类的开头就做了一个介绍，并贴心的给出了一段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实例变量，有两个步骤。首先，调用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);

这里写图片描述

修改实例变量的值

函数原型

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

这里写图片描述

除了实例变量，还有用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);

这里写图片描述

修改静态变量的值

函数原型

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

这里写图片描述

在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,"<init>", "([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反射其实是一致的

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

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

获取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是一样的，最后两个参数传入方法名和方法签名，需要注意的一点是，如果获取的是构造方法，那么方法名统一使用"<init>"，这里还有一个知识点就是方法签名的使用，我们在最后做一个总结

调用构造方法创建对象

函数原型

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还有静态方法，静态方法的调用步骤与实例方法也是相同的

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

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

这里写图片描述

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

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

类型签名

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

方法签名
与签名的类型前不同的是，方法签名是有返回值的，其固定格式如下
```
 (形参列表)返回值类型
```

需要注意的是，形参之间是没有分隔符号的，紧跟在一起
这里写图片描述

当我们手写方法签名的时候很容易出错，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上使用，可进入官网下载静态或动态库地址该库的使用也非常简单

编程之路从0到1

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java 之JNI基础篇（三）

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

扫一扫