jni编程 C++调用java详解

最新推荐文章于 2024-05-09 19:49:13 发布
最新推荐文章于 2024-05-09 19:49:13 发布
阅读量3.7k 收藏 22
点赞数 3
文章标签： c++ java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41949110/article/details/124822609
版权

文章目录

前言

前段时间公司因项目需要，需要使用C++调用jar包，但是网上的资料零零散散，完整的可借鉴的开发资料少之又少，于是就有了这篇文章， 把这段时间的开发的经验总结一下，以后，自己也可以回过头来温习一下,各位读者如果对调用流程不是很熟悉，只要细心的阅读，相信一定会有收获的。

一、说明

C++调用java的是通过加载java虚拟机来解释java字节码，然后再通过虚拟机来调用对应的java代码，
首先加载jvm库，只要安装了JDK都会有jvm库（动态库和静态库都有），加载流程如下
本文以动态库为实例

二、使用步骤

1.加载jvm动态库

代码如下（示例）：

char szJVMpath[MAX_PATH] = {0};

//通过环境变量javahome直接获取jvm.dll的路径，这里说明一下这个路径可以自己设置，不一定非要使用已经安装的jdk。
sprintf(szJVMpath, "%s\\jre\\bin\\server\\jvm.dll", getenv("JAVA_HOME"));

HINSTANCE hInstance = LoadLibrary(szJVMpath);
	if (hInstance == NULL)
	{
		return false;
	}

	pFnCreateJavaVM m_CreateJavaVM = (pFnCreateJavaVM)GetProcAddress(hInstance, "JNI_CreateJavaVM");

	pFnGetCreatedJavaVMs m_GetCreatedJavaVMs = (pFnGetCreatedJavaVMs)GetProcAddress(hInstance, "JNI_GetCreatedJavaVMs");

	if (NULL == m_CreateJavaVM || NULL == m_GetCreatedJavaVMs)
	{
		return false;
	}

2.创建虚拟机

代码如下（示例）：


	int ret = 0;

	JavaVM* Tempjvm = NULL;
	jsize count;
	
