JNI方法调用 ⭐⭐

// JNI 提供的 FindClass 函数原型
// 参数 env  : 指向 JNI 函数表的环境指针，每个 Native 方法都会自动接收
// 参数 name : 目标类的全限定名（使用 '/' 替代 '.'）
// 返回值    : 成功时返回 jclass（类引用），失败时返回 NULL
jclass FindClass(JNIEnv *env, const char *name);

// Java 层：定义一个简单的 User 类
package com.example;
 
public class User {
    public String name;     // 用户名
    public int age;         // 年龄
 
    public void greet() {   // 打招呼方法
        System.out.println("Hello, I am " + name);
    }
}

// native-lib.c
#include <jni.h>
#include <android/log.h>
 
// 定义日志宏，方便输出调试信息
#define TAG "JNI_FindClass"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
 
// Native 方法实现：演示 FindClass 的基本用法
JNIEXPORT void JNICALL
Java_com_example_MainActivity_testFindClass(JNIEnv *env, jobject thiz) {
 
    // 第一步：使用 FindClass 查找 User 类
    // 注意：包名用 '/' 分隔，而不是 '.'
    jclass userClass = (*env)->FindClass(env, "com/example/User");
 
    // 第二步：必须检查返回值是否为 NULL（类可能不存在或未加载）
    if (userClass == NULL) {
        // FindClass 失败，JVM 会自动抛出 ClassNotFoundException
        // 此时应立即返回，让异常传播回 Java 层
        LOGE("FindClass failed: com/example/User not found!");
        return;  // 直接返回，异常会在 Java 层被捕获
    }
 
    // 第三步：成功获取类引用，可以继续后续操作
    LOGI("FindClass succeeded! jclass = %p", userClass);
 
    // 后续可以用 userClass 去获取方法ID、字段ID、创建对象等
    // ... (后续章节详细讲解)
}

// native-lib.cpp（C++ 版本）
extern "C" JNIEXPORT void JNICALL
Java_com_example_MainActivity_testFindClass(JNIEnv *env, jobject thiz) {
 
    // C++ 版本：直接用 env-> 调用，无需解引用和传入 env
    jclass userClass = env->FindClass("com/example/User");
 
    // 空指针检查逻辑与 C 版本完全相同
    if (userClass == NULL) {
        // 打印错误日志并返回
        __android_log_print(ANDROID_LOG_ERROR, "JNI", "FindClass failed!");
        return;
    }
 
    // 成功后继续操作...
}

// ❌ 错误示范：在 Native 线程中直接调用 FindClass
#include <pthread.h>
#include <jni.h>
 
// 全局变量：缓存 JavaVM 指针（整个进程生命周期有效）
static JavaVM *g_jvm = NULL;
 
// JNI_OnLoad：库被加载时由 JVM 自动调用
// 这是缓存 JavaVM 指针的标准位置
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    g_jvm = vm;          // 保存 JavaVM 指针到全局变量
    return JNI_VERSION_1_6;  // 返回支持的 JNI 版本
}
 
// Native 线程的入口函数
void *background_task(void *arg) {
    JNIEnv *env = NULL;
 
    // 将当前 Native 线程附加（Attach）到 JVM，获取 JNIEnv*
    (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 
    // ❌ 这里大概率会失败！
    // 原因：当前线程是 Native 创建的，调用栈上没有 Java 帧
    // JVM 会使用 System ClassLoader，它找不到应用自定义类
    jclass cls = (*env)->FindClass(env, "com/example/User");
    // cls 很可能为 NULL，且 JVM 会抛出 ClassNotFoundException
 
    // 从 JVM 分离当前线程（必须在线程退出前调用）
    (*g_jvm)->DetachCurrentThread(g_jvm);
    return NULL;
}
 
// 某个被 Java 调用的 Native 方法，它启动了后台线程
JNIEXPORT void JNICALL
Java_com_example_MainActivity_startBackgroundTask(JNIEnv *env, jobject thiz) {
    pthread_t tid;
    // 创建一个新的 Native 线程
    pthread_create(&tid, NULL, background_task, NULL);
}

// ✅ 正确做法：在 JNI_OnLoad 中缓存需要的 jclass
#include <jni.h>
#include <pthread.h>
#include <android/log.h>
 
#define TAG "JNI_Cache"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
 
// 全局变量区：缓存 JavaVM 和常用的 jclass
static JavaVM *g_jvm = NULL;        // JavaVM 指针（进程级唯一）
static jclass g_userClass = NULL;   // 缓存的 User 类全局引用
 
// JNI_OnLoad：Native 库被加载时的初始化入口
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    g_jvm = vm;  // 保存 JavaVM 指针
 
    JNIEnv *env = NULL;
    // 从 JavaVM 获取当前线程的 JNIEnv 指针
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;  // 获取失败，返回错误
    }
 
    // 此时调用栈上有 Java 帧，FindClass 可以正确使用应用的 ClassLoader
    jclass localRef = (*env)->FindClass(env, "com/example/User");
    if (localRef == NULL) {
        return JNI_ERR;  // 类不存在，初始化失败
    }
 
    // ⚠️ 关键步骤：将 Local Reference 转为 Global Reference
    // Local Reference 在当前 Native 方法返回后就会失效
    // Global Reference 则在整个进程生命周期内有效（直到手动 DeleteGlobalRef）
    g_userClass = (jclass)(*env)->NewGlobalRef(env, localRef);
 
    // 删除不再需要的 Local Reference（释放局部引用表的槽位）
    (*env)->DeleteLocalRef(env, localRef);
 
    LOGI("JNI_OnLoad: User class cached successfully.");
    return JNI_VERSION_1_6;  // 返回支持的 JNI 版本
}
 
// JNI_OnUnload：库被卸载时的清理入口（可选但推荐）
void JNI_OnUnload(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) == JNI_OK) {
        // 释放全局引用，防止内存泄漏
        if (g_userClass != NULL) {
            (*env)->DeleteGlobalRef(env, g_userClass);
            g_userClass = NULL;  // 置空，防止野指针
        }
    }
}
 
