JNI实现JAVA和C++互相调用

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JNI实现JAVA和C++互相调用，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8717字，纯文字阅读大概需要13分钟。

内容图文

SDK.h

             1
            #ifndef SDK_H

             2
            #define SDK_H
 3 4 #include "AsyncProxy.h" 5 #include "Module.h" 6 #include <map>
 7 #include <vector>
 8 #include <string>
 9using std::map;
10using std::vector;
11using std::string;
121314class SDK
15{
16private:
17     vector<Module*> m_modules;
18     AsyncProxy* mp_asyncProxy;
19     map<string,Method*> m_methodIndex;
20private:
21     Method* checkMethod(string methodName, map<std::string, std::string> &params);
22void init();
23public:
24    SDK();
25     SDK(CallBackFun* p_exceptionFun);
26     ~SDK();
27void addModule(Module* p_module);
28string request(string methodName, map<string,string>& params);
29void requestAsync(string methodName, map<string, string> &params, CallBackFun* p_callBack = NULL);
30};
3132#endif

CallBackFun.h

            1
            class
             CallBackFun

            2
            {

            3
            public
            :

            4
            virtual ~CallBackFun(){}
5virtualvoid callBack(string& result){SDK_DEBUG("%s",result.c_str());}
6 };

main.cpp

#include <string.h>
#include <jni.h>
#include "core/SDK.h"static JavaVM* p_vm = NULL;

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
{
    p_vm = vm;
    return JNI_VERSION_1_6;
}

class JavaCallBackFun:public CallBackFun
{
private:
    jobject m_object;
    jstring m_method;
    staticconstchar* m_signature;
    bool m_destroy;
public:
    JavaCallBackFun( JNIEnv* env,jobject object,jstring method,bool destroy)
    {
        m_object = env->NewGlobalRef(object);
        m_method = (jstring)env->NewGlobalRef(method);
        m_destroy = destroy;
    }
    
    ~JavaCallBackFun()
    {
        if(m_destroy == false)
        {
            JNIEnv* env;
            p_vm->AttachCurrentThread(&env, NULL);
            env->DeleteGlobalRef(m_object);
            env->DeleteGlobalRef(m_method);
        }
    }
    
    void callBack(string& result)
    {
        JNIEnv* env;
        p_vm->AttachCurrentThread(&env, NULL);
        jstring jresult = env->NewStringUTF(result.c_str());
        constchar* methodStr = env->GetStringUTFChars(m_method, 0);
        jclass clazz = env->GetObjectClass(m_object);
        jmethodID  methodID = env -> GetMethodID(clazz,methodStr,m_signature);
        env -> CallVoidMethod(m_object,methodID,jresult);
        env -> ReleaseStringUTFChars(m_method,methodStr);
        if(m_destroy == true)
        {
            env->DeleteGlobalRef(m_object);
            env->DeleteGlobalRef(m_method);
        }
    }
};
constchar* JavaCallBackFun::m_signature = "(Ljava/lang/String;)V";



extern"C" {
    JNIEXPORT jlong JNICALL Java_com_pptv_sdk_CommonSDK_initSDKNative( JNIEnv* env,jobject thiz,jobject callBackObj,jstring exceptionFun);
    JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_cleanSDKNative( JNIEnv* env,jobject thiz,jlong sdkptr);
    JNIEXPORT jstring JNICALL Java_com_pptv_sdk_CommonSDK_requestNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,                                                                         jobjectArray paramKeys,jobjectArray paramValues);
    JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_requestAsyncNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,                                                jobjectArray paramKeys,jobjectArray paramValues,jobject callBackObj,jstring callBackMethod);
};

JNIEXPORT jlong JNICALL Java_com_pptv_sdk_CommonSDK_initSDKNative( JNIEnv* env,jobject thiz,jobject callBackObj,jstring exceptionFun)
{
    JavaCallBackFun* p_callBack = new JavaCallBackFun(env,callBackObj,exceptionFun,false);
    return (jlong)new SDK(p_callBack);
}

JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_cleanSDKNative( JNIEnv* env,jobject thiz,jlong sdkptr)
{
    SDK* p_sdk = (SDK*)sdkptr;
    delete p_sdk;
}

JNIEXPORT jstring JNICALL Java_com_pptv_sdk_CommonSDK_requestNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,                                                                     jobjectArray paramKeys,jobjectArray paramValues)
{
    SDK* p_sdk = (SDK*)sdkptr;
    constchar * methodNameStr = env->GetStringUTFChars( methodName, 0);
    //init param map    jstring jkey,jvalue;
    jsize keysLen=env->GetArrayLength(paramKeys);
    map<string,string> params;
    for(jsize i=0;i<keysLen;++i)
    {
        jkey = (jstring)(env->GetObjectArrayElement(paramKeys,i));
        jvalue = (jstring)(env->GetObjectArrayElement(paramValues,i));
        constchar *key = env->GetStringUTFChars(jkey, 0);
        constchar *value = env->GetStringUTFChars(jvalue,0);
        params[string(key)] = string(value);
        env->ReleaseStringUTFChars(jkey,key);
        env->ReleaseStringUTFChars(jvalue,value);
    }
    
    string result = p_sdk->request(methodNameStr,params);
    env->ReleaseStringUTFChars(methodName,methodNameStr);
    return env->NewStringUTF(result.c_str());
}

JNIEXPORT void JNICALL Java_com_pptv_sdk_CommonSDK_requestAsyncNative( JNIEnv* env,jobject thiz,jlong sdkptr,jstring methodName,                                            jobjectArray paramKeys,jobjectArray paramValues,jobject callBackObj,jstring callBackMethod)
{
    SDK* p_sdk = (SDK*)sdkptr;
    constchar * methodNameStr = env->GetStringUTFChars(methodName, 0);
    //init param map    jstring jkey,jvalue;
    jsize keysLen=env->GetArrayLength(paramKeys);
    map<string,string> params;
    for(jsize i=0;i<keysLen;++i)
    {
        jkey = (jstring)(env->GetObjectArrayElement(paramKeys,i));
        jvalue = (jstring)(env->GetObjectArrayElement(paramValues,i));
        constchar *key = env->GetStringUTFChars(jkey, 0);
        constchar *value = env->GetStringUTFChars(jvalue,0);
        params[string(key)] = string(value);
        env->ReleaseStringUTFChars(jkey,key);
        env->ReleaseStringUTFChars(jvalue,value);
    }
    //init callback fun
    JavaCallBackFun* p_callBack = NULL;
    if(callBackObj != NULL && callBackMethod != NULL)
    {
        p_callBack = new JavaCallBackFun(env,callBackObj,callBackMethod,true);
    }
    //async call 
    p_sdk->requestAsync(methodNameStr,params,p_callBack);
    env->ReleaseStringUTFChars(methodName,methodNameStr);
}

