javap使用實例圖解,實例方法java

本文目錄一覽：

• 1、怎樣使用javap來反編譯class文件
• 2、eclipse bytecode visualizer怎麼用
• 3、java反編譯後是scala嗎
• 4、如何在C/C++中調用Java

怎樣使用javap來反編譯class文件

當然可以了。在java軟體包的bin文件夾下有一個javap程序，就是用來反編譯的。 用法如java一樣。就是先用javac變成位元組碼文件就是.class文件後，用javap 加上文件名就可以反編譯了。 舉個例子test.class，反編譯用javap test就行了。

eclipse bytecode visualizer怎麼用

1、使用javap命令閱讀

進入Test.class目錄，然後使用javap -v Test.class out將位元組碼文件讀取後存入out文件，然後用notepad++打開out文件：

test()函數的樣子：

從位元組碼可以看到，編譯器已經自動的將變數a的值合併在一起，成為了xy1，因此相當於xy1兩個字元串的比較，兩者都處於常量區，因此相等；

2、使用eclipse的Bytecode visualizer插件閱讀

安裝好插件之後，首先將其配置一下，以顯示最大化的位元組碼信息

然後打開eclipse的Navigator窗口，找到編譯好的Test.class，右鍵，用位元組碼方式打開，就會看到更易讀的位元組碼

同時在編輯器的右側，能夠自動查看該段代碼的流程圖，非常方便；

使用這兩種方式，就能夠查看代碼編譯後的內幕，對一些奇怪的語法現象，就能夠自己找出為什麼了

但是在測試的過程中，自己寫了個print(ListString strs)的方法，使用Javap命令和Byte visualizer兩者，輸出的位元組碼中，前者帶著泛型信息，後者進行了泛型擦除，兩者不同

附上出處鏈接：

java反編譯後是scala嗎

javap是JDK提供的一個反編譯工具。常用的選項有-c -l -s。如果僅僅是想查看編譯的得到的位元組碼文件中函數與變數，不需要帶選項。使用javap很容易發現源文件與編譯後得到的位元組碼文件有什麼不同，可以加深對編譯器的理解。

javap -help

Usage: javap options classes…

where options include:

-c Disassemble the code

-classpath pathlist Specify where to find user class files

-extdirs dirs Override location of installed extensions

-help Print this usage message

-Jflag Pass flag directly to the runtime system

-l Print line number and local variable tables

-public Show only public classes and members

-protected Show protected/public classes and members

-package Show package/protected/public classes and members (default)

-private Show all classes and members

-s Print internal type signatures

-bootclasspath pathlist Override location of class files loaded by the bootstrap class loader

-verbose Print stack size, number of locals and args for methods If verifying, print reasons for failure

Scala是基於JVM的，所有其位元組碼和Java編譯得到的位元組碼應該是一致的。首先從Hello World開始

object Main {

def main(args: Array[String]) = {

println(“Hello, ” + args(0))

}

}

使用scalac編譯都得到兩個位元組碼文件：Main.class和Main$.class。

在class文件所在的目錄分別運行javap Main和javap Main$得到如下結果：

Compiled from “Main.scala”

public final class Main extends java.lang.Object{

public static final void main(java.lang.String[]);

}

Compiled from “Main.scala”

public final class Main$ extends java.lang.Object implements scala.ScalaObject{

public static final Main$ MODULE$;

public static {};

public void main(java.lang.String[]);

}

Scala的object是單例模式。上面的反編譯結果給了我們Scala實現原理的提示。MODULE$指向類的實例，相當於this。而方法也是被聲明為靜態的。做了一個測試，更加直觀。說如果不是去發射火箭，Object的代碼跟Java的靜態代碼可以認為是等價的。

把上面的代碼稍作修改：

case class Main {

def main(args: Array[String]) = {

println(“Hello, ” + args(0))

}

}

在class文件所在的目錄分別運行javap Main和javap Main$得到如下結果：

Compiled from “Main.scala”

