JNI概念

最新推荐文章于 2023-05-10 09:59:44 发布

guoyf123321

最新推荐文章于 2023-05-10 09:59:44 发布

阅读量459

点赞数

分类专栏：网络通信

网络通信专栏收录该内容

5 篇文章 0 订阅

订阅专栏

JNI

编辑

JNI是Java Native Interface的缩写，它提供了若干的 API实现了Java和其他语言的通信（主要是 C& C++）。从Java1.1开始，JNI标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他编程语言，只要调用约定受支持就可以了。使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的。例如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少要保证本地代码能工作在任何Java 虚拟机环境下。

中文名

Java本地接口

外文名

Java Native Interface

功能

Java和本地代码间的双向交互

允许

Java代码

JNI的角色编辑

JNI可以这样与本地程序进行交互：

1、你可以使用JNI来实现“本地方法”（ native methods），并在JAVA程序中调用它们。

2、JNI支持一个“调用接口”（invocation interface），它允许你把一个 JVM嵌入到本地程序中。本地程序可以链接一个实现了JVM的本地库，然后使用“调用接口”执行JAVA语言编写的软件模块。例如，一个用C语言写的浏览器可以在一个嵌入式JVM上面执行从网上下载下来的applets。

JNI的副作用编辑

一旦使用JNI，JAVA程序就丧失了JAVA平台的两个优点：

1、程序不再跨平台。要想跨平台，必须在不同的系统环境下重新编译本地语言部分。

2、程序不再是绝对安全的，本地代码的不当使用可能导致整个程序崩溃。一个通用规则是，你应该让本地方法集中在少数几个类当中。这样就降低了JAVA和C之间的耦合性。

什么场合下应该使用JNI编辑

当你开始着手准备一个使用JNI的项目时，请确认是否还有替代方案。像上一节所提到的，应用程序使用JNI会带来一些副作用。下面给出几个方案，可以避免使用JNI的时候，达到与本地代码进行交互的效果：

1、JAVA程序和本地程序使用 TCP/IP或者 IPC进行交互。

2、当用JAVA程序连接本地数据库时，使用 JDBC提供的API。

3、JAVA程序可以使用分布式对象技术，如JAVA IDL API。

这些方案的共同点是，JAVA和C处于不同的线程，或者不同的机器上。这样，当本地程序崩溃时，不会影响到JAVA程序。

下面这些场合中，同一进程内JNI的使用无法避免：

1、程序当中用到了JAVA API不提供的特殊系统环境才会有的特征。而跨进程操作又不现实。

2、你可能想访问一些己有的本地库，但又不想付出跨进程调用时的代价，如效率，内存，数据传递方面。

3、JAVA程序当中的一部分代码对效率要求非常高，如算法计算，图形渲染等。

总之，只有当你必须在同一进程中调用本地代码时，再使用JNI。

JNI的演化编辑

JDK1.0包含了一个本地方法接口，它允许JAVA程序调用C/C++写的程序，许多第三方的程序和JAVA类库。如：java.lang,java.io,java.net等都依赖于本地方法来访问底层系统环境的特征。

不幸的是，JDK1.0中的本地方法有两个主要问题：

1、本地方法像访问C中的结构（structures）一样访问对象中的字段。尽管如此，JVM规范并没有定义对象怎么样在内存中实现。如果一个给定的JVM实现在布局对象时，和本地方法假设的不一样，那你就不得不重新编写本地方法库。

2、因为本地方法可以保持对JVM中对象的直接指针，所以，JDK1.0中的本地方法采用了一种保守的 GC策略。

JNI的诞生就是为了解决这两个问题，它可以被所有平台下的JVM支持：

（1）每一个JVM实现方案可以支持大量的本地代码。

（2）开发工具作者不必处理不同的本地方法接口。

（3）本地代码可以运行在不同的JVM上面。

JDK1.1中第一次支持JNI，但是，JDK1.1仍在使用老风格的本地代码来实现JAVA的API。这种情况在JDK1.2下被彻底改变成符合标准的写法。

JNI的设计目的编辑

标准的java类库可能不支持你的程序所需的特性。或许你已经有了一个用其他语言写成的库或程序，而你希望在java程序中使用它。

你可能需要用底层语言实现一个小型的时间敏感代码，比如汇编，然后在你的java程序中调用这些功能。

书写步骤编辑

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

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

JNI (2张)

,然后使用javah + java类名生成扩展名为h的头文件

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

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

·ok

1) 编写java程序：这里以HelloWorld为例。