CommonSDK.java

             1
            package com.pptv.sdk;

             2
            import java.util.Map;

             3
             4
            /*
            *

             5
             * CommonSDK is a common interface to interact with sdk.so

             6
             * <p>

             7
             * CommonSDK use jni to call native method written by C++,and it 

             8
             * provide a common interface for Java developer.You can directly

             9
             * call the common interface,but it is suggested to use the special

            10
             * interface based on CommonSDK,which is more understandable.  

            11
             * @author      guoxiaoqian

            12
            */
            13
            public
            class
             CommonSDK implements SDKCallBack

            14
            {

            15
            static
            16
                {

            17         System.loadLibrary("sdk");
18    }
1920//Exception Call Back21    @Override
22publicvoid callBack(String result)
23    {
24// TODO Auto-generated method stub25         System.out.println("Exception occured: "+result);
26    }
2728privatelong m_sdkHandle;
29privatestatic final CommonSDK m_sdk = new CommonSDK();
3031private CommonSDK()
32    {
33         m_sdkHandle = initSDKNative(this,SDKCallBack.callBackName);
34    }
353637/** 
38     * getInstance()     get a singleton CommonSDK object
39     * @return          CommonSDK object
40*/41publicstatic CommonSDK getInstance()
42    {
43return m_sdk;
44    }
4546protectedvoid finalize()
47    {
48        cleanSDKNative(m_sdkHandle);
49    }
5051/** 
52     * request()             sync request
53     * @param methodName    specify the method to call
54     * @param params        multi params in key-value map
55     * @return              json string containing complex result
56*/57public String request(String methodName,Map<String,String> params)
58    {
59         String[] keyArr = new String[params.size()];
60         String[] valueArr = new String[params.size()];
61int i=0;
62for(Map.Entry<String, String> entry:params.entrySet())
63        {    
64             keyArr[i] = entry.getKey();
65             valueArr[i] = entry.getValue();
66             ++i;
67        }
68return requestNative(m_sdkHandle,methodName,keyArr,valueArr);
69    }
7071/** 
72     * requestAsync()         async request
73     * @param methodName    specify the method to call
74     * @param params        multi params in key-value map
75     * @param callBackObj    specify the obj to handle callback from sdk
76*/77publicvoid requestAsync(String methodName,Map<String,String> params,SDKCallBack callBackObj)
78    {
79         String[] keyArr = new String[params.size()];
80         String[] valueArr = new String[params.size()];
81int i=0;
82for(Map.Entry<String, String> entry:params.entrySet())
83        {    
84             keyArr[i] = entry.getKey();
85             valueArr[i] = entry.getValue();
86             ++i;
87        }
88         requestAsyncNative(m_sdkHandle,methodName,keyArr,valueArr,callBackObj,callBackObj==null?null:SDKCallBack.callBackName);
89    }
9091private native long initSDKNative(Object callBackObject,String exceptionFun);
92private native void cleanSDKNative(long sdkHandle);
93private native String requestNative(long sdkHandle,String methodName,String keys[],String values[]);
94private native void requestAsyncNative(long sdkHandle,String methodName,String keys[],String values[],Object callBackObject,String callBackFunName);
9596 }

SDKCallBack.java

             1
            package com.pptv.sdk;

             2
             3
            /*
            *

             4
             * SDKCallBack is an interface that you must implements when

             5
             * you want to have an object to handle the callback form sdk.

             6
             * @author      guoxiaoqian

             7
            */
             8
            public
            interface
             SDKCallBack {

             9
            public final String callBackName = "callBack";
10publicabstractvoid callBack(String result);
11 }

原文：http://www.cnblogs.com/guoxiaoqian/p/3915429.html

内容总结

以上是互联网集市为您收集整理的JNI实现JAVA和C++互相调用全部内容，希望文章能够帮你解决JNI实现JAVA和C++互相调用所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1299123.html

来源：【匿名】

【上一篇】Java的“影子克隆”和“深度克隆”【下一篇】JAVA/JSP学习系列之五

更多 ►

【JNI实现JAVA和C++互相调用】教程文章相关的互联网学习教程文章

SDK.h 1#ifndef SDK_H2#define SDK_H3 4 #include "AsyncProxy.h" 5 #include "Module.h" 6 #include <map>7 #include <vector>8 #include <string>9using std::map; 10using std::vector; 11using std::string; 121314class SDK 15{ 16private: 17 vector<Module*> m_modules; 18 AsyncProxy* mp_asyncProxy; 19 map<string,Method*> m_methodIndex; 20private: 21 Method* checkMethod(string methodName, map<s...

java调用R

环境：win7 32位 jdk1.7 R 2.15.0 java调用r主要有三种方式，rJava，rServer还有rCaller，这边主要讲用rJava调用rJava是一个R语言和Java语言的通信接口，通过底层JNI实现调用，允许在R中直接调用Java的对象和方法。由于rJava是底层接口，并使用JNI作为接口调用，所以效率非常高。在JRI的方案中，JVM直接通过内存直接加载RVM，调用过程性能几乎无损耗，因此是非常高效连接通道，是R和Java通信的首选开发包。之前用R3.0.2，不知道...

