Java如何使用JNI提取平台及硬件信息

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

1 Welcome示例

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

 1.1 定义Java接口

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

 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加入如下代码：

 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自动会根据系统加上不同后缀。

接着要创建一个测试类

 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 代码实现

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

物理内存获取

 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

 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地址的稍微麻烦点

#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;
}

3 其它方式

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

3.1 命令模式

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

3.1.1重构Java文件

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

 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：

 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，在主程序写如下类似代码：

#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就会停住了。