安卓so动态库加载代理实现，可以实现C层的类反射效果

一般来说如果我们需要加载so文件，需要一个java对应层的类，即有一个类必须要是包名和类名是不变的。

比如说下面的c层代码，这样写就必须要求有个类是com.example.hellojni.HelloJni,调用的方法为stringFromJNI

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_example_hellojni_HelloJni */

#ifndef _Included_com_example_hellojni_HelloJni
#define _Included_com_example_hellojni_HelloJni
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class:     com_example_hellojni_HelloJni
* Method:    stringFromJNI
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_example_hellojni_HelloJni_stringFromJNI
(JNIEnv *, jobject);

/*
* Class:     com_example_hellojni_HelloJni
* Method:    unimplementedStringFromJNI
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI
(JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

但是有些时候我们需要不使用这个包名，因为可能包名有冲突，这种时候，我们应该怎么办呢？

我们知道，C层是可以用本地方法去加载so文件的。

即dlopen 和dlsym

dlopen是打开so，dlsym是导出函数，可以对应到函数指针实现。

我们知道jni可以动态注册函数，它会在运行时里动态映射函数表。

我们想要实现的是完整的功能，就是不需要再编写c层，一次编写，就只需要更改java层代码实现，就可以实现所有对应的本地代码代理。

类似反射的实现办法。

这里是c层的实现，本质就是在调用的时候将函数指针重新注册到jni的映射中。

#include <string.h>
#include <jni.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <android/log.h>
#include <assert.h>
#include <vector>
#define LOG_TAG "debug log"
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##args)
using namespace std;
const char *kClassName = "com/siecom/nativelibs/NativeLoad";//指定要注册的类
void *fp;
vector<JNINativeMethod> vec;
static int registerJniMapping(JNIEnv *env, jobject thiz, jstring java_func, jstring native_func);

jstring native_hello(JNIEnv *env, jobject thiz, jstring str) {
return env->NewStringUTF("test");
}

char *jstringTostring(JNIEnv *env, jstring jstr) {
char *rtn = NULL;
jclass clsstring = env->FindClass("java/lang/String");
jstring strencode = env->NewStringUTF("utf-8");
jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
jbyteArray barr = (jbyteArray) env->CallObjectMethod(jstr, mid, strencode);
jsize alen = env->GetArrayLength(barr);
jbyte *ba = env->GetByteArrayElements(barr, JNI_FALSE);
if (alen > 0) {
rtn = (char *) malloc(alen + 1);
memcpy(rtn, ba, alen);
rtn[alen] = 0;
}
env->ReleaseByteArrayElements(barr, ba, 0);
return rtn;
}

jint load_so(JNIEnv *env, jobject thiz, jstring so_name, jstring func_name) {
void *filehandle = NULL;
void *getResult = NULL;
jint result = -1;
char *so = jstringTostring(env, so_name);
char *func = jstringTostring(env, func_name);
filehandle = dlopen(so, RTLD_LAZY);
if (filehandle) {
LOGE("filehandle %d", filehandle);
getResult = dlsym(filehandle, func);
LOGE("dlsym %d", getResult);
fp = getResult;
if (getResult) {
result = 0;
return result;
}
}
return result;
}

static void getMethods(){

JNINativeMethod method1,method2,method3;
method1.name = "test";
method1.signature = "(Ljava/lang/String;)Ljava/lang/String;";
method1.fnPtr = (void *) native_hello;
vec.push_back(method1);

method2.name = "load_so";
method2.signature = "(Ljava/lang/String;Ljava/lang/String;)I",
method2.fnPtr = (void*)load_so;
vec.push_back(method2);

method3.name = "registerJniMapping";
method3.signature = "(Ljava/lang/String;Ljava/lang/String;)I",
method3.fnPtr = (void*)registerJniMapping;
vec.push_back(method3);

}

/*
* 为某一个类注册本地方法
*/
static int registerNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *gMethods,
int numMethods) {
jclass clazz;
clazz = env->FindClass(className);
if (clazz == NULL) {
LOGE("Native registration unable to find class '%s'", className);
return JNI_FALSE;
}
if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
LOGE("RegisterNatives failed for '%s'", className);
return JNI_FALSE;
}
return JNI_TRUE;
}

static int registerJniMapping(JNIEnv *env, jobject thiz, jstring java_func, jstring native_func) {
void *tmp = fp;
int pos = vec.size();
LOGE("before pos:%d", pos);
JNINativeMethod method;
method.name = jstringTostring(env, java_func);
method.signature = jstringTostring(env, native_func);
method.fnPtr = (void *) tmp;
vec.push_back(method);
pos = vec.size();
LOGE("after pos:%d", pos);
return registerNativeMethods(env, kClassName, &vec[0],
vec.size());
}
/*
* 为所有类注册本地方法
*/
static int registerNatives(JNIEnv *env) {
getMethods();
return registerNativeMethods(env, kClassName, &vec[0],
vec.size());
}
typedef union {
JNIEnv *env;
void *venv;
} UnionJNIEnvToVoid;
/*
* System.loadLibrary("lib")时调用
* 如果成功返回JNI版本, 失败返回-1
*/
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
UnionJNIEnvToVoid uenv;
uenv.venv = NULL;
jint result = -1;
JNIEnv *env = NULL;
//LOGI("JNI_OnLoad");
if (vm->GetEnv(&uenv.venv, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed");
goto bail;
}
env = uenv.env;
if (registerNatives(env) != JNI_TRUE) {
LOGE("ERROR: registerNatives failed");
goto bail;
}
result = JNI_VERSION_1_4;
bail:
return result;
}

这是对应java层，当然java层还是需要有个固定的包名的，这是不能避免的，但是你可以直接使用这个类去load你需要的so库类

static
{
System.loadLibrary("Loadso");
/**
* 动态注册jni函数
* 不需要写对应的c层函数，直接映射对应关系
* 需要函数的返回类型和入参java层变量签名如(Ljava/lang/String;)I
*
*/
int res = NativeLoad.load_so("libwltdecode.so","Java_com_ivsign_android_IDCReader_IDCReaderSDK_wltInit");
if(res==0)
Log.e("loadso", "正确加载so和函数");
res = NativeLoad.registerJniMapping("init","(Ljava/lang/String;)I");
if(res==1)
Log.e("loadso：", "正确重注册jni");

res = NativeLoad.load_so("libwltdecode.so","Java_com_ivsign_android_IDCReader_IDCReaderSDK_wltGetBMP");
if(res==0)
Log.e("loadso", "正确加载so和函数");
res = NativeLoad.registerJniMapping("wltGetBMP","([B[B)I");
if(res==1)
Log.e("loadso：", "正确重注册jni");

}