java的JNI相关知识

学习了一下JNI，发表文章的时候不知道该选什么好了，不知道JNI应该属于那个范畴^_^。

Java基础知识——JNI入门介绍（上）

1．简介

JNI是Java Native Interface的缩写，它的设计目的是：

The standard Java class library may not support the platform-dependent features needed by your application.

You may already have a library or application written in another programming language and you wish to make it accessible to Java applications

You may want to implement a small portion of time-critical code in a lower-level programming language, such as assembly, and then have your Java application call these functions

2．JNI的书写步骤

编写带有native声明的方法的java类

使用javac命令编译所编写的java类

使用javah ?jni java类名生成扩展名为h的头文件

使用C/C++实现本地方法

将C/C++编写的文件生成动态连接库

ok

1) 编写java程序：

这里以HelloWorld为例。

代码1：

class HelloWorld {

public native void displayHelloWorld();

static {

System.loadLibrary("hello");

}

public static void main(String[] args) {

new HelloWorld().displayHelloWorld();

}

}

声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。

Load动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是System.loadLibrary();的参数“hello”是动态库的名字。

main()方法

2) 编译没有什么好说的了

javac HelloWorld.java

3) 生成扩展名为h的头文件

javah ?jni HelloWorld

头文件的内容：

/* DO NOT EDIT THIS FILE - it is machine generated */

#include

/* Header for class HelloWorld */

#ifndef _Included_HelloWorld

#define _Included_HelloWorld

#ifdef __cplusplus

extern "C" {

#endif

/*

* Class:HelloWorld

* Method:displayHelloWorld

* Signature: ()V

*/

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld

(JNIEnv *, jobject);

#ifdef __cplusplus

}

#endif

#endif

（这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。

4) 编写本地方法

实现和由javah命令生成的头文件里面声明的方法名相同的方法。

代码2：

1 #include

2 #include "HelloWorld.h"

3 #include

4 JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)

{

printf("Hello world!\n");

return;

}

注意代码2中的第1行，需要将jni.h（该文件可以在%JA V A_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入（我是这么理解的：相当于我们在编写java程序的时候，实现一个接口的话需要声明才可以，这里就是将HelloWorld.h头文件里面声明的方法加以实现。当然不一定是这样）。然后保存为HelloWorldImpl.c就ok了。

5) 生成动态库

这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。

cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll

注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。

6) 运行程序

java HelloWorld就ok。^_^

Java基础知识——JNI入门介绍（下）

3．Java类型和本地类型对应

在如下情况下，需要在本地方法中应用java对象的引用，就会用到类型之间的转换：

1）java方法里面将参数传入本地方法；

2）在本地方法里面创建java对象；

3）在本地方法里面return结果给java程序。

分为如下两种情况：

Java原始类型

像booleans、integers、floats等从Java程序中传到本地方法中的原始类型可以直接使用，下面是java中的原始类型和本地方法中的类型的对应：

Java类型本地类型字节(bit)

boolean jboolean8, unsigned

byte jbyte8

char jchar16, unsigned

short jshort16

int jint32

long jlong64

float jfloat32

double jdouble64

void void n/a

也就是说如果我在方法中传进去了一个boolean的参数的话，那么我在本地方法中就有jboolean类型与之对应。同理，如果在本地方法中return一个jint的话，那么在java中就返回一个int类型。

Java对象

Java对象做为引用被传递到本地方法中，所有这些Java对象的引用都有一个共同的父类型jobject(相当于java中的Object类是所有类的父类一样)。下面是JNI实现的一些jobject 的子类：

4．本地方法中访问java程序中的内容

1)访问String对象：

从java程序中传过去的String对象在本地方法中对应的是jstring类型，jstring类型和c 中的char*不同，所以如果你直接当做char*使用的话，就会出错。因此在使用之前需要将jstring转换成为c/c++中的char*，这里使用JNIEnv的方法转换。下面是一个例子：

代码3：

JNIEXPORT jstring JNICALL Java_Prompt_getLine

(JNIEnv *env, jobject obj, jstring prompt)

