java native方法與JNI實現

native方法定義：        

      簡單地講，一個Native Method就是一個java呼叫非java程式碼的介面。一個Native Method是這樣一個java的方法：該方法的實現由非java語言實現，比如C。這個特徵並非java所特有，很多其它的程式語言都有這一機制，比如在C＋＋中，你可以用extern "C"告知C＋＋編譯器去呼叫一個C的函式。

VM怎樣使Native Method跑起來：
    我們知道，當一個類第一次被使用到時，這個類的位元組碼會被載入到記憶體，並且只會回載一次。在這個被載入的位元組碼的入口維持著一個該類所有方法描述符的list，這些方法描述符包含這樣一些資訊：方法程式碼存於何處，它有哪些引數，方法的描述符（public之類）等等。
    如果一個方法描述符內有native，這個描述符塊將有一個指向該方法的實現的指標。這些實現在一些DLL檔案內，但是它們會被作業系統載入到java程式的地址空間。當一個帶有本地方法的類被載入時，其相關的DLL並未被載入，因此指向方法實現的指標並不會被設定。當本地方法被呼叫之前，這些DLL才會被載入，這是通過呼叫java.system.loadLibrary()實現的。

 

2.概述

今天在看Java多執行緒程式設計的時候，發現Thread這個類中有多個native方法，以前從來沒有見過這種方法，因此對於比較好奇，查閱了一些資料，現在整理一下，以作備忘。

 

2.1.native關鍵字用法

native是與C++聯合開發的時候用的！使用native關鍵字說明這個方法是原生函式，也就是這個方法是用C/C++語言實現的，並且被編譯成了DLL，由java去呼叫。 這些函式的實現體在DLL中，JDK的原始碼中並不包含，你應該是看不到的。對於不同的平臺它們也是不同的。這也是java的底層機制，實際上java就是在不同的平臺上呼叫不同的native方法實現對作業系統的訪問的。總而言之：

1. native 是用做java 和其他語言（如c++）進行協作時使用的，也就是native 後的函式的實現不是用java寫的。
2.  既然都不是java，那就別管它的原始碼了，我們只需要知道這個方法已經被實現即可。
3. native的意思就是通知作業系統， 這個函式你必須給我實現，因為我要使用。 所以native關鍵字的函式都是作業系統實現的， java只能呼叫。
4. java是跨平臺的語言，既然是跨了平臺，所付出的代價就是犧牲一些對底層的控制，而java要實現對底層的控制，就需要一些其他語言的幫助，這個就是native的作用了

2.2JNI簡介

native方法是通過java中的JNI實現的。JNI是Java Native Interface的 縮寫。從Java 1.1開始，Java Native Interface (JNI)標準成為java平臺的一部分，它允許Java程式碼和其他語言寫的程式碼進行互動。JNI一開始是為了本地已編譯語言，尤其是C和C++而設計 的，但是它並不妨礙你使用其他語言，只要呼叫約定受支援就可以了。

使用java與本地已編譯的程式碼互動，通常會喪失平臺可移植性。但是，有些情況下這樣做是可以接受的，甚至是必須的，比如，使用一些舊的庫，與硬體、作業系統進行互動，或者為了提高程式的效能。JNI標準至少保證原生代碼能工作在任何Java 虛擬機器實現下。

目前java與dll互動的技術主要有3種：jni，jawin和jacob。Jni（Java Native Interface）是sun提供的java與系統中的原生方法互動的技術（在windows\Linux系統中，實現java與native method互調）。目前只能由c/c++實現。後兩個都是sourceforge上的開源專案，同時也都是基於jni技術的windows系統上的一個應用庫。Jacob（Java-Com Bridge）提供了java程式呼叫microsoft的com物件中的方法的能力。而除了com物件外，jawin（Java/Win32 integration project）還可以win32-dll動態連結庫中的方法。就功能而言：jni >> jawin>jacob，其大致的結構如下圖：

就易用性而言，正好相反：jacob>jawin>>jni。

Jvm封裝了各種作業系統實際的差異性的同時，提供了jni技術，使得開發者可以通過java程式（程式碼）呼叫到作業系統相關的技術實現的庫函式，從而與其他技術和系統互動，使用其他技術實現的系統的功能；同時其他技術和系統也可以通過jni提供的相應原生介面開呼叫java應用系統內部實現的功能。