public class Main extends java.lang.Object implements scala.ScalaObject,scala.Product,scala.Serializable{

public scala.collection.Iterator productIterator();

public scala.collection.Iterator productElements();

public void main(java.lang.String[]);

public int hashCode();

public java.lang.String toString();

public boolean equals(java.lang.Object);

public java.lang.String productPrefix();

public int productArity();

public java.lang.Object productElement(int);

public boolean canEqual(java.lang.Object);

public Main();

}

Compiled from “Main.scala”

public final class Main$ extends scala.runtime.AbstractFunction0 implements scala.ScalaObject,scala.Serializable{

public static final Main$ MODULE$;

public static {};

public final java.lang.String toString();

public boolean unapply(Main);

public Main apply();

public java.lang.Object readResolve();

public java.lang.Object apply();

}

與輸入的文件相比，Scala添加了許多東西：

1. Scala自動幫助Case類生成toString， equals，hashCode等方法。

2. Scala自動幫助Case類生成apply方法，不需要new就可以直接創建類的實例或引用。

3. 對於類的成員，Scala自動生成成員的Getter和Setter。

4. Case類提供對模式匹配的支持。

下面來看Scala對類和隱式轉換的處理，有一個Rational類：

class Rational(n: Int, d: Int) {

require(d != 0)

private val g = gcd(n.abs, d.abs)

val numer = n / g

val denom = d / g

def this(n: Int) = this(n, 1)

def +(that: Rational): Rational =

new Rational(numer * that.denom + that.numer * denom, denom * that.denom)

def +(i: Int): Rational = new Rational(numer + i * denom, denom)

def -(that: Rational): Rational =

new Rational(numer * that.denom – that.numer * denom, denom * that.denom)

def -(i: Int): Rational = new Rational(numer – i * denom, denom)

def *(that: Rational): Rational = new Rational(numer * that.numer, denom * that.denom)

def *(i: Int): Rational = new Rational(numer * i, denom)

def /(that: Rational): Rational = new Rational(numer * that.denom, denom * that.numer)

def /(i: Int): Rational = new Rational(numer, denom * i)

override def toString = numer + “/” + denom

private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)

}

object Rational{

implicit def intToRational(x: Int) = new Rational(x)

}

javap得到：

Compiled from “Rational.scala”

public class Rational extends java.lang.Object implements scala.ScalaObject{

public static final Rational intToRational(int);

public int numer();

public int denom();

public Rational(int);

public Rational $plus(Rational);

public Rational $plus(int);

public Rational $minus(Rational);

public Rational $minus(int);

public Rational $times(Rational);

public Rational $times(int);

public Rational $div(Rational);

public Rational $div(int);

public java.lang.String toString();

public Rational(int, int);

}

Compiled from “Rational.scala”

public final class Rational$ extends java.lang.Object implements scala.ScalaObje

ct{

public static final Rational$ MODULE$;

public static {};

public Rational intToRational(int);

}

對於普通類，Scala自動添加的東西稍微少一些。一直出現的還有一個特別的函數：public static {};通過帶參數-c的javap可以看到其彙編代碼：

public static {};

Code:

0: new #9; //class Rational$

3: invokespecial #12; //Method “init”:()V

6: return

new創建一個對象並將其引用值壓入棧頂，invokespecial調用父類的構造方法，return從當前方法返回void。該方法實際上就是一個創建自身的靜態方法。Java虛擬機指令參考

Rational$中的intToRational是我們提供的隱式類型轉換，將一個Int轉換為Rational。其彙編代碼如下：

public Rational intToRational(int);

Code:

0: new #16; //class Rational

3: dup

4: iload_1

5: invokespecial #20; //Method Rational.”init”:(I)V

8: areturn

new首先創建一個Rational對象並將其引用值壓入棧頂，dup複製棧頂數值並將複製值壓入棧頂，iload_1將第二個int型本地變數推送至棧頂，invokespecial調用Rational的構造方法，最後areturn從當前方法返回對象引用。