{

char buf[128];

const char *str = (*env)->GetStringUTFChars(env, prompt, 0);

printf("%s", str);

(*env)->ReleaseStringUTFChars(env, prompt, str);

这里使用GetStringUTFChars方法将传进来的prompt（jstring类型）转换成为UTF－8的格式，就能够在本地方法中使用了。

注意：在使用完你所转换之后的对象之后，需要显示调用ReleaseStringUTFChars方法，让JVM释放转换成UTF-8的string的对象的空间，如果不显示的调用的话，JVM中会一直保存该对象，不会被垃圾回收器回收，因此就会导致内存溢出。

下面是访问String的一些方法：

◆GetStringUTFChars将jstring转换成为UTF-8格式的char*

◆GetStringChars将jstring转换成为Unicode格式的char*

◆ReleaseStringUTFChars释放指向UTF-8格式的char*的指针

◆ReleaseStringChars释放指向Unicode格式的char*的指针

◆NewStringUTF创建一个UTF-8格式的String对象

◆NewString创建一个Unicode格式的String对象

◆GetStringUTFLengt获取UTF-8格式的char*的长度

◆GetStringLength获取Unicode格式的char*的长度

2) 访问Array对象：

和String对象一样，在本地方法中不能直接访问jarray对象，而是使用JNIEnv指针指向的一些方法来是用。

访问Java原始类型数组：

1）获取数组的长度：

代码4：

JNIEXPORT jint JNICALL Java_IntArray_sumArray

(JNIEnv *env, jobject obj, jintArray arr)

{

int i, sum = 0;

jsize len = (*env)->GetArrayLength(env, arr);

如代码4所示，这里获取数组的长度和普通的c语言中的获取数组长度不一样，这里使用JNIEvn的一个函数GetArrayLength。

2）获取一个指向数组元素的指针：

代码4：

jint *body = (*env)->GetIntArrayElements(env, arr, 0);

使用GetIntArrayElements方法获取指向arr数组元素的指针，注意该函数的参数，第一个是JNIEnv，第二个是数组，第三个是数组里面开始的元素

3）使用指针取出Array中的元素

代码5：

for (i=0; i

sum += body[i];

}

这里使用就和普通的c中的数组使用没有什么不同了

4）释放数组元素的引用

代码6：

(*env)->ReleaseIntArrayElements(env, arr, body, 0);

和操作String中的释放String的引用是一样的，提醒JVM回收arr数组元素的引用。

这里举的例子是使用int数组的，同样还有boolean、float等对应的数组。

获取数组元素指针的对应关系：

函数数组类型

GetBooleanArrayElements boolean

GetByteArrayElements byte

GetCharArrayElements char

GetShortArrayElements short

GetIntArrayElements int

GetLongArrayElements long

GetFloatArrayElements float

GetDoubleArrayElements double

释放数组元素指针的对应关系：

Function Array Type

ReleaseBooleanArrayElements boolean

ReleaseByteArrayElements byte

ReleaseCharArrayElements char

ReleaseShortArrayElements short

ReleaseIntArrayElements int

ReleaseLongArrayElements long

ReleaseFloatArrayElements float

ReleaseDoubleArrayElements double

访问自定义Java对象数组

The JNI provides a separate set of functions to access elements of object arrays. You can use these functions to get and set individual object array elements.

Note:You cannot get all the object array elements at once.

GetObjectArrayElement returns the object element at a given index.

SetObjectArrayElement updates the object element at a given index.

3) 访问Java对象的方法：

在本地方法中调用Java对象的方法的步骤：

①.获取你需要访问的Java对象的类：

jclass cls = (*env)->GetObjectClass(env, obj);

使用GetObjectClass方法获取obj对应的jclass。

②.获取MethodID：

jmethodID mid = (*env)->GetMethodID(env, cls, "callback", "(I)V");

使用GetMethdoID方法获取你要使用的方法的MethdoID。其参数的意义：

env??>JNIEnv

cls??>第一步获取的jclass

"callback"??>要调用的方法名

"(I)V"??>方法的Signature

③.调用方法：

(*env)->CallV oidMethod(env, obj, mid, depth);

使用CallV oidMethod方法调用方法。参数的意义：

env??>JNIEnv

obj??>通过本地方法穿过来的jobject

mid??>要调用的MethodID（即第二步获得的MethodID）

depth??>方法需要的参数（对应方法的需求，添加相应的参数）

注：这里使用的是CallVoidMethod方法调用，因为没有返回值，如果有返回值的话使用对应的方法，在后面会提到。

方法的Signature

方法的Signature是由方法的参数和返回值的类型共同构成的，下面是他们的结构：

"(argument-types)return-type"

其中Java程序中参数类型和其对应的值如下：

Signature Java中的类型

Z boolean

B byte

C char

S short

I int

J long

F float

D double

L fully-qualified-class;fully-qualified-class