代码1：

 
        public  
        class  
        HelloWorld { 
       
        public  
        native  
        void  
        displayHelloWorld(); 
        //所有native关键词修饰的都是对本地的声明 
       
        static  
        { 
       
        System.loadLibrary( 
        "hello" 
        ); 
        //载入本地库 
       
        } 
       
        public  
        static  
        void  
        main(String[] args) { 
       
        new  
        HelloWorld().displayHelloWorld(); 
       
        } 
       
        }

声明 native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明该方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。 Load动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法 displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以 static块进行加载的。同时需要注意的是System. loadLibrary();的参数“hello”是动态库的名字。

2) 编译

没有什么好说的了 javac HelloWorld.java

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

jni HelloWorld 头文件的内容：

 
        /*DO NOT EDI TTHIS FILE - it is mach inegenerated*/ 
       
        #include<jni.h> 
       
        /*Header for class HelloWorld*/ 
       
        #ifndef_Included_HelloWorld 
       
        #define_Included_HelloWorld 
       
        #ifdef__cplusplus 
       
        extern 
        "C" 
        { 
       
        #endif 
       
        /* 
       
        *Class:HelloWorld 
       
        *Method:displayHelloWorld 
       
        *Signature:()V 
       
        */ 
       
        JNIEXPORTvoidJNICALL 
       
        Java_HelloWorld_displayHelloWorld(JNIEnv*,jobject); 
       
        #ifdef__cplusplus 
       
        } 
       
        #endif 
       
        #endif

JNI

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

4) 编写本地方法实现和由javah命令生成的头文件里面声明的方法名相同的方法。

代码2：

 
        #include"jni.h" 
       
        #include"HelloWorld.h" 
       
        //#includeotherheaders 
       
        JNIEXPORT  
        void  
        JNICALL 
       
        Java_HelloWorld_displayHelloWorld(JNIEnv*env,jobject obj) 
       
        { 
       
        printf 
        ( 
        "Helloworld!\n" 
        ); 
       
        return 
        ; 
       
        }

JNI

注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_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文件。

如果配置了MinGW,也可以这样来编译：gcc -Wall -D_JNI_IMPLEMENTATION_ -Wl,--kill-at -Id:/java/include –Id:/java/include/win32 -shared -o (输出的dll文件名，如sum.dll) (输入的c/c++源文件,如abc.c)。

6) 运行程序

javaHelloWorld就ok.

如果用eclipse，需将dll或so文件放在项目下，而不是src及其子目录下。

如果用命令行编译，把dll文件放在该包的同目录下。 ^[1]

使用例子编辑

下面是一个简单的例子实现打印一句话的功能，但是用的c的printf最终实现。一

JNI

般提供给java的jni接口包括一个so文件（封装了 c函数的实现）和一个java文件（需要调用 path的类）。

1． JNI的目的是使java方法中能够调用c实现的一些函数，比如以下的java类，就需要调用一个本地函数testjni（一般声明为private native类型），首先需要创建文件weiqiong.java，内容如下：