我們用如下代碼來測試隱式類型轉換：

import Rational._

object RationalTest {

def main(args: Array[String]) {

val r = new Rational(2,3)

println(2 * r)

}

}

2 * r本身不合法的，因為Int不存在*(Rational)的方法，由於隱式轉換的存在，Scala將做一些轉換工作。上面程序的彙編代碼如下：

Compiled from “RationalTest.scala”

public final class RationalTest$ extends java.lang.Object implements scala.Scala

Object{

public static final RationalTest$ MODULE$;

public static {};

Code:

0: new #9; //class RationalTest$

3: invokespecial #12; //Method “init”:()V

6: return

public void main(java.lang.String[]);

Code:

0: new #16; //class Rational

3: dup

4: iconst_2

5: iconst_3

6: invokespecial #20; //Method Rational.”init”:(II)V

9: astore_2

10: getstatic #25; //Field Rational$.MODULE$:LRational$;

13: iconst_2

14: invokevirtual #29; //Method Rational$.intToRational:(I)LRational;

17: aload_2

18: invokevirtual #33; //Method Rational.$times:(LRational;)LRational;

21: astore_3

22: getstatic #38; //Field scala/Console$.MODULE$:Lscala/Console$;

25: aload_3

26: invokevirtual #42; //Method scala/Console$.println:(Ljava/lang/Object;

)V

29: return

}

在做乘法（$times）之前調用了 intToRational，返回一個Rational對象， 調用Rational對象的*方法已經合法化了。

如何在C/C++中調用Java

如何在C/C++中調用Java

java跨平台的特性使Java越來越受開發人員的歡迎，但也往往會聽到不少的抱怨：用Java開發的圖形用戶窗口界面每次在啟動的時候都會跳出一個控制台窗口，這個控制台窗口讓本來非常棒的界面失色不少。怎麼能夠讓通過Java開發的GUI程序不彈出Java的控制台窗口呢?其實現在很多流行的開發環境例如JBuilder、Eclipse都是使用純Java開發的集成環境。這些集成環境啟動的時候並不會打開一個命令窗口，因為它使用了JNI(Java Native Interface)的技術。通過這種技術，開發人員不一定要用命令行來啟動Java程序，可以通過編寫一個本地GUI程序直接啟動Java程序，這樣就可避免另外打開一個命令窗口，讓開發的Java程序更加專業。

JNI答應運行在虛擬機的Java程序能夠與其它語言(例如C和C++)編寫的程序或者類庫進行相互間的調用。同時JNI提供的一整套的API，答應將Java虛擬機直接嵌入到本地的應用程序中。圖1是Sun站點上對JNI的基本結構的描述。

如何在C/C++中調用Java 三聯

本文將介紹如何在C/C++中調用Java方法，並結合可能涉及到的問題介紹整個開發的步驟及可能碰到的難題和解決方法。本文所採用的工具是Sun公司創建的 Java Development Kit (JDK) 版本 1.3.1，以及微軟公司的Visual C++ 6開發環境。

環境搭建

為了讓本文以下部分的代碼能夠正常工作，我們必須建立一個完整的開發環境。首先需要下載並安裝JDK 1.3.1，其下載地址為「」。假設安裝路徑為C：JDK。下一步就是設置集成開發環境，通過Visual C++ 6的菜單Tools→Options打開選項對話框如圖2。

