JNI学习

最新推荐文章于 2023-07-20 17:08:01 发布
最新推荐文章于 2023-07-20 17:08:01 发布
阅读量467 收藏 2
点赞数
分类专栏： c/c++

  参看：高煥堂的课程《JNI：Java与C++的美好结合》http://edu.csdn.net/course/detail/1469

    参看：http://www.cnblogs.com/yejg1212/archive/2013/06/07/3125392.html

    参看：http://blog.csdn.net/jiangwei0910410003/article/details/17465457

一、基本介绍

1、JNI是什么？

      Java本机接口（Java Native Interface (JNI)）是本机编程接口，它是JDK的一部分，JNI它提供了若干的API,实现了和Java和其他通信（主要是C&C++）。

2、JNI有什么用？

      JNI最常见的两个应用:从Java程序调用C/C++，以及从C/C++程序调用Java代码。

3、使用JNI需要什么环境？

      (1)、JDK

     工具及组件：(Java编译器：javac.exe 、JVM ：java.exe 、本地方法C文件生成器：javah.exe)

     库文件和头文件：jni.h( C头文件)、jvm.lib 和jvm.dll(windows下) 或libjvm.so(linux下)。

     (2)、能够创建动态链接库的C和C++编译器

     最常见的两个C编译器是用于Windows的Visual C++ 和用于基于UNIT系统的gcc/cc。

二、Java调用C++代码的完美方法

     JNI是Java与C++之间的桥梁，它们之间的层次关系如下图所示：

JNI层是以C方式实现的，逻辑上讲还属于Java类的。

C与C++的语法是通用的，因此从理论上讲可以将JNI(C层)代码和C++层代码可以放在相同的文档中。

1、保持JNI层稳定的原则：“静态对静态，动态对动态”

     JNI层既可以创建Java层对象，也可以C++层对象。需要特别注意的是：JNI层（C层）的全局或静态（static）变量只适合存储静态的数据，例如methodID或fieldID等。把动态的Java或C++对象引用储存于JNI(C层)的全局变量，会导致JNI层（C层）的不稳定性。

     所以：“静态对静态”的原则是：JNI层的全局变量或静态变量只能存储Java层或C++层的静态数据。

      “动态对动态”的原则是：JNI层动态创建的对象只能存储在Java层或C++层中动态创建的对象中。

2、以下例子展示了如何在Java层存储JNI层动态创建的C++对象。

首先：该例的需求是在Java中使用已经在C++中实现的类。

C++层的代码如下：

#pragma once
 
class CFood 
{
private:
    char* name;
    double price;
public:
    CFood(char* name, double price) 
    {
        this->name = name;
        this->price = price;
    }
 
    ~CFood() 
    {
        if(name != NULL) 
        {
            free(name);
            name = NULL;
        }
    }
 
    const char* getName() 
    {
        return this->name;
    }
 
    double getPrice() 
    {
        return this->price;
    }
};

Java层为了使用上述代码，引入一个新的类Food，如下：

public class Food {
 
    static {
        System.loadLibrary("jniFood");
    }
    
    // 用于存储C++层的对象指针
    private int mObject;
    
    public Food(String name, double price) {
        setFoodParam(name, price);
    }
    
    public native void setFoodParam(String name, double price);
    public native String getName();
    public native double getPrice();
    protected native void finalize();
    
    public static void main(String[] args) {
        Food f1 = new Food("面包", 1.99);
        Food f2 = new Food("牛奶", 3.99);
        
        System.out.println(String.format("食物：%s， 单价：%f", f1.getName(), f1.getPrice()));
        System.out.println(String.format("食物：%s， 单价：%f", f2.getName(), f2.getPrice()));
    }
}