// Native 线程入口函数
void *background_task(void *arg) {
    JNIEnv *env = NULL;
    // 附加当前线程到 JVM
    (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 
    // ✅ 直接使用缓存的全局引用，不再需要 FindClass
    // g_userClass 是 Global Reference，任何线程都可以安全使用
    if (g_userClass != NULL) {
        LOGI("background_task: Using cached User class = %p", g_userClass);
        // 可以正常使用 g_userClass 获取方法ID、创建对象等
    }
 
    // 从 JVM 分离当前线程
    (*g_jvm)->DetachCurrentThread(g_jvm);
    return NULL;
}

// 演示：循环中的 Local Reference 管理
JNIEXPORT void JNICALL
Java_com_example_MainActivity_batchProcess(JNIEnv *env, jobject thiz) {
    for (int i = 0; i < 1000; i++) {
        // 每次循环都会创建一个新的 Local Reference
        jclass cls = (*env)->FindClass(env, "com/example/Item");
 
        // ... 使用 cls 做一些操作 ...
 
        // ⚠️ 必须手动释放，否则循环 1000 次会耗尽 Local Ref Table
        (*env)->DeleteLocalRef(env, cls);
    }
    // 更好的做法：将 FindClass 提到循环外面，只调用一次
}

// 查找各种数组类型
JNIEXPORT void JNICALL
Java_com_example_MainActivity_testArrayClasses(JNIEnv *env, jobject thiz) {
 
    // 一维 int 数组：int[]
    // 描述符为 "[I"（[ 表示数组，I 表示 int）
    jclass intArrayClass = (*env)->FindClass(env, "[I");
 
    // 一维 String 数组：String[]
    // 描述符为 "[Ljava/lang/String;"（L 开头 ; 结尾表示对象类型）
    jclass stringArrayClass = (*env)->FindClass(env, "[Ljava/lang/String;");
 
    // 二维 int 数组：int[][]
    // 描述符为 "[[I"（两个 [ 表示二维数组）
    jclass int2dArrayClass = (*env)->FindClass(env, "[[I");
 
    // 二维 String 数组：String[][]
    // 描述符为 "[[Ljava/lang/String;"
    jclass string2dArrayClass = (*env)->FindClass(env, "[[Ljava/lang/String;");
 
    // 注意：基本类型（int, float, boolean 等）本身不是类，
    // 不能用 FindClass("int") 查找。
    // 如果需要基本类型的 Class 对象，应通过字段访问：
    // 例如 java.lang.Integer.TYPE 对应 int.class
}

// 健壮的 FindClass 封装函数
// 统一处理查找失败的情况，返回全局引用或 NULL
static jclass findClassOrDie(JNIEnv *env, const char *className) {
    // 尝试查找目标类
    jclass localRef = (*env)->FindClass(env, className);
 
    // 检查是否有挂起的异常
    if ((*env)->ExceptionCheck(env)) {
        // 打印异常的堆栈信息到 logcat（调试用）
        (*env)->ExceptionDescribe(env);
        // 清除挂起的异常，允许后续 JNI 调用正常进行
        (*env)->ExceptionClear(env);
        return NULL;  // 返回 NULL 表示失败
    }
 
    // 转为全局引用并返回（调用者负责在不需要时 DeleteGlobalRef）
    jclass globalRef = (jclass)(*env)->NewGlobalRef(env, localRef);
    // 释放局部引用
    (*env)->DeleteLocalRef(env, localRef);
 
    return globalRef;
}
 
// 使用示例
JNIEXPORT void JNICALL
Java_com_example_MainActivity_safeDemo(JNIEnv *env, jobject thiz) {
 
    // 使用封装函数安全地获取类引用
    jclass userClass = findClassOrDie(env, "com/example/User");
    if (userClass == NULL) {
        // 可以选择抛出自定义异常回 Java 层
        jclass exCls = (*env)->FindClass(env, "java/lang/RuntimeException");
        if (exCls != NULL) {
            // ThrowNew：创建并抛出指定异常，附带错误信息
            (*env)->ThrowNew(env, exCls, "Failed to find User class in JNI");
            (*env)->DeleteLocalRef(env, exCls);
        }
        return;
    }
 
    // 正常使用 userClass ...
    // 用完后释放全局引用
    (*env)->DeleteGlobalRef(env, userClass);
}

// 推荐模式：批量缓存初始化
// 定义一个结构体来管理所有缓存
typedef struct {
    jclass userClass;       // com/example/User
    jclass orderClass;      // com/example/Order
    jclass networkClass;    // com/example/NetworkHelper
    // ... 按需添加更多
} JniClassCache;
 
// 全局唯一的缓存实例
static JniClassCache g_cache = {0};
 
// 批量初始化函数
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env;
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;
    }
 
    // 宏定义简化重复的查找与缓存逻辑
    #define CACHE_CLASS(field, name) do {                              \
        jclass local = (*env)->FindClass(env, name);                  \
        if (local == NULL) return JNI_ERR;                            \
        g_cache.field = (jclass)(*env)->NewGlobalRef(env, local);     \
        (*env)->DeleteLocalRef(env, local);                           \
    } while(0)
 
    // 一次性缓存所有需要的类
    CACHE_CLASS(userClass,    "com/example/User");
    CACHE_CLASS(orderClass,   "com/example/Order");
    CACHE_CLASS(networkClass, "com/example/NetworkHelper");
 
    #undef CACHE_CLASS  // 取消宏定义，避免污染
 
    return JNI_VERSION_1_6;
}

void *worker(void *arg) {
    JNIEnv *env;
    (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);       // Line 1
    jclass cls = (*env)->FindClass(env, "com/example/Foo");  // Line 2
    jmethodID mid = (*env)->GetMethodID(env, cls, "<init>", "()V"); // Line 3
    jobject obj = (*env)->NewObject(env, cls, mid);          // Line 4
    (*g_jvm)->DetachCurrentThread(g_jvm);                    // Line 5
    return NULL;
}

┌─────────────────────────────────────────────────────┐
│              JVM Metaspace (方法区)                   │
│  ┌───────────────────────────────────────────────┐  │
│  │         Class: com.example.Calculator         │  │
│  │  ┌─────────────────────────────────────────┐  │  │
│  │  │  Method Table (方法表)                   │  │  │
│  │  │  ┌───────┬──────────────────────────┐   │  │  │
│  │  │  │ idx 0 │ <init>()V       ──────────┼─► jmethodID_0  │
│  │  │  ├───────┼──────────────────────────┤   │  │  │
│  │  │  │ idx 1 │ add(II)I        ──────────┼─► jmethodID_1  │
│  │  │  ├───────┼──────────────────────────┤   │  │  │
│  │  │  │ idx 2 │ multiply(II)I   ──────────┼─► jmethodID_2  │
│  │  │  └───────┴──────────────────────────┘   │  │  │
│  │  └─────────────────────────────────────────┘  │  │
│  └───────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

// JNI 函数签名
jmethodID GetMethodID(JNIEnv *env,      // JNI 环境指针
                      jclass clazz,      // 目标类的 jclass 引用
                      const char *name,  // 方法名（UTF-8 字符串）
                      const char *sig);  // 方法签名（JNI 类型签名）

// Java 层：一个简单的计算器类
public class Calculator {
    // 实例方法：两数相加
    public int add(int a, int b) {
        return a + b;
    }
 
    // 实例方法：带有 String 返回值
    public String describe(String operation, int result) {
        return operation + " = " + result;
    }
 
    // 构造方法
    public Calculator() {
        System.out.println("Calculator created!");
    }
}

#include <jni.h>
#include <cstdio>
 
