AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

02.Jni开发流程_C/C++调用java

2018-03-20 921
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： (创建于2017/11/18)c/c++调用Java包括几个分类，调用Java静态和非静态属性，静态和非静态方法四种提示：生成一个类中所有属性成员签名的方法如下：1.

(创建于2017/11/18)

c/c++调用Java包括几个分类，调用Java静态和非静态属性，静态和非静态方法四种

提示：
生成一个类中所有属性成员签名的方法如下：
1.进入这个类class文件所在的路径：如JniUtils这个类在d盘下 D:\application\java\eclipse-workspace\TestJni\bin\com\renzhenming\bsdiff>
2.执行命令D:\application\java\eclipse-workspace\TestJni\bin\com\renzhenming\bsdiff>javap -p -s JniUtils
3.会得到结果：descriptor所对应的就是签名

Compiled from "JniUtils.java"
public class com.renzhenming.bsdiff.JniUtils {
  public static int key;
    descriptor: I
  static {};
    descriptor: ()V

  public com.renzhenming.bsdiff.JniUtils();
    descriptor: ()V

  public native void changeIntKey();
    descriptor: ()V

  public native void accessMethod();
    descriptor: ()V

  public native void accessStaticMethod();
    descriptor: ()V

  public int getRandomInt(int);
    descriptor: (I)I

  public static java.lang.String getUUId();
    descriptor: ()Ljava/lang/String;
}

生成系统类签名的方法，以java.util.Date为例

直接进入命令行，输入javap -s -p 完整类名