JavaWeb_(SSH)struts.xml核心配置、动态方法调用、结果集的处理【代码】【图】

前导博文　　　　JavaWeb_(SSH)使用Struts框架实现用户的登陆　　传送门　　　　JavaWeb_(SSH)Struts创建Action的三种方式　　　传送门　　核心配置　　动态方法调用　　结果集处理一、核心配置　　struts.xml<package name="MyPackage" namespace="/user" extends="struts-default"><!-- action:配置action类name：决定了action访问的资源名称 servlet:u...

java调用peoplesoft提供的webservice接口【图】

使用到了soapui,apache-cxf,eclipse1、使用soapui测试提供的地址有效性wsdl地址：http://192.168.56.101:8800/PSIGW/PeopleSoftServiceListeningConnector/PSFT_HR/C_HR_CLUB.1.wsdl创建soapui项目File->new soapUI Project点击ok.显示的界面，双击Request1,点击绿色按钮，执行，看响应结果右侧是响应结果。2、生成java客户端代码现在要在java端调用接口，首先，在soapUI界面，File->Preferences,配置全局设置。如图：使用cxf生成j...

java使用JNA框架调用dll动态库【代码】【图】

这两天了解了一下java调用dll动态库的方法，总的有三种：JNI、JNA、JNative。其中JNA调用DLL是最方便的。·JNI·JNA·JNative java使用 JNI来调用dll动态库的调用，工作量略大，一般情况下开发人员会选用JNA或JNative。使用JNative调用DLL除了要引入jar包外还需要额外引入一个dll文件，而JNA只需要引入jar即可使用。使用JNA框架调用DLL动态库，步骤如下：1.导入JNA支持的jar包添加jna-4.x.x.jar、jna-platform-4.x.x.jar到项目buil...

linux 调用java main方法

#!/bin/shexport LANG=zh_CNtimestamp=`date +%Y%m%d%H%M`/opt/java6/bin/java -Xms128m -Xmx512m -Dfile.encoding=gbk -classpath /weblogic/mpms_job/WEB-INF/classes:/weblogic/mpms_job/mpms_job.jar:/weblogic/mpms_job/lib/* com.guohualife.mpms.app.StartMpmsTask > /weblogic/mpms_job/logs/StartMpmsTask.log原文：http://www.cnblogs.com/javacofe/p/5582290.html

JavaScript或者Jqurey把控件id作为參数来调用

1.JavaScript把控件id作为參数调用<script type="text/javascript">function xx(pmba){document.getElementById(pmba).style.display = "block";}</script><div id="overlay"><input type="button" value="弹出A" onclick="xx(‘xa‘)" /><input type="button" value="弹出B" onclick="xx(‘xb‘)" /></div><div class="win" id="xa">网页a</div><div class="win" id="xb">窗体b</div> 2.这个弄了好一会儿，仅仅写一个Jqurey函数，...

按要求编写Java应用程序。（1）建立一个名叫Cat的类：属性：姓名、毛色、年龄行为：显示姓名、喊叫（2）编写主类：创建一个对象猫，姓名为“妮妮”，毛色为“灰色”，年龄为2岁，在屏幕上输出该对象的毛色和年龄，让该对象调用显示姓名和喊叫两个方法。【代码】【图】

package com.homework.zw; //类Cat部分publicclass Cat {String name="妮妮";String skin="灰色";int age =2;void outputname(){System.out.println("这只猫咪的名字叫："+name);}void outputhanjiao(){System.out.println("喵喵....");} }package com.homework.zw; //主类部分publicclass TextCAT {publicstaticvoid main(String[] args) {Cat nini = new Cat();System.out.println("年龄："+nini.age);System.out.println("毛色...

