C++11 JNI开发中RAII的应用(二)--JNI函数封装

在上一节《C++11 JNI开发中RAII的应用(一)》中我们已经有了一些基本的RAII封装工具，本节就简单了，就是根据需要把一些常用的JNIEnv函数封装成更方便使用的模板函数。

raii_NewGlobalRef

raii_NewGlobalRef函数顾名思义，就是封装JNIEnv::NewGlobalRef,将一个本地引用的jobject转为全局引用封装在raii_var中。

	/* 封装JNIEnv::NewGlobalRef 返回jobject对象全局引用(RAII管理) */
	template<typename T=jobject,typename TYPE=typename std::conditional<!std::is_same<T,jobject>::value,T,jobject>::type>
	static raii_var<TYPE>
	raii_NewGlobalRef(T localRef) {
		static_assert(
				std::is_base_of<typename std::remove_pointer<jobject>::type,
										typename std::remove_pointer<T>::type>::value,
				"T is not derived from jobject");
		return raii_var<TYPE>(
			[localRef]()->TYPE {return static_cast<TYPE>(getJNIEnv()->NewGlobalRef(localRef));},
			[](TYPE &gref) {getJNIEnv()->DeleteGlobalRef(gref);});
	}

在调用时，如果不指定T的类型，则返回的raii_var类中的类型默认为jobject，否则

下面所有的模板函数都是这个用法。

raii_FindClass_LocalRef & raii_FindClass_GlobalRef

raii_FindClass_LocalRef 和raii_FindClass_GlobalRef,封装了JNIEnv::FindClass,返回字符串name指定的类名的jclass对象,raii_FindClass_LocalRef 返回的是本地引用，raii_FindClass_GlobalRef返回全局引用。

	/* 封装JNIEnv::FindClass 返回jclass对象局部引用(RAII管理) */
		static raii_var<jclass> raii_FindClass_LocalRef(const char* name) {
		assert(nullptr != name);
		return raii_jobject_env(&JNIEnv::FindClass, name);
	}
	/* 封装JNIEnv::FindClass 返回jclass对象全局引用(RAII管理) */
	static raii_var<jclass> raii_FindClass_GlobalRef(const char* name) {
		return raii_NewGlobalRef<jclass>(raii_FindClass_LocalRef(name).get());
	}

比如：

auto jstring_class=raii_FindClass_LocalRef("Ljava/lang/String;");
//返回String类的jclass对象

raii_GetObjectClass

raii_GetObjectClass封装JNIEnv::GetObjectClass，返回一个jobject的jclass对象

	static raii_var<jclass> raii_GetObjectClass(jobject obj) {
		assert(nullptr != obj);
		return raii_jobject_env(&JNIEnv::GetObjectClass, obj);
	}

raii_CallObjectMethod

raii_CallObjectMethod封装JNIEnv:CallObjectMethod

//通过methodID调用指定的方法
	template<typename T=jobject,typename... Args>
	static raii_var<T> raii_CallObjectMethod( jobject obj, jmethodID methodID, Args&&... args) {
		return raii_jobject_env<T>(&JNIEnv::CallObjectMethod,obj, methodID,std::forward<Args>(args)...);
	}
//通过name指定的方法名和sig指定的方法签名调用指定的方法
	template<typename T=jobject,typename... Args>
	static raii_var<T> raii_CallObjectMethod( jobject obj, const char *name, const char *sig, Args&&... args) {
		raii_var<jclass> clazz=raii_GetObjectClass(obj);
		auto methodID = getJNIEnv()->GetMethodID(clazz.get(), name, sig);
		assert(nullptr != methodID);
		return raii_CallObjectMethod<T>(obj,methodID,std::forward<Args>(args)...);
	}

raii_NewObject

raii_NewObject封装JNIEnv::NewObject有5个重载函数

//通过constructor指定的jmethodID调用指定的构造方法
	template<typename T=jobject,typename... Args>
	static raii_var<T> raii_NewObject( jclass clazz, jmethodID constructor, Args&&... args) {
		return raii_jobject_env(&JNIEnv::NewObject,clazz,constructor,std::forward<Args>(args)...);
	}
//通过sig指定的构造方法签名来调用指定的构造方法
	template<typename T=jobject,typename... Args>
	static raii_var<T> raii_NewObject( jclass clazz, const char *sig, Args&&... args) {
		assert(nullptr != clazz);
		auto constructor = getJNIEnv()->GetMethodID(clazz, "<init>", nullptr==sig?"void (V)":sig);
		assert(nullptr != constructor);
		return raii_NewObject<T>(clazz,constructor,std::forward<Args>(args)...);
	}
//通过class_name指定类名和sig指定的构造方法签名来创建新对象	
	template<typename T=jobject,typename... Args>
	static raii_var<T> raii_NewObject( const char * class_name, const char *sig,Args&&... args) {
		return raii_NewObject<T>(raii_FindClass_LocalRef(class_name).get(),sig,std::forward<Args>(args)...);
	}
//用默认构造方法创建clazz指定的对象
	template<typename T=jobject>
	static raii_var<T> raii_NewObject( jclass clazz) {
		return raii_NewObject<T>(clazz,(const char *)nullptr);
	}