class weiqiong { static { System.loadLibrary("testjni");//载入静态库，test函数在其中实现 } private native void testjni(); //声明本地调用 public void test() { testjni(); } public static void main(String args[]) { weiqiong haha = new weiqiong(); haha.test(); } }

2．然后执行 javac weiqiong.java，如果没有报错，会生成一个weiqiong.class。

3．然后设置classpath为你当前的工作目录，如直接输入命令行：set classpath = weiqiong.class所在的完整目录（如 c:\test)再执行javah weiqiong，会生成一个文件weiqiong.h文件，其中有一个函数的声明如下：

JNIEXPORT void JNICALL Java_weiqiong_testjni (JNIEnv *, jobject);

4．创建文件testjni.c将上面那个函数实现，内容如下：

1. include

2. include

JNIEXPORT void JNICALL Java_weiqiong_testjni (JNIEnv *env, jobject obj) { printf("haha---------go into c!!!\n"); }

5．为了生成.so文件，创建makefile文件如下：

libtestjni.s o:testjni.o makefile gcc -Wall -rdynamic -shared -o libtestjni. so testjni.o testjni.o:testjni.c weiqiong.h gcc -Wall -c testjni.c -I./ -I/usr/java/j2sdk1.4.0/include -I/usr/java/j2sdk1.4.0/include/linux cl: rm -rf *.o *.so 注意：gcc前面是tab空，j2sdk的目录根据自己装的j2sdk的具体版本来写，生成的so文件的名字必须是loadLibrary的参数名前加“lib”。

6．export LD_LIBRARY_PATH=.，由此设置library路径为当前目录，这样java文件才能找到so文件。一般的做法是将so文件copy到本机的LD_LIBRARY_PATH目录下。

7．执行java weiqiong，打印出结果：“haha---------go into c!!!”

调用问题编辑

在首次使用JNI的时候有些疑问，后来在使用中一一解决，下面就是这些问题的备忘：

1.java和c是如何互通的？

其实不能互通的原因主要是数据类型的问题，jni解决了这个问题，例如那个c文件中的jstring数据类型就是java传入的String对象，经过jni函数的转化就能成为c的char*。

对应数据类型关系如下表：

Java 类型	本地 C 类型	实际表示的 C 类型（Win32）	说明
boolean	jboolean	unsigned char	无符号，8 位
byte	jbyte	signed char	有符号，8 位
char	jchar	unsigned short	无符号，16 位
short	jshort	short	有符号，16 位
int	jint	long	有符号，32 位
long	jlong	__int64	有符号，64 位
float	jfloat	float	32 位
double	jdouble	double	64 位
void	void	N/A	N/A

JNI 还包含了很多对应于不同 Java 对象的引用类型如下图：

2. 如何将java传入的String参数转换为c的char*，然后使用?

java传入的String参数，在c文件中被jni转换为jstring的数据类型，在c文件中声明char* test，然后test = (char*)(*env)->GetStringUTFChars(env, jstring, NULL);注意：test使用完后，通知虚拟机平台相关代码无需再访问：(*env)->ReleaseStringUTFChars(env, jstring, test);

3. 将c中获取的一个char*的buffer传递给java？

这个char*如果是一般的字符串的话，作为string传回去就可以了。如果是含有’\0’的buffer，最好作为bytearray传出，因为可以制定copy的length，如果copy到string，可能到’\0’就截断了。

有两种方式传递得到的数据：

一种是在jni中直接new一个byte 数组，然后调用函数(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);将buffer的值copy到bytearray中，函数直接return bytearray就可以了。

一种是return错误号，数据作为参数传出，但是java的基本数据类型是传值，对象是传递的引用，所以将这个需要传出的byte 数组用某个类包一下，如下：

class RetObj { public byte[] bytearray; } 这个对象作为函数的参数retobj传出，通过如下函数将retobj中的byte数组赋值便于传出。代码如下：

jclass cls;

jfieldID fid;

jbyteArray bytearray;

bytearray = (*env)->NewByteArray(env,len);

(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);

cls = (*env)->GetObjectClass(env, retobj);

fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]);

(*env)->SetObjectField(env, retobj, fid, bytearray);

4. 不知道占用多少空间的buffer，如何传递出去呢？

在jni的c文件中new出空间，传递出去。java的数据不初始化，指向传递出去的空间即可。

数据处理编辑

1．如果传入的是bytearray的话，作如下处理得到buffer：

char *tmpdata = (char*)(*env)->GetByteArrayElements(env, bytearray, NULL); (*env)->ReleaseByteArrayElements(env, bytearray, tmpdata, 0);

软件开发编辑

基于JNI的嵌入式手机软件开发实例下面通过一个实例来描述运用JNI技术在手机上操纵摄像头，捕捉视频并存储图片的过程。

活动状态

图2为捕捉视频并存储图片的活动/状态图

JNI

根据图2的活动/状态，具体的对应步骤如下：

①发起该流程。

②发起流程后，建立文件用于存储图片。

③用指针获得分配的缓冲器，用于存储获得的帧。

④将指针压栈(序列化缓冲器)。由于手机的内存较小，为了防止内存泄漏， Symbian操作系统有一个Cleanupstack的要求，即在使用指针时，用PushL把指针压入栈中，使用完后再用Pop弹出栈．如果在中间调用导致崩溃的函数时果真出现了问题，那么Cleanupstack可以通过调用该指针的析构函数回收占用的空间。

⑤操纵摄像头，捕捉视频，并将图像流从摄像头端传到缓冲器。

⑥将摄像头内的图像流存入缓冲器内，并将缓冲器内的流转化为文件流，存为jpg格式的文件，将指向缓冲器的指针弹栈。

⑦在过程⑥中，如果使用完了序列化的缓冲器，则要重新序列化缓冲器，以备后面使用。

⑧当接收到停止视频捕捉的信号后，关闭文件。

⑨流程结束。

视频捕捉