// Native 方法：演示 GetMethodID 获取实例方法
JNIEXPORT void JNICALL
Java_com_example_NativeLib_testGetMethodID(JNIEnv *env, jobject thiz) {
 
    // ========== 第一步：获取目标类的 jclass ==========
    // FindClass 接受 JNI 格式的类全限定名（用 '/' 替代 '.'）
    jclass calcClass = env->FindClass("com/example/Calculator");
 
    // 检查 FindClass 是否成功
    if (calcClass == nullptr) {
        // 如果类找不到，JVM 已抛出 ClassNotFoundException
        return; // 直接返回，让异常传播回 Java 层
    }
 
    // ========== 第二步：获取实例方法 add(int, int) 的方法ID ==========
    // 方法名: "add"
    // 签名: "(II)I" 表示接受两个 int，返回一个 int
    jmethodID addMethod = env->GetMethodID(calcClass,  // 目标类
                                           "add",      // 方法名
                                           "(II)I");   // 方法签名
 
    // 必须检查返回值！失败时 addMethod == NULL
    if (addMethod == nullptr) {
        // JVM 已抛出 NoSuchMethodError
        printf("ERROR: Cannot find method 'add(II)I'\n");
        return; // 让异常传播
    }
 
    // 此时 addMethod 是一个有效的方法ID，可以用于后续 CallIntMethod 调用
    printf("Successfully obtained method ID for 'add': %p\n", addMethod);
 
    // ========== 第三步：获取 describe(String, int) 的方法ID ==========
    // 签名: "(Ljava/lang/String;I)Ljava/lang/String;"
    // L + 全限定类名 + ; 表示对象类型
    jmethodID describeMethod = env->GetMethodID(
        calcClass,                                  // 目标类
        "describe",                                 // 方法名
        "(Ljava/lang/String;I)Ljava/lang/String;"); // 方法签名
 
    // 检查
    if (describeMethod == nullptr) {
        printf("ERROR: Cannot find method 'describe'\n");
        return;
    }
 
    printf("Successfully obtained method ID for 'describe': %p\n", describeMethod);
 
    // ========== 第四步：获取构造方法的方法ID ==========
    // 构造方法的方法名固定为 "<init>"
    // 无参构造的签名为 "()V"（无参数，返回 void）
    jmethodID constructor = env->GetMethodID(calcClass,  // 目标类
                                             "<init>",   // 构造方法固定名
                                             "()V");     // 无参构造签名
 
    if (constructor == nullptr) {
        printf("ERROR: Cannot find constructor\n");
        return;
    }
 
    printf("Successfully obtained constructor ID: %p\n", constructor);
}

// JNI 函数签名
jmethodID GetStaticMethodID(JNIEnv *env,      // JNI 环境指针
                            jclass clazz,      // 目标类的 jclass 引用
                            const char *name,  // 静态方法名
                            const char *sig);  // 方法签名

// Java 层：包含静态方法的工具类
public class MathUtils {
    // 静态方法：计算阶乘
    public static long factorial(int n) {
        long result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }
 
    // 静态方法：带有对象参数
    public static String formatResult(String label, double value) {
        return label + ": " + value;
    }
}

#include <jni.h>
 
// Native 方法：演示 GetStaticMethodID
JNIEXPORT void JNICALL
Java_com_example_NativeLib_testGetStaticMethodID(JNIEnv *env, jobject thiz) {
 
    // 第一步：获取 MathUtils 类
    jclass mathClass = env->FindClass("com/example/MathUtils");
    if (mathClass == nullptr) {
        return; // ClassNotFoundException 已抛出
    }
 
    // 第二步：获取静态方法 factorial(int) 的方法ID
    // 注意：此处必须使用 GetStaticMethodID 而不是 GetMethodID
    // 签名: "(I)J" — 接受 int，返回 long (J)
    jmethodID factorialMethod = env->GetStaticMethodID(
        mathClass,      // 目标类
        "factorial",    // 静态方法名
        "(I)J");        // 签名：int -> long
 
    if (factorialMethod == nullptr) {
        return; // NoSuchMethodError 已抛出
    }
 
    // 第三步：获取 formatResult(String, double) 的方法ID
    // 签名: "(Ljava/lang/String;D)Ljava/lang/String;"
    // D 表示 double 类型
    jmethodID formatMethod = env->GetStaticMethodID(
        mathClass,                                          // 目标类
        "formatResult",                                     // 方法名
        "(Ljava/lang/String;D)Ljava/lang/String;");         // 签名
 
    if (formatMethod == nullptr) {
        return; // NoSuchMethodError 已抛出
    }
 
    // 到这里，两个静态方法ID都已成功获取
    // 后续可用 CallStaticLongMethod / CallStaticObjectMethod 进行调用
}

方法签名公式:
 
    (ParamType1ParamType2...ParamTypeN)ReturnType
 