將目錄C:JDKinclude和C:JDKincludewin32加入到開發環境的Include Files目錄中，同時將C:JDKlib目錄添加到開發環境的Library Files目錄中。這三個目錄是JNI定義的一些常量、結構及方法的頭文件和庫文件。集成開發環境已經設置完畢，同時為了執行程序需要把Java虛擬機所用到的動態鏈接庫所在的目錄C:JDK jreinclassic設置到系統的Path環境變數中。這裡需要提出的是，某些開發人員為了方便直接將JRE所用到的DLL文件直接拷貝到系統目錄下。這樣做是不行的，將導致初始化Java虛擬機環境失敗(返回值-1)，原因是Java虛擬機是以相對路徑來尋找所用到的庫文件和其它一些相關文件的。至此整個JNI的開發環境設置完畢，為了讓此次JNI旅程能夠順利進行，還必須先預備一個Java類。在這個類中將用到Java中幾乎所有有代表性的屬性及方法，如靜態方法與屬性、數組、異常拋出與捕捉等。我們定義的Java程序(Demo.java)如下，本文中所有的代碼演示都將基於該Java程序，代碼如下：

package jni.test; /** * 該類是為了演示JNI如何訪問各種對象屬性等 * @author liudong */ public class Demo { //用於演示如何訪問靜態的基本類型屬性 public static int COUNT = 8; //演示對象型屬性 public String msg; PRivate int[] counts; public Demo() { this(“預設構造函數”); } /** * 演示如何訪問構造器 */ public Demo(String msg) { System.out.println(“:” + msg); this.msg = msg; this.counts = null; } /** * 該方法演示如何訪問一個訪問以及中文字元的處理 */ public String getMessage() { return msg; } /** * 演示數組對象的訪問 */ public int[] getCounts() { return counts; } /** * 演示如何構造一個數組對象 */ public void setCounts(int[] counts) { this.counts = counts; } /** * 演示異常的捕捉 */ public void throwExcp() throws IllegalaccessException { throw new IllegalAccessException(“exception occur.”); } }

初始化虛擬機

本地代碼在調用Java方法之前必須先載入Java虛擬機，而後所有的Java程序都在虛擬機中執行。為了初始化Java虛擬機，JNI提供了一系列的介面函數Invocation API。通過這些API可以很方便地將虛擬機載入到內存中。創建虛擬機可以用函數 jint JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args)。對於這個函數有一點需要注重的是，在JDK 1.1中第三個參數總是指向一個結構JDK1_ 1InitArgs， 這個結構無法完全在所有版本的虛擬機中進行無縫移植。在JDK 1.2中已經使用了一個標準的初始化結構JavaVMInitArgs來替代JDK1_1InitArgs。下面我們分別給出兩種不同版本的示例代碼。

在JDK 1.1初始化虛擬機:

#include int main() { JNIEnv *env; JavaVM *jvm; JDK1_1InitArgs vm_args; jint res; /* IMPORTANT: 版本號設置一定不能漏 */ vm_args.version = 0x00010001; /*獲取預設的虛擬機初始化參數*/ JNI_GetDefaultJavaVMInitArgs(vm_args); /* 添加自定義的類路徑 */ sprintf(classpath, “%s%c%s”, vm_args.classpath, PATH_SEPARATOR, USER_CLASSPATH); vm_args.classpath = classpath; /*設置一些其他的初始化參數*/ /* 創建虛擬機 */ res = JNI_CreateJavaVM(jvm,env,vm_args); if (res 0) { fprintf(stderr, “Can’t create Java VM “); exit(1); } /*釋放虛擬機資源*/ (*jvm)-DestroyJavaVM(jvm); }

JDK 1.2初始化虛擬機：

/* invoke2.c */ #include int main() { int res; JavaVM *jvm; JNIEnv *env; JavaVMInitArgs vm_args; JavaVMOption options[3]; vm_args.version=JNI_VERSION_1_2;//這個欄位必須設置為該值 /*設置初始化參數*/ options[0].optionString = “-Djava.compiler=NONE”; options[1].optionString = “-Djava.class.path=.”; options[2].optionString = “-verbose:jni”;//用於跟蹤運行時的信息 /*版本號設置不能漏*/ vm_args.version = JNI_VERSION_1_2; vm_args.nOptions = 3; vm_args.options = options; vm_args.ignoreUnrecognized = JNI_TRUE; res = JNI_CreateJavaVM(jvm, (void**)env, vm_args); if (res 0) { fprintf(stderr, “Can’t create Java VM “); exit(1); } (*jvm)-DestroyJavaVM(jvm); fprintf(stdout, “Java VM destory. “); }