/*先获取当前进程中是否有已存在的jvm虚拟机， 如果存在则直接获取该虚拟机句柄， 如果不存在则创建新的虚拟机，

 因为较新的jdk中一个进程中只允许存在创建一个虚拟机，如果当前进程中已存在虚拟机，重新调用m_CreateJavaVM接口创建虚拟机会失败。

如果你需要多线程使用虚拟机，则需要考虑这种情况， 因为虚拟机中  JavaVM虚拟机句柄是线程共享的    环境上下文env是非线程共享的
*/
	ret = m_GetCreatedJavaVMs(&Tempjvm, sizeof(JavaVM) * 10, &count);
	
	JNIEnv* env;
	JavaVM* jvm;

		
	if (0 == ret  &&  NULL != Tempjvm && count > 0)
	{
		jvm = Tempjvm;
	}
	else
	{
		JavaVMInitArgs vm_args;
		const int OPTION_COUNT = 5;
		vm_args.nOptions = OPTION_COUNT;
		JavaVMOption options[OPTION_COUNT] = { 0 };
	
		char Currpath[256] = {0};
		int nCurrpathlen = 255;
		getcwd(Currpath, nCurrpathlen);
	
		char JarPath[256] = {0};
		char optionStringBuffer[1024] = {0};
	
		strcpy(JarPath, Currpath);
		strcat(JarPath, "\\icbc-api-sdk-cop.zip");
	
		char JarPath_io[256] = {0};
		strcpy(JarPath_io, Currpath);
		strcat(JarPath_io, "\\icbc-api-sdk-cop-io.zip");
	
		char JarPath_hsm[256] = {0};
		strcpy(JarPath_hsm, Currpath);
		strcat(JarPath_hsm, "\\hsm-software-share-1.0.3.jar");

		sprintf(optionStringBuffer, "-Djava.class.path=%s;%s;%s", JarPath, JarPath_io, JarPath_hsm);
	
		//这里是设置需要加载的java文件，或者jar包，不同的源文件用;隔开即可。
		options[0].optionString = optionStringBuffer;
	
		/*这里是设置虚拟机的内存空间大小，vm虚拟机的内存 主要由三块构成（年轻代+老年代+持久代）
		年轻代：所有新生成的对象都是放在年轻代中，年轻代的目的就是快速回收那些短生命周期的对象，年轻代分三个区，一个Edge区, 两个Survivor区域，大部分对象在Edge区生成，
	当Edge区满了之后，虚拟机会将触发Scavenge GC,将edge还存活的对象移到Survivor区（两个其中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，
	当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，
	没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor复制过来的对象。
	而且，Survivor区总有一个是空的。同时，根据程序需要，Survivor区是可以配置为多个的（多于两个），这样可以增加对象在年轻代中的存在时间，减少被放到年老代的可能。
	
	年老代:
	
	在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
	
	持久代:
	用于存放静态文件，如今Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，
	例如Hibernate等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=<N>进行设置。
	*/
	
		//设置虚拟机最大可使用的内存大小 一般根据实际内存情况来设置
		options[1].optionString = "-Xmx1024m";  
		//设置新生代区域大小，看情况具体而定，如果在执行过程如果出现虚拟机崩溃，查看hs_err_pid***.log 每次崩溃的最后调用堆栈是申请内存，初始化对象的时候 那就要增加新生代区域大小。
		options[2].optionString = "-Xmn256m";  // 新生代堆大小256M
		options[3].optionString = "-XX:PrintHeapAtGC"; //打印GC前后的详细堆栈信息
		options[4].optionString = "-Xloggc:gccdebug.txt"; //打印日志到该文件
	
	

	//设置版本号，版本号有JNI_VERSION_1_1，JNI_VERSION_1_2和JNI_VERSION_1_4  
	  //选择一个跟你安装的JRE版本最近的版本号即可，不过你的JRE版本一定要等于或者高于指定的版本号  
		vm_args.version = JNI_VERSION_1_8;
		//vm_args.nOptions = 1;
		vm_args.options = options;
		//该参数指定是否忽略非标准的参数，如果填JNI_FLASE，当遇到非标准参数时，JNI_CreateJavaVM会返回JNI_ERR  
		vm_args.ignoreUnrecognized = JNI_TRUE;
	
	
			ret = m_CreateJavaVM(&jvm, (void**)&env, &vm_args);
	
		}
	
		if (ret < 0)
		{
	
			return false;
		}
	
	
		FreeLibrary(hInstance);
		/*虚拟机是依赖该动态库运行的，所以当你确定你已经不需要在使用java虚拟机的时候，再释放该动态库（虚拟机未释放即时你主动释放该动态库句柄，也是没有作用的，最后章节会具体解释虚拟机destroy问题。）*/
	}
		//到这里虚拟机算是创建成功了 创建虚拟机的时候会返回一个虚拟机上下文env，获取对应的java类和对象，

注：虚拟机崩溃一定会产生hs_err_pid***.log日志，如果没有未则说明不是虚拟机本身引起的崩溃，

3.加载java类

		
		jclass ClsArrayList;
		jclass ClsJsonObject;
		jclass ClsMybankPayDigitalwalletHdsubwalletinitRequestV1;
		jclass ClsMybankPayDigitalwalletHdsubwalletinitRequestV1Biz;
		
		
		//这是java系统类list
		ClsArrayList = env->FindClass("java/util/ArrayList");

//这是java打印类，按照json格式打印当前类的所有数据 调试，C++打印日志超级方便
			ClsJsonObject = env->FindClass("com/icbc/api/internal/util/internal/util/fastjson/JSONObject");

//这是java自定义类，在java中每一个每一个'/'代表当前是一个文件夹
			ClsMybankPayDigitalwalletHdsubwalletinitRequestV1 = env->FindClass("com/icbc/api/request/MybankPayDigitalwalletHdsubwalletinitRequestV1");
			
			
			//这是java自定义类 这是子类 以'$'分隔
			ClsMybankPayDigitalwalletHdsubwalletinitRequestV1Biz = env->FindClass("com/icbc/api/request/MybankPayDigitalwalletHdsubwalletinitRequestV1$MybankPayDigitalwalletHdsubwalletinitRequestV1Biz");