多语言（Java、.NET、Node.js）混合架构下开源调用链追踪APM项目初步选型

1. 背景我们的技术栈包括了Java、.NET、Node.js等，并且采用了分布式的技术架构，系统性能管理、问题排查成本越来越高。2. 基本诉求针对我们的情况，这里列出了选型的主要条件，作为最终判断依据基本条件：多平台探针（Java、.NET Core、Node.js）无侵入的探针部署方式探针对应用性能和高可用影响小服务端高可用，服务端不可用时，客户端无影响3. 主要选项主流的调用链追踪项目有Pinpoint、Zipkin、Skywalking、CAT3.1. PinpointPi...

[转]java 为什么wait(),notify(),notifyAll()必须在同步方法/代码块中调用？

在 Java中，所有对象都能够被作为"监视器monitor"——指一个拥有一个独占锁，一个入口队列和一个等待队列的实体entity。　　所有对象的非同步方法都能够在任意时刻被任意线程调用，此时不需要考虑加锁的问题。　　而对于对象的同步方法来说，在任意时刻有且仅有一个拥有该对象独占锁的线程能够调用它们。例如，一个同步方法是独占的。如果在线程调用某一对象的同步方法时，对象的独占锁被其他线程拥有，那么当前线程将处于阻塞状态...

Java调用Linux命令执行【代码】【图】

调用方式Java调用linux命令执行的方式有两种，一种是直接调用linux命令，一种是将linux命令写到.sh脚本中，然后调用脚本执行。详细说明直接调用：使用java中lang包下面的Runtime类和Process类，其中Runtime类中的Runtime.getRuntime().exec(linux command)方法可以直接执行linux命令，而Process类可以接收Runtime.getRuntime().exec()类的返回值，并提供了waitFor()方法和destroy()方法，waitFor()方法的作用在于等待此process执...

tinkerpop（2）使用java调用tinkerpop，存储到derby数据库【代码】【图】

1，关于tinkerpop本文原文连接: http://blog.csdn.net/freewebsys/article/details/46470651 转载请注明出处！之前体验了下tinkerpop的console服务。存储数据，然后进行查询数据。之前写的文章： http://blog.csdn.net/freewebsys/article/details/463489752，关于blueprints Blueprints是一组针对属性图数据模型的接口、实现、测试套件，有些类似于JDBC，不同之处在于Blueprints是针对图形数据库的。Blueprints提供了一组通用...

java基础 super 子类调用父类【代码】

如果希望在子类中，去调用父类的构造方法，要求在子类的构造函数调用example如下：package test; /** 如果希望在子类中，去调用父类的构造方法，要求在子类的构造函数调用* */publicclass test4 {/*** @param args*/publicstaticvoid main(String[] args) {// TODO Auto-generated method stubKkk kk = new Kkk(12,"dd");}}class Base {int age;String name;public Base(int age,String name){System.out.println("base");this.ag...

java调用ruby代码【代码】【图】

问题：最近在做一个应用的时候碰到了一个问题。客户端需要调用服务器端传回的脚本信息，然后执行。其中脚本类型包括ruby。而java中调用ruby的代码大致如下：1 String jrubyCode="puts ‘hello world‘"; 2 ScriptEngineManager manager = new ScriptEngineManager(); 3 ScriptEngine engine = manager.getEngineByName("jruby"); 4 engine.eval(jrubyCode);JavaCallRuby却发现最后getEngineByName("jruby")老是返回null。网上搜了很...

es5语法下，javascript如何判断函数是new还是()调用

es5语法没有支持类class，但是可以通关函数来申明一个类，如下：function Person(name){　　this.name=name;}var john=new Person(‘john‘)；console.log(john.name);//john但是这个类可以直接像函数执行那样调用：Person()判断是不是被new还是()调用得这样修改上面这个类：function Person(name){　　this.name=name;　　if(this instanceof Person){ 　　　　alert(‘new调用‘); 　　}else{ 　　　　alert(‘函数调用...