//用默认构造方法创建clas_name指定的对象
	template<typename T=jobject>
	static raii_var<T> raii_NewObject( const char * class_name) {
		return raii_NewObject<T>(raii_FindClass_LocalRef(class_name).get());
	}

raii_NewByteArray

raii_NewByteArray封装JNIEnv::NewByteArray,创建指定长度的byte数组

	static raii_var<jbyteArray> raii_NewByteArray( jsize len) {
		return raii_jobject_env(&JNIEnv::NewByteArray, len);
	}

tojbytearray

调用raii_NewByteArray将一个C++的字节数组转为java字节数组(jbyteArray)

	/* 将bytes转成raii_var<jbyteArray>对象 */
	static raii_var<jbyteArray> tojbytearray(jbyte* bytes, jsize len) {
		auto byteArray = raii_NewByteArray(len);
		if (nullptr != bytes)
			getJNIEnv()->SetByteArrayRegion(byteArray.get(), 0, len, bytes);
		return byteArray;
	}

raii_NewStringUTF&raii_NewString

raii_NewStringUTF封装JNIEnv::NewStringUTF,将一个UTF-8编码的字符串转为java String(jstring)
raii_NewStringUTF封装JNIEnv::NewString,将一个Unicode 编码的jchar数组转为java String(jstring)

	/* 将UTF-8字符串转成一个raii_var管理的JString对象 */
	static raii_var<jstring> raii_NewStringUTF(const char* pStr) {
		return raii_jobject_env(&JNIEnv::NewStringUTF, pStr);
	}
	/* 将Unicode字符串转成一个raii_var管理的JString对象 */
	static raii_var<jstring> raii_NewString(const jchar* pStr, jsize len) {
		return raii_jobject_env(&JNIEnv::NewString, pStr, len);
	}

raii_GetObjectField

raii_GetObjectField封装JNIEnv::GetObjectField，返回指定fieldID的对象(jobject)

	/* 封装JNIEnv::GetObjectField 返回T指定的jobject基类对象(RAII管理) */
	template<typename T=jobject>
	static raii_var<T> raii_GetObjectField(jobject obj, jfieldID fieldID) {
		return raii_jobject_env<T>(&JNIEnv::GetObjectField,obj,fieldID);
	}

raii_GetObjectArrayElement

raii_GetObjectArrayElement封装JNIEnv::GetObjectArrayElement,返回对象数组指定下标的java 对象(jobject)

	/* 封装JNIEnv::GetObjectField 返回T指定的jobject基类对象(RAII管理) */
	template<typename T=jobject>
	static raii_var<T> raii_GetObjectArrayElement(jobjectArray array, jsize index) {
		return raii_jobject_env<T>(&JNIEnv::GetObjectArrayElement,array,index);
	}

raii_GetByteArrayElements

raii_GetByteArrayElements封装JNIEnv::GetByteArrayElements,返回java字节数组byte[]的C++字节数组

	static auto raii_GetByteArrayElements(jbyteArray bytes,	jint release_mode = JNI_ABORT)
		-> raii_var<decltype(getJNIEnv()->GetByteArrayElements(bytes, nullptr))> {
		using type = decltype(getJNIEnv()->GetByteArrayElements(bytes, nullptr));
		assert(nullptr != bytes);
		return raii_var<type>(
				[bytes]()->type {
					jboolean isCopy;
					auto result=getJNIEnv()->GetByteArrayElements(bytes, &isCopy);
					assert(isCopy); // 调用成功断言
					return std::move(result);
				},
				[release_mode,bytes](type &obj) {getJNIEnv()->ReleaseByteArrayElements(bytes, obj, release_mode);});
	}

raii_GetStringUTFChars

raii_GetStringUTFChars封装JNIEnv::GetStringUTFChars,返回java String的UTF-8字符串

	static auto raii_GetStringUTFChars(
			jstring jstr) -> raii_var<decltype(getJNIEnv()->GetStringUTFChars(jstr, nullptr))> {
		using type = decltype(getJNIEnv()->GetStringUTFChars(jstr, nullptr));
		assert(nullptr != jstr);
		return raii_var<type>([jstr]()->type {
			jboolean isCopy;
			auto result=getJNIEnv()->GetStringUTFChars(jstr, &isCopy);
			assert(isCopy); // 调用成功断言
				return std::move(result);
			}, [jstr](type &obj) {getJNIEnv()->ReleaseStringUTFChars(jstr,obj);});
	}

throwByName

throwByName抛出name指定类名的异常,msg为异常信息
throwIllegalArgumentException抛出 java.lang.IllegalArgumentException异常

void throwByName(const char* name, const char* msg) {
	auto cls = raii_FindClass_LocalRef(name);
	/* if cls is NULL, an exception has already been thrown */
	if (cls.get() != nullptr) {
		getJNIEnv()->ThrowNew(cls.get(), name);
	} else {
		throw invalid_argument(string("not found java class:").append(name).data());
	}
}
void throwIllegalArgumentException(const char* msg) {
	throwByName("java/lang/IllegalArgumentException", msg);
}