C++调用JAVA方法详解

C++调用JAVA方法详解          博客分类：

本文主要参考http://tech.ccidnet.com/art/1081/20050413/237901_1.html 上的文章。

C++调用JAVA主要用到了SUN公司的JNI技术， JNI是Java Native Interface的 缩写。从Java 1.1开始，Java Native Interface (JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。相关资料见http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/jniTOC.html

开发环境安装及配置

1.1  安装JDK
        到SUN公司网站可以下载到最新版的JDK。下载下来后开始安装，一路选择默认配置即可，本文档中假定安装的是JDK1.4，安装目录为C:\j2sdk1.4.2_15。
 
1.2  配置VC6.0
         通过Visual C++ 6的菜单Tools→Options打开选项对话框。在Directories标签页下添加JDK的相关目录到Include和目录下。               

 开发测试用到的JAVA类

2.1  开发JAVA类

在硬盘的任意地方新建一个名叫test的文件夹，本文档示例中将test文件夹建立在C盘根目录，然后在里面新建一个名称叫Demo.java的JAVA文件，将下面测试用的代码粘贴到该文件中。

1. package test;
2. /**
3. * 该类是为了演示JNI如何访问各种对象属性等
4. */
5. public class Demo
6. {
7. //用于演示如何访问静态的基本类型属性
8. public static int COUNT = 8;
9. //演示对象型属性
10. private String msg;
11. private int[] counts;
12. public Demo()
13. {
14. this("缺省构造函数");
15. }
16. /**
17. * 演示如何访问构造器
18. */
19. public Demo(String msg)
20. {
21. this.msg = msg;
22. this.counts = null;
23. }
24. public String getMessage()
25. {
26. return msg;
27. }
28. /**
29. * 该方法演示如何访问一个静态方法
30. */
31. public static String getHelloWorld()
32. {
33. return "Hello world!";
34. }
35. /**
36. * 该方法演示参数的传入传出及中文字符的处理
37. */
38. public String append(String str, int i)
39. {
40. return str + i;
41. }
42. /**
43. * 演示数组对象的访问
44. */
45. public int[] getCounts()
46. {
47. return counts;
48. }
49. /**
50. * 演示如何构造一个数组对象
51. */
52. public void setCounts(int[] counts)
53. {
54. this.counts = counts;
55. }
56. /**
57. * 演示异常的捕捉
58. */
59. public void throwExcp()throws IllegalAccessException
60. {
61. throw new IllegalAccessException("exception occur.");
62. }
63. }

package test;
/**
* 该类是为了演示JNI如何访问各种对象属性等
*/
public class Demo
{
	//用于演示如何访问静态的基本类型属性
	public static int COUNT = 8;
	//演示对象型属性
	private String msg;
	private int[] counts;

	public Demo()
	{
		this("缺省构造函数");
	}
	/**
	 * 演示如何访问构造器
	 */
	public Demo(String msg)
	{
		this.msg = msg;
		this.counts = null;
	}
	public String getMessage()
	{
		return msg;
	}
	/**
	 * 该方法演示如何访问一个静态方法
	 */
	public static String getHelloWorld()
	{
		return "Hello world!";
	}

	/**
	 * 该方法演示参数的传入传出及中文字符的处理
	 */
	public String append(String str, int i)
	{
		return str + i;
	}
	/**
	 * 演示数组对象的访问
	 */
	public int[] getCounts()
	{
	 return counts;
	}
	/**
	 * 演示如何构造一个数组对象
	*/
	public void setCounts(int[] counts)
	{
	 this.counts = counts;
	}
	/**
	 * 演示异常的捕捉
	*/
	public void throwExcp()throws IllegalAccessException
	{
		throw new IllegalAccessException("exception occur.");
	}
}

2.2 编译JAVA类

运行CMD控制台程序进入命令行模式，输入命令javac -classpath c:\ c:\test\Demo.java，-classpath参数指定classpath的路径，这里就是test目录所在的路径。（注意：如果你没有将JDK的环境变量设置好，就需要先进入JDK的bin目录下，如下图所示。）

2.3 查看方法的签名

我们知道Java中允许方法的多态，仅仅是通过方法名并没有办法定位到一个具体的方法，因此需要一个字符串来唯一表示一个方法。但是怎么利用一个字 符串来表示方法的具体定义呢？JDK中已经准备好一个反编译工具javap，通过这个工具就可以得到类中每个属性、方法的签名。在CMD下运行javap -s -p -classpath c:\ test.Demo即可看到属性和方法的签名。如下图红色矩形框起来的字符串为方法String append(String str, int i)的签名。

在VC中调用JAVA类

3.1 快速调用JAVA中的函

在VC中新建一个控制台程序，然后新建一个CPP文件，将下面的代码添加到该文件中。运行该文件，即可得到Demo类中String append(String str, int i)函数返回的字符串。

1. #include "windows.h"
2. #include "jni.h"
3. #include <string>
4. #include <iostream>
5. using namespace std;
6. jstring NewJString(JNIEnv *env, LPCTSTR str);
7. string  JStringToCString (JNIEnv *env, jstring str);
8. int main()
9. {
10. //定义一个函数指针，下面用来指向JVM中的JNI_CreateJavaVM函数
11. typedef jint (WINAPI *PFunCreateJavaVM)(JavaVM **, void **, void *);
12. int res;
13. JavaVMInitArgs vm_args;
14. JavaVMOption options[3];
15. JavaVM *jvm;
16. JNIEnv *env;
17. /*设置初始化参数*/
18. //disable JIT，这是JNI文档中的解释，具体意义不是很清楚 ，能取哪些值也不清楚。
19. //从JNI文档里给的示例代码中搬过来的
20. options[0].optionString = "-Djava.compiler=NONE";
21. //设置classpath，如果程序用到了第三方的JAR包，也可以在这里面包含进来
22. options[1].optionString = "-Djava.class.path=.;c:\\";
23. //设置显示消息的类型，取值有gc、class和jni，如果一次取多个的话值之间用逗号格开，如-verbose:gc,class
24. //该参数可以用来观察C++调用JAVA的过程，设置该参数后，程序会在标准输出设备上打印调用的相关信息
25. options[2].optionString = "-verbose:NONE";
26. //设置版本号，版本号有JNI_VERSION_1_1，JNI_VERSION_1_2和JNI_VERSION_1_4
27. //选择一个根你安装的JRE版本最近的版本号即可，不过你的JRE版本一定要等于或者高于指定的版本号
28. vm_args.version = JNI_VERSION_1_4;
29. vm_args.nOptions = 3;
30. vm_args.options = options;
31. //该参数指定是否忽略非标准的参数，如果填JNI_FLASE，当遇到非标准参数时，JNI_CreateJavaVM会返回JNI_ERR
32. vm_args.ignoreUnrecognized = JNI_TRUE;
33. //加载JVM.DLL动态库
34. HINSTANCE hInstance = ::LoadLibrary("C:\\j2sdk1.4.2_15\\jre\\bin\\client\\jvm.dll");
35. if (hInstance == NULL)
36. {
37. return false;
38. }
39. //取得里面的JNI_CreateJavaVM函数指针
40. PFunCreateJavaVM funCreateJavaVM = (PFunCreateJavaVM)::GetProcAddress(hInstance, "JNI_CreateJavaVM");
41. //调用JNI_CreateJavaVM创建虚拟机
42. res = (*funCreateJavaVM)(&jvm, (void**)&env, &vm_args);
43. if (res < 0)
44. {
45. return -1;
46. }
47. //查找test.Demo类，返回JAVA类的CLASS对象
48. jclass cls = env->FindClass("test/Demo");
49. //根据类的CLASS对象获取该类的实例
50. jobject obj = env->AllocObject(cls);
51. //获取类中的方法，最后一个参数是方法的签名，通过javap -s -p 文件名可以获得
52. jmethodID mid = env->GetMethodID(cls, "append","(Ljava/lang/String;I)Ljava/lang/String;");
53. //构造参数并调用对象的方法
54. const char szTest[] = "电信";
55. jstring arg = NewJString(env, szTest);
56. jstring msg = (jstring) env->CallObjectMethod(obj, mid, arg, 12);
57. cout<<JStringToCString(env, msg);
58. //销毁虚拟机并释放动态库
59. jvm->DestroyJavaVM();
60. ::FreeLibrary(hInstance);
61. return 0;
62. }
63. string  JStringToCString (JNIEnv *env, jstring str)// (jstring str, LPTSTR desc, int desc_len)
64. {
65. if(str==NULL)
66. {
67. return "";
68. }
69. //在VC中wchar_t是用来存储宽字节字符(UNICODE)的数据类型
70. int len = env->GetStringLength(str);
71. wchar_t *w_buffer = new wchar_t[len+1];
72. char *c_buffer = new char[2*len+1];
73. ZeroMemory(w_buffer,(len+1)*sizeof(wchar_t));
74. //使用GetStringChars而不是GetStringUTFChars
75. const jchar * jcharString = env->GetStringChars(str, 0);
76. wcscpy(w_buffer,jcharString);
77. env->ReleaseStringChars(str,jcharString);
78. ZeroMemory(c_buffer,(2*len+1)*sizeof(char));
79. /调用字符编码转换函数(Win32 API)将UNICODE转为ASCII编码格式字符串
80. len = WideCharToMultiByte(CP_ACP,0,w_buffer,len,c_buffer,2*len,NULL,NULL);
81. string cstr = c_buffer;
82. delete[] w_buffer;
83. delete[] c_buffer;
84. return cstr;
85. }
86. jstring NewJString(JNIEnv *env, LPCTSTR str)
87. {
88. if(!env || !str)
89. {
90. return 0;
91. }
92. int slen = strlen(str);
93. jchar* buffer = new jchar[slen];
94. int len = MultiByteToWideChar(CP_ACP,0,str,strlen(str),buffer,slen);
95. if(len>0 && len < slen)
96. {
97. buffer[len]=0;
98. }
99. jstring js = env->NewString(buffer,len);
100. delete [] buffer;
101. return js;
102. }

#include "windows.h"
#include "jni.h"
#include <string>
#include <iostream>
using namespace std;

jstring NewJString(JNIEnv *env, LPCTSTR str);
string  JStringToCString (JNIEnv *env, jstring str);

int main()
{
    //定义一个函数指针，下面用来指向JVM中的JNI_CreateJavaVM函数
    typedef jint (WINAPI *PFunCreateJavaVM)(JavaVM **, void **, void *);

    int res;
    JavaVMInitArgs vm_args;
    JavaVMOption options[3];
    JavaVM *jvm;
    JNIEnv *env;

    /*设置初始化参数*/
    //disable JIT，这是JNI文档中的解释，具体意义不是很清楚 ，能取哪些值也不清楚。
    //从JNI文档里给的示例代码中搬过来的
    options[0].optionString = "-Djava.compiler=NONE";
    //设置classpath，如果程序用到了第三方的JAR包，也可以在这里面包含进来
    options[1].optionString = "-Djava.class.path=.;c:\\";
    //设置显示消息的类型，取值有gc、class和jni，如果一次取多个的话值之间用逗号格开，如-verbose:gc,class
    //该参数可以用来观察C++调用JAVA的过程，设置该参数后，程序会在标准输出设备上打印调用的相关信息
    options[2].optionString = "-verbose:NONE";

    //设置版本号，版本号有JNI_VERSION_1_1，JNI_VERSION_1_2和JNI_VERSION_1_4
    //选择一个根你安装的JRE版本最近的版本号即可，不过你的JRE版本一定要等于或者高于指定的版本号
    vm_args.version = JNI_VERSION_1_4;
    vm_args.nOptions = 3;
    vm_args.options = options;
    //该参数指定是否忽略非标准的参数，如果填JNI_FLASE，当遇到非标准参数时，JNI_CreateJavaVM会返回JNI_ERR
    vm_args.ignoreUnrecognized = JNI_TRUE;
    //加载JVM.DLL动态库
    HINSTANCE hInstance = ::LoadLibrary("C:\\j2sdk1.4.2_15\\jre\\bin\\client\\jvm.dll");
    if (hInstance == NULL)
    {
        return false;
    }
    //取得里面的JNI_CreateJavaVM函数指针
    PFunCreateJavaVM funCreateJavaVM = (PFunCreateJavaVM)::GetProcAddress(hInstance, "JNI_CreateJavaVM");
    //调用JNI_CreateJavaVM创建虚拟机
    res = (*funCreateJavaVM)(&jvm, (void**)&env, &vm_args);
    if (res < 0)
    {
        return -1;
    }
    //查找test.Demo类，返回JAVA类的CLASS对象
    jclass cls = env->FindClass("test/Demo");
    //根据类的CLASS对象获取该类的实例
    jobject obj = env->AllocObject(cls);

    //获取类中的方法，最后一个参数是方法的签名，通过javap -s -p 文件名可以获得
    jmethodID mid = env->GetMethodID(cls, "append","(Ljava/lang/String;I)Ljava/lang/String;");
    //构造参数并调用对象的方法
    const char szTest[] = "电信";
    jstring arg = NewJString(env, szTest);
    jstring msg = (jstring) env->CallObjectMethod(obj, mid, arg, 12);
    cout<<JStringToCString(env, msg);

    //销毁虚拟机并释放动态库
    jvm->DestroyJavaVM();
    ::FreeLibrary(hInstance);
    return 0;
}

string  JStringToCString (JNIEnv *env, jstring str)// (jstring str, LPTSTR desc, int desc_len)
{
    if(str==NULL)
    {
        return "";
    }
    //在VC中wchar_t是用来存储宽字节字符(UNICODE)的数据类型
    int len = env->GetStringLength(str);
    wchar_t *w_buffer = new wchar_t[len+1];
    char *c_buffer = new char[2*len+1];
    ZeroMemory(w_buffer,(len+1)*sizeof(wchar_t));
    //使用GetStringChars而不是GetStringUTFChars
    const jchar * jcharString = env->GetStringChars(str, 0);
    wcscpy(w_buffer,jcharString);
    env->ReleaseStringChars(str,jcharString);
    ZeroMemory(c_buffer,(2*len+1)*sizeof(char));
    /调用字符编码转换函数(Win32 API)将UNICODE转为ASCII编码格式字符串
    len = WideCharToMultiByte(CP_ACP,0,w_buffer,len,c_buffer,2*len,NULL,NULL);
    string cstr = c_buffer;
    delete[] w_buffer;
    delete[] c_buffer;

    return cstr;
}

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(len>0 && len < slen)
    {
        buffer[len]=0;
    }
    jstring js = env->NewString(buffer,len);
    delete [] buffer;
    return js;
}

