[Java && C++] JNI开发

JNI（Java Native Interface）是 Java 提供的一种编程桥梁，它允许 Java 代码和本地（Native）代码进行交互。通过 JNI，Java 程序可以调用本地语言（如C、C++）编写的代码，并且本地代码也可以调用 Java 方法。

JNI 的主要作用包括：

1. 调用本地库：Java 可以调用本地库中的函数，实现对底层系统的访问和控制。
2. 提高性能：通过 JNI，可以使用本地语言编写高性能的代码，例如对计算密集型任务进行优化。
3. 平台特定功能：JNI 可以用于实现与特定平台相关的功能，比如访问操作系统特定的功能或者硬件设备。

在 JNI 中，主要涉及到以下几个方面的内容：

• Java 本地方法接口声明：在 Java 代码中声明 native 方法，并使用关键字 native 来标识这些方法。
• 本地方法库实现：使用 C、C++ 或者其他本地语言编写与 Java 本地方法相对应的本地方法实现。
• 编译和链接：将本地方法实现编译成动态链接库，并确保 Java 虚拟机能够加载和调用这些库中的方法。
• 调用本地方法：在 Java 代码中通过 JNI 调用本地方法，实现 Java 与本地代码的交互。

大致步骤:

1. 编写 C++ 代码：首先，你需要编写带有 JNI 方法的 C++ 代码。在 C++ 中，你可以使用 JNI 提供的函数来与 Java 交互。确保你的 C++ 代码中包含了 JNI 函数，并且实现了与 Java 交互所需的功能。

2. 生成动态链接库（DLL 或 SO 文件）：将你的 C++ 代码编译成动态链接库文件（在 Windows 下通常是 DLL 文件，在类 Unix 系统下是 SO 文件）。这个库文件将被 Java 加载并调用其中的函数。

3. 创建 Java 类：在 Java 中声明 native 方法，并加载动态链接库。在 Java 类中，你需要使用关键字 native 声明方法，以便 JVM 知道这些方法的实现在本地库中。

4. 生成头文件：使用 javah 工具生成与 Java 类对应的头文件，这个头文件包含了 JNI 接口函数的声明，以便在 C++ 代码中引用这些函数。

5. 实现 JNI 方法：在 C++ 中实现 JNI 方法，这些方法与 Java 中的 native 方法相对应。在 JNI 方法中，你可以通过 JNI 函数和数据结构与 Java 代码进行交互。

6. 编译和链接：将 Java 类编译成字节码文件，然后使用 JNI 提供的函数将 Java 代码与本地库链接起来。

7. 运行 Java 代码：运行 Java 代码，在 Java 代码中调用 native 方法，触发 JNI 调用 C++ 代码的过程。

1.windows环境JNI开发

动态链接库与编译器要对应目标操作系统和架构，对于 64 位的 Windows 操作系统，你需要使用 64 位的编译工具链来生成相应的 64 位 DLL 文件。

• 将C/C++实现的方法用native关键字声明

• 用静态代码块进行动态链接库加载

public class JNIDemo {
    public static void main(String[] args) {
        System.out.println(add(100,200));
    }

    public static native int add(int a,int b);

    static {
        System.loadLibrary("JNIDemo");
    }
}

• javac -h ./ JNIDemo.java生成头文件

• 根据.h文件里的声明，创建.cpp文件实现对应的函数

#include "JNIDemo.h"
#include <iostream>
JNIEXPORT jint JNICALL Java_JNIDemo_add(JNIEnv *, jclass, jint a, jint b){
    std::cout << "a = "<< a << std::endl;
    std::cout << "b = "<< b << std::endl;
    std::cout << "CPP算法调用成功:" << std::endl;
    return a + b;
}

• 生成动态库

g++ -o jnidemo.dll -fPIC -shared -I"D:\JAVA\jdk1.8.0\include\win32" -I"D:\JAVA\jdk1.8.0\include" JNIDemo.cpp

运行java文件

2.Android系统JNI开发