在windows系統上，一般可執行的應用程式都是基於native的PE結構，windows上的jvm也是基於native結構實現的。Java應用體系都是構建於jvm之上。

Jni對於應用本身來說，可以看做一個代理模式。對於開發者來說，需要使用c/c++來實現一個代理程式（jni程式）來實際操作目標原生函式，java程式中則是jvm通過載入並呼叫此jni程式來間接地呼叫目標原生函式。

 

2.3JN的書寫步驟

1. 編寫帶有native宣告的方法的java類，生成.java檔案
2. 使用javac命令編譯所編寫的java類，生成.class檔案
3. 使用javah -jni java類名生成副檔名為h的標頭檔案，也即生成.h檔案
4. 使用C/C++（或者其他程式設計想語言）實現本地方法，建立.h檔案的實現，也就是建立.cpp檔案實現.h檔案中的方法
5. 將C/C++編寫的檔案生成動態連線庫，生成dll檔案

3.JNI例項

下列是所有操作都是在目錄：D:\JNI 下進行的，這樣做的好處是便於控制。還有另外一個要求是我們的java類不含包名，當前我只測試成功不含包名的型別。

3.1.編寫帶有native宣告的方法的java類：HelloWorld.java

public class HelloWorld {  
    public native void displayHelloWorld();// java native方法申明  
  
    static {  
        System.loadLibrary("HelloWorldImpl");// 裝入動態連結庫，"HelloWorldImpl"是要裝入的動態連結庫名稱。  
    }  
  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        HelloWorld helloWorld = new HelloWorld();  
        helloWorld.displayHelloWorld();  
    }  
}  

3.2.使用javac命令編譯所編寫的java類

1. d:\JNI>javac HelloWorld.java  

執行完上述命令以後生成D:\JNI\HelloWorld.class檔案

3.3.使用javah -jni java類名生成副檔名為h的標頭檔案

d:\JNI>javah -jni HelloWorld  

執行完上述命令以後生成D:\JNI\HelloWorld.h檔案，該檔案內容如下：

/* DO NOT EDIT THIS FILE - it is machine generated */  
#include <jni.h>  
/* 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++程式的時候所使用的方法名必須和這裡的一致

3.4.使用C/C++實現本地方法

建立HelloWorldImpl.cpp，程式碼如下所示：

#include "HelloWorld.h"  
#include <stdio.h>  
#include <jni.h>  
/* 
 * Class:     HelloWorld 
 * Method:    displayHelloWorld 
 * Signature: ()V 
 */  
JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld  
  (JNIEnv *, jobject)  
 {  
    printf("Hello World!\n");  
    return;  
}  

3.5.將C/C++編寫的檔案生成動態連線庫

將D:\Program Files\Java\jdk1.6.0_26\include\jni.h和D:\Program Files\Java\jdk1.6.0_26\include\win32\jni_md.h這兩個檔案拷貝到D:\JNI\目錄下。與HelloWorldImpl.cpp同目錄，目錄結構如下圖所示：

3.7 執行 cl/LD D:\JNI\HelloWorldImpl.cpp  得到HelloWorldImpl.dll檔案

我使用的是visual studio 2010，要使用其中的cl命令，必須開啟visual studio 命令列，如下圖所示：

然後再命令列中輸入如下命令

1. cl/LD D:\JNI\HelloWorldImpl.cpp    

具體如下圖所示：

執行完上述命令以後，我們在C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC可以看到生成的四個檔案，分別是：

• HelloWorldImpl.dll
• HelloWorldImpl.exp
• HelloWorldImpl.lib
• HelloWorldImpl.obj

將其中的HelloWorldImpl.dll拷貝到D:\JNI\目錄下。

3.8.執行class得到結果

在cmd中執行：

d:\JNI>java HelloWorld  

具體如下圖所示：

===============================================================================================

案例2：

使用java與本地已編譯的程式碼互動，通常會喪失平臺可移植性。但是，有些情況下這樣做是可以接受的，甚至是必須的。例如，使用一些舊的庫，與硬體、作業系統進行互動，或者為了提高程式的效能。JNI標準至少保證原生代碼能工作在任何Java虛擬機器環境下。閒話不說，直接上示例。