示例映射:
 
    Java: void    foo()                → ()V
    Java: int     add(int a, int b)    → (II)I
    Java: String  bar(int x, String s) → (ILjava/lang/String;)Ljava/lang/String;
    Java: long[]  baz(double d)        → (D)[J
    Java: void    qux(int[] arr)       → ([I)V

# -s 选项：输出内部类型签名（internal type signatures）
# -p 选项：显示所有成员（包括 private）
javap -s -p com.example.Calculator

public class com.example.Calculator {
  public com.example.Calculator();
    descriptor: ()V                          // ← 这就是构造方法的签名
 
  public int add(int, int);
    descriptor: (II)I                        // ← add 方法的签名
 
  public java.lang.String describe(java.lang.String, int);
    descriptor: (Ljava/lang/String;I)Ljava/lang/String;  // ← describe 的签名
}

// 获取不同构造方法的方法ID
 
// 无参构造: public Calculator()
jmethodID ctor0 = env->GetMethodID(clazz, "<init>", "()V");
 
// 单参数构造: public Calculator(int initialValue)
jmethodID ctor1 = env->GetMethodID(clazz, "<init>", "(I)V");
 
// 多参数构造: public Calculator(String name, double precision)
jmethodID ctor2 = env->GetMethodID(clazz, "<init>",
                                   "(Ljava/lang/String;D)V");

// ❌ 错误：对象类型签名忘记末尾的分号
jmethodID mid = env->GetMethodID(clazz, "foo", "(Ljava/lang/String)V");
//                                                                ^ 缺少 ';'
 
// ✅ 正确：
jmethodID mid = env->GetMethodID(clazz, "foo", "(Ljava/lang/String;)V");
//                                                                 ^ 有 ';'

// ❌ 错误：使用点号而非斜杠
jmethodID mid = env->GetMethodID(clazz, "foo", "(Ljava.lang.String;)V");
//                                                    ^    ^  应该是 '/'
 
// ✅ 正确：
jmethodID mid = env->GetMethodID(clazz, "foo", "(Ljava/lang/String;)V");

// Java: public static int compute(int x) { ... }
 
// ❌ 错误：用 GetMethodID 查找 static 方法 → NoSuchMethodError
jmethodID mid = env->GetMethodID(clazz, "compute", "(I)I");
 
// ✅ 正确：
jmethodID mid = env->GetStaticMethodID(clazz, "compute", "(I)I");

// ❌ 危险：未检查返回值直接使用
jmethodID mid = env->GetMethodID(clazz, "nonExistent", "()V");
env->CallVoidMethod(obj, mid); // 💥 mid 为 NULL，行为未定义！可能导致 JVM 崩溃
 
// ✅ 安全：总是检查
jmethodID mid = env->GetMethodID(clazz, "nonExistent", "()V");
if (mid == nullptr) {
    // 此时 JVM 已有 pending exception (NoSuchMethodError)
    // 选择 1：直接 return，让异常传播到 Java 层
    return;
    // 选择 2：清除异常并做自定义处理
    // env->ExceptionClear();
    // ... 自定义错误处理 ...
}

// Java 层存在重载方法
public class Printer {
    public void print(int value)    { ... }  // 签名: (I)V
    public void print(String text)  { ... }  // 签名: (Ljava/lang/String;)V
    public void print(int a, int b) { ... }  // 签名: (II)V
}

// Native 层：通过不同签名精确获取不同的重载版本
jmethodID print_int    = env->GetMethodID(cls, "print", "(I)V");
jmethodID print_string = env->GetMethodID(cls, "print", "(Ljava/lang/String;)V");
jmethodID print_two    = env->GetMethodID(cls, "print", "(II)V");
// 三个 jmethodID 各不相同，分别指向不同的重载方法

public class Demo {
    public static String[] resolve(int code, String name, boolean flag) {
        // ...
    }
}

// 每次调用都会触发 JVM 内部查找
jmethodID mid = (*env)->GetMethodID(env, cls, "calculate", "(II)I");

/* 
 * 策略一：使用时缓存 (Lazy Caching)
 * 利用 C 的 static 局部变量，首次调用时查找，后续直接复用
 */
JNIEXPORT void JNICALL
Java_com_example_MyClass_nativeProcess(JNIEnv *env, jobject thiz) {
 
    // static 变量只会初始化一次，后续调用保留上次的值
    // 首次进入时 cachedMid == NULL
    static jmethodID cachedMid = NULL;
 
    // 仅在第一次调用时执行查找
    if (cachedMid == NULL) {
        // 获取 thiz 对象的类引用
        jclass cls = (*env)->GetObjectClass(env, thiz);
 
        // 查找方法 ID（只执行这一次）
        cachedMid = (*env)->GetMethodID(env, cls, "onResult", "(I)V");
 
        // 查找失败时 cachedMid 仍为 NULL，需要处理异常
        if (cachedMid == NULL) {
            // GetMethodID 失败会自动抛出 NoSuchMethodError
            // 直接 return，让 Java 层捕获异常
            return;
        }
 
        // cls 是局部引用，函数结束自动释放
        // 注意：我们缓存的是 jmethodID，不是 jclass
        (*env)->DeleteLocalRef(env, cls);
    }
 
    // 后续所有调用都直接使用缓存的 cachedMid
    // 无需再次查找，性能极高
    (*env)->CallVoidMethod(env, thiz, cachedMid, 42);
}

// ========== 第 1 次调用 ==========
//
//  Stack Frame (nativeProcess)
//  ┌─────────────────────────────────┐
//  │  static cachedMid: NULL ──────────► 触发 GetMethodID 查找
//  │                     ↓           │
//  │  static cachedMid: 0x7F3A ◄───────  查找成功，写入地址
//  └─────────────────────────────────┘
//
// ========== 第 2~N 次调用 ==========
//
//  Stack Frame (nativeProcess)
//  ┌─────────────────────────────────┐
//  │  static cachedMid: 0x7F3A ──────── 直接使用，跳过查找！
//  └─────────────────────────────────┘

public class AudioProcessor {
 
    // 在类加载时（static 块）调用 native 初始化方法
    // 这确保了在任何其他 native 方法被调用前，缓存已经建立
    static {
        System.loadLibrary("audioprocessor");
        nativeClassInit();  // 触发 C 端的缓存初始化
    }
 
    // 私有的 native 初始化方法，仅用于缓存 ID
    private static native void nativeClassInit();
 
    // 以下是业务方法，供 native 层回调
    public void onDecodeComplete(byte[] data, int sampleRate) {
        // 解码完成回调
    }
 
    public static void onError(int errorCode, String message) {
        // 静态错误回调
    }
 
    // 业务 native 方法
    public native void startDecode(String filePath);
    public native void stopDecode();
}

#include <jni.h>
#include <stddef.h>  // for NULL
 
/* ============================================================
 *  全局缓存区 (Global Cache)
 *  使用文件作用域的 static 变量，所有函数共享
 * ============================================================ */
 
// 缓存 AudioProcessor 类的全局引用
static jclass    gAudioProcessorClass  = NULL;
 
// 缓存实例方法 ID
static jmethodID gOnDecodeCompleteMid  = NULL;
 
// 缓存静态方法 ID
static jmethodID gOnErrorMid           = NULL;
 
// 缓存字段 ID（如果需要的话）
static jfieldID  gSampleRateFid        = NULL;
 
 
/* ============================================================
 *  类初始化函数：一次性完成所有 ID 查找
 * ============================================================ */
JNIEXPORT void JNICALL
Java_com_example_AudioProcessor_nativeClassInit(JNIEnv *env, jclass cls) {
    // 参数 cls 就是 AudioProcessor.class（调用者是 static 方法）
    // 但 cls 是局部引用，函数返回后失效
    // 因此必须创建全局引用来缓存类对象
    gAudioProcessorClass = (*env)->NewGlobalRef(env, cls);
    if (gAudioProcessorClass == NULL) {
        // NewGlobalRef 失败（内存不足），直接返回
        return;
    }
 
    // 一次性查找所有实例方法 ID
    gOnDecodeCompleteMid = (*env)->GetMethodID(
        env,
        gAudioProcessorClass,     // 使用全局引用
        "onDecodeComplete",       // 方法名
        "([BI)V"                  // 签名：(byte[], int) -> void
    );
    if (gOnDecodeCompleteMid == NULL) return;  // 查找失败，已抛异常
 
    // 一次性查找所有静态方法 ID
    gOnErrorMid = (*env)->GetStaticMethodID(
        env,
        gAudioProcessorClass,
        "onError",
        "(ILjava/lang/String;)V"  // 签名：(int, String) -> void
    );
    if (gOnErrorMid == NULL) return;
 
    // 一次性查找所有字段 ID
    gSampleRateFid = (*env)->GetFieldID(
        env,
        gAudioProcessorClass,
        "sampleRate",             // 字段名
        "I"                       // 签名：int
    );
    // 如果失败，Java 层会收到 NoSuchFieldError
}
 
 
/* ============================================================
 *  业务函数：直接使用缓存，零查找开销
 * ============================================================ */
JNIEXPORT void JNICALL
Java_com_example_AudioProcessor_startDecode(JNIEnv *env, jobject thiz,
                                            jstring filePath) {
    // ......（解码逻辑省略）......
 
    // 创建 byte[] 结果（示意）
    jbyteArray resultData = (*env)->NewByteArray(env, 1024);
 
    // 直接使用缓存的方法 ID 回调 Java
    // 无需任何 FindClass / GetMethodID！
    (*env)->CallVoidMethod(
        env,
        thiz,                     // AudioProcessor 实例
        gOnDecodeCompleteMid,     // 缓存的方法 ID
        resultData,               // byte[] 参数
        44100                     // sampleRate 参数
    );
 
    // 如果出错，使用缓存的静态方法 ID
    jstring errMsg = (*env)->NewStringUTF(env, "File not found");
    (*env)->CallStaticVoidMethod(
        env,
        gAudioProcessorClass,    // 缓存的全局类引用
        gOnErrorMid,             // 缓存的静态方法 ID
        -1,                      // errorCode
        errMsg                   // message
    );
 
    // 清理局部引用
    (*env)->DeleteLocalRef(env, resultData);
    (*env)->DeleteLocalRef(env, errMsg);
}

#include <jni.h>
 
/* ============================================================
 *  多类全局缓存
 * ============================================================ */
 
// ----- AudioProcessor 相关 -----
static jclass    gAudioProcessorClass     = NULL;
static jmethodID gOnDecodeCompleteMid     = NULL;
 
// ----- VideoProcessor 相关 -----
static jclass    gVideoProcessorClass     = NULL;
static jmethodID gOnFrameRenderedMid      = NULL;
 
// ----- Logger 工具类相关 -----
static jclass    gLoggerClass             = NULL;
static jmethodID gLogDebugMid            = NULL;
 
 
/* ============================================================
 *  辅助宏：简化重复的查找 + 错误检查模式
 * ============================================================ */
 
// 查找类并创建全局引用的宏
// 如果失败则 goto error 标签（集中清理）
#define FIND_CLASS(var, className)                                    \
    do {                                                              \
        jclass _localCls = (*env)->FindClass(env, className);         \
        if (_localCls == NULL) goto error;                            \
        var = (*env)->NewGlobalRef(env, _localCls);                   \
        (*env)->DeleteLocalRef(env, _localCls);                       \
        if (var == NULL) goto error;                                  \
    } while (0)
 
// 查找实例方法 ID 的宏
#define GET_METHOD(var, cls, name, sig)                               \
    do {                                                              \
        var = (*env)->GetMethodID(env, cls, name, sig);               \
        if (var == NULL) goto error;                                  \
    } while (0)
 
// 查找静态方法 ID 的宏
#define GET_STATIC_METHOD(var, cls, name, sig)                        \
    do {                                                              \
        var = (*env)->GetStaticMethodID(env, cls, name, sig);         \
        if (var == NULL) goto error;                                  \
    } while (0)
 
 
/* ============================================================
 *  JNI_OnLoad：库加载时自动调用，集中初始化所有缓存
 * ============================================================ */
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
 
    // 从 JavaVM 获取 JNIEnv
    // 参数 JNI_VERSION_1_6 表示我们需要的最低 JNI 版本
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;  // 获取环境失败
    }
 
    // ===== 集中查找所有类 =====
    FIND_CLASS(gAudioProcessorClass, "com/example/AudioProcessor");
    FIND_CLASS(gVideoProcessorClass, "com/example/VideoProcessor");
    FIND_CLASS(gLoggerClass,         "com/example/Logger");
 
    // ===== 集中查找所有方法 ID =====
    GET_METHOD(gOnDecodeCompleteMid,
               gAudioProcessorClass, "onDecodeComplete", "([BI)V");
 
    GET_METHOD(gOnFrameRenderedMid,
               gVideoProcessorClass, "onFrameRendered", "(JII)V");
 
    GET_STATIC_METHOD(gLogDebugMid,
                      gLoggerClass, "debug", "(Ljava/lang/String;)V");
 
    // 全部成功，返回所需的 JNI 版本号
    return JNI_VERSION_1_6;
 
error:
    // 集中清理：任何一步失败都走到这里
    // 释放已创建的全局引用（NULL 安全）
    if (gAudioProcessorClass) (*env)->DeleteGlobalRef(env, gAudioProcessorClass);
    if (gVideoProcessorClass) (*env)->DeleteGlobalRef(env, gVideoProcessorClass);
    if (gLoggerClass)         (*env)->DeleteGlobalRef(env, gLoggerClass);
 
    // 重置所有全局变量
    gAudioProcessorClass = NULL;
    gVideoProcessorClass = NULL;
    gLoggerClass         = NULL;
 
    return JNI_ERR;  // 返回错误，库加载失败
}
 
 
/* ============================================================
 *  JNI_OnUnload：库卸载时自动调用（可选但推荐）
 * ============================================================ */