其中，声明了本地方法，需要注意的是创建一个int型字段用来存放C++层对象的指针。另外需要注意的是通过本地方法finalize(）来析构c++对象。

下面是JNI层的实现代码：

头文件：

#include <jni.h>
/* Header for class test2_Food */
 
#ifndef _Included_test2_Food
#define _Included_test2_Food
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     test2_Food
 * Method:    setFoodParam
 * Signature: (Ljava/lang/String;D)V
 */
JNIEXPORT void JNICALL Java_test2_Food_setFoodParam
  (JNIEnv *, jobject, jstring, jdouble);
 
/*
 * Class:     test2_Food
 * Method:    getName
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_test2_Food_getName
  (JNIEnv *, jobject);
 
/*
 * Class:     test2_Food
 * Method:    getPrice
 * Signature: ()D
 */
JNIEXPORT jdouble JNICALL Java_test2_Food_getPrice
  (JNIEnv *, jobject);
 
/*
 * Class:     test2_Food
 * Method:    finalize
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_test2_Food_finalize
  (JNIEnv *, jobject);
 
#ifdef __cplusplus
}
#endif
#endif

源文件：

#include "stdafx.h"
#include <stdlib.h>
#include "test2_Food.h"
#include "Food.h"
 
char* jstring2string(JNIEnv* env, jstring jstr)
{
    char* rtn = NULL;
    jclass clsstring = env->FindClass("java/lang/String");
    jstring strencode = env->NewStringUTF("utf-8");
    jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
    jbyteArray barr= (jbyteArray)env->CallObjectMethod(jstr, mid, strencode);
    jsize alen = env->GetArrayLength(barr);
    jbyte* ba = env->GetByteArrayElements(barr, JNI_FALSE);
 
    if (alen > 0)
    {
        rtn = (char*)malloc(alen + 1);
 
        memcpy(rtn, ba, alen);
        rtn[alen] = 0;
    }
    env->ReleaseByteArrayElements(barr, ba, 0);
    return rtn;
}
 
jstring char2Jstring(JNIEnv* env, const char* pat)
{
    jclass strClass = env->FindClass("Ljava/lang/String;");
    jmethodID ctorID = env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
    jbyteArray bytes = env->NewByteArray(strlen(pat));
    env->SetByteArrayRegion(bytes, 0, strlen(pat), (jbyte*)pat);
    jstring encoding = env->NewStringUTF("utf-8");
    return (jstring)env->NewObject(strClass, ctorID, bytes, encoding);
}
 
CFood* getCFood(JNIEnv *env, jobject thiz) 
{
    jclass clazz = env->GetObjectClass(thiz);
    jfieldID fid = env->GetFieldID(clazz, "mObject", "I");
    jint p = env->GetIntField(thiz, fid);
    return (CFood*)p;
}
 
void setFood(JNIEnv *env, jobject thiz, const CFood* pFood) 
{
    jclass clazz = env->GetObjectClass(thiz);
    jfieldID fid = env->GetFieldID(clazz, "mObject", "I");
    env->SetIntField(thiz, fid, (jint)pFood);
}
 
JNIEXPORT void JNICALL Java_test2_Food_setFoodParam
  (JNIEnv *env, jobject thiz, jstring name, jdouble price) 
{
    //const char* tempName = env->GetStringUTFChars(name, 0);
    char* tempName = jstring2string(env, name);
    double tempPrice = price;
 
    CFood* pFood = new CFood(tempName, tempPrice);
    setFood(env, thiz, pFood);
}
 
JNIEXPORT jstring JNICALL Java_test2_Food_getName
  (JNIEnv *env, jobject thiz)
{
    CFood* pFood = getCFood(env, thiz);
    const char* name = pFood->getName();
    return char2Jstring(env, name);
}
 
JNIEXPORT jdouble JNICALL Java_test2_Food_getPrice
  (JNIEnv *env, jobject thiz)
{
    CFood* pFood = getCFood(env, thiz);
    return pFood->getPrice();
}
 
JNIEXPORT void JNICALL Java_test2_Food_finalize
  (JNIEnv *env, jobject thiz) 
{
    CFood* pFood = getCFood(env, thiz);
    if (pFood != NULL) 
    {
        delete pFood;
        pFood = NULL;
        setFood(env, thiz, pFood);
    }
}

三、Java（Eclipse）与C++(Visual Studio)的完美联调

      将Debug版本的dll放在Java项目下，在Eclipse中设置为本地方法设置断点，启动Debug调试，同时在VS该dll项目中设置：Debug->Attach to Process ->选择javaw.exe然后点击“Attach”。

      这样本地方法就可以直接跳到VS环境下跟踪调试，本地方法调试完成后（在VS中按F5）就转到Eclipse中继续调试。

四、C++中回调Java方法（不太完美）

      如上所述，在Java中保存C++对象堪称完美，不会有任何副作用。但是在C++中存放Java对象，就比较麻烦了。据我实验测试 jobject类型并不可靠，用它在C++中保存Java对象有很大隐患。以下是我实验数据：(完整测试代码上传于:http://download.csdn.net/detail/xiaoxiaoyusheng2012/9766376)

---------------------- java中包装调用本地方法
public static void main(String[] args) {
        MyFile myFile = new MyFile();
        MyPrint myPrint = new MyPrint();
        //myFile.registerPrint(myPrint);
        myFile.setPrint(myPrint);
        myFile.setMyPrint(myPrint);
        myFile.doPrint("hello world!");
        myFile.doPrint("again!");
        myFile.doPrint("next!");
    }
-----------------------
关系：jclass clazz = env->GetObjectClass(thiz); 

序号<1> : evn = 0x004ba514   thiz = 0x0346fc6c  clazz = 0x03508a30 // init
序号<1> : evn = 0x004ba514   thiz = 0x0346fc6c  clazz = 0x03508a34 // register
序号<1> : evn = 0x004ba514   thiz = 0x0346fc9c  clazz = 0x03508a30 // doPrint 
序号<1> : evn = 0x004ba514   thiz = 0x0346fc9c  clazz = 0x03508a30 // doPrint
序号<1> : evn = 0x004ba514   thiz = 0x0346fc9c  clazz = 0x03508a30 // doPrint


------------------------java中直接调用本地方法

关系：jclass clazz = env->GetObjectClass(thiz); 
public static void main(String[] args) {
        MyFile myFile = new MyFile();
        MyPrint myPrint = new MyPrint();
        myFile.registerPrint(myPrint);
        myFile.setPrint(myPrint);
        //myFile.setMyPrint(myPrint);
        myFile.doPrint("hello world!");
        myFile.doPrint("again!");
        myFile.doPrint("next!");
    }
序号<1> : evn = 0x004fa514   thiz = 0x034ffc6c  clazz = 0x03598a30  // init
序号<2> : evn = 0x004fa514   thiz = 0x034ffc9c  clazz = 0x03598a34  // register
序号<3> : evn = 0x004fa514   thiz = 0x034ffc9c  clazz = 0x03598a30  // doPrint
序号<4> : evn = 0x004fa514   thiz = 0x034ffc9c  clazz = 0x03598a30  // doPrint
序号<5> : evn = 0x004fa514   thiz = 0x034ffc9c  clazz = 0x03598a30  // doPrint
     上述结果是：jobject的值会变化，不能保存在C++代码中，jobject的值变化的原因，我猜测与Java的垃圾回收机制有关。JVM不断地整理内存，导致Java对象的内存移动等变化。所以，网上好多文章讲jobject可以直接使用的，应该都是有很多问题的。

      如果这样，那C++该如何回调java代码，我的方法是“始终将 JNI接口参数中的JNIEnv * 和 jobject ”一起传参使用，不作保存。以下是一份实现代码：

Java层代码：

package test1;
 
class MyPrint {
    
    public void onPrint(String text) {
        System.out.println(text);
    }
}
 
public class MyFile {
 
    private MyPrint myPrint = null;
    
    static {
        System.loadLibrary("jniTest5");
    }
    
    private int mObject;
 
    public MyFile() {
        init();
    }
    
    public void onPrint(String text) {
        myPrint.onPrint(text);
    }
    
    public void setPrint(MyPrint myPrint) {
        this.myPrint = myPrint;
    }
    
    public void setMyPrint(MyPrint myPrint) {
        setPrint(myPrint);
        this.registerPrint(myPrint);
    }
    
    public void myPrint(String text) {
        this.doPrint(text);
    }
    
    public native void init();
    
    public native void registerPrint(MyPrint myPrint);
    
    public native void doPrint(String text);
    
    protected native void finalize();
    
    public static void main(String[] args) {
        MyFile myFile = new MyFile();
        MyPrint myPrint = new MyPrint();
        
        myFile.setMyPrint(myPrint);
        myFile.doPrint("hello world!");
        myFile.doPrint("again!");
        myFile.doPrint("next!");
    }
}

JNI接口层：

头文件：test1_MyFile.h

#include <jni.h>
/* Header for class test1_MyFile */
 
#ifndef _Included_test1_MyFile
#define _Included_test1_MyFile
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     test1_MyFile
 * Method:    init
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_test1_MyFile_init
  (JNIEnv *, jobject);
 
/*
 * Class:     test1_MyFile
 * Method:    registerPrint
 * Signature: (Ltest1/MyPrint;)V
 */
JNIEXPORT void JNICALL Java_test1_MyFile_registerPrint
  (JNIEnv *, jobject, jobject);
 
/*
 * Class:     test1_MyFile
 * Method:    doPrint
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_test1_MyFile_doPrint
  (JNIEnv *, jobject, jstring);
 
/*
 * Class:     test1_MyFile
 * Method:    finalize
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_test1_MyFile_finalize
  (JNIEnv *, jobject);
 
#ifdef __cplusplus
}
#endif
#endif
源文件：

#include "stdafx.h"
#include <jni.h>
#include "MyFile.h"
#include "test1_MyFile.h"
 
char* jstring2string(JNIEnv* env, jstring jstr)
{
    char* rtn = NULL;
    jclass clsstring = env->FindClass("java/lang/String");
    jstring strencode = env->NewStringUTF("utf-8");
    jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
    jbyteArray barr= (jbyteArray)env->CallObjectMethod(jstr, mid, strencode);
    jsize alen = env->GetArrayLength(barr);
    jbyte* ba = env->GetByteArrayElements(barr, JNI_FALSE);
 
    if (alen > 0)
    {
        rtn = (char*)malloc(alen + 1);
 
        memcpy(rtn, ba, alen);
        rtn[alen] = 0;
    }
    env->ReleaseByteArrayElements(barr, ba, 0);
    return rtn;
}
 
CMyFile* getMyFile(JNIEnv *env, jobject thiz) 
{
    jclass clazz = env->GetObjectClass(thiz);
    jfieldID fid = env->GetFieldID(clazz, "mObject", "I");
    jint p = env->GetIntField(thiz, fid);
    return (CMyFile*)p;
}
 
void setMyFile(JNIEnv *env, jobject thiz, CMyFile* pFile)
{
    jclass clazz = env->GetObjectClass(thiz);
    jfieldID fid = env->GetFieldID(clazz, "mObject", "I");
    env->SetIntField(thiz, fid, (jint)pFile);
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_init
  (JNIEnv *env, jobject thiz)
{
    CMyFile* pFile = new CMyFile();
    setMyFile(env, thiz, pFile);
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_registerPrint
  (JNIEnv *env, jobject thiz, jobject jobj)
{
    CMyPrint* pPrint = new CMyPrint();
    CMyFile* pFile = getMyFile(env, thiz);
    pFile->registerPrint(pPrint);
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_doPrint
  (JNIEnv *env, jobject thiz, jstring strText)
{
    CMyFile* pFile = getMyFile(env, thiz);
    char* pText = jstring2string(env, strText);
    pFile->doPrint(env, thiz, pText);
    if (pText != NULL)
    {
        free(pText);
        pText = NULL;
    }
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_finalize
  (JNIEnv *env, jobject thiz)
{
    CMyFile* pFile = getMyFile(env, thiz);
    if (pFile != NULL) 
    {
        delete pFile;
        pFile = NULL;
        setMyFile(env, thiz, pFile);
    }
}
C++层：

// MyPrint.h

#include "stdafx.h"
#include <jni.h>
#include <stdlib.h>
 
class CMyPrint
{
public:
    jstring char2Jstring(JNIEnv* env, const char* pat)
    {
        jclass strClass = env->FindClass("Ljava/lang/String;");
        jmethodID ctorID = env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
        jbyteArray bytes = env->NewByteArray(strlen(pat));
        env->SetByteArrayRegion(bytes, 0, strlen(pat), (jbyte*)pat);
        jstring encoding = env->NewStringUTF("utf-8");
        return (jstring)env->NewObject(strClass, ctorID, bytes, encoding);
    }
 
    // 如下传递JNIEnv* 和 jobject来获取Java对象，然后回调
    void onPrint(JNIEnv *env, jobject thiz, char* text) 
    {
        jclass clazz = env->GetObjectClass(thiz);
        jmethodID methodID = env->GetMethodID(clazz, "onPrint", "(Ljava/lang/String;)V");
        jstring strText = char2Jstring(env, text);
        env->CallVoidMethod(thiz, methodID, strText);
    }
};
// MyFile.h

#pragma once
 
#include "MyPrint.h"
 
class CMyFile 
{
private:
    CMyPrint* pPrint;
public:
 
    ~CMyFile() 
    {
        if (pPrint != NULL) 
        {
            delete pPrint;
            pPrint = NULL;
        }
    }
 
    void registerPrint(CMyPrint* pPrint) 
    {
        this->pPrint = pPrint;
    }
 
    void doPrint(JNIEnv *env1, jobject thiz, char* text) 
    {
        pPrint->onPrint(env1, thiz, text);
    }
};


五、C++中回调Java方法（完美）

      上述的回调是在一个线程栈中完成的，不能称为正真的回调。在后续学习实践中发现： JNIEnv *只在当前线程中有效，所以JNIEnv*不应该被缓存。可以缓存的是JavaVM*。另外，JNI中接口的参数都是局部引用，当该方法栈执行完毕，局部引用就会被销毁，因此即使要缓存JavaVM*,也应该将JavaVM*转换为全局引用再缓存。jobject也可以转换为全局引用后缓存。

       这里讲的完美回调方法是：我们在C++层保存Java对象。具体做法就是将jobject转换为全局引用后缓存。

以下是一份测试代码：

Java层：

package test1;
 
class MyPrint {
    public void onPrint(String text) {
        System.out.println(text);
    }
}
 
public class MyFile {
 
    private MyPrint myPrint = null;
    
    static {
        System.loadLibrary("jniTest7");
    }
    
    private int mObject;
 
    public MyFile() {
        init();
    }
    
    public void setPrint(MyPrint myPrint) {
        this.myPrint = myPrint;
    }
    
    public void setMyPrint(MyPrint myPrint) {
        setPrint(myPrint);
        this.registerPrint(myPrint);
    }
    
    public native void init();
    protected native void finalize();
    public native void registerPrint(MyPrint myPrint);
    public native void doPrint(String text);
    
    public static void main(String[] args) {
        MyFile myFile = new MyFile();
        MyPrint myPrint = new MyPrint();
        myFile.setMyPrint(myPrint);
        myFile.doPrint("hello world!");
        System.out.println("等待打印结果...");
        try {
            Thread.sleep(20*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

JNI层：

CMyFile* getMyFile(JNIEnv *env, jobject thiz) 
{
    jclass clazz = env->GetObjectClass(thiz);
    jfieldID fid = env->GetFieldID(clazz, "mObject", "I");
    jint p = env->GetIntField(thiz, fid);
    return (CMyFile*)p;
}
 
void setMyFile(JNIEnv *env, jobject thiz, CMyFile* pFile)
{
    jclass clazz = env->GetObjectClass(thiz);
    jfieldID fid = env->GetFieldID(clazz, "mObject", "I");
    env->SetIntField(thiz, fid, (jint)pFile);
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_init
  (JNIEnv *env, jobject thiz)
{
    CMyFile* pFile = new CMyFile();
    setMyFile(env, thiz, pFile);
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_finalize
  (JNIEnv *env, jobject thiz)
{
    CMyFile* pFile = getMyFile(env, thiz);
    if (pFile != NULL) 
    {
        delete pFile;
        pFile = NULL;
        setMyFile(env, thiz, pFile);
    }
}
 
JNIEXPORT void JNICALL Java_test1_MyFile_registerPrint
  (JNIEnv *env, jobject thiz, jobject jPrint)
{
    JavaVM* pVM = NULL;
    env->GetJavaVM(&pVM);
 
    // 根据局部引用生成全局引用
    JavaVM* g_pVM = (JavaVM*)env->NewGlobalRef((jobject)pVM);
    jobject g_javaPrint = env->NewGlobalRef(jPrint);
 
    CMyPrint* pPrint = new CMyPrint(g_pVM, g_javaPrint);
    CMyFile* pFile = getMyFile(env, thiz);
    pFile->registerPrint(pPrint);
}
 
 
JNIEXPORT void JNICALL Java_test1_MyFile_doPrint
  (JNIEnv *env, jobject thiz, jstring strText)
{
    CMyFile* pFile = getMyFile(env, thiz);
    char* pText = CMyPrint::jstring2string(env, strText);
 
    pFile->doPrint(pText);
 
    if (pText != NULL)
    {
        free(pText);
        pText = NULL;
    }
}

C++层：

typedef struct _ThreadParam
{
    JavaVM* jvm;
    jobject javaPrint;
    string text;
}ThreadParam;
 
DWORD WINAPI funproc(LPVOID lpparentet);
 
class CMyPrint
{
private:
    jobject mJavaPrintObj;
    JavaVM* jvm;
public:
 
    CMyPrint(JavaVM* jvm, jobject javaPrintObj) 
    {
        this->jvm = jvm;
        this->mJavaPrintObj = javaPrintObj;
    }
 
    ~CMyPrint()
    {
        JNIEnv* pEnv = NULL;
        jvm->AttachCurrentThread((void**)&pEnv, NULL);
        pEnv->DeleteGlobalRef(mJavaPrintObj);
        pEnv->DeleteGlobalRef((jobject)jvm);
    }
 
    static char* jstring2string(JNIEnv* env, jstring jstr)
    {
        char* rtn = NULL;
        jclass clsstring = env->FindClass("java/lang/String");
        jstring strencode = env->NewStringUTF("utf-8");
        jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
        jbyteArray barr= (jbyteArray)env->CallObjectMethod(jstr, mid, strencode);
        jsize alen = env->GetArrayLength(barr);
        jbyte* ba = env->GetByteArrayElements(barr, JNI_FALSE);
 
        if (alen > 0)
        {
            rtn = (char*)malloc(alen + 1);
 
            memcpy(rtn, ba, alen);
            rtn[alen] = 0;
        }
        env->ReleaseByteArrayElements(barr, ba, 0);
        return rtn;
    }
 
    static jstring char2Jstring(JNIEnv* env, const char* pat)
    {
        jclass strClass = env->FindClass("Ljava/lang/String;");
        jmethodID ctorID = env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
        jbyteArray bytes = env->NewByteArray(strlen(pat));
        env->SetByteArrayRegion(bytes, 0, strlen(pat), (jbyte*)pat);
        jstring encoding = env->NewStringUTF("utf-8");
        return (jstring)env->NewObject(strClass, ctorID, bytes, encoding);
    }
 
    void onPrint(char* text) 
    {
        ThreadParam* param = new ThreadParam();
        param->jvm = jvm;
        param->javaPrint = mJavaPrintObj;
        param->text = text;
 
        HANDLE hander = CreateThread(NULL,0,funproc,param,0,NULL);
    }
};
 
DWORD WINAPI funproc(LPVOID lpparentet)  
{  
    Sleep(10*1000);
 
    ThreadParam* param = (ThreadParam*)lpparentet;
 
    JNIEnv* pEnv = NULL;
    param->jvm->AttachCurrentThread((void**)&pEnv, NULL);
 
    jclass clazz = pEnv->GetObjectClass(param->javaPrint);
 
    // 获取非静态方法ID
    jmethodID methodID = pEnv->GetMethodID(clazz, "onPrint", "(Ljava/lang/String;)V");
    
    jstring strText = CMyPrint::char2Jstring(pEnv, param->text.c_str());
 
    // 调用非静态方法
    pEnv->CallVoidMethod(param->javaPrint, methodID, strText);
 
    if (param != NULL) 
    {
        delete param;
        param = NULL;
    }
    return 0;  
}  
 
class CMyFile 
{
private:
    CMyPrint* pPrint;
public:
 
    ~CMyFile() 
    {
        if (pPrint != NULL) 
        {
            delete pPrint;
            pPrint = NULL;
        }
    }
 
    void registerPrint(CMyPrint* pPrint) 
    {
        this->pPrint = pPrint;
    }
 
    void doPrint(char* text) 
    {
        pPrint->onPrint(text);
    }
};

运行结果：

等待打印结果...
hello world!


六、JNI中的字符编码方式的完美转换

参看：http://www.cnblogs.com/westblade/p/4803968.html

1、相关概念：

       (1)、Java层使用的是16bit的unicode编码(utf-16)来表示字符串，无论中文还是英文，都是两个字节。

       (2)、JNI层使用的是UTF-8编码，UTF-8是变长编码的unicode,一般ascii字符1字节，中文3字节。

       (3)、C/C++使用的是原始数据，ascii就是一个字节，中文一般是GB2312编码，用两个字节表示一个汉字。

2、字符流向

       (1)、Java ---> C/C++

       这时候，Java调用的时候使用的是UTF-16编码，当字符串传递给JNI方法时，C/C++得到的输入是jstring，这时候，JNI提供了两个函数，一个是GetStringUTFChars,该函数将得到一个UTF-8编码的字符串（char*类型），另一个函数是GetStringChars，该函数将得到一个UTF-16编码的字符串（wchar_t*类型）。无论哪种结果，得到的字符串如果含有中文，都需要进一步转换为GB2312编码。

       (2)、C/C++ ---> Java

       这时候，是JNI返回给Java字符串。C/C++首先应该负责把这个字符串变成UTF-8或UTF-16格式，然后通过NewStringUTF或者NewString来把它封装成jstring,返回给Java就可以了。

       如果字符串中不含中文字符，只是标准的ascii码，那么使用GetStringUTFChars/NewStringUTF就可以搞定了，因为这种情况下，UTF-8编码和ascii编码是一致的，不需要转换。

      如果字符串中有中文字符，那么在C/C++部分就必须进行编码转换。我们需要两个转换函数，一个是把UTf-8/-16编码转成GB2312;另一个是把GB2312转成UTF-8/-16。

      这里需要说明一下：linux和win32都支持wchar,这个事实上就是宽度为16bit的unicode编码UTF-16，所以，如果我们的c/c++程序中完全使用wchar类型，那么理论上就不需要这种转换。但是实际上，我们不可能完全用wchar来取代char的，所以就目前大多数应用而言，转换仍然是必须的。

      (3)、使用wide char类型来转换

char* jstringToWindows( JNIEnv *env, jstring jstr )
{ //UTF8/16转换成gb2312
  int length = (env)->GetStringLength(jstr );
  const jchar* jcstr = (env)->GetStringChars(jstr, 0 );
 
  int clen = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)jcstr, length, NULL,0, NULL, NULL );
 
  char* rtn = (char*)malloc( clen ) //更正。作者原来用的是(char*)malloc( length*2+1 )，当java字符串中同时包含汉字和英文字母时，所需缓冲区大小并不是2倍关系。
  int size = 0;
  size = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)jcstr, length, rtn,clen, NULL, NULL );
  if( size <= 0 )
    return NULL;
  (env)->ReleaseStringChars(jstr, jcstr );
  rtn[size] = 0;
  return rtn;
}
 
jstring WindowsTojstring( JNIEnv* env, const char* str )
{//gb2312转换成utf8/16
    jstring rtn = 0;
    int slen = strlen(str);
    unsigned short * buffer = 0;
    if( slen == 0 )
        rtn = (env)->NewStringUTF(str );
    else
    {
        int length = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str, slen, NULL, 0 );
        buffer = (unsigned short *)malloc( length*2 + 1 );
        if( MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str, slen, (LPWSTR)buffer, length ) >0 )
            rtn = (env)->NewString(  (jchar*)buffer, length );
    }
    if( buffer )
        free( buffer );
    return rtn;
}


七、附录

1、查看Java方法签名的办法：

      CMD 跳转到 .class文件所在目录，执行javap -s -p XXX即可。（其中XXX为类名）。
--------------------- 
作者：demystify 
来源：CSDN 
原文：https://blog.csdn.net/xiaoxiaoyusheng2012/article/details/56672173 
版权声明：本文为博主原创文章，转载请附上博文链接！

wiggens
关注
专栏目录
java jni调用c++
wcqdong的专栏
09-19 754
环境 jdk1.8 visual studio 2017 windows 步骤1：编写jni类 public class Main { /** 方法 */ public native String hello(); /** 静态方法 */ public native static void helloStatic(); /** 已经传参数方法 */ public native static void hello(int a); /** 测试性能方法
JNI学习资料-有图有真相
04-02
通过阅读提供的"JNI学习资料-有图有真相.doc"文档，你可以更深入地了解这些概念，并通过实例学习如何实际应用JNI。文档中的图形和示例将有助于直观理解复杂的概念，从而提升你的JNI开发技能。记得在实践过程中，不断...
JNI：Java与C++的美好结合 视频地址
01-14
【课程介绍】 这课程，我们的主题就是对C函数，或是对Shared Library，或是对JNI的本地代码的代码写法，我们要讲求它的稳定性。也就是要让它有更好的设计，是我们对这设计做优化的思考，也是架构师的一个很重要的职责。本节，我提出一个原则是：<静态对静态，动态对动态>的原则。 【课程目标】 我们知道，在C层有*.SO，它有全局变量，不要将Java或C++对象参考储存于C层的全局变量，把动态的对象指针放在全局变量是不好的。这样可以增加C函数的稳定度，包括它的通用性，可适应于更多更多的环境里使用，表示它可以很稳定的适用于不同的run-time的动态环境上，都不会让C函数无意中爆掉或产生其它问题。
Java通过JNI调用C++程序
daxiang3255的博客
12-20 165
　　JNI是Java Native Interface的缩写，中文为JAVA本地调用。使用JNI可以很方便的用我们的Java程序调用C/C++程序。很多时候，某些功能用Java无法实现，比如说涉及到底层驱动的一些功能，这时候我们就可以利用JNI来调用C或者C++程序来实现，这就是JNI的强大之处。但是JNI也有它的缺点，使用java与本地已编译的代码交互，通常会丧失平台可移植性。 　　...
JNI：Java与C++的美好结合-高煥堂-专题视频课程
u013821818的专栏
09-21 113
这课程，我们的主题就是对C函数，或是对Shared Library，或是对JNI的本地代码的代码写法，我们要讲求它的稳定性。也就是要让它有更好的设计，是我们对这设计做优化的思考，也是架构师的一个很重要的职责。本节，我提出一个原则是：的原则。...
java通过jni调用c++
xiji321的博客
07-28 608
创建java文件：HelloNative.java public class HelloNative {     public native void sayHello();     /**      * @param args      */     public static void main(String[] args) {         System.load
android studio 下jni学习
12-02
总结来说，Android Studio中的JNI学习涉及项目配置、数据类型转化、本地方法调用以及可能的JSON操作。理解这些基础知识是掌握JNI的关键，这能帮助开发者在遇到需要混合编程的场景时游刃有余。在实际应用中，务必注意...
JNI学习资料
02-25
JNI，即Java Native Interface，是Java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI在Android开发中扮演着重要角色，因为它使得开发者能够利用C和C++的强大功能来编写部分性能敏感或者需要调用操作...
JAVA 中使用 jni 调用 C++
m0_44993395的博客
11-05 459
前言 编程语言多种多样，在一个工程中有时会用到多种编程语言，这时就需要一个方法将两种语言联系起来，下文小编以 jni 为例，jni 用于在 JAVA 程序中引入 C 或 C++ 文件。 具体方法 首先在本地任意的一个目录下创建2各类 JNI.java 和 Test.java ,我在 D:\JNITest 目录下创建了这两个文件。 //JNI.java文件 public class JNI{ //创建一个native接口方法，此方法在C++代码中实现 public native int cal
android jni使用static变量
12-22
这是我自己写的android jni调用java static属性的例子
java JNI 调用c++编程
10-26 383
一，DLL_Source 文件为第三方提供的dll 二，Dll_test 文件 自己封装的dll 三，testDll 文件  javaweb 程序 四，第三方dll接口文档 Call_dll.java文件的代码如下：  package com.testDll; import com.sun.org.apache.xpath.internal.operations.Bool; //imp...
java 使用jni调用c++代码
technologyleader的专栏
10-15 599
流程如下： 1、使用eclipse建立一个java工程，建立一个java文件，在这里我只写了一个方法，myadd()。 package com.imgMatch;//包名影响着javah的使用 public class ForDll { static { System.loadLibrary("javaCallcpp");//javaCallcpp就是要加载的dll的名字，这是相对路径加载方式 } public native int myadd(int a , int b);//
Java使用JNI(Java Native Interface)调用C/C++函数
lonewolves的博客
07-20 915
JNI即Java Native Interface(Java本地接口)，主要作用为：它允许Java代码和其他语言写的进行交互。本文主要使用Java调用c/c++代码（类库）。
Java与c++通过JNI的完美结合
dabaojian的博客
10-19 242
Java与c++通过JNI的完美结合 https://blog.csdn.net/xiaoxiaoyusheng2012/article/details/56672173
java jni 调用c++_java通过JNI调用c++代码 | 学步园
weixin_39692037的博客
02-28 121
java通过JNI调用c++代码1 用java约定接口，生成头文件创建JniHelloWorld.javapublic class JniHelloWorld {public JniHelloWorld(){}public native void sayHello(String name);}生成头文件供c++使用javah-jni JniHelloWorld产生JniHelloWorld.h文件...
java使用JNI调用C++程序流程（含windows、linux下）
qq_42029265的博客
06-11 1193
本文实现在windows下编写C++代码并使用java进行调用 然后将该C++代码进行响应修改在centos环境下使用java进行调用 整体是基于JNI实现SM4加密。 windows下实现 1.编写java代码 CallSM4.java package com.sm4; import java.io.IOException; import java.util.Arrays; import java.util.List; public class CallSM4 { static {
JAVA通过JNI调用C++程序实践
ylzhusky的博客
08-01 2188
整体思路：将需要调用的C++函数在java中声明一个对应的native函数，利用javah生成对应的h头文件，用C++封装成动态链接库，提供给java调用 实践步骤：1.声明需要调用的C++函数在java中对应的native函数,这里只有两个是native函数，只要这2个函数在动态库中能找到就可以了：package com.ylzhang.service.config;/** * Ylzhang
【NDK系列11】Java和c++交互 Jni初识
大帅在唱歌
06-21 433
文章目录1. Java调用c++方法2. JNI数据类型3. C/C++反射Java反射调用方法反射修改变量4. JNI_OnLoad5. c++线程中调用Java代码 JNI是一种本地编程接口。它允许运行在JAVA虚拟机中的JAVA代码和用其他编程语言，诸如C语言、C++、汇编，应用和库之间的交互操作。 不只是Android特有的东西 1. Java调用c++方法 静态加载so static ...
Android jni学习路线
最新发布
01-11
Android JNI学习路线可以按照以下步骤进行： 1. 了解JNI的基本概念和作用：JNI（Java Native Interface）是Java提供的一种机制，用于实现Java与其他编程语言（如C、C++）之间的交互。它允许在Java代码中调用本地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值