為了保證JNI代碼的可移植性，建議使用JDK 1.2的方法來創建虛擬機。JNI_CreateJavaVM函數的第二個參數JNIEnv *env，就是貫穿整個JNI始末的一個參數，因為幾乎所有的函數都要求一個參數就是JNIEnv *env。

訪問類方法

初始化了Java虛擬機後，就可以開始調用Java的方法。要調用一個Java對象的方法必須經過幾個步驟：

1.獲取指定對象的類定義(jclass)

有兩種途徑來獲取對象的類定義：第一種是在已知類名的情況下使用FindClass來查找對應的類。但是要注重類名並不同於平時寫的Java代碼，例如要得到類jni.test.Demo的定義必須調用如下代碼：

jclass cls = (*env)-FindClass(env, “jni/test/Demo”);//把點號換成斜杠

然後通過對象直接得到其所對應的類定義：

jclass cls = (*env)- GetObjectClass(env, obj); //其中obj是要引用的對象，類型是jobject

2.讀取要調用方法的定義(jmethodID)

我們先來看看JNI中獲取方法定義的函數：

jmethodID (JNICALL *GetMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig); jmethodID (JNICALL *GetStaticMethodID)(JNIEnv *env, jclass class, const char *name, const char *sig);

這兩個函數的區別在於GetStaticMethodID是用來獲取靜態方法的定義，GetMethodID則是獲取非靜態的方法定義。這兩個函數都需要提供四個參數：env就是初始化虛擬機得到的JNI環境;第二個參數class是對象的類定義，也就是第一步得到的obj;第三個參數是方法名稱;最重要的是第四個參數，這個參數是方法的定義。因為我們知道Java中答應方法的多態，僅僅是通過方法名並沒有辦法定位到一個具體的方法，因此需要第四個參數來指定方法的具體定義。但是怎麼利用一個字元串來表示方法的具體定義呢?JDK中已經預備好一個反編譯工具javap，通過這個工具就可以得到類中每個屬性、方法的定義。下面就來看看jni.test.Demo的定義：

打開命令行窗口並運行 javap -s -p jni.test.Demo 得到運行結果如下：

Compiled from Demo.java public class jni.test.Demo extends java.lang.Object { public static int COUNT; /* I */ public java.lang.String msg; /* Ljava/lang/String; */ private int counts[]; /* [I */ public jni.test.Demo(); /* ()V */ public jni.test.Demo(java.lang.String); /* (Ljava/lang/String;)V */ public java.lang.String getMessage(); /* ()Ljava/lang/String; */ public int getCounts()[]; /* ()[I */ public void setCounts(int[]); /* ([I)V */ public void throwExcp() throws java.lang.IllegalAccessException; /* ()V */ static {}; /* ()V */ }

我們看到類中每個屬性和方法下面都有一段注釋。注釋中不包含空格的內容就是第四個參數要填的內容(關於javap具體參數請查詢JDK的使用幫助)。下面這段代碼演示如何訪問jni.test.Demo的getMessage方法：

/* 假設我們已經有一個jni.test.Demo的實例obj */ jmethodID mid; jclass cls = (*env)- GetObjectClass (env, obj);//獲取實例的類定義 mid=(*env)-GetMethodID(env,cls,”getMessage”,” ()Ljava/lang/String; “); /*假如mid為0表示獲取方法定義失敗*/ jstring msg = (*env)- CallObjectMethod(env, obj, mid); /* 假如該方法是靜態的方法那隻需要將最後一句代碼改為以下寫法即可： jstring msg = (*env)- CallStaticObjectMethod(env, cls, mid); */

3.調用方法