子功能捕捉视频的实现是由操纵摄像头、视频播放( 解码器准备)以及建立摄像头和手机之间的连接会话三个活动组成的。其中操纵摄像头是通过调用底层设备的驱动来实现的，需要利用JNI来实现，完成的方法包括准备、建立、删除、销毁摄像头等。视频播放的一系列过程也是通过c++代码来实现的，除了准备、建立、删除、销毁解码器外，还有开始、暂停、停止解码等。建立摄像头和手机之间的连接类似建立客户端和服务器连接，视频流从摄像头传到手机界面是通过多媒体会话来完成的。多媒体会话的建立、关闭、摧毁以及会话建立后的发送、取消、读取数据等也是JNI的应用范畴。

最近好几个朋友问我怎样通过Java获得系统硬件相关信息，比如CPU频率，占用，内存大小，磁盘大小，MAC地址等等，正常的Java SDK没法提供这些功能，只能通过JNI来实现。这里就写一下大致的步骤，希望能帮助那些想系统性掌握类似平台相关信息获取的开发方法。如果你想完整的看下去，最好需要知道以下几点：

有一定的C/C++开发基础
熟悉Windows的API机制(win32)
了解Java Native Interface(JNI)

开发一个JNI应用一般分为两个两个部分，Java接口和C/C++实现，这里为了方便，我们将使用C++，因为Windows的普遍性，这里使用Windows作为Java的安装平台。下面首先从Welcome演示这两步骤。

1 Welcome示例

welcome示例非常简单，传入一个String参数，响应一个字符串，比如参数为 "令狐冲"，响应结果为" 欢迎令狐冲同学"。

1.1 定义Java接口

使用Eclipse创建一个工程，接着创建一个类，如下图：

1 package com.lifesting.jni;
2
3 public class SysInfo {
4 public native String welcome(String who);
5 }

1.2 生成JNI头文件

打开命令行，使用javah程序(%JAVA_HOME%\bin\javah)生成JNI头文件，比如：

javah -classpath ./bin com.lifesting.jni.SysInfo

这将会在目录下生成一个com_lifesting_jni_SysInfo.h的头文件，里面申明了Java welcome方法声明对应的C 声明

JNIEXPORT jstring JNICALL Java_com_lifesting_jni_SysInfo_welcome
(JNIEnv * , jobject, jstring);

1.3 创建JNI实现工程

为了体验一把c++0x，我机器上装的是Visual Studio 2010 ，这个工程并没有使用到VS 2010的特性，2005、2008、2010基本差不多。

通过菜单new一个为win32 console application project，将application type设置为dll选项，去除掉MFC和ATL，因为只需要用到Windows SDK。其它默认。创建完毕之后添加java开发的头文件和库文件。

1.3.1 添加头文件

打开项目属性页，点击Configuration Properties -> C/C++ ->General，在Additional Include Directories中输入两条

$(JAVA_HOME)\include

$(JAVA_HOME)\include\win32

1.3.2 添加库文件

打开项目属性页，点击Configuration Properties -> Linker -> General，在Additional Library Directories中输入一条

$(JAVA_HOME)\lib

仅接着选择 Configuration Properties -> Linker -> Input，在Additional Dependencies中输入两条

jvm.lib

jawt.lib(这个是awt的native接口，可以不用)

1.3.3 编写

将 com_lifesting_jni_SysInfo.h文件拷贝到工程目录并添加到工程中，然后打开与项目名同名的cpp文件，然后加上以下代码

代码

1 #include " com_lifesting_jni_SysInfo.h "
2
3 JNIEXPORT jstring JNICALL Java_com_lifesting_jni_SysInfo_welcome
4     (JNIEnv * env, jobject obj, jstring who){
5         jboolean no_copy = JNI_FALSE;
6         wchar_t * w_who = (wchar_t * )env -> GetStringChars(who, & no_copy);
7         wchar_t * pre = L " 欢迎 " ;
8         wchar_t * post = L " 同学! " ;
9         wchar_t * stmt = new wchar_t[wcslen(pre) + wcslen(w_who) + wcslen(post) + 1 ];
10         wsprintf(stmt,L " %s%s%s " ,pre,w_who,post);
11         jstring welcome = env -> NewString((jchar * )stmt,wcslen(stmt));
12         delete[] stmt;
13          return welcome;
14 }

这段代码的意思很简单，就是通过JNI API重新创建一个String，值得注意的是这里将wchar_t*和jchar*直接对等起来，因为它们都使用了utf-16的编码，不仅Java的String，.Net的char也可以与wchar_t直接对等，.Net String同样使用了utf-16编码。

编译将会产生与项目名称相同的dll文件，这里假设创建了一个jnihello工程，生成一个jnihello.dll。

1.4 运行