本例基於Windows平臺，首先生成被呼叫的目的dll動態庫：Lib4JNI.dll
Lib4JNI動態庫中匯出了一個add方法。在本例中用JNI去呼叫。

// dllmain.cpp : Defines the entry point for the DLL application.
#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                                    )
{

       switch (ul_reason_for_call)
       {
       case DLL_PROCESS_ATTACH:
       case DLL_THREAD_ATTACH:
       case DLL_THREAD_DETACH:
       case DLL_PROCESS_DETACH:
              break;
       }
       return TRUE;
}


extern "C"
int _declspec(dllexport) add(int a, int b)
{
       int iResult = a + b;
       printf("%d + %d = ", a, b);
       return iResult;
}

接下來要做的是，使用中介（或者叫代理）dll呼叫目的動態庫（目的動態庫就是本例中的Lib4JNI.dll）。在Java中，是不可以直接呼叫目的動態庫的。因此，需要有一箇中介（或代理），由本地的Java程式碼先呼叫這個中介（或代理）動態庫，再由這個中介（或代理）動態庫呼叫目的動態庫。
我們給中介dll起個名字，叫做Lib2Invoke。生成這個中介dll的過程比較複雜，下面，我們用分解動作，詳細說明。

第一步：需要建立本地Java的呼叫程式碼。

public class TestJNI {
   public native int getNumber(int a, int b); //宣告Native方法

   public static void main(String[] args) {
   }
} 

將以上程式碼，以文字形式，儲存為TestJNI.java。

第二步：用javac編譯。javac TestJNI.java

第三步：用javah生成中介（或代理）動態庫的標頭檔案。javah TestJNI，執行後，生成TestJNI.h檔案，本例中生成的檔案示例如下：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class TestJNI */

#ifndef _Included_TestJNI
#define _Included_TestJNI
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     TestJNI
 * Method:    getNumber
 * Signature: (II)I
 */
JNIEXPORT jint JNICALL Java_TestJNI_getNumber
  (JNIEnv *, jobject, jint, jint);

#ifdef __cplusplus
}
#endif
#endif

第四步：生成中介（或代理）動態庫
為什麼到這裡才開始生成中介dll呢？因為，我們需要上一步生成的TestJNI.h，作為中介dll的標頭檔案。詳細請參考程式碼。

// dllmain.cpp : Defines the entry point for the DLL application.
#include "stdafx.h"

#include "jni.h"    //在這裡，我們要注意的是，需要引用
#include "TestJNI.h" 

#ifdef WIN32
       #ifdef _X86_
              #define _T(x) x
       #else
              #ifdef _AMD64_
              #define _T(x) L ## x
              #endif
       #endif
#endif

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                                    )
{
       switch (ul_reason_for_call)
       {
       case DLL_PROCESS_ATTACH:
       case DLL_THREAD_ATTACH:
       case DLL_THREAD_DETACH:
       case DLL_PROCESS_DETACH:
              break;
       }
       return TRUE;
}


JNIEXPORT jint JNICALL Java_TestJNI_getNumber
(JNIEnv * env, jobject o, jint x, jint y)
{
       typedef int(*ADD)(int, int);//函式指標型別
       HINSTANCE Hint = ::LoadLibrary(_T("Lib4JNI.dll"));//載入我們剛才生成的dll
       ADD add = (ADD)GetProcAddress(Hint, "add");//取得dll匯出的add方法
       return add(x, y);

       FreeLibrary(Hint);
}

編譯完成後，生成了我們需要的中介（或代理）動態庫Lib2Invoke.dll。

第五步： 完善本地Java呼叫程式碼。

public class TestJNI {

   public native int getNumber(int a, int b);

   public static void main(String[] args) {
      System.loadLibrary("Lib2Invoke");
      TestJNI p = new TestJNI();
      System.out.println(p.getNumber(100, 100));
   }
}

編譯完成後，把生成的class檔案，和Lib4JNI.dll、Lib2Invoke.dll放在一個目錄下。

第六步：執行 java TestJNI
執行成功後即會輸出結果。