在 Android 开发中，直接使用 Java 语言引入 Windows 平台上的 DLL 库是行不通的。这是因为 Android 运行在基于 Linux 内核的移动设备上，并不支持 Windows 上的 DLL 文件。此外，Android 使用的是基于 Java 的 Dalvik 虚拟机（现在是 ART 虚拟机），而不是标准的 Java 虚拟机。

如果想在 Android 应用中使用本地库，可以通过使用 Android NDK 来编写 C/C++ 代码，并将其编译为适用于 Android 平台的共享库（.so 文件）。然后，可以使用 JNI（Java Native Interface）来在 Java 代码中调用这些本地库。

在 Android 开发中，需要使用 Android NDK 提供的工具链（例如 ndk-build 或 CMake）来编译和构建你的 C/C++ 代码，生成适用于 Android 平台的 .so 文件。然后，在 Java 代码中使用 JNI 来加载和调用这些本地库。

1.新建JNI工程

2.下载JNI开发所需工具包

NDK：Native Development Kit(本地开发工具)，一系列工具的集合，这套工具允许你在Android开发中使用C和C++代码。

CMake：跨平台编译工具。

LLDB：一种调试程序，ANDROID STUDIO使用它来调试原生代码。

3.切换到project选项，编写C++算法接口函数

• 声明接口函数

• alt+enter键，在native-lib.cpp中生成该接口函数的实现体:
• 

该接口函数的实现与cpp并不完全相同，如jint表示整型变量，jintArray表示整形数组，因为接口函数是通过JNI编码实现的，JNI与java语言和C语言都能进行交互。

4.构建如下cmake工程

• signalfeature.h代码如下

#ifndef MACHINELEARNING_SIGNALFEATURE_H
#define MACHINELEARNING_SIGNALFEATURE_H
#include <vector>
#include <cmath>
class SignalFeature {
public:
    static double calculateMean(const double* data, int length);//均值
};
#endif //MACHINELEARNING_SIGNALFEATURE_H

• signalfeature.cpp

#include "../includes/signalfeature.h"

// 计算均值
double SignalFeature::calculateMean(const double* data, int length) {
    double sum = 0.0;
    for (int i = 0; i < length; i++) {
        sum += data[i];
    }
    return sum / length;
}

•  内层cmake

cmake_minimum_required(VERSION 3.4.1)
ADD_LIBRARY(signalfeature SHARED signalfeature.cpp)

• 外层cmake

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

add_subdirectory(thirdlib)    # 添加子目录
include_directories(includes) # 头文件搜索路径

add_library( # Sets the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             native-lib.cpp)

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
              log-lib

              # Specifies the name of the NDK library that
              # you want CMake to locate.
              log )

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
                       native-lib
                       signalfeature
                       # Links the target library to the log library
                       # included in the NDK.
                       ${log-lib} )

• native-lib.cpp

extern "C"
JNIEXPORT jdouble JNICALL
Java_com_afison_machinelearning_MainActivity_calculateMean(JNIEnv *env, jobject thiz,
                                                           jdoubleArray data) {
    // TODO: implement calculateMean()
    jboolean isCopy1;
    //获取数组长度
    jsize len = env->GetArrayLength(data);
    double *srcData = env->GetDoubleArrayElements(data,&isCopy1);
    double res = SignalFeature::calculateMean(srcData,len);
    return res;
}

5.MainActivity中调用

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Example of a call to a native method
        TextView tv = findViewById(R.id.sample_text);
        double [] data = {1,2,3,4};
        double res = calculateMean(data);
        tv.setText(String.valueOf(res));
    }
//均值
    public native double calculateMean(double[] data);

6.结果展示

7.总结

这个例子展示了Android系统下，Java语言调用C++算法，当我们开发嵌入式软件时，选用的Android系统作界面展示，若需要使用算法对某些信号处理，就可以用这种方式调用机器学习算法。

3.JNI传参细节