JNIEXPORT void JNICALL
JNI_OnUnload(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    // 获取 JNIEnv
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        return;
    }
 
    // 释放所有全局引用
    if (gAudioProcessorClass) (*env)->DeleteGlobalRef(env, gAudioProcessorClass);
    if (gVideoProcessorClass) (*env)->DeleteGlobalRef(env, gVideoProcessorClass);
    if (gLoggerClass)         (*env)->DeleteGlobalRef(env, gLoggerClass);
 
    // 全部置 NULL，防止野指针
    gAudioProcessorClass = NULL;
    gVideoProcessorClass = NULL;
    gLoggerClass         = NULL;
 
    // 注意：jmethodID / jfieldID 不需要释放
    // 它们不是引用，不占 GC 资源
    // 但置 NULL 是好习惯
    gOnDecodeCompleteMid = NULL;
    gOnFrameRenderedMid  = NULL;
    gLogDebugMid         = NULL;
}

/* ❌ 错误示范：缓存了局部引用 */
static jclass cachedClass = NULL;
 
void someFunction(JNIEnv *env) {
    if (cachedClass == NULL) {
        // FindClass 返回的是局部引用 (Local Reference)
        // 局部引用在函数返回后即失效！
        cachedClass = (*env)->FindClass(env, "com/example/MyClass");
    }
    // 第二次调用此函数时，cachedClass 指向已失效的引用
    // 导致 crash 或不可预测行为！ 💥
    jmethodID mid = (*env)->GetMethodID(env, cachedClass, "foo", "()V");
}

/* ✅ 正确做法：将局部引用提升为全局引用 */
static jclass cachedClass = NULL;
 