另一種可以選擇的方法JNative。以程式設計師特有的本質，少說話，多程式碼：

import org.xvolks.jnative.JNative;
import org.xvolks.jnative.Type;
import org.xvolks.jnative.exceptions.NativeException;

public class TestJNI {
    static JNative myjnative = null;

     public int getnumber(int a, int b) throws NativeException,
            IllegalAccessException {

        try {
            if (myjnative == null) {
                myjnative = new JNative("Lib4JNI.dll", "add");
                myjnative.setRetVal(Type.INT);
            }

            myjnative.setParameter(0, a);
            myjnative.setParameter(1, b);

            myjnative.invoke();
            return myjnative.getRetValAsInt();
        } finally {
            if (myjnative != null) {
                myjnative.dispose();
            }
        }
    }

    public static void main(String[] args) throws NativeException, IllegalAccessException {
        test uc = new test();
        int result = uc.getnumber(1,100);

        System.err.println("result:" + result);
    }
}

優點是：不用中介dll，不用生成.h中介標頭檔案
缺點是：（缺點不準確，只是為了對齊優點）需要外部包支援。

再來說說Linux平臺下JNI的使用方法。基本步驟同上。下面給出主要示例程式碼。
1、Java呼叫部分

NativeAgent.java

public class NativeAgent {

    static
    {
        try {
            System.loadLibrary("NativeAgent");
        }
        catch(UnsatisfiedLinkError e) {
            System.err.println(">>> Can not load library: " + e.toString());
        }
    }

    public native int toConsole(String s);

    public static void main(String[] args) {

        NativeAgent na = new NativeAgent();

        na.toConsole("This is a JNI Project test.\n");
    }

}

2、生成動態庫部分

NativeAgent.h

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class NativeAgent */

#ifndef _Included_NativeAgent
#define _Included_NativeAgent
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     NativeAgent
 * Method:    toConsole
 * Signature: (Ljava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_NativeAgent_toConsole
  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus
}
#endif
#endif

NativeAgent.c

#include <stdio.h>
#include <stdlib.h>
#include <jni.h>

#include "NativeAgent.h"

JNIEXPORT jint JNICALL Java_NativeAgent_toConsole(JNIEnv *pEnv, jobject obj, jstring str) {

    const char* msg = (*pEnv)->GetStringUTFChars(pEnv, str, 0);

    printf("%s", msg);

    return 0;

}

3、編譯生成動態庫

javac NativeAgent.java

javah NativeAgent

gcc -o libNativeAgent.so -I/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.102-1.b14.el7_2.x86_64/include -I/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.102-1.b14.el7_2.x86_64/include/linux -I. -fPIC -shared NativeAgent.c

java -Djava.library.path=. NativeAgent

這裡有二個非常重要的地方，要十分注意：
1、對於System.loadLibrary("NativeAgent");
在Linux下，動態庫輸出的檔名要是libNativeAgent.so。
也就是說，如果System.loadLibrary("XXX")；那麼，在匯出動態庫時，動態庫的名字就要是libXXX。否則，會報錯：

java.lang.UnsatisfiedLinkError: no NativeAgent in java.library.path
Exception in thread "main" java.lang.UnsatisfiedLinkError: NativeAgent.toConsole(Ljava/lang/String;)I
        at NativeAgent.toConsole(Native Method)
        at NativeAgent.main(NativeAgent.java:20)

2、Linux一般預設的java.library.path在/usr/lib下。也可以自己通過VM引數-Djava.library.path=/usr/lib來顯式的指定；或者通過增加環境變數export LD_LIBRARY_PATH=~/JavaNativeTest:$LD_LIBRARY_PATH

 

1.參考文獻：

http://blog.csdn.net/youjianbo_han_87/article/details/2586375

http://blog.csdn.net/yangjiali014/article/details/1633017

http://blog.chinaunix.net/space.php?uid=7437948&do=blog&id=2054823

http://www.iteye.com/topic/72543

http://www.enet.com.cn/article/2007/1029/A20071029886398.shtml

http://blog.csdn.net/heqingrong623/article/details/3906350

參考1:用JNI呼叫C或C++動態聯接庫原來如此簡單

參考2：JNI技術實踐小結

參考3：jni簡單例項