[ type type[]

( arg-types ) ret-type method type

一个Java类的方法的Signature可以通过javap命令获取：

javap -s -p Java类名

给调用的函数传参数：

通常我们直接在methodID后面将要传的参数添加在后面，但是还有其他的方法也可以传参数：

CallVoidMethodV可以获取一个数量可变的列表作为参数；

CallVoidMethodA可以获取一个union。

调用静态方法：

就是将第二步和第三步调用的方法改为对应的：

GetStaticMethodID获取对应的静态方法的ID

CallStaticIntMethod调用静态方法

调用超类的方法：

用的比较少，自己看啦。^_^。

4)访问Java对象的属性：

访问Java对象的属性和访问Java对象的方法基本上一样，只需要将函数里面的Method 改为Field即可（当然还有不

JA V A JNI 使用实例

JA V A可以通过JNI接口访问本地的动态连接库，从而扩展JA V A的功能。使用JA V A JNI接口主要包括以下步骤：

(1)编写JA V A代码，注明要访问的本地动态连接库和本地方法；

(2)编译JA V A代码得到.class文件；

(3)使用javah -jni 生成该类对应的C语言.h文件；

(4)使用C/C++实现（3）生成的.h文件中声明的各函数；

(5)编译C/C++实现代码生成动态连接库。

本文使用一个简单的helloWorld示例演示JNI的使用。

（1）编写JA V A代码

public class helloWorld

{

public native void SayHello(String name);

static

{

System.loadLibrary("examdll");

}

public static void main(String [] argv)

{

helloWorld hello = new helloWorld();

hello.SayHello("myName");

}

}

（2）编译JA V A代码

javac helloWorld.java

（3）生成实现函数头文件

javah -classpath . helloWorld

得到的文件内容如下：

/* DO NOT EDIT THIS FILE - it is machine generated */

#include

/* Header for class helloWorld */

#ifndef _Included_helloWorld

#define _Included_helloWorld

#ifdef __cplusplus

extern "C" {

#endif

/*

* Class: helloWorld

* Method: SayHello

* Signature: (Ljava/lang/String;)V

*/

JNIEXPORT void JNICALL Java_helloWorld_SayHello

(JNIEnv *, jobject, jstring);

#ifdef __cplusplus

}

#endif

#endif

（4）在VC中实现上述函数

#include "helloWorld.h"

#include

#include

void JNICALL Java_helloWorld_SayHello(JNIEnv * env, jobject obj, jstring str)

{

jboolean b = true;

char s[80];

memset(s, 0, sizeof(s));

strcpy_s(s ,(char*)env->GetStringUTFChars(str, &b));

printf("Hello, %s", s);

env->ReleaseStringUTFChars(str , NULL);

}

**** 这是JNI的关键：通过env我们可以使用JA V A提供的一组函数操作与转换函数传递的参数。

（5）编译VC项目得到动态连接库examdll.dll。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

附：如何操作与返回JA V A的参数与类型，这篇文章有些实际的例子可供参考：

https://www.360docs.net/doc/3315372107.html,/s/blog_548cc485010005ct.html

JA V A以其跨平台的特性深受人们喜爱，而又正由于它的跨平台的目的，使得它和本地机器的各种内部联系变得很少，约束了它的功能。解决JA V A对本地操作的一种方法就是JNI。JA V A通过JNI调用本地方法，而本地方法是以库文件的形式存放的（在WINDOWS平台上是DLL文件形式，在UNIX机器上是SO文件形式）。通过调用本地的库文件的内部方法，使JA V A可以实现和本地机器的紧密联系，调用系统级的各接口方法。

JNI在Windows上的使用

运行环境

CPU ：AMD Moblie Athlon 64 3200+

Mem ：1024 MB

OS : Windows xp sp2

JDK ：java version "1.5.0_06"

IDE : Eclipse 3.1.2 、Microsoft Visual Studio

2005

编写JA V A 代码

//JNITest.java

/**

* @author chunyv

*

*/