在运行之前，需要对SysInfo对一个小改动，告诉Java需要引入一个JNI实现包，即我们的dll，在SysInfo加入如下代码：

1 public class SysInfo {
2      static {
3         System.loadLibrary( " jnihello " );
4     }
5      public native String welcome(String who);
6 }

因为Java在winows下面的dynamic library后缀为dll，在linux下面为so，所以这个System.loadLibrary自动会根据系统加上不同后缀。

接着要创建一个测试类

1 package com.lifesting.jni;
2
3 public class TestNative {
4
5      public static void main(String[] args) {
6         SysInfo sys = new SysInfo();
7         System.out.println(sys.welcome( " 令狐冲 " ));
8     }
9 }

因为java.exe在运行的时候java.library.path属性不能指定，所以我们有两种选择，一种是将jnihello.dll拷贝到eclipse工程根目录，然后直接运行TestNative，或者在有jnihello.dll的目录运行命令行，比如我使用第二种，如下图

这样一个JNI应用的代码基本过程和框架就确定下来了，剩下的就是添加java api和c++ implementation

2 获取CPU，内存，MAC地址信息

2.1 定义三个Java接口，分别获取内存大小，MAC地址信息和CPU主频

代码

1 public class SysInfo {
2      static {
3         System.loadLibrary( " jnihello " );
4     }
5      public native String welcome(String who);
6      // in MB
7      public native int memorySize();
8      // in MHZ: 1866
9      public native int cpuSpeed();
10      public native String[] macAddress();
11 }

真实的接口应该不是这个样子，这儿主要是为了演示方便

重新生成jni头文件，放到jni c++工程中。

2.2 代码实现

这三个中获取内存是最简单的，先从内存开始

物理内存获取

1 JNIEXPORT jint JNICALL Java_com_lifesting_jni_SysInfo_memorySize
2     (JNIEnv * env, jobject obj)
3 {
4     MEMORYSTATUSEX ms;
5     ms.dwLength = sizeof (ms);
6     GlobalMemoryStatusEx( & ms);
7      long mb = ms.ullTotalPhys >> 20 ;
8      return (jint)mb;
9 }

要注意的是这里使用了MEMORYSTATUSEX，因为现在好多电脑都使用超过2G内存， >>20 表示从Byte到MB，即除以1024*1024

CPU频率

1 unsigned __int64 CycleCount()
2 {
3     ULARGE_INTEGER t0;
4     __asm
5     {
6         _emit   0x0f
7             _emit   0x31
8             MOV t0.LowPart, EAX
9             MOV t0.HighPart, EDX
10     }
11      return * ((__int64 * ) & t0);
12 }
13
14 long GetCpuSpeed()
15 {
16     unsigned __int64 start, stop;
17      long total;
18     start = CycleCount();
19     Sleep( 1000 );
20     stop = CycleCount();
21     stop = stop - start;
22     total = ( long )(stop / 1000000 );
23      return total;
24 }
25
26 JNIEXPORT jint JNICALL Java_com_lifesting_jni_SysInfo_cpuSpeed
27     (JNIEnv * env, jobject obj)
28 {
29      return GetCpuSpeed();
30 }

这段代码使用了win32位汇编，主频的高低位来自于EAX、EDX寄存器，采集的是1秒的频率，此代码来自于http://www.codeproject.com/KB/system/Processor_Speed.aspx

取MAC地址的稍微麻烦点

获取mac地址

#include < winsock2.h >
#include < iphlpapi.h >
#include < stdio.h >
#include < stdlib.h >
#pragma comment(lib, "IPHLPAPI.lib")

JNIEXPORT jobjectArray JNICALL Java_com_lifesting_jni_SysInfo_macAddress
    (JNIEnv * env, jobject obj){
    IP_ADAPTER_INFO adapter_info[ 4 ];
    DWORD dwBufLen = sizeof (adapter_info);
    PIP_ADAPTER_INFO adapter = NULL;

     if (GetAdaptersInfo(
            adapter_info,
             & dwBufLen) == NO_ERROR){
        jobjectArray mac_addresses = env -> NewObjectArray( 4 , env -> FindClass( " java/lang/String " ),NULL);
        adapter = adapter_info;
         int count = 0 ;
         char mac_buffer[ 24 ];
         while (adapter){
　　      memset(mac_buffer,NULL, 24 );
             for ( int i = 0 ; i < adapter -> AddressLength; i ++ ){
                 if (i == (adapter -> AddressLength - 1 ))
                {
                     char mac_seg[ 3 ];
                    sprintf(mac_seg, " %.2X " , ( int ) adapter -> Address[i]);
                    strcat(mac_buffer,mac_seg);
                }
                 else {
                     char mac_seg[ 4 ];
                    sprintf(mac_seg, " %.2X- " ,( int )adapter -> Address[i]);
                    strcat(mac_buffer,mac_seg);
                }
            }
            env -> SetObjectArrayElement(mac_addresses,count++,env -> NewStringUTF(mac_buffer));
            adapter = adapter -> Next;
        }
         return mac_addresses;
    }
     return NULL;
}