返回值和参数类型根据等价约定映射到本地C/C++类型，如表JNI类型映射所示。有些类型，在本地代码中可直接使用，而其他类型只有通过JNI调用操作。

（int,boolean,String）数组传参

JNI通过JNIEnv提供的操作Java数组的功能。它提供了两个函数：一个是操作java的简单型数组的，另一个是操作对象类型数组的。

对象传参

JNI提供的另外一个功能是在本地代码中使用Java对象。通过使用合适的JNI函数，你可以创建Java对象，get、set 静态(static)和实例（instance）的域，调用静态(static)和实例（instance）函数。JNI通过ID识别域和方法，一个域或方法的ID是任何处理域和方法的函数的必须参数。

下表列出了用以得到静态(static)和实例（instance）的域与方法的JNI函数。每个函数接受（作为参数）域或方法的类，它们的名称，符号和它们对应返回的jfieldID或jmethodID。

函数	描述
GetFieldID	得到一个实例的域的ID
GetStaticFieldID	得到一个静态的域的ID
GetMethodID	得到一个实例的方法的ID
GetStaticMethodID	得到一个静态方法的ID

如果你有了一个类的实例，它就可以通过方法GetObjectClass得到，或者如果你没有这个类的实例，可以通过FindClass得到。符号是从域的类型或者方法的参数，返回值得到字符串，如下表所示。