4.加载java类方法或静态成员

java方法从加载方式来说分两种
第一种格式static方法需要调用GetStaticMethodID 来获取jmethodID
第二种普通的方法通过getGetMethodID

jmethodID GetMethodID(jclass clazz, const char *name,const char *sig) 
参数说明 clazz：加载的类方法所属作用域的类名，
name： 方法名称,区分大小写
sig: java函数对应的唯一标识符 ,可以通过 javap -verbose  -***.class > 123.txt  命令 查看对应类,静态	变量,方法的 标识符。

注意：只能加载自己的类成员或者方法，第一个参数为派生类对象，不能加载基类的成员方法。


//这是javalist操作函数
	if (NULL != ClsArrayList)
			{
				//list 初始化方法
				Jmdlist_init = env->GetMethodID(ClsArrayList, "<init>", "()V");
				
				//list  get 方法
				Jmdalist_get = env->GetMethodID(ClsArrayList, "get", "(I)Ljava/lang/Object;");

				// size()
				Jmdalist_size = env->GetMethodID(ClsArrayList, "size", "()I");


				// add
				Jmdlist_add = env->GetMethodID(ClsArrayList, "add", "(Ljava/lang/Object;)Z");

			}
			
			//这是自定义函数
			if (NULL != ClsAbstractIcbcRequest)
			{
				JmdsetServiceUrl = env->GetMethodID(ClsAbstractIcbcRequest, "setServiceUrl", "(Ljava/lang/String;)V");
				JmdsetBizContent = env->GetMethodID(ClsAbstractIcbcRequest, "setBizContent", "(Lcom/icbc/api/BizContent;)V");
			}

//加载静态成员变量, 静态成员变量的标识符获取方式和java函数相同。
			
			jfieldID fileID = env->GetStaticFieldID(Cls_IcbcConstants, "CHARSET_UTF8", "Ljava/lang/String;");
			CHARSET_UTF8 = (jstring) env->GetStaticObjectField(Cls_IcbcConstants, fileID);

			fileID = env->GetStaticFieldID(Cls_IcbcConstants, "FORMAT_JSON", "Ljava/lang/String;");
			FORMAT_JSON = (jstring) env->GetStaticObjectField(Cls_IcbcConstants, fileID);

			fileID = env->GetStaticFieldID(Cls_IcbcConstants, "ENCRYPT_TYPE_AES", "Ljava/lang/String;");
			ENCRYPT_TYPE_AES = (jstring) env->GetStaticObjectField(Cls_IcbcConstants, fileID);

5.创建对象和方法调用

jobject NewObject(jclass clazz, jmethodID methodID, …)；
void CallVoidMethod(jobject obj, jmethodID methodID, …) ；