#progra编译扩展与手动添加Linker Dependency效果一样的。mac_buffer使用了24个是因为定义里Address可以有8段，每段2个字符，加上7个'-'字符，还有一个NULL结束符，共计24个。此段代码参考 http://msdn.microsoft.com/en-us/library/aa365917%28VS.85%29.aspx

3 其它方式

这个演示程序简单演示了通过Java获取系统信息的过程，还有更多更好的方式我一定不知道，除了这种方式外，我还想了其它几种方式。

3.1 命令模式

刚才每个获取系统信息都使用了native方法，这个有两个弊端：一是每次都得使用javah然后拷贝过去再编写新实现；二是因为使用了Native方法，不好重构扩展。这里我简单将获取各种系统信息的函数每个变成一个带参数的命令，然后将这个命令传给一个公共native函数，比如executeCommand()，这样C++只需要一个编写一个实现即可。

3.1.1重构Java文件

这里我们重新创建一个Java文件和一个测试文件，分别为SysInfo2和TestNative2，TestNative2相比TestNative只是使用了SysInfo2

Java

1 package com.lifesting.jni;
2
3 public class SysInfo2 {
4      static {
5         System.loadLibrary( " jnihello " );
6     }
7      public String welcome(String who){
8          return executeCommand( " welcome -p " + who);
9     }
10      // in MB
11      public int memorySize(){
12         String mem_size_str = executeCommand( " memsize " );
13          return Integer.parseInt(mem_size_str);
14     }
15      // in MHZ: 1866
16      public    int cpuSpeed(){
17         String cpu_speed_str = executeCommand( " cpuspeed " );
18          return Integer.parseInt(cpu_speed_str);
19     }
20      public String[] macAddress(){
21         String cpu_speed_str = executeCommand( " allmac " );
22          // separated by space
23          return cpu_speed_str.split( " [\\s] " );
24     }
25      public native String executeCommand(String command);
26 }
27

executeCommand只有一个返回值，为字符串，各个函数根据需要再转换回来。

3.1.2 C++ executeCommand实现

executeCommand实现分为两部分，一个是解析命令行成为命令+参数，二是根据不同命令调用不同函数，这里我复用了前面的单个函数。

首先定义一个struct，表示命令：

typedef struct {
wstring command;
map < wstring,wstring > options;
} * PCMD,SYS_CMD;

这个struct使用了stl里的wstring

接着编写一个解析命令行参数的函数：

编译参数

1 PCMD parse( const jchar * raw_command){
2     WCHAR * comand = (WCHAR * ) raw_command;
3      int len = wcslen(comand);
4     wstring cmd;
5     wstring buffer;
6     wstring key_snapshot;
7     map < wstring,wstring > options;
8      bool greedy = false ;
9      enum PART{OCMD,OKEY,OVALUE};
10      enum PART status = OCMD;
11     WCHAR last_char = NULL;
12      for ( int i = 0 ; i <= len; i ++ )
13     {
14         WCHAR c = * (comand + i);
15          switch (c)
16         {
17          case 0x0020 : // space
18          case 0x0000 : // NULL terminate
19              if ( ! greedy){
20                  if (last_char != 0x0020 ){
21                      if (status == OKEY){
22                         options[buffer] = L "" ;
23                         key_snapshot = buffer;
24                         status = OVALUE;
25                     } else if (status == OCMD){
26                         cmd = buffer;
27                         status = OKEY;
28                     } else { // OValue
29                         options[key_snapshot] = buffer;
30                         status = OKEY;
31                     }
32                 }
33                 buffer.clear();
34             } else {
35                 buffer.push_back(c);
36             }
37              break ;
38          case 0x0022 : // quote,greedy
39             greedy = ! greedy;
40              break ;
41          case 0x002D : // option start
42              if ( ! greedy){
43                  if (last_char != 0x0020 ){
44                     printf( " ERROR! " );
45                 }
46                 status = OKEY;
47             } else {
48                 buffer.push_back(c);
49             }
50              break ;
51          default :
52             buffer.push_back(c);
53              break ;
54         }
55         last_char = c;
56     }
57     PCMD pc = new SYS_CMD;
58     pc -> command = cmd;
59     pc -> options = options;
60      return pc;
61 }