3.2 调用步骤分析及注意事项

a、加载jvm.dll动态库，然后获取里面的JNI_CreateJavaVM函数。这个步骤也可以通过在VC工程的LINK标签页里添加对jvm.lib的连接，然后在环境变量里把jvm.dll所在的路径加上去来实现。但后面这种方法在部署的时候会比前一个方法麻烦。

b、利用构造好的参数，调用JNI_CreateJavaVM函数创建JVM。JNI_CreateJavaVM函数内部会自动根据jvm.dll的路径来获取JRE的环境，所以千万不要把jvm.dll文件拷贝到别的地方，然后再通过LoadLibrary函数导入。

c、JVM创建成功后，JNI_CreateJavaVM函数会传出一个JNI上下文环境对象（JNIEnv），利用该对象的相关函数就可以调用JAVA类的属性和方法了。

d、以上面的代码为例：先调用JNIEnv的FindClass方法，该函数传入一个参数，该参数就是java类的全局带包名的名称，如上面示例中的test/Demo表示test包中的Demo类。这个方法会在你创建JVM时设置的classpath路径下找相应的类，找到后就会返回该类的class对象。 Class是JAVA中的一个类，每个JAVA类都有唯一的一个静态的Class对象，Class对象包含类的相关信息。为了使FindClass方法能找到你的类，请确保创建JVM时-Djava.class.path=参数设置正确。注意：系统环境变量中的CLASSPATH对这里创建JVM没有影响，所以不要以为系统CLASSPATH设置好了相关路径后这里就不用设置了。