1.NewObject 和 CallVoidMethod 参数形参说明表一模一样，  因为初始化实际上也是调用构造函数，只不过初始化和static方法一样不需要this指针，所以第一个参数是class, CallVoidMethod第一个参数是实例化对象。
2. 后面是一个初始化参数列表（可变长参数），这个参数列表时根据GetMethodID后面的函数标识符来规定的，假如你的标识符说明有三个行参（string,string,string）, 但是实际传入的时候你参数类型对不上或者参数个数对不上，编译器不会做类型检查，他会把你传过去的C++对象强转为java对象，jvm虚拟机会在运行的时候出现未知行为（很有可能会崩溃）。
3.第一个参数（一般是类或者类对象）不能为NULL, 调用之前必须做异常判断， 如果为NULL，jvm虚拟机会崩溃，因为 jvm虚拟机对C++传过去的值做校验。
4.调用java方法 根据其返回值采用不同的调用方式， 没有返回值env->CallvoidMethod ， 返回值为对象 env->CallobjectMethod, 其他的int, char, bool 参照jin.h头文件，


	ClsDefaultIcbcClient = env->FindClass("com/icbc/api/DefaultIcbcClient");
	
	jmethodID Jmd_DefaultIcbcClient_Init = env->GetMethodID(Cls_DefaultIcbcClient, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
	
			jstring appId =  env->NewStringUTF("");
			jstring signType =  env->NewStringUTF("");
			jstring privateKey =  env->NewStringUTF(NULL);
			jstring charset = CHARSET_UTF8;
			jstring format = FORMAT_JSON;
			jstring icbcPulicKey =  env->NewStringUTF(NULL);
			jstring encryptType = ENCRYPT_TYPE_AES;
			jstring encryptKey =  env->NewStringUTF(NULL);
			jstring ca =  env->NewStringUTF("");
			jstring password =  env->NewStringUTF(NULL);
			jstring emSignIp =  env->NewStringUTF(NULL);
			jstring emSignPort =  env->NewStringUTF(NULL);
			jstring emProduct =  env->NewStringUTF(NULL);

			jobject DefaultIcbcClient =  env->NewObject(Cls_DefaultIcbcClient, Jmd_DefaultIcbcClient_Init, appId,  signType,  privateKey,  charset,  format,  icbcPulicKey,  encryptType,  encryptKey,  ca,  password,  emSignIp,  emSignPort,  emProduct);


			jobject request = env->NewObject(ClsMybankPayDigitalwalletBatchhdsubwalinitRequestV1, JmdMybankPayDigitalwalletBatchhdsubwalinitRequestV1_Init);
			//request赋值很复杂这里我不贴代码。


			Jmdexecute = env->GetMethodID(ClsDefaultIcbcClient, "execute", "(Lcom/icbc/api/IcbcRequest;)Lcom/icbc/api/IcbcResponse;");
			
			jobject JObjRespone  = env->CallObjectMethod(DefaultIcbcClient, Jmdexecute, request);

6.辅助通用函数

那些简单的helloworld的测试代码，网上一搜一大堆，我这里再提供一些很常用的基础功能函数

6.1.C++ List -> java List

//因为JniEnv 和其加载的方法不能线程共享 所以需要当做参数传入
jobject ListCToJavaObject(list<string> & CList, JNIEnv* env, jclass ClsArrayList, jmethodID Jmdlist_init, jmethodID Jmdlist_add)
{

	jobject list_obj = env->NewObject(ClsArrayList, Jmdlist_init);

	list<string>::const_iterator ListIter = CList.cbegin();
	while (ListIter != CList.cend())
	{
		env->CallVoidMethod(list_obj, Jmdlist_add, env->NewStringUTF(ListIter->c_str()));
		++ListIter;
	}

	return list_obj;
}

6.2. java List -> C++ List

list<string> ListJavaObjectToC(jobject & JList, JNIEnv* env, jclass ClsArrayList, jmethodID Jmdalist_size, jmethodID Jmdalist_get)
{

	list<string> StrList;

	int list_obj_size = env->CallIntMethod(JList, Jmdalist_size);

	int i = 0;
	while (i < list_obj_size)
	{
		jstring  jStr = (jstring)env->CallObjectMethod(JList, Jmdalist_get, i);

		StrList.push_back(jstring2string(env, jStr));

		env->DeleteLocalRef(jStr);

		++i;
	}

	return StrList;

}

6.3. Java jstring -> C++ string

string jstring2string(JNIEnv* env, jstring jStr)
{
	if (!jStr)
	{
		return "";
	}
	const jclass stringClass = env->GetObjectClass(jStr);
	const jmethodID getBytes = env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
	const jbyteArray stringJbytes = (jbyteArray) env->CallObjectMethod(jStr, getBytes, env->NewStringUTF("UTF-8"));

	size_t length = (size_t) env->GetArrayLength(stringJbytes);
	jbyte* pBytes = env->GetByteArrayElements(stringJbytes, NULL);

	std::string ret = std::string((char*)pBytes, length);
	env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);

	env->DeleteLocalRef(stringJbytes);
	env->DeleteLocalRef(stringClass);
	return ret;
}

6.3. C++ utf-8转gbk函数

因为java虚拟机默认是utf-8编码，如果有中文的话当前程序不能正常显示，可以转为gbk