Java 类型	符号
boolean	Z
byte	B
char	C
short	S
int	I
long	J
float	F
double	D
void	V
objects对象	Lfully-qualified-class-name;L类名
Arrays数组	[array-type [数组类型
methods方法	(argument-types)return-type(参数类型)返回类型

一、在Native层返回一个字符串

Java层原型方法：

public class HelloJni {
    ...
	public native void getAJNIString();
    ...
}	

Native层该方法实现:

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    getAJNIString
 * Signature: ()Ljava/lang/String;
 */ 
//返回字符串
JNIEXPORT jstring JNICALL Java_com_feixun_jni_HelloJni_getAJNIString(JNIEnv * env, jobject obj)
{
    jstring str = env->newStringUTF("HelloJNI");  //直接使用该JNI构造一个jstring对象返回
	return str ;
}

二、在Native层返回一个int型二维数组(int[][])

Java层原型方法：

public class HelloJni {
	...
	//参数代表几行几列数组 ，形式如：int a[dimon][dimon]
	private native int[][] getTwoArray(int dimon) ; 
	...
}	

Native层该方法实现为 :

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    getTwoArray
 * Signature: (I)[[I
 */
//通过构造一个数组的数组， 返回 一个二维数组的形式
JNIEXPORT jobjectArray JNICALL Java_com_feixun_jni_HelloJni_getTwoArray
  (JNIEnv * env, jobject object, jint dimion)
{
	
	jclass intArrayClass = env->FindClass("[I"); //获得一维数组 的类引用，即jintArray类型
	//构造一个指向jintArray类一维数组的对象数组，该对象数组初始大小为dimion
	jobjectArray obejctIntArray  =  env->NewObjectArray(dimion ,intArrayClass , NULL);
 
    //构建dimion个一维数组，并且将其引用赋值给obejctIntArray对象数组
	for( int i = 0 ; i< dimion  ; i++ )
	{
		//构建jint型一维数组
		jintArray intArray = env->NewIntArray(dimion);
 
        jint temp[10]  ;  //初始化一个容器，假设 dimion  < 10 ;
		for( int j = 0 ; j < dimion ; j++)
		{
            temp[j] = i + j  ; //赋值
		}
		
		//设置jit型一维数组的值
        env->SetIntArrayRegion(intArray, 0 , dimion ,temp);
        //给object对象数组赋值，即保持对jint一维数组的引用
		env->SetObjectArrayElement(obejctIntArray , i ,intArray);
 
		env->DeleteLocalRef(intArray);  //删除局部引用
	}
 
    return   obejctIntArray; //返回该对象数组
}

三、在Native层操作Java的类：读取/设置类属性

Java层原型方法：

public class HelloJni {
	...
	//在Native层读取/设置属性值
	public native void native_set_name() ;
	...
	
	private String name = "I am at Java" ; //类属性
}	

Native层该方法实现为 :

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    native_set_name
 * Signature: ()V 
 */
//在Native层操作Java对象，读取/设置属性等
JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_native_1set_1name
  (JNIEnv *env , jobject  obj )  //obj代表执行此JNI操作的类实例引用
{
   //获得jfieldID 以及 该字段的初始值
   jfieldID  nameFieldId ;
 
   jclass cls = env->GetObjectClass(obj);  //获得Java层该对象实例的类引用，即HelloJNI类引用
 
   nameFieldId = env->GetFieldID(cls , "name" , "Ljava/lang/String;"); //获得属性句柄
 
   if(nameFieldId == NULL)
   {
	   cout << " 没有得到name 的句柄Id \n;" ;
   }
   jstring javaNameStr = (jstring)env->GetObjectField(obj ,nameFieldId);  // 获得该属性的值
   const char * c_javaName = env->GetStringUTFChars(javaNameStr , NULL);  //转换为 char *类型
   string str_name = c_javaName ;  
   cout << "the name from java is " << str_name << endl ; //输出显示
   env->ReleaseStringUTFChars(javaNameStr , c_javaName);  //释放局部引用
 
   //构造一个jString对象
   char * c_ptr_name = "I come from Native" ;
   
   jstring cName = env->NewStringUTF(c_ptr_name); //构造一个jstring对象
 
   env->SetObjectField(obj , nameFieldId , cName); // 设置该字段的值
}

四、在Native层操作Java层的类:回调Java方法

Java层原型方法：

public class HelloJni {
	...
	//Native层回调的方法实现
	public void callback(String fromNative){	 
	    System.out.println(" I was invoked by native method  ############# " + fromNative);
	};
	public native void doCallBack(); //Native层会调用callback()方法
	...	
	
	// main函数
	public static void main(String[] args) 
	{
		new HelloJni().ddoCallBack();
	}	
}	

Native层该方法实现为 :

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    doCallBack
 * Signature: ()V
 */
//Native层回调Java类方法
JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_doCallBack
  (JNIEnv * env , jobject obj)
{
     //回调Java中的方法
 
	jclass cls = env->GetObjectClass(obj);//获得Java类实例
    jmethodID callbackID = env->GetMethodID(cls , "callback" , "(Ljava/lang/String;)V") ;//或得该回调方法句柄
 
	if(callbackID == NULL)
	{
		 cout << "getMethodId is failed \n" << endl ;
	}
  
	jstring native_desc = env->NewStringUTF(" I am Native");
 
	env->CallVoidMethod(obj , callbackID , native_desc); //回调该方法，并且传递参数值
}

 接下来，我们会操作复杂对象，也就是Java层的类，包括从Native层返回一个类以及传递一个类到Native层去， 这儿我们

Student.java类

package com.feixun.jni;
 
public class Student
{
    private int age ;
    private String name ;
    //构造函数，什么都不做
    public Student(){ }
    
    public Student(int age ,String name){
        this.age = age ;
        this.name = name ;
    }
    
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    
    public String toString(){
        return "name --- >" + name + "  age --->" + age ;
    }
}

五、在Native层返回一个复杂对象(即一个类咯)

Java层的方法对应为：

public class HelloJni {
	...
	//在Native层返回一个Student对象
	public native Student nativeGetStudentInfo() ;
	...	
}	

Native层该方法实现为 :        

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    nativeGetStudentInfo
 * Signature: ()Lcom/feixun/jni/Student;
 */
//返回一个复杂对象
JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_nativeGetStudentInfo
  (JNIEnv * env, jobject obl)
{
	//关于包描述符，这儿可以是 com/feixun/jni/Student 或者是 Lcom/feixun/jni/Student; 
	//   这两种类型 都可以获得class引用
	jclass stucls = env->FindClass("com/feixun/jni/Student"); //或得Student类引用
 
	//获得得该类型的构造函数  函数名为 <init> 返回类型必须为 void 即 V
	jmethodID constrocMID = env->GetMethodID(stucls,"<init>","(ILjava/lang/String;)V");
 
	jstring str = env->NewStringUTF(" come from Native ");
 
    jobject stu_ojb = env->NewObject(stucls,constrocMID,11,str);  //构造一个对象，调用该类的构造函数，并且传递参数
 
 
    return stu_ojb ;
}

六、从Java层传递复杂对象至Native层

Java层的方法对应为：

public class HelloJni {
	...
	//在Native层打印Student的信息
	public native void  printStuInfoAtNative(Student stu);
	...	
}

 Native层该方法实现为 :       

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    printStuInfoAtNative
 * Signature: (Lcom/feixun/jni/Student;)V
 */
//在Native层输出Student的信息
JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_printStuInfoAtNative
  (JNIEnv * env, jobject obj,  jobject obj_stu) //第二个类实例引用代表Student类，即我们传递下来的对象
{
	
    jclass stu_cls = env->GetObjectClass(obj_stu); //或得Student类引用
 
	if(stu_cls == NULL)
	{
     	cout << "GetObjectClass failed \n" ;
	}
	//下面这些函数操作，我们都见过的。O(∩_∩)O~
	jfieldID ageFieldID = env->GetFieldID(stucls,"age","I"); //获得得Student类的属性id 
    jfieldID nameFieldID = env->GetFieldID(stucls,"name","Ljava/lang/String;"); // 获得属性ID
 
	jint age = env->GetIntField(objstu , ageFieldID);  //获得属性值
	jstring name = (jstring)env->GetObjectField(objstu , nameFieldID);//获得属性值
 
    const char * c_name = env->GetStringUTFChars(name ,NULL);//转换成 char *
 
	string str_name = c_name ; 
    env->ReleaseStringUTFChars(name,c_name); //释放引用
    
	cout << " at Native age is :" << age << " # name is " << str_name << endl ; 
}

七、在Native层返回集合对象

 Java层的对应方法为：

public class HelloJni {
	...
	//在Native层返回ArrayList集合 
	public native ArrayList<Student> native_getListStudents();
	...	
}	

Native层该方法实现为 :        

/*
 * Class:     com_feixun_jni_HelloJni
 * Method:    native_getListStudents
 * Signature: ()Ljava/util/ArrayList;
 */ //获得集合类型的数组
JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_native_getListStudents
  (JNIEnv * env, jobject obj)
{
    jclass list_cls = env->FindClass("Ljava/util/ArrayList;");//获得ArrayList类引用
 
	if(listcls == NULL)
    {
		cout << "listcls is null \n" ;
	}
    jmethodID list_costruct = env->GetMethodID(list_cls , "<init>","()V"); //获得得构造函数Id
 
	jobject list_obj = env->NewObject(list_cls , list_costruct); //创建一个Arraylist集合对象
    //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ;
	jmethodID list_add  = env->GetMethodID(list_cls,"add","(Ljava/lang/Object;)Z"); 
  
	jclass stu_cls = env->FindClass("Lcom/feixun/jni/Student;");//获得Student类引用
	//获得该类型的构造函数  函数名为 <init> 返回类型必须为 void 即 V
	jmethodID stu_costruct = env->GetMethodID(stu_cls , "<init>", "(ILjava/lang/String;)V");
 
    for(int i = 0 ; i < 3 ; i++)
	{
	    jstring str = env->NewStringUTF("Native");
		//通过调用该对象的构造函数来new 一个 Student实例
        jobject stu_obj = env->NewObject(stucls , stu_costruct , 10,str);  //构造一个对象
        
        env->CallBooleanMethod(list_obj , list_add , stu_obj); //执行Arraylist类实例的add方法，添加一个stu对象
	}
 
	return list_obj ;
}