e、利用FindClass返回的class对象，调用GetMethodID函数可以获得里面方法的ID，在这里GetMethodID函数传入了三个参数：第一个参数是class对象，因为方法属于某个具体的类；第二个参数是方法的名称；第三个参数是方法的签名，这个签名可以在前面3.3中介绍的方法获得。

f、利用class对象，可以通过调用AllocObject函数获得该class对象对应类的一个实例，即Demo类的对象。

g、利用上面获取的函数ID和Demo类的对象，就可以通过CallObjectMethod函数调用相应的方法，该函数的参数跟printf函数的参数一样，个数是不定的。第一个参数是类的对象；第二个参数是要调用的方法的ID；后面的参数就是需要传给调用的JAVA类方法的参数，如果调用的JAVA类方法没有参数，则调用CallObjectMethod时传前两个参数就可以了。

h、从上面的示例中可以看到，在调用JAVA的方法前，构造传入的字符串时，用到了NewJString函数；在调用该方法后，对传出的字符串调用了JstringToCString函数。这是由于Java中所有的字符都是Unicode编码，但是在本地方法中，例如用VC编写的程序，如果没有特殊的定义一般都没有使用Unicode的编码方式。为了让本地方法能够访问Java中定义的中文字符及Java访问本地方法产生的中文字符串，定义了两个方法用来做相互转换。