int UTF82GBK(const char* szUtf8, char* szGbk, int Len)
{
	int n = MultiByteToWideChar(CP_UTF8, 0, szUtf8, -1, NULL, 0);
	WCHAR* wszGBK = new WCHAR[sizeof(WCHAR) * n];
	memset(wszGBK, 0, sizeof(WCHAR) * n);
	MultiByteToWideChar(CP_UTF8, 0, szUtf8, -1, wszGBK, n);
	n = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
	if (n > Len)
	{
		delete[]wszGBK;
		return -1;
	}
	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGbk, n, NULL, NULL);
	delete[]wszGBK;
	wszGBK = NULL;
	return 0;
}

7.多线程开发注意事项

7.1. Jvm共享

jvm是线程共享的，进程唯一的，你可以把他作为一个线程共享变量存储起来，但是当你无法获取该变量是，你可以直接查询当前进程是否存在jvm虚拟机，调用方法为JNI_GetCreatedJavaVMs


	JNIEnv* env;
	JavaVM* jvm;


	JavaVM* Tempjvm = NULL;
	jsize count;
	ret = m_GetCreatedJavaVMs(&Tempjvm, sizeof(JavaVM) * 10, &count);

	EnterCriticalSection(&m_JvmMutex);

	if (0 == ret  &&  NULL != Tempjvm && count > 0)
	{
		jvm = Tempjvm;
	}
	else
	{
	
		ret = m_CreateJavaVM(&jvm, (void**)&env, &vm_args);
	}

7.2. 线程获取env

上面是单线程的测试流程，但是众所周知 其他的线程我们无法引用当前线程env，就因为env非线程共享，在其他的线程我们无法使用该线程env以及其获取的class。
首次使用JNI_GetCreatedJavaVMs接口 创建虚拟机的时候会返回以恶搞env，但是这只能再当前线程使用，
在多线程的情况下，调用首次使用JNI_GetCreatedJavaVMs接口成功创建虚拟机之后，再调用该接口会失败，因为一个进程只能存在一个虚拟机。
这个时候我们需要使用AttachCurrentThread()函数， AttachCurrentThread是将当前线程附加到虚拟机上，并获取属于当前线程的env，

JNIEnv* env = NULL;
			jint nRet = jvm->AttachCurrentThread((void**)&env, NULL);
			
			//如果env不为空，则说明附加成功， 在程序最后需要DetachCurrentThread()来释放当前线程的env
			
			if (NULL == env)
			{
				IfGetEnvCorrentsuccess = false;
				break;
			}
			else
			{
				IfGetEnvCorrentsuccess = true;
			}
			

//再当前线程退出时 再调用DetachCurrentThread释放该env	
		if(true == IfGetEnvCorrentsuccess)
		{
			jvm->DetachCurrentThread()
		}

8. Jvm destroy问题

问题引入：当我们首次使用JNI_GetCreatedJavaVMs接口成功创建虚拟机之后
正常流程 我们应当使用jvm->destrory来释放虚拟机， 但是当我们destory（destroy函数是非阻塞的）之后 调用JNI_GetCreatedJavaVMs返回-1，会创建失败，并且JNI_GetCreatedJavaVMs返回NULL,
看这段官方关于destrory函数的说明

”The VM waits until the current thread is the only non-daemon user
thread before it actually unloads. User threads include both Java
threads and attached native threads. This restriction exists because
a Java thread or attached native thread may be holding system
resources, such as locks, windows, and so on. The VM cannot
automatically free these resources. By restricting the current
thread to be the only running thread when the VM is unloaded, the
burden of releasing system resources held by arbitrary threads is on
the programmer.“

中文翻译为

虚拟机等待当前线程成为唯一的非守护进程用户线程，然后才实际卸载。用户线程包括Java线程和附加的本机线程。存在这种限制是因为Java线程或附加的本机线程可能持有系统资源，如锁、窗口等。
虚拟机无法自动释放这些资源。通过在卸载VM时将当前线程限制为唯一正在运行的线程，释放由任意线程持有的系统资源的负担就落在了程序员身上。

JDK / JRE 1.1不完全支持DestroyJavaVM. 在JDK/JRE 1.1 只有主线程可以叫DestroyJavaVM。 从JDK/JRE 1.2, 任何线程都可以调用这个函数， 不管是否从依附的线程中. 如果与当前线程连接,
VM等到当前线程是唯一非守护进程。如果没有与当前线程相连接，那么VM会与当前线程相连，并且等待当前线程是非守护线程. The JDK/JRE still does not support VM unloading, however.