然后复用我们之前的实现编写executeCOmmand：

executeCommand

1 JNIEXPORT jstring JNICALL Java_com_lifesting_jni_SysInfo2_executeCommand
2     (JNIEnv * env, jobject obj, jstring cmd)
3 {
4     jboolean cp = JNI_TRUE;
5      const jchar * raw = env -> GetStringChars(cmd, & cp);
6     PCMD pc = parse(raw);
7      if (pc -> command == L " welcome " )
8     {
9         wstring who = pc -> options[L " p " ];
10         jstring j_who = env -> NewString((jchar * )who.c_str(),who.size());
11          return Java_com_lifesting_jni_SysInfo_welcome(env,obj,j_who);
12     } else if (pc -> command == L " memsize " ){
13         jint ms = Java_com_lifesting_jni_SysInfo_memorySize(env,obj);
14          char ms_buffer[ 15 ];
15         itoa(ms,ms_buffer, 10 );
16          return env -> NewStringUTF(ms_buffer);
17     } else if (pc -> command == L " cpuspeed " ){
18         jint ms = Java_com_lifesting_jni_SysInfo_cpuSpeed(env,obj);
19          char ms_buffer[ 15 ];
20         itoa(ms,ms_buffer, 10 );
21          return env -> NewStringUTF(ms_buffer);
22     } else if (pc -> command == L " allmac " ){
23          // use java string to merge string array
24         jobjectArray all_mac = Java_com_lifesting_jni_SysInfo_macAddress(env,obj);
25         jstring ret = env -> NewStringUTF( "" );
26         jstring sp = env -> NewStringUTF( " " );
27          int total = 0 ;
28         jmethodID concat = env -> GetMethodID(env -> FindClass( " java/lang/String " ), " concat " , " (Ljava/lang/String;)Ljava/lang/String; " );
29          for ( int j = 0 ;j < MAX_NIC;j ++ ){
30             jstring str = (jstring)env -> GetObjectArrayElement(all_mac,j);
31             ret = (jstring)env -> CallObjectMethod(ret,concat,str);
32              if (j < MAX_NIC - 1 ){
33                 ret = (jstring) env -> CallObjectMethod(ret,concat,sp);
34             }
35         }
36          return ret;
37     } else {
38          return env -> NewStringUTF( " Does not support this command! " );
39     }
40     delete pc;
41      return env -> NewStringUTF( " Hello " );
42 }

在处理allmac命令的时候，为了简洁，直接使用了Java的String方法拼接字符。这儿值得注意的是jmethodID的获得，其关键是最后一个参数method signature，可以通过javap -s -p a.b.c.MyClass来获得，并且不要忘了最后的一个分号;

最终的Java代码和结果：

3.2 WMI方式获取

如果JNI只是针对Windows平台，还有一种更方便的获取方式：WMI。WMI查询各种系统信息就跟查询数据库没啥区别，比如下面的代码将查询WMI，找到我笔记本有两个内存插槽，每个2G：