void someFunction(JNIEnv *env) {
    if (cachedClass == NULL) {
        // 先获取局部引用
        jclass localCls = (*env)->FindClass(env, "com/example/MyClass");
        if (localCls == NULL) return;  // 类未找到
 
        // 创建全局引用（跨函数、跨线程有效）
        cachedClass = (*env)->NewGlobalRef(env, localCls);
 
        // 释放局部引用（全局引用已持有，局部不再需要）
        (*env)->DeleteLocalRef(env, localCls);
 
        if (cachedClass == NULL) return;  // 全局引用创建失败
    }
    // 安全使用 ✅
    jmethodID mid = (*env)->GetMethodID(env, cachedClass, "foo", "()V");
}

// 内存关系图:
//
//   ┌──────────────────────────────────────────────┐
//   │             GC Roots                         │
//   │  ┌─────────────────┐                         │
//   │  │  gGlobalClass ──────► jclass (MyClass)    │ ← 全局引用阻止卸载
//   │  │  (GlobalRef)    │     │                   │
//   │  └─────────────────┘     │ 包含              │
//   │                          ▼                   │
//   │                    ┌─────────────┐           │
//   │                    │ Method Table│           │
//   │                    │ ┌─────────┐ │           │
//   │  gCachedMid ──────►│ │  foo()  │ │           │ ← ID 指向方法表条目
//   │                    │ └─────────┘ │           │
//   │                    └─────────────┘           │
//   └──────────────────────────────────────────────┘
//
//   ✅ 只要 gGlobalClass 存在，整个链条都安全
//   ❌ 若无 gGlobalClass，类可能被卸载，gCachedMid 悬空

/* 
 * Android AOSP 风格的缓存模式
 * 来源：frameworks/base/media/jni/android_media_MediaPlayer.cpp（简化）
 */
 
// 使用结构体集中管理一个类的所有缓存
struct fields_t {
    jclass    clazz;                  // MediaPlayer.class 的全局引用
    jmethodID post_event;            // postEventFromNative 方法
    jfieldID  context;               // mNativeContext 字段
    jfieldID  surface_texture;       // mNativeSurfaceTexture 字段
};
 
// 全局缓存实例
static fields_t fields;
 
// 在 JNI_OnLoad 或 register 阶段调用
static void
android_media_MediaPlayer_native_init(JNIEnv *env) {
    jclass clazz;
 
    // 查找 MediaPlayer 类
    clazz = env->FindClass("android/media/MediaPlayer");
    if (clazz == NULL) {
        return;  // 抛出 ClassNotFoundException
    }
 
    // 缓存为全局引用
    fields.clazz = (jclass)env->NewGlobalRef(clazz);
 
    // 缓存回调方法
    fields.post_event = env->GetStaticMethodID(
        clazz,
        "postEventFromNative",
        "(Ljava/lang/Object;IIILjava/lang/Object;)V"
    );
    if (fields.post_event == NULL) {
        return;  // 抛出 NoSuchMethodError
    }
 
    // 缓存字段
    fields.context = env->GetFieldID(clazz, "mNativeContext", "J");
    if (fields.context == NULL) {
        return;
    }
 
    fields.surface_texture = env->GetFieldID(
        clazz, "mNativeSurfaceTexture", "J"
    );
    // ... 后续使用 fields.xxx 直接访问
}

// Java 侧: int add(int a, int b)
// 直接将参数逐个列出，C 编译器自动处理
jint result = (*env)->CallIntMethod(env, obj, addMethodID, 10, 20);

#include <stdarg.h>
 
// 通用包装函数：调用任意返回 int 的 Java 方法
jint callIntMethodWrapper(JNIEnv *env, jobject obj, jmethodID mid, ...) {
    va_list args;             // 声明 va_list 变量
    va_start(args, mid);      // 初始化，指向 mid 之后的第一个可变参数
    // 使用 V 变体，将 va_list 直接转发给 JNI
    jint result = (*env)->CallIntMethodV(env, obj, mid, args);
    va_end(args);             // 清理 va_list
    return result;            // 返回 Java 方法的执行结果
}

// jvalue 的定义（来自 jni.h）
typedef union jvalue {
    jboolean z;   // boolean
    jbyte    b;   // byte
    jchar    c;   // char
    jshort   s;   // short
    jint     i;   // int
    jlong    j;   // long
    jfloat   f;   // float
    jdouble  d;   // double
    jobject  l;   // 引用类型（包括 String、数组、对象等）
} jvalue;

// Java 侧: int add(int a, int b)
 
jvalue args[2];      // 创建一个长度为 2 的 jvalue 数组，对应 2 个参数
args[0].i = 10;      // 第一个参数是 int 类型，赋值 10
args[1].i = 20;      // 第二个参数是 int 类型，赋值 20
 
// 使用 A 变体，传入 jvalue 数组指针
jint result = (*env)->CallIntMethodA(env, obj, addMethodID, args);

public class Calculator {
 
    // 实例方法：两数相加
    public int add(int a, int b) {
        return a + b;
    }
 
    // 实例方法：拼接描述信息（演示引用类型参数和返回值）
    public String describe(String operation, int result) {
        return operation + " = " + result;
    }
 
    // 实例方法：无返回值，打印日志
    public void log(String message) {
        System.out.println("[Calculator] " + message);
    }
}

// native 函数：演示调用 Calculator 的三个方法
JNIEXPORT void JNICALL
Java_com_example_Main_testCalculator(JNIEnv *env, jobject thiz, jobject calculator) {
 
    // ========== 1. 获取类引用 ==========
    // 通过对象实例获取其 Class（等价于 calculator.getClass()）
    jclass clazz = (*env)->GetObjectClass(env, calculator);
 
    // ========== 2. 获取三个方法的 ID ==========
    // add(int, int) -> 签名 "(II)I"
    jmethodID addMid = (*env)->GetMethodID(env, clazz, "add", "(II)I");
    // describe(String, int) -> 签名 "(Ljava/lang/String;I)Ljava/lang/String;"
    jmethodID describeMid = (*env)->GetMethodID(env, clazz, "describe",
                                                 "(Ljava/lang/String;I)Ljava/lang/String;");
    // log(String) -> 签名 "(Ljava/lang/String;)V"
    jmethodID logMid = (*env)->GetMethodID(env, clazz, "log", "(Ljava/lang/String;)V");
 
    // ========== 3. 调用 add 方法 ==========
    // CallIntMethod：返回 jint，对应 Java 的 int
    jint sum = (*env)->CallIntMethod(env, calculator, addMid, 30, 12);
    // sum 现在是 42
 
    // ========== 4. 调用 describe 方法 ==========
    // 先构造 Java String 作为参数
    jstring operation = (*env)->NewStringUTF(env, "30 + 12");
    // CallObjectMethod：返回 jobject，这里实际是 jstring
    jstring desc = (jstring)(*env)->CallObjectMethod(env, calculator, describeMid,
                                                      operation, sum);
    // 将 jstring 转为 C 字符串以便在 native 层使用
    const char *descChars = (*env)->GetStringUTFChars(env, desc, NULL);
    // descChars = "30 + 12 = 42"
 
    // ========== 5. 调用 log 方法 ==========
    // CallVoidMethod：无返回值
    jstring logMsg = (*env)->NewStringUTF(env, "Calculation complete!");
    (*env)->CallVoidMethod(env, calculator, logMid, logMsg);
    // Java 控制台输出：[Calculator] Calculation complete!
 
    // ========== 6. 释放资源 ==========
    (*env)->ReleaseStringUTFChars(env, desc, descChars);  // 释放 UTF 字符串
    (*env)->DeleteLocalRef(env, operation);                // 释放局部引用
    (*env)->DeleteLocalRef(env, logMsg);                   // 释放局部引用
    (*env)->DeleteLocalRef(env, desc);                     // 释放局部引用
    (*env)->DeleteLocalRef(env, clazz);                    // 释放类引用
}

