package org.qftm.learn.jni.demo1;

/**
 * Created by IntelliJ IDEA.
 * User: Qftm
 * Date: 2022/5/11
 * Time: 17:36
 */

public class IntSum {
    // 声明 native 本地函数
    public native int sums(int num1, int num2);
    // 静态代码块，加载动态链接库
    static {
        System.loadLibrary("IntSum");
    }

    public static void main(String[] args) {
        // 实例化调用 native 本地函数
        System.out.println((new IntSum()).sums(10, 5));
    }
}

λ Qftm >>>: javac org\qftm\learn\jni\demo1\IntSum.java

λ Qftm >>>: javah -o IntSum.h org.qftm.learn.jni.demo1.IntSum

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

#ifndef _Included_org_qftm_learn_jni_demo1_IntSum
#define _Included_org_qftm_learn_jni_demo1_IntSum
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     org_qftm_learn_jni_demo1_IntSum
 * Method:    sums
 * Signature: (II)D
 */
JNIEXPORT jdouble JNICALL Java_org_qftm_learn_jni_demo1_IntSum_sums (JNIEnv *, jobject, jint, jint);

#ifdef __cplusplus
}
#endif
#endif

// define1.h 定义自定义函数
extern "C" {
    int add1(int num1, int num2);
    void info1(char* name, int age);
}

int add2(int num1, int num2);
void info2(char* name, int age);


// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include "stdio.h"
#include "define1.h"

int add1(int num1, int num2) {
    return num1 + num2;
}

void info1(char* name, int age) {
    printf("");
}

int add2(int num1, int num2) {
    return num1 + num2;
}

void info2(char* name, int age) {
    printf("");
}

int add2(int num1, int num2)      ->    ?add2@@YAHHH@Z
void info2(char* name, int age)   ->    ?info2@@YAXPADH@Z

/*
 * Class:     org_qftm_learn_jni_demo1_IntSum
 * Method:    sums
 * Signature: (II)D
 */
JNIEXPORT jdouble JNICALL Java_org_qftm_learn_jni_demo1_IntSum_sums (JNIEnv *, jobject, jint, jint);

Class:     对应的Java层Class完整类
Method:    对应的Java层Native方法
Signature: 对应的Java层Native方法的签名

// Windows JDK 1.8
#define JNIEXPORT __declspec(dllexport)
#define JNIIMPORT __declspec(dllimport)
#define JNICALL __stdcall

// Linux JDK 1.8
#if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility)
  #define JNIEXPORT     __attribute__((visibility("default")))
  #define JNIIMPORT     __attribute__((visibility("default")))
#else
  #define JNIEXPORT
  #define JNIIMPORT
#endif

#define JNICALL

default：表示外部可见，类似于public修饰符，可以被外部发现调用
hidden ：表示隐藏，类似于private修饰符，只能被内部发现调用

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <stdio.h>
#include "intsum.h"

// JNIEnv *env 为JVM环境指针, 用于和JVM交互、jobject obj 表示当前操作的对象
JNIEXPORT jdouble JNICALL Java_org_qftm_learn_jni_demo1_IntSum_sums(JNIEnv* env, jobject obj, jint num1, jint num2) {
   return num1+num2;
}

// java
public native double sums(int num1, int num2);

// c++
JNIEXPORT jdouble JNICALL Java_org_qftm_learn_jni_demo1_IntSum_sums(JNIEnv*, jobject, jint, jint);

/*
 * JNI Native Method Interface.
 */

struct JNINativeInterface_;

struct JNIEnv_;

#ifdef __cplusplus   // C++
typedef JNIEnv_ JNIEnv;
#else                // C
typedef const struct JNINativeInterface_ *JNIEnv;
#endif

/*
 * We use inlined functions for C++ so that programmers can write:
 *
 *    env->FindClass("java/lang/String")
 *
 * in C++ rather than:
 *
 *    (*env)->FindClass(env, "java/lang/String")
 *
 * in C.
 */

struct JNIEnv_ {
    const struct JNINativeInterface_ *functions;
#ifdef __cplusplus

    jint GetVersion() {
        return functions->GetVersion(this);
    }
    jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
                       jsize len) {
        return functions->DefineClass(this, name, loader, buf, len);
    }
    jclass FindClass(const char *name) {
        return functions->FindClass(this, name);
    }
    jmethodID FromReflectedMethod(jobject method) {
        return functions->FromReflectedMethod(this,method);
    }
    jfieldID FromReflectedField(jobject field) {
        return functions->FromReflectedField(this,field);
    }

    jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
        return functions->ToReflectedMethod(this, cls, methodID, isStatic);
    }
    .......

/*
 * JNI Invocation Interface.
 */

struct JNIInvokeInterface_;

struct JavaVM_;

