java 本地方法（JNI）

时间：2017-01-13 22:24:51 阅读：344 评论：0 收藏：0 [点我收藏+]

标签：不能 static char code sha win tostring open 语言

最近搞了一个调用第三方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;
}

java 本地方法（JNI）

标签：不能 static char code sha win tostring open 语言

原文地址：http://www.cnblogs.com/zh1164/p/6283831.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

java 本地方法（JNI）

调用本地方法

案例1：

计算两个int的和（传入int参数并返回int类型）

案例二：给传入的name加上hello前缀再返回（传入String参数并返回String类型）

案例三： 在C代码中调用PrintWriter.print方法（调用java对象的实例方法）

案例五： 在C中修改Employee的静态和实例属性（修改实例属性和静态属性）

案例六：访问修改数组

案例七：在Ｃ中访问构造函数并构造对象

案例八： 在本地方法中处理异常

案例三：在C代码中调用PrintWriter.print方法（调用java对象的实例方法）

案例五：在C中修改Employee的静态和实例属性（修改实例属性和静态属性）

案例八：在本地方法中处理异常