// 以下参数 100 和 200 被直接按值传入 JVM 栈帧
jint result = (*env)->CallIntMethod(env, obj, mid, 100, 200);
// result 也是直接从 JVM 栈帧上按值拷贝回来的

// ┌─────────────────────────────┐
// │       Native Stack          │
// │  arg1 = 100 (4 bytes)       │──值拷贝──┐
// │  arg2 = 200 (4 bytes)       │──值拷贝──┤
// └─────────────────────────────┘          │
//                                          ▼
// ┌─────────────────────────────┐
// │       Java Stack Frame      │
// │  slot[0] = this (objref)    │
// │  slot[1] = 100              │ ← 来自 native 的值
// │  slot[2] = 200              │ ← 来自 native 的值
// └─────────────────────────────┘

// ┌──── Native 侧 ───────┐        ┌──── JVM 内部 ──────────────┐
// │                       │        │                            │
// │  jstring s = 0xA100   │───────►│  Handle Table              │
// │  (Local Ref Handle)   │        │  [0xA100] ──► 堆对象 Str1 │
// │                       │        │                            │
// └───────────────────────┘        └────────────────────────────┘
//
// GC 发生后，Str1 可能被移动到新地址，但 Handle 0xA100 不变
// JVM 自动更新 Handle Table 中的映射

jboolean flag = (*env)->CallBooleanMethod(env, obj, isReadyMid);
// flag 的值为 JNI_TRUE (1) 或 JNI_FALSE (0)
 
jdouble pi = (*env)->CallDoubleMethod(env, obj, getPiMid);
// pi ≈ 3.141592653589793

// 调用一个返回 String 的方法
jobject rawResult = (*env)->CallObjectMethod(env, obj, getNameMid);
 
// 必须检查 null —— Java 侧可能返回 null
if (rawResult == NULL) {
    // 处理空值情况
    return;
}
 
// 安全地强转为 jstring
jstring name = (jstring) rawResult;
 
// 使用完毕后如果还在同一个 native 函数内，可以手动释放
(*env)->DeleteLocalRef(env, name);

jint result = (*env)->CallIntMethod(env, obj, riskyMethodMid, 999);
 
// ⚠️ 必须在使用 result 之前检查异常
if ((*env)->ExceptionCheck(env)) {          // 检查是否有挂起的异常
    (*env)->ExceptionDescribe(env);         // 将异常信息打印到 stderr（调试用）
    (*env)->ExceptionClear(env);            // 清除挂起的异常，恢复 JNI 正常状态
    // 此处进行错误恢复逻辑，不要使用 result
    return;
}
 
// 安全：此处 result 有效
printf("Result = %d\n", result);

public class Animal {
    public String speak() { return "..."; }
}
 
public class Dog extends Animal {
    @Override
    public String speak() { return "Woof!"; }
}

// dog 是一个 Dog 实例，但 clazz 是 Animal.class
jclass animalClass = (*env)->FindClass(env, "com/example/Animal");
jmethodID speakMid = (*env)->GetMethodID(env, animalClass, "speak",
                                          "()Ljava/lang/String;");
 
// 尽管 methodID 来自 Animal，但传入的 obj 是 Dog 实例
// CallObjectMethod 会走虚方法表，最终调用 Dog.speak()
jstring result = (jstring)(*env)->CallObjectMethod(env, dogObj, speakMid);
// result = "Woof!" —— 而不是 "..."

// 强制调用 Animal.speak()，忽略 Dog 的重写
jstring result = (jstring)(*env)->CallNonvirtualObjectMethod(
    env,
    dogObj,         // 对象仍然是 Dog 实例
    animalClass,    // 显式指定要调用哪个类的方法
    speakMid        // Animal.speak 的 methodID
);
// result = "..." —— 调用的是 Animal 的版本

// ❌ 错误：签名要求 2 个 int，却只传了 1 个
jint bad = (*env)->CallIntMethod(env, obj, addMid, 10);
// → 未定义行为，可能读取栈上的垃圾数据
 
// ✅ 正确：参数数量和类型完全匹配
jint good = (*env)->CallIntMethod(env, obj, addMid, 10, 20);

// ❌ 危险：循环 10000 次，创建 10000 个局部引用
for (int i = 0; i < 10000; i++) {
    jstring s = (jstring)(*env)->CallObjectMethod(env, obj, getItemMid, i);
    // 使用 s ...
    // 忘记释放！
}
 
// ✅ 正确：每次迭代及时释放
for (int i = 0; i < 10000; i++) {
    jstring s = (jstring)(*env)->CallObjectMethod(env, obj, getItemMid, i);
    // 使用 s ...
    const char *chars = (*env)->GetStringUTFChars(env, s, NULL);
    printf("%s\n", chars);
    (*env)->ReleaseStringUTFChars(env, s, chars);  // 释放字符串缓冲区
    (*env)->DeleteLocalRef(env, s);                 // 释放局部引用
}

jclass cls = (*env)->FindClass(env, "com/example/Formatter");                 // ①
jmethodID mid = (*env)->GetMethodID(env, cls, "format",
                                     "(ILjava/lang/String;)Ljava/lang/String"); // ②
jstring msg = (*env)->NewStringUTF(env, "hello");                              // ③
jstring result = (*env)->CallObjectMethod(env, formatterObj, mid, 200, msg);   // ④

// 通用签名模板（以 Int 为例）
// env      : JNI 环境指针
// clazz    : 目标类的 jclass 引用（注意：不是 jobject！）
// methodID : 通过 GetStaticMethodID 获取的方法 ID
// ...      : Java 方法所需的实际参数（变长参数）
jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...);

// Java 层 —— 一个简单的数学工具类
public class MathUtils {
 
    // 静态方法：计算两个整数的最大公约数 (GCD)
    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
 
    // 静态方法：打印日志（无返回值）
    public static void log(String message) {
        System.out.println("[MathUtils] " + message);
    }
 
    // 静态方法：创建格式化字符串（返回对象类型）
    public static String format(int value) {
        return String.format("Result = %d", value);
    }
}