DestroyJavaVM之后 会启动会一个Destroy线程监听进程， 将当前虚拟机状态置为不可用，但是虚拟机还是真实存在的， 当满足这个条件 “当前进程中只存在唯一的非守护线程” ，才会真正的释放jvm虚拟机， 所以才会出现问题引入的那种现象

显然 只有程序退出的时候 才会满足这个条件 “当前进程中只存在唯一的非守护线程”

解决方案：
大家看这样一段话：
Last time I looked at JNI_DestroyJVM(), it said “The JDK/JRE still does not support VM unloading, however.” Just don’t call it, and don’t re-initialize it either.、

所以 jni官方文档这样说 “As of JDK/JRE 1.1.2 unloading of the VM is not supported.”

文档资料出处

意思是我们不需要调用主动destrory来释放虚拟机，当前进程结束时会自动释放虚拟机。

鸿毛不浮 水漫富士
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
Android使用jni调用c++/c方法详解
01-20
以上append方法就是要调用c++/c中的方法。 JniTest是在Android.mk里约束好的，关于Android.mk的编写具体在后面详解。 3、使用javah -jni生成.h文件 编写好jni加载类之后，就要开始生成.h文件了，此文件相当于一个...
C/C++和Java的交互详解
09-02
总的来说，C/C++与Java的交互主要依赖于JNI，通过声明和实现native方法、生成头文件、编写C/C++实现、构建动态链接库以及利用JNI接口调用Java方法。这种交互方式在性能敏感的应用中尤其有用，比如游戏开发、图像处理...
用C++调用jar包以及一些注意事项
Tiny sheep
01-13 5333
用C++调用jar包以及一些注意事项 1.打出一个漂亮的jar包 （1）我创建的java工程目录： （2）编写JAVA代码 此处我写了三个函数，main()、add()、toUppercase() package com.yxyhard.test; public class Test { public static void main(String[] args) { Test test = new Test(); // test add
JNI Java与C的相互调用与基本操作
hdxx2022的博客
01-05 250
Java和Jni的类型对照表。一.Java调用C函数。二.C调用Java方法。然后在cpp文件中加入。
Android JNI实现线程内部调用JAVA方法
最新发布
wolf0706的专栏
05-09 353
【代码】Android JNI实现线程内部调用JAVA方法。
C调用Java代码 图文详解
zaq977684的博客
05-18 1968
通过图文讲解：C调用java方法的过程
c++调用java接口
baidu_35717091的博客
04-25 2195
最近遇到一个项目，要调用java的接口。目前只能调用java的接口，对于有jar包的接口还需要进一步探索，先上代码，每一步都有注释 typedef jint (WINAPI *PFunCreateJavaVM)(JavaVM **, void **, void *); int res; JavaVMInitArgs vm_args; JavaVMOption options[3]; JavaVM *jvm; JNIEnv *env; /*设置初始化参数*/ //disable JIT，这是JNI文档中的解
C++调用java应用程序
kingkaa的博客
09-27 1016
基本需求 利用java应用程序：输入两个字符串参数和一个整型参数，输出一个字符串结果。在C++中调用java程序包，获取输出的字符串。 实现方法 java提供了JNI方法支持C++和java的相互调用，但是简单的调用需求，不想费劲去配置JNI的头文件和静态库。 C或者C++提供了System()，WinExec()等方法来调用CMD命令。但是只有通过管道pipe（）的方法才能获取java应用程序输出的结果。 关键代码 #include <stdlib.h> #include <stdi
JNI——C调用JAVA
weixin_30790841的博客
06-08 91
步骤： 1. 创建虚拟机 2. 获得class 3. 实例化对象：获得构造方法（方法名为“<init>”）,构造参数，调用方法 4. 调用方法：又分为获得方法，构造方法，调用方法 操作方法： 1. 编译：javac Hello.java 2. javap -p -s Hello.class：查看Signature 3. gcc -I/usr/lib/jvm/jav...
java调用JNI
08-31
Java调用JNI详解 Java Native Interface（JNI）是Java虚拟机（JVM）与native代码之间的接口，允许Java程序调用native代码，反之亦然。本文将详细介绍如何使用Java的JNI调用C++的DLL包。 JNI的作用 JNI的主要作用...
c/c++调用java方法
12-06
《C/C++调用Java方法详解》 C/C++与Java之间的交互，主要依赖于Java Native Interface（JNI）技术。自Java 1.1以来，JNI已成为Java平台不可或缺的一部分，它提供了一种机制，使Java代码能够调用本地（非Java）代码...
JNI开发Java和C/C++互相传递List集合
07-11
JNI开发Java和C/C++互相传递List集合， 可以参考： Java从C/C++获取List集合对象：https://blog.csdn.net/niuba123456/article/details/80994166 Java传递List集合对象到C/C++ https://blog.csdn.net/niuba123456/article/details/80994168
C++封装成Jni库的详细步骤
热门推荐
buknow的博客
01-08 1万+
C++封装成Jni库的详细步骤第一步：配置java环境第二步：实现一个类，包含一些简单操作第三步：编写Add.cpp 封装类Twono中的Add()第四步：将该Add.cpp生成动态连接库第五步：重新编译可能出现的一些问题： 前段时间用C＋＋实现了一个数据库连接的类，类中包含了一些连接和断开操作。我想在java中调用这些功能。jni方法提供了只是函数接口的调用而没有类的调用（有关函数接口调用的网上...
JNI:C++调用java
y88uan11的专栏
12-28 551
编程人员有时会用到JNI,网上关于这方面的文章也很多，可是大多说的不够详细，或者就是转来转去，让我们这些菜鸟看了也自己弄不出来，不是找不到这个，就是找不到那个，今天闲来无事，自己做了一个例子，希望对菜鸟有些帮助，本例是C++调用java的静态方法，以后有时间再写一篇调用普通方法的，本例java文件是在netbeans下编写的，cpp文件是在VS2003下编写的。不再赘述，下面是步骤。     1
C++ 与 JAVA调用问题
Kaitiren的专栏
08-21 1450
c++调用java其实并不复杂，分为几个步骤：   在说调用之前，我们先来看看我们需要调用的java类 public class Test { Java代码   public Test() {          }      public String getMessage(){       return "test ok";   }  
java调用jni，及C/C++调用java全流程，简洁易懂！
大炮哥的博客
09-15 1184
'jni.h' file not found Undefined symbols for architecture x86_64: "_main", referenced from: implicit entry/start for main executable ld: symbol(s) not found for architecture x86_64 clang: error: linker command failed with exit code 1 (use -v to see
java利用JNI 调用C++(dll)函数完整代码示例
洛阳泰山的博客
01-11 2401
JNI是Java提供的一种用于与本地代码交互的编程接口。通过JNI，可以实现Java程序与本地代码之间的无缝对接，调用本地方法、访问本地资源，以及实现Java与其他编程语言之间的相互调用。尽管JNI在性能和功能扩展上具有很多优势，但也存在开发难度较大和跨平台兼容性问题等缺点。
c/c++反射调用JAVA方法
chenhao0568的专栏
09-23 1094
c/c++调用JAVA方法 与 java通过反射调用JAVA方法 原理一样。java通过类、方法名、参数 来唯一确定一个方法。 1.通过包名找到Java中的类名 2.获取java类中方法id：参数一为类对象，参数二为java中方法名，参数三为方法唯一签名 3.执行调用 先看java通过反射调用JAVA方法 public class Jk { public void p(String s) { System. out.println(s); }...
C/C++调用Java
hx_mraku的专栏
01-18 563
<br />一.C/C++调用Java 在C/C++中调用Java的方法一般分为五个步骤：初始化虚拟机、获取类、创建类对象、调用方法和退出虚拟机。 1. 初始化虚拟机 代码如下： JNIEnv *env; JavaVM *jvm; JavaVMInitArgs vm_args; JavaVMOption options[3]; int res; //设置参数 options[0].optionString = "-Djava.compiler=NONE"; //classpath有多个时，UNIX下以“：”

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值