public class JNITest {

/**

* @param args

*/

static

{

try

{

System.loadLibrary("JNITest");

}

catch(Exception e)

{

System.out.println("load library failure!");

}

}

public native static void version();

public native static void setint(int i);

public native static int getint();

public native static void setstr(String str);

public native static String getstr();

public native static void setgbk(byte[] gbkstr);

public native static byte[] getgbk();

public static void main(String[] args) {

// TODO Auto-generated method stub

String test = "Hello World!";

String test2 = "你好!\n\t\t--chunyv";

System.out.println("Proc Start");

byte[] end = {0};

try

{

byte[] mybytedb = test2.getBytes("gbk");

byte[] mybyte = new byte[mybytedb.length + end.length];

System.arraycopy(mybytedb , 0 , mybyte , 0 ,mybytedb.length);

System.arraycopy(end , 0 , mybyte , mybytedb.length , end.length);

JNITest jnitest = new JNITest();

jnitest.setint(6);

System.out.println("setint ok");

System.out.println("get int form library :"+jnitest.getint());

System.out.println("getint ok");

jnitest.setstr(test);

System.out.println("setstr ok");

System.out.println(jnitest.getstr());

System.out.println("getstr ok");

jnitest.setgbk(mybyte);

System.out.println("setgbk ok");

System.out.println(jnitest.getgbk());

System.out.println("getgbk ok");

jnitest.version();

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

生成.h 文件

javac JNITest.java

javah JNITest

实现JNITest.h 中的方法

/*

* author chunyv

* JNITest dll

*/

#include "JNITest.h"

#include

JNIEXPORT void JNICALL Java_JNITest_version (JNIEnv *, jclass)

{

printf("JNI Test\n\t\t--chunyv");

}

JNIEXPORT void JNICALL Java_JNITest_setint (JNIEnv *, jclass, jint ii)

{

i = ii;

}

JNIEXPORT jint JNICALL Java_JNITest_getint (JNIEnv *, jclass)

{

return i;

}

JNIEXPORT void JNICALL Java_JNITest_setstr (JNIEnv * env, jclass, jstring jstr)

{

jboolean test = true;

memset(str , 0 , sizeof(str));

sprintf_s(str ,env->GetStringUTFChars(jstr,&test)); env->ReleaseStringUTFChars(jstr , NULL);

}

JNIEXPORT jstring JNICALL Java_JNITest_getstr

(JNIEnv * env, jclass)

{

return WindowsTojstring(env , str);

}

JNIEXPORT void JNICALL Java_JNITest_setgbk

(JNIEnv * env, jclass, jbyteArray myjbyte)

{

memset(strgbk , 0 , sizeof(strgbk));

sprintf_s(strgbk ,(char *)env->GetByteArrayElements(myjbyte,0));

}

JNIEXPORT jstring JNICALL Java_JNITest_getgbk

(JNIEnv * env, jclass)

{

return WindowsTojstring(env , strgbk);

}

jstring WindowsTojstring( JNIEnv* env, char* str_tmp )

{

jstring rtn = 0;

int slen = (int)strlen(str_tmp);

unsigned short * buffer = 0;

if( slen == 0 )

{

rtn = env->NewStringUTF(str_tmp );

}

else

{

int length = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str_tmp, slen, NULL, 0 );

buffer = (unsigned short *)malloc( length*2 + 1 );

if( MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str_tmp, slen, (LPWSTR)buffer, length ) >0 )

{

rtn = env->NewString( (jchar*)buffer, length );

}

}

if( buffer )

{

free( buffer );

}

return rtn;

}

将生成的JNITest.dll 放到.class 所在的目录测试

java JNITest

Proc Start

setint ok

get int form library :6

getint ok

setstr ok

Hello World!

getstr ok

setgbk ok

你好!

--chunyv

getgbk ok

JNI Test

--chunyv

JNI 在FreeBSD 上的应用

运行环境

CPU ：Intel(R) Pentium(R) 4 CPU 2.40GHz (2393.94-MHz 686-class CPU)

Mem ：512 MB

OS : FreeBSD 6.2-PRERELEASE

JDK ：java version "1.5.0"

IDE : vim + gcc 3.4.4

java代码同上

生成.h 文件同上

实现JNITest.h 中的方法

/*

* author chunyv

* JNITest so

* add "int FreeBSD2Jstring(char * src ,

* char * dst,

* int * len);" into JNITest.h

*/

#include

#include

#include

#include

#include "JNITest.h"

int i = 0;

char str[1024];

char strgbk[1024];

JNIEXPORT void JNICALL Java_JNITest_version

(JNIEnv *env, jclass jc)

{

printf("JNI Test\n\t\t--chunyv\n");

}

JNIEXPORT void JNICALL Java_JNITest_setint

(JNIEnv * env, jclass jc, jint ii)

{

i = ii;

}

JNIEXPORT jint JNICALL Java_JNITest_getint

(JNIEnv * env, jclass jc)

{

return i;

}

JNIEXPORT void JNICALL Java_JNITest_setstr

(JNIEnv * env, jclass jc, jstring jstr)

{

jboolean test = 1;

memset(str , 0 , sizeof(str));

sprintf(str ,(*env)->GetStringUTFChars(env ,jstr,&test));

(*env)->ReleaseStringUTFChars(env ,jstr , NULL);

}

JNIEXPORT jstring JNICALL Java_JNITest_getstr

(JNIEnv * env, jclass jc)

{

return (*env)->NewStringUTF(env ,str);

}

JNIEXPORT void JNICALL Java_JNITest_setgbk

(JNIEnv * env, jclass jc, jbyteArray myjbyte)

{

memset(strgbk , 0 , sizeof(strgbk));

sprintf(strgbk ,(char *)(*env)->GetByteArrayElements(env ,myjbyte,0));

}

JNIEXPORT jstring JNICALL Java_JNITest_getgbk

(JNIEnv * env, jclass jc)

{

char test[1024] ;

sprintf(test ,strgbk);

int len = (int ) strlen(strgbk);

if( FreeBSD2Jstring(test , strgbk ,&len ))

{

printf("convert error\n");

return NULL;

}

return (*env)->NewStringUTF(env ,strgbk);

}

int FreeBSD2Jstring(char * src ,

char * dst,

int * len)

{

size_t n_in = strlen(src);

size_t n_out = *len+2;

memset(dst , 0 , n_out);

iconv_t test = iconv_open("UTF-8","GBK");

if(test == (iconv_t)-1)

{

printf("iconv open error\n");

return -1;

}

if((size_t)-1 == iconv(test ,(const char **) & src ,&n_in , & dst , &n_out))

{

printf("iconv convert error\n");

return -1;

}

if(test)

{

iconv_close(test);

}

*len = n_out;

return 0;

}

编译.c 文件，将生成的库文件放到.class 所在目录并测试.class

编译库文件

gcc -Wall -fPIC -shared -o libJNITest.so -I /usr/local/diablo-jdk1.5.0/include/ -I /usr/local/diablo-jdk1.5.0/include/freebsd/ -I /usr/local/include/ -liconv -L /usr/local/lib/ JNITest.c

测试 .class

java -Djava.library.path=./ JNITest

测试结果

Proc Start

setint ok

get int form library :6

getint ok

setstr ok

Hello World!

getstr ok

setgbk ok

你好!

--chunyv

getgbk ok

JNI Test

--chunyv

JNI在Linux上的使用请参阅《JNI在FreeBSD上的使用》部分

JA V A JNI在linux下开发的大致流程：

1. 编写带有native声明的方法的java类(比如:Test.java, 在linux环境下直接vim Test.java打开文件编写即可)

2. 使用javac命令编译所编写的java类,生成java类的.class文件(javac Test.java)

3. 使用javah+类名生成扩展名为.h的文件(javah Test生成Test.h)

4. 生成打开一个.c文件(vim Test.c)在该文件内实现.h文件中对应于java类中native函数所生成的JNI函数(该JNI函数实际上就是Java类中声明的native函数的一个本地映射，目的就是可以在该JNI函数内来调用本地的C语言函数库)

5. 在该.c文件中的JNI函数中就可以调用本地C语言函数库的API了(比如:t1.c内的函数)

6. 利用gcc -fPIC -shared -o libTest.so Test.c t1.c来生成linux下的.so文件

gcc -fPIC -shared -I/usr/java/jdk1.6.0_26/include -I/usr/java/jdk1.6.0_26/include/linux -I/platform/lsf/8.0/include -o libjob.so JobManager.c cresda.job.c /platform/lsf/8.0/linux2.6-glibc2.3-x86_64/lib/libbat.a

/platform/lsf/8.0/linux2.6-glibc2.3-x86_64/lib/liblsf.a

7. 然后回到Test.java类中添加相应的动态加载库文件的代码:

比如：static{

System.loadLibrary("Test");

}

8. 重新编译该Test.java文件

9. 如果在这个时候运行该编译后的Test.class文件, 可能会报如下错误：

https://www.360docs.net/doc/3315372107.html,ng.UnsatisfiedLinkError: libTest: libTest.so: cannot open shared object file: No such file or directory

at https://www.360docs.net/doc/3315372107.html,ng.Runtime._load(libgcj.so.7rh)

at https://www.360docs.net/doc/3315372107.html,ng.Runtime.loadLibrary(libgcj.so.7rh)

at https://www.360docs.net/doc/3315372107.html,ng.System.loadLibrary(libgcj.so.7rh)

at Test.(Test.java:11)

at https://www.360docs.net/doc/3315372107.html,ng.Class.initializeClass(libgcj.so.7rh)

这是由于环境变量没有设置相应当前这个Test类的路径造成的，可以通过export LD_LIBRARY_PA TH=/home/test/t2来设置当前这个类所在的路径(这里我们是把类放在了/home/test/t2的,所以这样设置)

10. 最后通过java Test命令来调用运行这个编译后的Test.class文件, 这个java类就能实现调用本地的函数库了(比如:t1.c内的函数)

wsimport –d . –keep wsdl地址