i、避免在被调用的JAVA类中使用静态final成员变量，因为在C++中生成一个JAVA类的对象时，静态final成员变量不会像JAVA中new对象时那样先赋值。如果出现这种情况，在C++中调用该对象的方法时会发现该对象的静态final成员变量值全为0或者null（根据成员变量的类型而定）。

3.3 调用JAVA中的静态方法

1. //调用静态方法
2. jclass cls = env->FindClass("test/Demo");
3. jmethodID mid = env->GetStaticMethodID(cls, "getHelloWorld","()Ljava/lang/String;");
4. jstring msg = (jstring)env->CallStaticObjectMethod(cls, mid);
5. cout<<JStringToCString(env, msg);

//调用静态方法
jclass cls = env->FindClass("test/Demo");
jmethodID mid = env->GetStaticMethodID(cls, "getHelloWorld","()Ljava/lang/String;");
jstring msg = (jstring)env->CallStaticObjectMethod(cls, mid);
cout<<JStringToCString(env, msg);

 

3.4 调用JAVA中的静态属性

1. //调用静态方法
2. jclass cls = env->FindClass("test/Demo");
3. jfieldID fid = env->GetStaticFieldID(cls, "COUNT","I");
4. int count = (int)env->GetStaticIntField(cls, fid);
5. cout<<count<<endl;

