最近搞了一个调用第三方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!\n");
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;
}
时间： 2024-10-02 23:48:27