#include <jni.h>
#include <cstdio>
 
extern "C"
JNIEXPORT void JNICALL
Java_com_example_NativeLib_testStaticCalls(JNIEnv *env, jobject thiz) {
 
    // ============================================================
    // 第一步：FindClass —— 获取 MathUtils 类的 jclass 引用
    // ============================================================
    // 使用全限定类名，包名分隔符用 '/' 而非 '.'
    jclass mathUtilsClass = env->FindClass("com/example/MathUtils");
 
    // 防御性检查：类未找到时 FindClass 返回 NULL 并抛出异常
    if (mathUtilsClass == nullptr) {
        // 此时 JVM 内部已经抛出 NoClassDefFoundError
        // 直接 return，让 Java 层捕获异常
        return;
    }
 
    // ============================================================
    // 第二步：GetStaticMethodID —— 获取各静态方法的 ID
    // ============================================================
 
    // 获取 gcd(int, int) -> int 的方法 ID
    // 签名 "(II)I" 表示：两个 int 参数，返回 int
    jmethodID gcdMethodID = env->GetStaticMethodID(
        mathUtilsClass,   // 目标类
        "gcd",            // 方法名
        "(II)I"           // 方法签名
    );
    if (gcdMethodID == nullptr) return; // 方法未找到，异常已抛出
 
    // 获取 log(String) -> void 的方法 ID
    // 签名 "(Ljava/lang/String;)V" 表示：一个 String 参数，返回 void
    jmethodID logMethodID = env->GetStaticMethodID(
        mathUtilsClass,              // 目标类
        "log",                       // 方法名
        "(Ljava/lang/String;)V"      // 方法签名（L...;表示对象类型）
    );
    if (logMethodID == nullptr) return;
 
    // 获取 format(int) -> String 的方法 ID
    // 签名 "(I)Ljava/lang/String;" 表示：一个 int 参数，返回 String
    jmethodID formatMethodID = env->GetStaticMethodID(
        mathUtilsClass,                  // 目标类
        "format",                        // 方法名
        "(I)Ljava/lang/String;"          // 方法签名
    );
    if (formatMethodID == nullptr) return;
 
    // ============================================================
    // 第三步：调用静态方法
    // ============================================================
 
    // --- 调用 gcd(48, 18)：返回 int，使用 CallStaticIntMethod ---
    jint result = env->CallStaticIntMethod(
        mathUtilsClass,   // 传入 jclass（不是 jobject！）
        gcdMethodID,      // 方法 ID
        48,               // 第一个参数 a
        18                // 第二个参数 b
    );
    printf("GCD(48, 18) = %d\n", result);  // 输出：GCD(48, 18) = 6
 
    // --- 调用 log("Hello from Native")：无返回值，使用 CallStaticVoidMethod ---
    // 先将 C 字符串转换为 Java 的 jstring
    jstring logMsg = env->NewStringUTF("Hello from Native");
    env->CallStaticVoidMethod(
        mathUtilsClass,   // 传入 jclass
        logMethodID,      // 方法 ID
        logMsg            // String 参数
    );
    // 用完后释放局部引用（良好实践）
    env->DeleteLocalRef(logMsg);
 
    // --- 调用 format(42)：返回对象（String），使用 CallStaticObjectMethod ---
    jobject formatResult = env->CallStaticObjectMethod(
        mathUtilsClass,   // 传入 jclass
        formatMethodID,   // 方法 ID
        42                // int 参数
    );
    // 将返回的 jstring 转换为 C 字符串以便打印
    const char *str = env->GetStringUTFChars((jstring)formatResult, nullptr);
    printf("Format result: %s\n", str);    // 输出：Format result: Result = 42
    // 释放 UTF 字符串的内存
    env->ReleaseStringUTFChars((jstring)formatResult, str);
    // 释放返回对象的局部引用
    env->DeleteLocalRef(formatResult);
 
    // 释放 jclass 局部引用
    env->DeleteLocalRef(mathUtilsClass);
}

// jvalue 的定义（来自 jni.h）
typedef union jvalue {
    jboolean z;   // boolean
    jbyte    b;   // byte
    jchar    c;   // char
    jshort   s;   // short
    jint     i;   // int
    jlong    j;   // long
    jfloat   f;   // float
    jdouble  d;   // double
    jobject  l;   // 对象引用（包括 String、数组等）
} jvalue;

extern "C"
JNIEXPORT void JNICALL
Java_com_example_NativeLib_testJvalueCall(JNIEnv *env, jobject thiz) {
 
    // 获取类和方法 ID（省略错误检查以突出重点）
    jclass clazz = env->FindClass("com/example/MathUtils");
    jmethodID mid = env->GetStaticMethodID(clazz, "gcd", "(II)I");
 
    // 构建 jvalue 数组，每个元素对应一个参数
    jvalue args[2];          // gcd 有两个参数，所以数组长度为 2
    args[0].i = 48;          // 第一个参数：int 类型，赋值给 .i 字段
    args[1].i = 18;          // 第二个参数：int 类型，赋值给 .i 字段
 
    // 使用 A 变体调用
    jint result = env->CallStaticIntMethodA(
        clazz,    // jclass
        mid,      // jmethodID
        args      // jvalue 数组指针
    );
 
    printf("GCD = %d\n", result);  // 输出：GCD = 6
 
    env->DeleteLocalRef(clazz);
}

// ❌ 错误示范：传入 jobject 而非 jclass
jobject someObject = ...; // 某个 MathUtils 的实例
env->CallStaticIntMethod(
    (jclass)someObject,   // 强转骗过编译器，但运行时可能崩溃！
    gcdMethodID,
    48, 18
);
 
// ✅ 正确做法：始终使用 FindClass 获取的 jclass
jclass clazz = env->FindClass("com/example/MathUtils");
env->CallStaticIntMethod(clazz, gcdMethodID, 48, 18);

// ❌ 常见签名错误
env->GetStaticMethodID(clazz, "gcd", "(I, I)I");    // 错！逗号和空格是多余的
env->GetStaticMethodID(clazz, "gcd", "(int,int)int");// 错！不能用 Java 源码类型名
env->GetStaticMethodID(clazz, "gcd", "(II)V");       // 错！返回类型不匹配
 
// ✅ 正确签名
env->GetStaticMethodID(clazz, "gcd", "(II)I");       // 两个 int 参数，返回 int

// 调用一个可能抛出异常的 Java 静态方法
env->CallStaticVoidMethod(clazz, riskyMethodID);
 
// 检查 Java 层是否有未捕获的异常
if (env->ExceptionCheck()) {
    // 打印异常堆栈信息到 stderr（调试用）
    env->ExceptionDescribe();
    // 清除异常状态，否则后续 JNI 调用会全部失败
    env->ExceptionClear();
    // 执行你的错误处理逻辑...
    return;
}