//调用静态方法
jclass cls = env->FindClass("test/Demo");
jfieldID fid = env->GetStaticFieldID(cls, "COUNT","I");
int count = (int)env->GetStaticIntField(cls, fid);
cout<<count<<endl;

3.5 调用JAVA中的带参数构造函数

1. //调用构造函数
2. jclass cls = env->FindClass("test/Demo");
3. jmethodID mid = env->GetMethodID(cls,"<init>","(Ljava/lang/String;)V");
4. const char szTest[] = "电信";
5. jstring arg = NewJString(env, szTest);
6. jobject demo = env->NewObject(cls,mid,arg);
7. //验证是否构造成功
8. mid = env->GetMethodID(cls, "getMessage","()Ljava/lang/String;");
9. jstring msg = (jstring)env->CallObjectMethod(demo, mid);
10. cout<<JStringToCString(env, msg);

//调用构造函数
jclass cls = env->FindClass("test/Demo");
jmethodID mid = env->GetMethodID(cls,"<init>","(Ljava/lang/String;)V");
const char szTest[] = "电信";
jstring arg = NewJString(env, szTest);
jobject demo = env->NewObject(cls,mid,arg);
//验证是否构造成功
mid = env->GetMethodID(cls, "getMessage","()Ljava/lang/String;");
jstring msg = (jstring)env->CallObjectMethod(demo, mid);
cout<<JStringToCString(env, msg);

3.6 传入传出数组