1 #include " stdafx.h "
2
3 #define _WIN32_DCOM
4 #include < iostream >
5 #include < windows.h >
6 using namespace std;
7 #include < wbemidl.h >
8 #include < comdef.h >
9 # pragma comment(lib, " wbemuuid.lib " )
10
11 int _tmain( int argc, _TCHAR * argv[])
12 {
13     CoInitializeEx( 0 , COINIT_MULTITHREADED);
14     CoInitializeSecurity(NULL, - 1 ,NULL,NULL,RPC_C_AUTHN_LEVEL_DEFAULT,RPC_C_IMP_LEVEL_IMPERSONATE,NULL,EOAC_NONE,NULL);
15     IWbemLocator * pLoc = 0 ;
16     CoCreateInstance(CLSID_WbemLocator, 0 , CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID * ) & pLoc);
17     IWbemServices * pSvc = 0 ;
18     pLoc -> ConnectServer(BSTR(L " ROOT\\CIMV2 " ), NULL, NULL, 0 , NULL, 0 , 0 , & pSvc);
19     CoSetProxyBlanket(pSvc,
20         RPC_C_AUTHN_WINNT,
21         RPC_C_AUTHZ_NONE,
22         NULL,
23         RPC_C_AUTHN_LEVEL_CALL,
24         RPC_C_IMP_LEVEL_IMPERSONATE,
25         NULL,
26         EOAC_NONE
27         );
28     IEnumWbemClassObject * pEnumerator = NULL;
29     pSvc -> ExecQuery(
30         bstr_t( " WQL " ),
31         bstr_t( " SELECT * FROM Win32_PhysicalMemory " ),
32         WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_ENSURE_LOCATABLE,
33         NULL,
34          & pEnumerator);
35     IWbemClassObject * pObj;
36     ULONG ret = NULL;
37      // iterate records
38      while (pEnumerator){
39         HRESULT hr = pEnumerator -> Next(WBEM_INFINITE, 1 , & pObj, & ret);
40          if (WBEM_S_FALSE == hr){
41              break ; // last row
42         }
43         VARIANT v;
44         HRESULT hget = pObj -> Get(L " BankLabel " , 0 , & v,NULL,NULL);
45          if (WBEM_S_NO_ERROR == hget){
46             wcout << v.bstrVal << " : " ;
47         }
48         VariantClear( & v);
49         hget = pObj -> Get(L " Capacity " , 0 , & v,NULL,NULL);
50          if (WBEM_S_NO_ERROR == hget){
51             wcout << v.bstrVal << " bytes " << endl;
52         }
53         VariantClear( & v);
54         pObj -> Release();
55     }
56     pSvc -> Release();
57     pLoc -> Release();
58     CoUninitialize();
59      return 0 ;
60 }
61
62

WMI其它硬件相关的WMI Class可以在 http://msdn.microsoft.com/en-us/library/aa394084%28v=VS.85%29.aspx 中找到，十分的丰富，十分的强大，可以写一个鲁大师完全没问题

WMI通过C++的方式因为靠着COM，稍显复杂。

3.3 非主流方式

其它还有一些方式如通过命令行，访问文件系统，系统软件查询等，大家有啥好的不啬告知。

4 JNI调试

如果JNI写的非常的复杂，特别是跟Java有好多互动的时候，调试是个很容易分清Bug出在那边的好办法。

在Visual Studio下，调试JNI的dll有两种方式，一种是通过项目设置命令行参数启动Java，在工程 properties->Configuration Properties->Debugging中设置执行程序(也就是Java.exe)和相关参数如cp，执行类等等；另外一种方式是通过C启动JVM，Native的方式启动Java，自然就能够调试JNI DLL了。

下面我简单说说以C++方式启动JVM去调试JNI。

在Solution下面在建立一个win32 console application 工程，如同JNI DLL Project一样设置好include和library，在主程序写如下类似代码：

C启动JVM

#include " stdafx.h "
#include < windows.h >
#include < jni.h >
#include < assert.h >
int _tmain( int argc, _TCHAR * argv[])
{
    JavaVM * vm;
    JNIEnv * env;
    JavaVMInitArgs args;
    JavaVMOption ops[ 1 ];
    ops[ 0 ].optionString = " -Djava.class.path=C:/Users/David/jbpm3/jniexample/bin " ;
    args.version = JNI_VERSION_1_6;
    args.options = ops;
    args.nOptions = 1 ;
    args.ignoreUnrecognized = JNI_TRUE;
    jint created = JNI_CreateJavaVM( & vm,( void ** ) & env, & args);
     if (created < 0 ){
        printf( " can't create java vm " );
    }
    jclass testNative2 = env -> FindClass( " com/lifesting/jni/TestNative2 " );
    assert(testNative2 != NULL);
    jobjectArray main_args = env -> NewObjectArray( 1 , env -> FindClass( " java/lang/String " ),env -> NewStringUTF( " FromC " ));
    jmethodID testNative2_main = env -> GetStaticMethodID(testNative2, " main " , " ([Ljava/lang/String;)V " );
    assert(testNative2_main != NULL);
    env -> CallStaticObjectMethod(testNative2,testNative2_main,main_args);
    vm -> DestroyJavaVM();
     return 0 ;
}

(在这个工程启动之前，一定设置好path。将%java_home%\jre\bin和%java_home%\jre\bin\client都加到path上，方便此启动程序找到相关dll)

现在按Ctrl+F5运行和在Eclipse中出现的效果是一样的，现在如果在DLL里相关JNI方法里面设置断点，调试启动后，VS就会停住了。

如果有问题，欢迎来信交流！

guoyf123321

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JNI概念

JNI编辑JNI是Java Native Interface的缩写，它提供了若干的API实现了Java和其他语言的通信（主要是C&C++）。从Java1.1开始，JNI标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他编程语言，只要调用约定受支持就可以了。使用java与本地已编
复制链接

扫一扫