為了調用對象的某個方法，可以使用函數CallMethod或者CallStaticMethod(訪問類的靜態方法)，根據不同的返回類型而定。這些方法都是使用可變參數的定義，假如訪問某個方法需要參數時，只需要把所有參數按照順序填寫到方法中就可以。在講到構造函數的訪問時，將演示如何訪問帶參數的構造函數。

訪問類屬性

訪問類的屬性與訪問類的方法大體上是一致的，只不過是把方法變成屬性而已。

1.獲取指定對象的類(jclass)

這一步與訪問類方法的第一步完全相同，具體使用參看訪問類方法的第一步。

2.讀取類屬性的定義(jfieldID)

在JNI中是這樣定義獲取類屬性的方法的：

jfieldID (JNICALL *GetFieldID) (JNIEnv *env, jclass clazz, const char *name, const char *sig); jfieldID (JNICALL *GetStaticFieldID) (JNIEnv *env, jclass clazz, const char *name, const char *sig);

這兩個函數中第一個參數為JNI環境;clazz為類的定義;name為屬性名稱;第四個參數同樣是為了表達屬性的類型。前面我們使用javap工具獲取類的具體定義的時候有這樣兩行：

public java.lang.String msg; /* Ljava/lang/String; */

其中第二行注釋的內容就是第四個參數要填的信息，這跟訪問類方法時是相同的。

3.讀取和設置屬性值

有了屬性的定義要訪問屬性值就很輕易了。有幾個方法用來讀取和設置類的屬性，它們是：GetField、SetField、GetStaticField、SetStaticField。比如讀取Demo類的msg屬性就可以用GetObjectField，而訪問COUNT用GetStaticIntField，相關代碼如下：

jfieldID field = (*env)-GetFieldID(env,obj,”msg”,” Ljava/lang/String;”); jstring msg = (*env)- GetObjectField(env, cls, field);//msg就是對應Demo的msg jfieldID field2 = (*env)-GetStaticFieldID(env,obj,”COUNT”,”I”); jint count = (*env)-GetStaticIntField(env,cls,field2);

訪問構造函數

很多人剛剛接觸JNI的時候往往會在這一節碰到問題，查遍了整個jni.h看到這樣一個函數NewObject，它應該是可以用來訪問類的構造函數。但是該函數需要提供構造函數的方法定義，其類型是jmethodID。從前面的內容我們知道要獲取方法的定義首先要知道方法的名稱，但是構造函數的名稱怎麼來填寫呢?其實訪問構造函數與訪問一個普通的類方法大體上是一樣的，惟一不同的只是方法名稱不同及方法調用時不同而已。訪問類的構造函數時方法名必須填寫「」。下面的代碼演示如何構造一個Demo類的實例：

jclass cls = (*env)-FindClass(env, “jni/test/Demo”); /** 首先通過類的名稱獲取類的定義，相當於Java中的Class.forName方法 */ if (cls == 0) jmethodID mid = (*env)-GetMethodID(env,cls,””,”(Ljava/lang/String;)V “); if(mid == 0) jobject demo = jenv-NewObject(cls,mid,0); /** 訪問構造函數必須使用NewObject的函數來調用前面獲取的構造函數的定義 上面的代碼我們構造了一個Demo的實例並傳一個空串null */

數組處理

創建一個新數組

要創建一個數組，我們首先應該知道數組元素的類型及數組長度。JNI定義了一批數組的類型jArray及數組操作的函數NewArray，其中就是數組中元素的類型。例如，要創建一個大小為10並且每個位置值分別為1-10的整數數組，編寫代碼如下：

int i = 1; jintArray array;//定義數組對象 (*env)- NewIntArray(env, 10); for(; i= 10; i++) (*env)-SetIntArrayRegion(env, array, i-1, 1, i);

訪問數組中的數據

訪問數組首先應該知道數組的長度及元素的類型。現在我們把創建的數組中的每個元素值列印出來，代碼如下：

int i; /* 獲取數組對象的元素個數 */ int len = (*env)-GetArrayLength(env, array); /* 獲取數組中的所有元素 */ jint* elems = (*env)- GetIntArrayElements(env, array, 0); for(i=0; i len; i++) printf(“ELEMENT %d IS %d “, i, elems[i]);