1. //传入传出数组
2. //构造数组
3. long        arrayCpp[] = {1,3,5,7,9};
4. jintArray array = env->NewIntArray(5);
5. env->SetIntArrayRegion(array, 0, 5, arrayCpp);
6. //传入数组
7. jclass cls = env->FindClass("test/Demo");
8. jobject obj = env->AllocObject(cls);
9. jmethodID mid = env->GetMethodID(cls,"setCounts","([I)V");
10. env->CallVoidMethod(obj, mid, array);
11. //获取数组
12. mid = env->GetMethodID(cls,"getCounts","()[I");
13. jintArray msg = (jintArray)env->CallObjectMethod(obj, mid, array);
14. int len =env->GetArrayLength(msg);
15. jint* elems =env-> GetIntArrayElements(msg, 0);
16. for(int i=0; i< len; i++)
17. {
18. cout<<"ELEMENT "<<i<<" IS "<<elems[i]<<endl;
19. }
20. env->ReleaseIntArrayElements(msg, elems, 0);

//传入传出数组
//构造数组
long		arrayCpp[] = {1,3,5,7,9};
jintArray array = env->NewIntArray(5);
env->SetIntArrayRegion(array, 0, 5, arrayCpp);
//传入数组
jclass cls = env->FindClass("test/Demo");
jobject obj = env->AllocObject(cls);
jmethodID mid = env->GetMethodID(cls,"setCounts","([I)V");
env->CallVoidMethod(obj, mid, array);
//获取数组
mid = env->GetMethodID(cls,"getCounts","()[I");
jintArray msg = (jintArray)env->CallObjectMethod(obj, mid, array);
int len =env->GetArrayLength(msg);
jint* elems =env-> GetIntArrayElements(msg, 0);
for(int i=0; i< len; i++)
{
    cout<<"ELEMENT "<<i<<" IS "<<elems[i]<<endl;
}
env->ReleaseIntArrayElements(msg, elems, 0);

3.7 异常处理      由于调用了Java的方法，因此难免产生操作的异常信息，如JAVA函数返回的异常，或者调用JNI方法（如GetMethodID）时抛出的异常。这些异常没有办法通过C++本身的异常处理机制来捕捉到，但JNI可以通过一些函数来获取Java中抛出的异常信息。

1. //异常处理
2. jclass cls = env->FindClass("test/Demo");
3. jobject obj = env->AllocObject(cls);
4. jmethodID mid = env->GetMethodID(cls,"throwExcp","()V");
5. env->CallVoidMethod(obj, mid);
6. //获取异常信息
7. string exceptionInfo = "";
8. jthrowable excp = 0;
9. excp = env->ExceptionOccurred();
10. if(excp)
11. {
12. jclass cls = env->GetObjectClass(excp);
13. env->ExceptionClear();
14. jmethodID mid = env->GetMethodID(cls, "toString","()Ljava/lang/String;");
15. jstring msg = (jstring) env->CallObjectMethod(excp, mid);
16. out<<JStringToCString(env, msg)<<endl;
17. env->ExceptionClear();
18. }

//异常处理
jclass cls = env->FindClass("test/Demo");
jobject obj = env->AllocObject(cls);
jmethodID mid = env->GetMethodID(cls,"throwExcp","()V");
env->CallVoidMethod(obj, mid);
//获取异常信息
string exceptionInfo = "";
jthrowable excp = 0;
excp = env->ExceptionOccurred();
if(excp)
{
    jclass cls = env->GetObjectClass(excp);
    env->ExceptionClear();
    jmethodID mid = env->GetMethodID(cls, "toString","()Ljava/lang/String;");
    jstring msg = (jstring) env->CallObjectMethod(excp, mid);
    out<<JStringToCString(env, msg)<<endl;
    env->ExceptionClear();
}

多线程

4.1 多线程中注意事项

JNIEnv和jobject对象都不能跨线程使用

对于jobject，解决办法是

a、m_obj = m_env->NewGlobalRef(obj);//创建一个全局变量

b、jobject obj = m_env->AllocObject(m_cls);//在每个线程中都生成一个对象

对于JNIEnv，解决办法是在每个线程中都重新生成一个env

JNIEnv *env;

m_jvm->AttachCurrentThread((void **)&env, NULL);