最近搞了一个调用第三方so库做登录认证的任务，以前对JNI没什么概念，最近学习了 《java核心技术》 本地方法 一章，把自己写的一些例子记录一下。 自己C语言真是渣渣，所以所有的例子都在可以包括基本API的基础上尽可能简单。以下所有例子都是在centos 7中测试的，window不太熟。
调用本地方法
java调用本地方法，首先需要加载包含对应方法的so库（linux）,一般使用下面这种方式加载so库。
1 public class Test{ 2 static 3 { 4 //so库的名字是libTest.so 5 System.loadLibrary("Test"); 6 } 7 8 public static native void hello(); 9 }
在static代码块中加载so库，这样就能在这个类被classLoader 加载的时候就被载入。要想正确载入so，必须将so库放在java.library.path 指定的路径中，我们可以通过以下两种方式来指定java.library.path 的值
1. 配置 LD_LIBRARY_PATH 环境变量
2. 通过java的运行参数指定 -Djava.library.path= .....
当我们调用本地方法时，会在加载的so库中去寻找与我们所调用方法对应的本地方法，比如上面定义的hello方法，就应该有一个对应的本地方法为
JNIEXPORT void JNICALL Java_Test_hello(JNIEnv *, jclass)
我们可以使用javah产生这个一个头文件，在其中就包含了这个方法的声明。
我们编写完c文件后，就可以用它生成一个对应的so了
gcc -fPIC -I jdk/include -I jdk/include/linux -shared -o libTest.so Test.c
其中jdk是含有jdk的目录，以我的环境为例，jdk目录为 /usr/lib/jvm/java-1.7.0-openjdk-1.7.0.79-2.5.5.1.el7_1.x86_64/， 配置JAVA_HOME指向这个目录，所以编译命令就是：
gcc -fPIC -I ${JAVA_HOME}/include -I ${JAVA_HOME}/include/linux -shared -o libTest.so Test.c
之所以要使用-I 参数指定这两个目录，是因为在其中包含了c文件需要的两个头文件， <jni.h>和 <jni_md.h>
总结出将一个本地方法链接到java程序中的步骤：
1）在java类中声明一个native方法
2）运行javah 得到一个本地方法需要的头文件
3）使用C实现本地方法
4）使用C代码编译出so文件，并将它放置在java.library.path中
5）使用java调用就可以了
下面的案例中重要的api都用红色标记了。
案例1：
计算两个int的和（传入int参数并返回int类型）
class Calc { static{ System.loadLibrary("Calc"); } public static native int add(int a, int b); public static void main(String[] args) { System.out.println(add(11,23)); } }
对应的C代码：
#include <stdio.h> #include "Calc.h" /* jint 对应着java 的int类型 */ JNIEXPORT jint JNICALL Java_Calc_add(JNIEnv *env, jclass jc, jint a, jint b) { jint ret = a + b; return ret; }
案例二：给传入的name加上hello前缀再返回（传入String参数并返回String类型）
class Hello { static { System.loadLibrary("Hello"); } public static native String hello(String name); public static void main(String[] args){ System.out.println(hello("zhangsan")); } }
对应的C代码：
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "Hello.h" /*拼接字符串 */ char* join(const char *s1, const char *s2) { char *result = malloc(strlen(s1)+strlen(s2)+1);//+1 for the zero-terminator //in real code you would check for errors in malloc here if (result == NULL) exit (1); strcpy(result, s1); strcat(result, s2); return result; } JNIEXPORT jstring JNICALL Java_Hello_hello(JNIEnv* env, jclass cl, jstring name) { /* 从java String 获得 C char* */ const char* cname; cname = (*env)->GetStringUTFChars(env, name, NULL); char* hello_s = join("hello, ", cname); /* 从 C char* 再获得 java String */ jstring ret = (*env)->NewStringUTF(env, hello_s); /* 主动释放内存, 表明不再需要通过 name 来访问 cname*/ (*env)->ReleaseStringUTFChars(env, name, cname); return ret; }
案例三： 在C代码中调用PrintWriter.print方法（调用java对象的实例方法）
感觉这种调用和反射基本类似。
import java.io.*; public class Hello { static { System.loadLibrary("Hello"); } public static native void sayHello(PrintWriter out, String message); public static void main(String[] args) { PrintWriter out = new PrintWriter(System.out); Hello.sayHello(out, "Hello world! "); out.flush(); } }
C代码实现：
#include <stdio.h> #include <stdlib.h> #include <string.h> #include "Hello.h" /*java 的Object类型对应jobject */ JNIEXPORT void JNICALL Java_Hello_sayHello(JNIEnv* env, jclass jc, jobject out, jstring message) { const char* cmessage; /*从 java String 得到 c char* */ cmessage = (*env)->GetStringUTFChars(env, message, NULL); /* 处理得到的字符串，加上前缀 */ const char* append = "I'm say: "; char* result = (char*)malloc(strlen(cmessage) + strlen(append) + 1); strcpy(result, append); strcat(result, cmessage); /*从 c char* 得到 java String */ jstring jresult = (*env)->NewStringUTF(env, result); /* 主动释放， 不再需要通过message获得cmessage */ (*env)->ReleaseStringUTFChars(env, message, cmessage); /* 下面就是 调用PrintWriter.print(String) */ /* 获得class */ jclass class_PrintWriter = (*env)->GetObjectClass(env, out); /* 获得 method ID , 最后一个参数是 print方法的签名 返回值为void（V）， 参数为java.lang.String */ jmethodID id_print = (*env)->GetMethodID(env, class_PrintWriter, "print", "(Ljava/lang/String;)V"); /* 调用方法 */ (*env)->CallVoidMethod(env, out, id_print, jresult); }
案例四： 在C代码中调用System.getProperty静态方法(调用java静态方法)
public class Test { static { System.loadLibrary("Test"); } public static native String getClassPath(); public static void main(String[] args) { System.out.println(getClassPath()); } }
c代码实现：
#include <stdio.h> #include "Test.h" JNIEXPORT jstring JNICALL Java_Test_getClassPath(JNIEnv* env, jclass jc) { /*获得System的class */ jclass class_System = (*env)->FindClass(env, "java/lang/System"); /*获得 getProperty 方法的 方法id */ jmethodID id_getProperty = (*env)->GetStaticMethodID(env, class_System, "getProperty", "(Ljava/lang/String;)Ljava/lang/String;"); /* 执行 静态方法 */ jobject obj_ret = (*env)->CallStaticObjectMethod(env, class_System, id_getProperty, (*env)->NewStringUTF(env, "version")); return (jstring)obj_ret; }
这个例子在运行的时候 增加 -Dversion=xxxx 就可以得到version运行参数了。
案例五： 在C中修改Employee的静态和实例属性（修改实例属性和静态属性）
public class Employee { static { System.loadLibrary("Employee"); } public static String a = "Good Employee"; private String name; private double salary; public Employee(String name, double salary) { this.name = name; this.salary = salary; } public String toString(){ return name + " " + salary; } public native void raiseSalary(double byPercent); public static native void updateDescription(String description); public static void main(String[] args) { Employee e = new Employee("zhangsan", 1000); System.out.println(e); e.raiseSalary(0.1); System.out.println(e); System.out.println("###############################"); System.out.println(e.a); Employee.updateDescription("Bad Employee"); System.out.println(e.a); } }
c代码：
#include <stdio.h> #include "Employee.h" JNIEXPORT void JNICALL Java_Employee_raiseSalary(JNIEnv* env, jobject this_obj, jdouble byPercent) { /* get the class */ jclass class_Employee = (*env)->GetObjectClass(env, this_obj); /* get the field Id */ jfieldID id_salary = (*env)->GetFieldID(env, class_Employee, "salary", "D"); //"D" 代表类型double /* get the field value */ jdouble salary = (*env)->GetDoubleField(env, this_obj, id_salary); salary *= 1 + byPercent / 100; /* set the field value */ (*env)->SetDoubleField(env, this_obj, id_salary, salary); } JNIEXPORT void JNICALL Java_Employee_updateDescription(JNIEnv* env, jclass jc, jstring description) { /* get static class field */ /*一定要注意类的签名方式， 前面的L 和最后的;（分号）都不能少，那个分号不是分隔符，是签名的一部分 */ jfieldID desc_id = (*env)->GetStaticFieldID(env, jc, "a", "Ljava/lang/String;"); /* set new static description field */ (*env)->SetStaticObjectField(env, jc, desc_id, description); }
案例六：访问修改数组
class Test { static { System.loadLibrary("Test"); } public static native void scaleArray(double[] arr); public static void main(String[] args) { double[] arr = {1.1, 2.2}; scaleArray(arr); for(double d : arr){ System.out.println(d); } } }
C代码实现：
#include <stdio.h> #include "Test.h" JNIEXPORT void JNICALL Java_Test_scaleArray(JNIEnv* env, jclass jc, jdoubleArray arr) { double scaleFactor = 2.0; /*获得 一个指向 数组的指针 */ double* a = (*env)->GetDoubleArrayElements(env, arr, NULL); int i; for(i = 0; i< (*env)->GetArrayLength(env, arr); i++) a[i] = a[i] * scaleFactor; (*env)->ReleaseDoubleArrayElements(env, arr, a, 0); }
案例七：在Ｃ中访问构造函数并构造对象
import java.util.Random; public class Test { static { System.loadLibrary("Test"); } public static native int nextInt(); public static void main(String[] args) { System.out.println(nextInt()); } }
在C代码中调用Random类的构造方法构造一个Random实例，然后调用nextInt实例方法。
#include <stdio.h> #include "Test.h" JNIEXPORT jint JNICALL Java_Test_nextInt(JNIEnv* env, jclass jc) { /* 获得 Random 类, 注意表示类的字符串 */ jclass class_Random = (*env)->FindClass(env, "java/util/Random"); /* 获得 Random 构造器 方法id, "<init>"代表构造方法 */ jmethodID id_Random = (*env)->GetMethodID(env, class_Random, "<init>", "()V"); /* 构造一个Random类型的对象 */ jobject obj_random = (*env)->NewObject(env, class_Random, id_Random, NULL); /* 下面调用这个对象的 nextInt 方法 */ jmethodID id_nextInt = (*env)->GetMethodID(env, class_Random, "nextInt", "()I"); jint ret = (*env)->CallIntMethod(env, obj_random, id_nextInt, NULL); return ret; }
案例八： 在本地方法中处理异常
public class Test { static { System.loadLibrary("Test"); } /* 这里的luckyNumber方法纯粹测试目的： 当name为zhangsan时一定会抛出一个IllegalArgumentException异常 当name为lisi时，会调用Random.next(-10)主动抛出一个IllegalArgumentException异常，但是可以使用第二个参数来决定是否要抛出到 jvm 当name为其他值时，无异常 */ public static native int luckyNumber(String name, boolean nativeHandleException); public static void main(String[] args) { System.out.println(Test.luckyNumber("zhangsan", false)); } }
C代码：
#include <stdio.h> #include <string.h> #include "Test.h" JNIEXPORT jint JNICALL Java_Test_luckyNumber(JNIEnv* env, jclass jc, jstring name, jboolean nativeHandleException) { const char* cname; cname = (*env)->GetStringUTFChars(env, name, NULL); /* 当name为zhangsan时我们主动抛出一个异常 */ if(strcmp(cname, "zhangsan") == 0) { jclass class_Exception = (*env)->FindClass(env, "java/lang/IllegalArgumentException"); /* 主动抛出异常 */ (*env)->ThrowNew(env, class_Exception, "zhangsan is a bad guy, he can't be given a lucky number"); /* 本地方法抛出异常后并不会主动终止，所以要手动return */ return; } /* 调用Random.nextInt 产生一个随机幸运数 */ jclass class_Random = (*env)->FindClass(env, "java/util/Random"); jmethodID id_Random = (*env)->GetMethodID(env, class_Random, "<init>", "()V"); jobject obj_random = (*env)->NewObject(env, class_Random, id_Random, NULL); jmethodID id_nextInt = (*env)->GetMethodID(env, class_Random, "nextInt", "(I)I"); jint ret; /* 当name为lisi时，我们使用负数来作为nextInt的参数，从而让他抛出一个异常 */ if(strcmp(cname, "lisi") == 0) { ret = (*env)->CallIntMethod(env, obj_random, id_nextInt, (-10) ); /*检查是否有异常挂起 */ jboolean hasException = (*env)->ExceptionCheck(env); /*当有异常挂起并且要求在native中主动处理异常时，主动clear，这样就不会通知 虚拟机 了*/ if(hasException && nativeHandleException) { /* 主动清除挂起的异常 */ (*env)->ExceptionClear(env); printf("the exception is handled in native function/n"); }else if(hasException){ return; } }else{ ret = (*env)->CallIntMethod(env, obj_random, id_nextInt, 10); } return ret; }