#ifdef __cplusplus
typedef JavaVM_ JavaVM;
#else
typedef const struct JNIInvokeInterface_ *JavaVM;
#endif

struct JNINativeInterface_ {
    void *reserved0;
    void *reserved1;
    void *reserved2;

    void *reserved3;
    jint (JNICALL *GetVersion)(JNIEnv *env);

    jclass (JNICALL *DefineClass)
      (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
       jsize len);
    jclass (JNICALL *FindClass)
      (JNIEnv *env, const char *name);

    jmethodID (JNICALL *FromReflectedMethod)
      (JNIEnv *env, jobject method);
    jfieldID (JNICALL *FromReflectedField)
      (JNIEnv *env, jobject field);

    jobject (JNICALL *ToReflectedMethod)
      (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
    .....

// Windows JDK 1.8
/*
 * JNI Types
 */

#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H

typedef unsigned char   jboolean;
typedef unsigned short  jchar;
typedef short           jshort;
typedef float           jfloat;
typedef double          jdouble;

typedef jint            jsize;

#ifdef __cplusplus

class _jobject {};
class _jclass : public _jobject {};
class _jthrowable : public _jobject {};
class _jstring : public _jobject {};
class _jarray : public _jobject {};
class _jbooleanArray : public _jarray {};
class _jbyteArray : public _jarray {};
class _jcharArray : public _jarray {};
class _jshortArray : public _jarray {};
class _jintArray : public _jarray {};
class _jlongArray : public _jarray {};
class _jfloatArray : public _jarray {};
class _jdoubleArray : public _jarray {};
class _jobjectArray : public _jarray {};

typedef _jobject *jobject;
typedef _jclass *jclass;
typedef _jthrowable *jthrowable;
typedef _jstring *jstring;
typedef _jarray *jarray;
typedef _jbooleanArray *jbooleanArray;
typedef _jbyteArray *jbyteArray;
typedef _jcharArray *jcharArray;
typedef _jshortArray *jshortArray;
typedef _jintArray *jintArray;
typedef _jlongArray *jlongArray;
typedef _jfloatArray *jfloatArray;
typedef _jdoubleArray *jdoubleArray;
typedef _jobjectArray *jobjectArray;

#else

struct _jobject;

typedef struct _jobject *jobject;
typedef jobject jclass;
typedef jobject jthrowable;
typedef jobject jstring;
typedef jobject jarray;
typedef jarray jbooleanArray;
typedef jarray jbyteArray;
typedef jarray jcharArray;
typedef jarray jshortArray;
typedef jarray jintArray;
typedef jarray jlongArray;
typedef jarray jfloatArray;
typedef jarray jdoubleArray;
typedef jarray jobjectArray;

#endif

typedef jobject jweak;

typedef union jvalue {
    jboolean z;
    jbyte    b;
    jchar    c;
    jshort   s;
    jint     i;
    jlong    j;
    jfloat   f;
    jdouble  d;
    jobject  l;
} jvalue;

struct _jfieldID;
typedef struct _jfieldID *jfieldID;

struct _jmethodID;
typedef struct _jmethodID *jmethodID;

(1) 如果是字段，表示字段类型的描述符
(2) 如果是函数，表示函数结构的描述符，即：(每个参数类型描述符) + 返回值类型描述符

// Signature: (II)D
public native double sums(int num1, int num2);

// int 类型描述符：I
// double 类型描述符：D
// 参数字段类型描述符：II
// 函数结构描述符：(II)D

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }
    .......

// openjdk\jdk\src\share\native\java\lang\Object.c

static JNINativeMethod methods[] = {
    {"hashCode",    "()I",                    (void *)&JVM_IHashCode},
    {"wait",        "(J)V",                   (void *)&JVM_MonitorWait},
    {"notify",      "()V",                    (void *)&JVM_MonitorNotify},
    {"notifyAll",   "()V",                    (void *)&JVM_MonitorNotifyAll},
    {"clone",       "()Ljava/lang/Object;",   (void *)&JVM_Clone},
};

JNIEXPORT void JNICALL
Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
{
    (*env)->RegisterNatives(env, cls,
                            methods, sizeof(methods)/sizeof(methods[0]));
}

JNIEXPORT jclass JNICALL
Java_java_lang_Object_getClass(JNIEnv *env, jobject this)
{
    if (this == NULL) {
        JNU_ThrowNullPointerException(env, NULL);
        return 0;
    } else {
        return (*env)->GetObjectClass(env, this);
    }
}

/*
 * used in RegisterNatives to describe native method name, signature,
 * and function pointer.
 */

typedef struct {
    char *name;
    char *signature;
    void *fnPtr;
} JNINativeMethod;

(1) Java 类中声明一个 registerNatives() 静态Java Native方法
(2) 动态链接库中定义一个JNI动态注册的映射表，JNINativeMethod 类型的结构体数组
(3) 动态链接库中定义并实现一个符合JNI静态注册规则的 Java_<PackageName>_<ClassName>_registerNatives C/C++方法
(4) Java 类中通过静态块加载相应动态链接库
(5) Java 类中通过静态块调用 registerNatives() 静态Java Native方法
(6) JNI 动态注册开始，Java_<PackageName>_<ClassName>_registerNatives C/C++方法调用JNI动态注册接口 RegisterNatives()
(7) JNI 动态注册完成，Java 类中可调用相应JNI动态注册的Native方法

package org.qftm.learn.jni.demo2;

/**
 * Created by IntelliJ IDEA.
 * User: Qftm
 * Date: 2022/6/6
 * Time: 21:34
 */

public class Multi {
    // 声明 registerNatives() 静态Java Native方法
    private static native void registerNatives();
    // 声明 multi 静态Java Native方法
    public static native double multi(int num1, double num2);