C:\Users\renzhenming>javap -s -p java.util.Date
Compiled from "Date.java"
public class java.util.Date implements java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<java.util.Date> {
  private static final sun.util.calendar.BaseCalendar gcal;
    descriptor: Lsun/util/calendar/BaseCalendar;
  private static sun.util.calendar.BaseCalendar jcal;
    descriptor: Lsun/util/calendar/BaseCalendar;
  private transient long fastTime;
    descriptor: J
  private transient sun.util.calendar.BaseCalendar$Date cdate;
    descriptor: Lsun/util/calendar/BaseCalendar$Date;
  private static int defaultCenturyStart;
    descriptor: I
  private static final long serialVersionUID;
    descriptor: J
  private static final java.lang.String[] wtb;
    descriptor: [Ljava/lang/String;
  private static final int[] ttb;
    descriptor: [I
  public java.util.Date();
    descriptor: ()V

  public java.util.Date(long);
    descriptor: (J)V

  public java.util.Date(int, int, int);
    descriptor: (III)V

  public java.util.Date(int, int, int, int, int);
    descriptor: (IIIII)V

  public java.util.Date(int, int, int, int, int, int);
    descriptor: (IIIIII)V

  public java.util.Date(java.lang.String);
    descriptor: (Ljava/lang/String;)V

  public java.lang.Object clone();
    descriptor: ()Ljava/lang/Object;

  public static long UTC(int, int, int, int, int, int);
    descriptor: (IIIIII)J

  public static long parse(java.lang.String);
    descriptor: (Ljava/lang/String;)J

  public int getYear();
    descriptor: ()I

  public void setYear(int);
    descriptor: (I)V

  public int getMonth();
    descriptor: ()I

  public void setMonth(int);
    descriptor: (I)V

  public int getDate();
    descriptor: ()I

  public void setDate(int);
    descriptor: (I)V

  public int getDay();
    descriptor: ()I

  public int getHours();
    descriptor: ()I

  public void setHours(int);
    descriptor: (I)V

  public int getMinutes();
    descriptor: ()I

  public void setMinutes(int);
    descriptor: (I)V

  public int getSeconds();
    descriptor: ()I

  public void setSeconds(int);
    descriptor: (I)V

  public long getTime();
    descriptor: ()J

  private final long getTimeImpl();
    descriptor: ()J

  public void setTime(long);
    descriptor: (J)V

  public boolean before(java.util.Date);
    descriptor: (Ljava/util/Date;)Z

  public boolean after(java.util.Date);
    descriptor: (Ljava/util/Date;)Z

  public boolean equals(java.lang.Object);
    descriptor: (Ljava/lang/Object;)Z

  static final long getMillisOf(java.util.Date);
    descriptor: (Ljava/util/Date;)J

  public int compareTo(java.util.Date);
    descriptor: (Ljava/util/Date;)I

  public int hashCode();
    descriptor: ()I

  public java.lang.String toString();
    descriptor: ()Ljava/lang/String;

  private static final java.lang.StringBuilder convertToAbbr(java.lang.StringBuilder, java.lang.String);
    descriptor: (Ljava/lang/StringBuilder;Ljava/lang/String;)Ljava/lang/StringBuilder;

  public java.lang.String toLocaleString();
    descriptor: ()Ljava/lang/String;

  public java.lang.String toGMTString();
    descriptor: ()Ljava/lang/String;

  public int getTimezoneOffset();
    descriptor: ()I

  private final sun.util.calendar.BaseCalendar$Date getCalendarDate();
    descriptor: ()Lsun/util/calendar/BaseCalendar$Date;

  private final sun.util.calendar.BaseCalendar$Date normalize();
    descriptor: ()Lsun/util/calendar/BaseCalendar$Date;

  private final sun.util.calendar.BaseCalendar$Date normalize(sun.util.calendar.BaseCalendar$Date);
    descriptor: (Lsun/util/calendar/BaseCalendar$Date;)Lsun/util/calendar/BaseCalendar$Date;

  private static final sun.util.calendar.BaseCalendar getCalendarSystem(int);
    descriptor: (I)Lsun/util/calendar/BaseCalendar;

  private static final sun.util.calendar.BaseCalendar getCalendarSystem(long);
    descriptor: (J)Lsun/util/calendar/BaseCalendar;

  private static final sun.util.calendar.BaseCalendar getCalendarSystem(sun.util.calendar.BaseCalendar$Date);
    descriptor: (Lsun/util/calendar/BaseCalendar$Date;)Lsun/util/calendar/BaseCalendar;

  private static final synchronized sun.util.calendar.BaseCalendar getJulianCalendar();
    descriptor: ()Lsun/util/calendar/BaseCalendar;

  private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    descriptor: (Ljava/io/ObjectOutputStream;)V

  private void readObject(java.io.ObjectInputStream) throws java.io.IOException, java.lang.ClassNotFoundException;
    descriptor: (Ljava/io/ObjectInputStream;)V

  public static java.util.Date from(java.time.Instant);
    descriptor: (Ljava/time/Instant;)Ljava/util/Date;

  public java.time.Instant toInstant();
    descriptor: ()Ljava/time/Instant;

  public int compareTo(java.lang.Object);
    descriptor: (Ljava/lang/Object;)I

  static {};
    descriptor: ()V
}

C:\Users\renzhenming>

1.在Java的一个类中，如下，定义各种类型的属性和方法

import java.util.Random;
import java.util.UUID;

public class JniUtils {

    public String key = "renzhenming";
    
    private Human human = new Man(); 
    
    public static int count = 9;
    
    public native static String getStringFromC();
    
    public native String getString2FromC(int i);
    //访问属性，返回修改之后的属性内容
    public native String accessField();
    
    public native void accessStaticField();
    
    public native void accessMethod();
    
    public native void accessStaticMethod();
    
    public native void accessNonVirtualMethod();

    public native String toChineseString(String value);
    
    public native void accessConstructor();
    
    public native void setArray(int [] arr);
    
    public native int[] getArray();
    
    public native void cached();
    
    public native static void initIds();
    
    public static void main(String[] args) {
        String text = getStringFromC();
        System.out.println(text);
        JniUtils t = new JniUtils();
        text = t.getString2FromC(6);
        System.out.println(text);
        
        System.out.println("key修改前："+t.key);
        t.accessField();
        System.out.println("key修改后："+t.key);
        
        System.out.println("count修改前："+count);
        t.accessStaticField();
        System.out.println("count修改后："+count);
        
        t.accessMethod();
        t.accessStaticMethod();
        
        System.out.println("访问构造方法");
        new JniUtils().accessConstructor();
        
        System.out.println("访问被子类重写后的父类方法");    
        new JniUtils().accessNonVirtualMethod();
        
        System.out.println(new JniUtils().toChineseString("想乱码的日子里"));
        
        int arr [] = {12,3,43,55,44,1,566};
        new JniUtils().setArray(arr);
        for(int i = 0 ; i < arr.length;i++ ) {
            System.out.println(arr[i]); 
        }
        
        System.out.println("-------------------------------");  
        int [] jarr = new JniUtils().getArray();
        for(int i = 0 ; i < jarr.length;i++ ) {
            System.out.println(jarr[i]);    
        }
        
        System.out.println("-------------------------------");  
        new JniUtils().createGlobalRef();
        System.out.println(new JniUtils().getGlobalRef());
        new JniUtils().deleteGlobalRef();
        //释放了再获取就会空指针
        //System.out.println(new JniUtils().getGlobalRef());
        
        try {
            new JniUtils().exception();
        } catch (Exception e) {
            System.out.println("发生异常："+e.getMessage());
        }
        //不断调用cached方法
        for (int i = 0; i < 100; i++) {
            t.cached();
        }
    }
    
    //产生指定范围的随机数
    public int genRandomInt(int max){
        System.out.println("genRandomInt 执行了...");
        return new Random().nextInt(max); 
    }
    
    //产生UUID字符串
    public static String getUUID(){
        return UUID.randomUUID().toString();
    }
    
    //加载动态库
    static{ 
        System.loadLibrary("JniTest");//这是生成的dll动态库的名字
        initIds();
    }

}

//类Human和类Man代码如下（测试jni调用父类方法而设置）：
public class Human {
    public void sayHi() {
        System.out.println("人打招呼");
    }
}
public class Man extends Human{
    public void sayHi() {
        System.out.println("男。。。。。人打招呼");
    }
}

2.创建native方法，使用javah生成头文件

/* DO NOT EDIT THIS FILE - it is machine generated */
#include "jni.h"
/* Header for class com_dongnaoedu_jni_JniTest */

#ifndef _Included_com_renzhenming_bsdiff_JniUtils
#define _Included_com_renzhenming_bsdiff_JniUtils
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     _com_renzhenming_bsdiff_JniUtils
 * Method:    getStringFromC
 * Signature: ()V
 */
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_getStringFromC
  (JNIEnv *, jclass);

JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_getString2FromC
(JNIEnv *, jobject, jint);

JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessField
(JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessStaticField
(JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessMethod
(JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessStaticMethod
(JNIEnv *, jobject);
    
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessConstructor
(JNIEnv *, jobject);
    
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessNonVirtualMethod
(JNIEnv *, jobject);
    
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_toChineseString
(JNIEnv *, jobject, jstring);
    
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_setArray
(JNIEnv *,jobject,jintArray);
    
JNIEXPORT jintArray JNICALL Java_com_renzhenming_bsdiff_JniUtils_getArray
(JNIEnv *, jobject);
    
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_localRef
(JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_createGlobalRef
(JNIEnv *,jobject);

JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_getGlobalRef
(JNIEnv *, jobject);

JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_deleteGlobalRef
(JNIEnv *, jobject);
    
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_exception
(JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

3.将头文件引入as中（jni.h和jni_md.h引入同上次笔记），编写c代码，如下

#define _CRT_SECURE_NO_WARNINGS
#include "com_renzhenming_bsdiff_JniUtils.h"
#include <string.h>

//功能：获取到指定类中一字符串类型成员变量，修改返回得到新的字符串
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_changeKey
(JNIEnv *env, jobject jobj) {
    //我们编写的native方法是非静态方法，所以这里是jobject，而我们需要jclass来获取fieldid,所以这样转换
    jclass clazz  = (*env)->GetObjectClass(env, jobj);
    //参数分别为class对象，属性名，属性签名（签名得到的方法查看文档），获取到我们需要修改的属性的id值
    jfieldID fieldId = (*env)->GetFieldID(env, clazz, "key", "Ljava/lang/String;");
    //从这个对象jobj中获取这个id fieldid的jstring 对象
    jstring jstr = (*env)->GetObjectField(env, jobj, fieldId);
    //将jni类型jstring 转换为c对象char ,从而我们可以调用c方法修改这个对象的值
    char *c_str = (*env)->GetStringUTFChars(env, jstr, JNI_FALSE);
    //将这个对象的值和text这个字符串连接得到我们需要的新值
    char text[30] = "handsome ";
    strcat(text, c_str);
    //再次将这个新值对应的c对象char转换为jni类型jstring，
    jstring new_jstr = (*env)->NewStringUTF(env, text);
    //将这个jstring类型的新对象设置给这个jobj这个对象中id值为fieldId的这个对象，至此对象值已经被我们修改
    (*env)->SetObjectField(env, jobj, fieldId, new_jstr);
    
    //删除
    (*env)->DeleteLocalRef(env,new_jstr);
    //返回这个新的字符串，这里没有用到
    return new_jstr;
}

#define _CRT_SECURE_NO_WARNINGS
#include "com_renzhenming_bsdiff_JniUtils.h"
#include <string.h>

//函数实现
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_getStringFromC
(JNIEnv *env, jclass jcls){
    return (*env)->NewStringUTF(env,"C String");
}

JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_getString2FromC
(JNIEnv *env, jobject jobj, jint num){
    return (*env)->NewStringUTF(env,"C String2");
}

//每个native函数，都至少有两个参数（JNIEnv*,jclass或者jobject)
//1）当native方法为静态方法时：
//jclass 代表native方法所属类的class对象(JniTest.class)
//2）当native方法为非静态方法时：
//jobject 代表native方法所属的对象

//基本数据
//Java基本数据类型与JNI数据类型的映射关系
//Java类型->JNI类型->C类型

/*
boolean jboolean
byte jbyte;
char jchar;
short jshort;
int jint;
long jlong;
float jfloat;
double jdouble;
void void
*/

//引用类型(对象)
//String jstring
//object jobject
//数组,基本数据类型的数组
//byte[] jByteArray
//对象数组
//object[](String[]) jobjectArray

//C/C++访问Java的成员

//1.访问属性
//修改属性key
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessField
(JNIEnv *env, jobject jobj){
     //我们编写的native方法是非静态方法，所以这里是jobject，而我们需要jclass来获取fieldid,所以这样转换
    jclass clazz  = (*env)->GetObjectClass(env, jobj);
    //参数分别为class对象，属性名，属性签名（签名得到的方法查看文档），获取到我们需要修改的属性的id值
    jfieldID fieldId = (*env)->GetFieldID(env, clazz, "key", "Ljava/lang/String;");
    //从这个对象jobj中获取这个id fieldid的jstring 对象
    jstring jstr = (*env)->GetObjectField(env, jobj, fieldId);
    //将jni类型jstring 转换为c对象char ,从而我们可以调用c方法修改这个对象的值
    char *c_str = (*env)->GetStringUTFChars(env, jstr, JNI_FALSE);
    //将这个对象的值和text这个字符串连接得到我们需要的新值
    char text[30] = "handsome ";
    strcat(text, c_str);
    //再次将这个新值对应的c对象char转换为jni类型jstring，
    jstring new_jstr = (*env)->NewStringUTF(env, text);
    //将这个jstring类型的新对象设置给这个jobj这个对象中id值为fieldId的这个对象，至此对象值已经被我们修改
    (*env)->SetObjectField(env, jobj, fieldId, new_jstr);
    (*env)->DeleteLocalRef(env,new_jstr);
    //返回这个新的字符串，这里没有用到
    return new_jstr;
}

//访问静态属性
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessStaticField
(JNIEnv *env, jobject jobj){
    //jclass
    jclass cls = (*env)->GetObjectClass(env, jobj);
    //jfieldID
    jfieldID fid = (*env)->GetStaticFieldID(env, cls, "count", "I");
    //GetStatic<Type>Field
    jint count = (*env)->GetStaticIntField(env, cls, fid);
    count++;
    //修改
    //SetStatic<Type>Field
    (*env)->SetStaticIntField(env,cls,fid,count);
}

//2.访问java方法
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessMethod
(JNIEnv *env, jobject jobj){
    //jclass
    jclass cls = (*env)->GetObjectClass(env, jobj);
    //jmethodID
    jmethodID mid = (*env)->GetMethodID(env, cls, "genRandomInt", "(I)I");
    //调用
    //Call<Type>Method
    jint random = (*env)->CallIntMethod(env, jobj, mid, 200);
    printf("random num:%ld",random);

    //.....
}

//静态方法
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessStaticMethod
(JNIEnv *env, jobject jobj){
    //jclass
    jclass cls = (*env)->GetObjectClass(env, jobj);
    //jmethodID 
    jmethodID mid = (*env)->GetStaticMethodID(env, cls, "getUUID", "()Ljava/lang/String;");
    
    //调用
    //CallStatic<Type>Method
    jstring uuid = (*env)->CallStaticObjectMethod(env, cls, mid);

    //随机文件名称 uuid.txt
    //jstring -> char*
    //isCopy JNI_FALSE，代表java和c操作的是同一个字符串
    char *uuid_str = (*env)->GetStringUTFChars(env, uuid, JNI_FALSE);
    //拼接
    char filename[100];
    sprintf(filename, "D://%s.txt",uuid_str);
    
    //w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
    FILE *fp = fopen(filename,"w");
    fputs("i love jason", fp);
    fclose(fp);
}

//访问构造方法（Date 生成一个时间戳）
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessConstructor
(JNIEnv *env, jobject jobj) {
    //根据包名得到类，类似反射
    jclass cls = (*env)->FindClass(env, "java/util/Date");
    //获取类中要获取的方法id(获取构造方法，方法名传"<init>")
    jmethodID methodid = (*env)->GetMethodID(env, cls, "<init>", "()V");
    //实例化一个对象，类似反射
    jobject date_obj = (*env)->NewObject(env, cls, methodid);
    //通过这个对象调用getTime方法，需要获取到这个方法的id
    jmethodID g_methodid = (*env)->GetMethodID(env, cls, "getTime", "()J");
    //执行这个方法,返回值是long类型，所以CallLong
    jlong time = (*env)->CallLongMethod(env, date_obj, g_methodid);
    //占位符用的lld，是long long类型的，如果直接用ld占位符打印，打出的是负数
    printf("\ntime:%lld\n", time);
    (*env)->DeleteLocalRef(env,date_obj);
}

//访问父类被子类重写的方法
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_accessNonVirtualMethod
(JNIEnv *env, jobject jobj) {
    //在java中，父类指向子类对象，调用被子类重写的方法，执行的是子类的方法，在jni中
    //我们可以调用到父类的方法
    jclass cls = (*env)->GetObjectClass(env, jobj);
    //获取类中human属性(先获取到id)  对象的签名
    jfieldID fid  = (*env)->GetFieldID(env, cls, "human", "Lcom/renzhenming/bsdiff/Human;");
    jobject human_obj = (*env)->GetObjectField(env, jobj, fid);
    //获取父类class
    jclass human_class = (*env)->FindClass(env, "com/renzhenming/bsdiff/Human");
    //获取父类中需要调用的方法的methodid
    jmethodID s_mid = (*env)->GetMethodID(env,human_class,"sayHi","()V");
    //执行指定方法

    //子类方法
    (*env)->CallObjectMethod(env, human_obj, s_mid);
    //父类方法（c++中要重写父类方法，用的是virtual关键字）（调用父类方法传入的class不能通过
    //GetObjectClass从human_obj中获取，因为这样获取到的是子类的class）
    (*env)->CallNonvirtualObjectMethod(env, human_obj, human_class, s_mid);
}
//解决jni中文乱码的问题
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_toChineseString_
(JNIEnv *env, jobject jobj, jstring jstr) {
    //输出
    //char *c_str = (*env)->GetStringUTFChars(env, in, JNI_FALSE);
    //printf("%s\n",c_str);

    //c -> jstring
    char *c_str = "马蓉与宋江";
    //char c_str[] = "马蓉与宋喆";
    //jstring jstr = (*env)->NewStringUTF(env, c_str);
    //执行String(byte bytes[], String charsetName)构造方法需要的条件
    //1.jmethodID
    //2.byte数组
    //3.字符编码jstring

    jclass str_cls = (*env)->FindClass(env, "java/lang/String");
    jmethodID constructor_mid = (*env)->GetMethodID(env, str_cls, "<init>", "([BLjava/lang/String;)V");

    //jbyte -> char 
    //jbyteArray -> char[]
    jbyteArray bytes = (*env)->NewByteArray(env, strlen(c_str));
    //byte数组赋值
    //0->strlen(c_str)，从头到尾
    //对等于，从c_str这个字符数组，复制到bytes这个字符数组
    (*env)->SetByteArrayRegion(env, bytes, 0, strlen(c_str), c_str);

    //字符编码jstring
    jstring charsetName = (*env)->NewStringUTF(env, "GB2312");

    //调用构造函数，返回编码之后的jstring
    return (*env)->NewObject(env, str_cls, constructor_mid, bytes, charsetName);
}

//-----------------------操作数组涉及到数组的同步问题（ReleaseIntArrayElements）-----------------------------//

//操作传入的数组
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_setArray
(JNIEnv *env, jobject  jobj, jintArray array) {
    //jintArray ->jint指针->c int数组
    jint *elems = (*env)->GetIntArrayElements(env, array, JNI_FALSE);
    //数组的长度
    int len = (*env)->GetArrayLength(env, array);
    //排序（传入的compare类似Java中的比较器）
    qsort(elems, len, sizeof(jint), compare);
    //将排序结果同步到Java中的数组
    //最后一个参数 mode
    //0  表示Java数组进行更新，并且释放c/c++数组
    //JNI_ABORT  表示Java数组不更新，释放c/c++数组
    //JNI_COMMIT 表示Java数组进行更新，但不释放c/c++数组
    (*env)->ReleaseIntArrayElements(env, array, elems, 0);
}

//返回一个数组
JNIEXPORT jintArray JNICALL Java_com_renzhenming_bsdiff_JniUtils_getArray
(JNIEnv *env, jobject jobj) {
    //创建一个指定大小的数组
    jintArray jint_arr = (*env)->NewIntArray(env, 10);
    //获取到数组指针
    jint *elems = (*env)->GetIntArrayElements(env, jint_arr, NULL);
    int i = 0;
    for ( ;  i< 10; i++)
    {
        elems[i] = i;
    }

    //同步
    (*env)->ReleaseIntArrayElements(env, jint_arr, elems, 0);
    return jint_arr;
}

//局部引用
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_localRef
(JNIEnv *env, jobject jobj) {
    int i = 0;
    for (; i < 5; i++) {
        //创建对象，以Date为例
        jclass cls = (*env)->FindClass(env, "java/util/Date");
        jmethodID constructor_id = (*env)->GetMethodID(env, cls, "init", "()V");
        jobject obj = (*env)->NewObject(env, cls, constructor_id);
        //....
        //不在使用这个对象了需要回收
        (*env)->DeleteLocalRef(env, obj);
        //....
    }
}

//创建全局引用(共享，可以跨多个线程)
jstring global_str;
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_createGlobalRef
(JNIEnv *env, jobject jobj) {
    jstring jstr = (*env)->NewStringUTF(env,"jni is a bitch");
    global_str = (*env)->NewGlobalRef(env, jstr);
}
//获取全局引用
JNIEXPORT jstring JNICALL Java_com_renzhenming_bsdiff_JniUtils_getGlobalRef
(JNIEnv *env, jobject jobj) {
    return global_str;
}
//删除全局引用
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_deleteGlobalRef
(JNIEnv *env, jobject jobj) {
    (*env)->DeleteGlobalRef(env, global_str);
}

//Java捕获c异常（如果不做抛异常处理，直接再Java层try是抓不到异常信息的）
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_exception
(JNIEnv *env, jobject jobj) {
    jclass cls = (*env)->GetObjectClass(env, jobj);
    jfieldID fid = (*env)->GetFieldID(env, cls, "value2", "Ljava/lang/String;");
    //检测是否发生Java异常
    jthrowable exception = (*env)->ExceptionOccurred(env);
    if (exception != NULL) {
        //让Java代码可以继续运行
        //清空异常信息
        (*env)->ExceptionClear(env);
        //补救措施
        fid = (*env)->GetFieldID(env, cls, "value", "Ljava/lang/String;");
    }

    //获取属性值
    jstring jstr = (*env)->GetObjectField(env, jobj, fid);
    char *str = (*env)->GetStringUTFChars(env, jstr, NULL);

    //对比属性是否合法
    if (stricmp(str, "renzhenming") != 0) {
        //抛出异常，给Java处理
        jclass newExcCls = (*env)->FindClass(env, "java/lang/IllegalArgumentException");
        (*env)->ThrowNew(env, newExcCls, "key's value is invalid!");
    }
}

//静态缓存

//static jfieldID key_id 
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_cached(JNIEnv *env, jobject jobj){
    jclass cls = (*env)->GetObjectClass(env, jobj); 
    //»ñÈ¡jfieldIDÖ»»ñÈ¡Ò»´Î
    //¾Ö²¿¾²Ì¬±äÁ¿
    static jfieldID key_id = NULL;
    if (key_id == NULL){
        key_id = (*env)->GetFieldID(env, cls, "key", "Ljava/lang/String;");
        printf("--------GetFieldID-------\n");
    }
}

//加载动态库的时候就初始化全局变量，再loadLibrary后调用
jfieldID key_fid;
jmethodID random_mid;
JNIEXPORT void JNICALL Java_com_renzhenming_bsdiff_JniUtils_initIds(JNIEnv *env, jclass jcls){  
    key_fid = (*env)->GetFieldID(env, jcls, "key", "Ljava/lang/String;");
    random_mid = (*env)->GetMethodID(env, jcls, "genRandomInt", "(I)I");
}

4.生成dll动态库，放到eclipse中调用

public static void main(String[] args) {
        String text = getStringFromC();
        System.out.println(text);
        JniTest t = new JniTest();
        text = t.getString2FromC(6);
        System.out.println(text);
        
        System.out.println("key修改前："+t.key);
        t.accessField();
        System.out.println("key修改后："+t.key);
        
        System.out.println("count修改前："+count);
        t.accessStaticField();
        System.out.println("count修改后："+count);
        
        t.accessMethod();
        t.accessStaticMethod();
    
        System.out.println("访问构造方法");
        new JniUtils().accessConstructor();
    
        System.out.println("访问被子类重写后的父类方法");    
        new JniUtils().accessNonVirtualMethod();
    
        System.out.println(new JniUtils().toChineseString("想乱码的日子里"));
    
        int arr [] = {12,3,43,55,44,1,566};
        new JniUtils().setArray(arr);
        for(int i = 0 ; i < arr.length;i++ ) {
            System.out.println(arr[i]); 
        }
    
        System.out.println("-------------------------------");  
        int [] jarr = new JniUtils().getArray();
        for(int i = 0 ; i < jarr.length;i++ ) {
            System.out.println(jarr[i]);    
        }
    
        System.out.println("-------------------------------");  
        new JniUtils().createGlobalRef();
        System.out.println(new JniUtils().getGlobalRef());
        new JniUtils().deleteGlobalRef();

        //释放了再获取就会空指针
        //System.out.println(new JniUtils().getGlobalRef());
        
        try {
            new JniUtils().exception();
        } catch (Exception e) {
            System.out.println("发生异常："+e.getMessage());
        }
        
    }
文章标签：
Java
C++
Android开发
缓存
关键词：
Java C++
C++ java
Java jni
jni C++
C++ jni
黑夜路口
目录
相关文章
sunrr
|
24天前
|
Java Android开发 C++
Java和C++
Java和C++
sunrr
36 15
WK
|
1月前
|
安全 Java 编译器
C++和Java哪个更好用
C++和Java各具优势，选择取决于项目需求、开发者偏好及目标平台特性。C++性能出色，适合游戏、实时系统等；Java平台独立性强，适合跨平台、安全敏感应用。C++提供硬件访问和灵活编程范式，Java有自动内存管理和丰富库支持。两者各有千秋，需根据具体需求选择。
WK
43 1
mzlogin
|
2月前
|
IDE Java 程序员
C++ 程序员的 Java 指南
一个 C++ 程序员自己总结的 Java 学习中应该注意的点。
mzlogin
26 5
WK
|
1月前
|
开发框架 移动开发 Java
C++和Java哪个更适合开发移动应用
本文对比了C++和Java在移动应用开发中的优劣，从市场需求、学习难度、开发效率、跨平台性和应用领域等方面进行了详细分析。Java在Android开发中占据优势，而C++则适合对性能要求较高的场景。选择应根据具体需求和个人偏好综合考虑。
WK
64 0
WK
|
1月前
|
安全 Java 编译器
C++和Java哪个更适合开发web网站
在Web开发领域，C++和Java各具优势。C++以其高性能、低级控制和跨平台性著称，适用于需要高吞吐量和低延迟的场景，如实时交易系统和在线游戏服务器。Java则凭借其跨平台性、丰富的生态系统和强大的安全性，广泛应用于企业级Web开发，如企业管理系统和电子商务平台。选择时需根据项目需求和技术储备综合考虑。
WK
114 0
nanshaws
|
2月前
|
缓存 并行计算 Java
C++矢量运算与java矢量运算
本文探讨了C++和Java中的矢量运算与标量运算的性能比较，解释了矢量运算的原理和为什么它比标量运算快，包括并行性、数据局部性、指令优化和数据重用等优势。文章还提供了C++和Java的矢量运算示例代码，并展示了运行结果，以证明矢量运算在处理大量数据时的性能优势。
nanshaws
30 0
C++矢量运算与java矢量运算
众所周知
|
3月前
|
Java Android开发 C++
🚀Android NDK开发实战！Java与C++混合编程，打造极致性能体验！📊
在Android应用开发中，追求卓越性能是不变的主题。本文介绍如何利用Android NDK（Native Development Kit）结合Java与C++进行混合编程，提升应用性能。从环境搭建到JNI接口设计，再到实战示例，全面展示NDK的优势与应用技巧，助你打造高性能应用。通过具体案例，如计算斐波那契数列，详细讲解Java与C++的协作流程，帮助开发者掌握NDK开发精髓，实现高效计算与硬件交互。
众所周知
170 1
1941623231718325
|
3月前
|
安全 Java API
【性能与安全的双重飞跃】JDK 22外部函数与内存API：JNI的继任者，引领Java新潮流！
【9月更文挑战第7天】JDK 22外部函数与内存API的发布，标志着Java在性能与安全性方面实现了双重飞跃。作为JNI的继任者，这一新特性不仅简化了Java与本地代码的交互过程，还提升了程序的性能和安全性。我们有理由相信，在外部函数与内存API的引领下，Java将开启一个全新的编程时代，为开发者们带来更加高效、更加安全的编程体验。让我们共同期待Java在未来的辉煌成就！
1941623231718325
77 11
1941623231718325
|
3月前
|
安全 Java API
【本地与Java无缝对接】JDK 22外部函数和内存API：JNI终结者，性能与安全双提升！
【9月更文挑战第6天】JDK 22的外部函数和内存API无疑是Java编程语言发展史上的一个重要里程碑。它不仅解决了JNI的诸多局限和挑战，还为Java与本地代码的互操作提供了更加高效、安全和简洁的解决方案。随着FFM API的逐渐成熟和完善，我们有理由相信，Java将在更多领域展现出其强大的生命力和竞争力。让我们共同期待Java编程新纪元的到来！
1941623231718325
125 11
rbvb2ms5saimy
|
4月前
|
Rust 安全 Java
Java代码规范--排版,命名.：Rust能否撼动C++的王座？
系统编程是计算机科学的核心，C++长期占据主导地位，但其内存安全问题备受诟病。Rust以安全性为核心，通过所有权和生命周期概念避免了野指针和内存泄漏。此外，Rust的并发模型和日益丰富的生态系统使其成为现代系统编程的新选择，尤其在安全性和并发性方面表现出色。尽管C++依然强大，但Rust为开发者提供了更安全、易管理的选项，未来有望推动更多系统级应用的发展。
rbvb2ms5saimy
30 0

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    java小工具util系列2：字符串工具
  • 3
    Java爬虫：数据采集的强大工具
  • 4
    Java多线程并发编程：同步机制与实践应用
  • 5
    Java中的异常处理：从基础到高级
  • 6
    深入理解Java异常处理机制
  • 7
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 8
    Java爬虫：深入解析商品详情的利器
  • 9
    java实现从HDFS上下载文件及文件夹的功能，以流形式输出，便于用户自定义保存任何路径下
  • 10
    Java 异常处理：机制、策略与最佳实践
  • 1
    c++引用是什么意思？
    49
  • 2
    C++ 多态 虚函数和纯虚函数
    52
  • 3
    C++ 重载运算符和重载函数
    52
  • 4
    C++ 类构造函数 & 析构函数
    54
  • 5
    C++ this 指针详解
    47
  • 6
    C++友元函数和友元类
    56
  • 7
    从C++看编程语言发展脉络
    119
  • 8
    LabVIEW使用Python MathWorks® MATLAB®软件和C/C++
    79
  • 9
    LabVIEW传递接收C/C++DLL指针
    212
  • 10
    LabVIEW调用C/C++ DLLs
    137

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)