中文處理

中文字元的處理往往是讓人比較頭疼的事情，非凡是使用Java語言開發的軟體，在JNI這個問題更加突出。由於Java中所有的字元都是Unicode編碼，但是在本地方法中，例如用VC編寫的程序，假如沒有非凡的定義一般都沒有使用Unicode的編碼方式。為了讓本地方法能夠訪問Java中定義的中文字元及Java訪問本地方法產生的中文字元串，我定義了兩個方法用來做相互轉換。

· 方法一，將Java中文字元串轉為本地字元串

/** 第一個參數是虛擬機的環境指針第二個參數為待轉換的Java字元串定義第三個參數是本地存儲轉換後字元串的內存塊第三個參數是內存塊的大小 */ int JStringToChar(JNIEnv *env, jstring str, LPTSTR desc, int desc_len) { int len = 0; if(desc==NULLstr==NULL) return -1; //在VC中wchar_t是用來存儲寬位元組字元(UNICODE)的數據類型 wchar_t *w_buffer = new wchar_t[1024]; ZeroMemory(w_buffer,1024*sizeof(wchar_t)); //使用GetStringChars而不是GetStringUTFChars wcscpy(w_buffer,env-GetStringChars(str,0)); env-ReleaseStringChars(str,w_buffer); ZeroMemory(desc,desc_len); //調用字元編碼轉換函數(Win32 API)將UNICODE轉為ASCII編碼格式字元串 //關於函數WideCharToMultiByte的使用請參考MSDN len = WideCharToMultiByte(CP_ACP,0,w_buffer,1024,desc,desc_len,NULL,NULL); //len = wcslen(w_buffer); if(len0 len

· 方法二，將C的字元串轉為Java能識別的Unicode字元串

jstring NewJString(JNIEnv* env,LPCTSTR str) { if(!env !str) return 0; int slen = strlen(str); jchar* buffer = new jchar[slen]; int len = MultiByteToWideChar(CP_ACP,0,str,strlen(str),buffer,slen); if(len0 len slen) buffer[len]=0; jstring js = env-NewString(buffer,len); delete [] buffer; return js; }

異常

由於調用了Java的方法，因此難免產生操作的異常信息。這些異常沒有辦法通過C++本身的異常處理機制來捕捉到，但JNI可以通過一些函數來獲取Java中拋出的異常信息。之前我們在Demo類中定義了一個方法throwExcp，下面將訪問該方法並捕捉其拋出來的異常信息，代碼如下：

/** 假設我們已經構造了一個Demo的實例obj，其類定義為cls */ jthrowable excp = 0;/* 異常信息定義 */ jmethodID mid=(*env)-GetMethodID(env,cls,”throwExcp”,”()V”); /*假如mid為0表示獲取方法定義失敗*/ jstring msg = (*env)- CallVoidMethod(env, obj, mid); /* 在調用該方法後會有一個IllegalAccessException的異常拋出 */ excp = (*env)-ExceptionOccurred(env); if(excp){ (*env)-ExceptionClear(env); //通過訪問excp來獲取具體異常信息 /* 在Java中，大部分的異常信息都是擴展類java.lang.Exception，因此可以訪問excp的toString 或者getMessage來獲取異常信息的內容。訪問這兩個方法同前面講到的如何訪問類的方法是相同的。 */ }

線程和同步訪問

有些時候需要使用多線程的方式來訪問Java的方法。我們知道一個Java虛擬機是非常消耗系統的內存資源，差不多每個虛擬機需要內存大約在20MB左右。為了節省資源要求每個線程使用的是同一個虛擬機，這樣在整個的JNI程序中只需要初始化一個虛擬機就可以了。所有人都是這樣想的，但是一旦子線程訪問主線程創建的虛擬機環境變數，系統就會出現錯誤對話框，然後整個程序終止。