    static {
        // 静态块加载动态链接库
        System.loadLibrary("demo2");
        // 通过JNI静态命名规则进行查找调用
        registerNatives();
    }

    public static void main(String[] args) {
        // 通过JNI动态注册映射表进行查找调用
        System.out.println(multi(2, 3.3));
    }
}

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

#ifndef _Included_org_qftm_learn_jni_demo2_Multi
#define _Included_org_qftm_learn_jni_demo2_Multi
#ifdef __cplusplus
extern "C" {
#endif
    /*
     * Class:     org_qftm_learn_jni_demo2_Multi
     * Method:    registerNatives
     * Signature: ()V
     */
    JNIEXPORT void JNICALL Java_org_qftm_learn_jni_demo2_Multi_registerNatives (JNIEnv*, jclass);

#ifdef __cplusplus
}
#endif
#endif

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <stdio.h>
#include "multi.h"

jdouble MultiNumber(JNIEnv* env, jclass cls, jint num1, jdouble num2) {
    return num1 * num2;
}

// typedef struct { char *name; char *signature; void *fnPtr;} JNINativeMethod;
static JNINativeMethod methods[] = {
    {(char*)"multi", (char*)"(ID)D", (void*)MultiNumber},
};

// C: env->FindClass("java/lang/String")、C++: (*env)->FindClass(env, "java/lang/String")
// jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, jint nMethods)
// jclass clazz: Java Native 层对应的类
// const JNINativeMethod *methods: 结构体数组，数组的元素是JNI定义的一个结构体 JNINativeMethod
// jint nMethods: methods 结构体数组的大小
JNIEXPORT void JNICALL Java_org_qftm_learn_jni_demo2_Multi_registerNatives(JNIEnv* env, jclass cls) {
    env->RegisterNatives(cls, methods, sizeof(methods) / sizeof(methods[0]));
}

(1) 动态链接库中定义一个JNI动态注册的映射表，JNINativeMethod 类型的结构体数组
(2) 动态链接库中重写 JNI_OnLoad() 方法
(3) Java 类中通过静态块加载相应动态链接库
(4) JNI 动态注册开始，JNI_OnLoad() 方法调用JNI动态注册接口 RegisterNatives()
(5) JNI 动态注册完成，Java 类中可调用相应JNI动态注册的Native方法

package org.qftm.learn.jni.demo3;

/**
 * Created by IntelliJ IDEA.
 * User: Qftm
 * Date: 2022/6/7
 * Time: 7:54
 */

public class Sub {
    // 声明 sub 静态Java Native方法
    public static native double sub(int num1, double num2);

    static {
        // 静态块加载动态链接库
        System.loadLibrary("demo3");
    }

    public static void main(String[] args) {
        // 通过JNI动态注册映射表进行查找调用
        System.out.println(sub(8, 3.4));
    }
}

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <jni.h>

jdouble SubNumber(JNIEnv* env, jclass cls, jint num1, jdouble num2) {
    return num1 - num2;
}

// typedef struct { char *name; char *signature; void *fnPtr;} JNINativeMethod;
static JNINativeMethod methods[] = {
    {(char*)"sub", (char*)"(ID)D", (void*)SubNumber},
};

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env = NULL;

    // 获取 JNIENV
    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK)
    {
        return -1;
    }

    // 获取 Java Native 对应的 Class
    jclass jClassName = env->FindClass("org/qftm/learn/jni/demo3/Sub");

    // C: env->FindClass("java/lang/String")、C++: (*env)->FindClass(env, "java/lang/String")
    // jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, jint nMethods)
    // jclass clazz: Java Native 层对应的类
    // const JNINativeMethod *methods: 结构体数组，数组的元素是JNI定义的一个结构体 JNINativeMethod
    // jint nMethods: methods 结构体数组的大小
    jint ret = env->RegisterNatives(jClassName, methods, sizeof(methods)/sizeof(methods[0]));

    return JNI_VERSION_1_6;
}