NDK编程Java如何保存C或C++对象

前言

最近有个想进阶Android，学习NDK编程的小伙伴问我说看了不少网上的视频教程，大多数的主题都是讲JNI的方法签名、JNI线程绑定、JNI调用Java方法等主要的内容。
自己在练习的过程中发现如果需要重复利用一个C或者C++的对象时就不知道怎么处理了。其实这就是Java对象如何保存Native对象的一个问题而已。

听了这个朋友的疑问，我翻了下网上关于NDK的视频教程，确实是很多教程都没有介绍Java对象如何复用一个Native对象。但是这又是一个在NDK实战中必然会碰到的一个关键点。
有道是老师带入门，修行在自身，这句话是很在理的。在这个信息爆炸的年代，你与知识的距离就是一跟网线的距离，那么如何拉开大家的距离呢？或许这个时候就看谁的自学自研能力，甚至是
无师自通的拓荒能力更胜一筹了。

别人是怎么做的

虽然说不知道怎么做，但是Android官方的人肯定会啊，知名的C或者C++开源项目肯定也会涉及到这个问题啊。偷偷喵一下别人怎么做的不就可以了吗？

安卓经常使用的一个类Bitmap,我们看看它是怎么处理的：

public final class Bitmap implements Parcelable {
    private static final String TAG = "Bitmap";

    /**
     * Indicates that the bitmap was created for an unknown pixel density.
     *
     * @see Bitmap#getDensity()
     * @see Bitmap#setDensity(int)
     */
    public static final int DENSITY_NONE = 0;

    // Estimated size of the Bitmap native allocation, not including
    // pixel data.
    private static final long NATIVE_ALLOCATION_SIZE = 32;


    // 重点看这里，看注释
    // Convenience for JNI access
    @UnsupportedAppUsage
    private final long mNativePtr;

就是一个long类型而已啊，没有学过C/C++的朋友一定很惊讶，为什么一个Java中的long类型就能保存Native中的一个对象呢？这就是C/C++指针的神秘之处了，
这个long类型保存的不是一个普通的数字，而是对象的Native对象的一个内存地址。哦，原来Java并不直接保存C或者C++的对象，仅仅是保存它的一个地址而已，
当我们需要复用这个Native对象的时候只需要拿到这个long类型的地址，再通过指针的方式访问即可。就是这么简单。。。

牛刀初试一下

直接show me the code！！！

JNIActivity.java

public class JNIActivity extends AppCompatActivity {

    private Teacher teacher;

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

        teacher = new Teacher();
        teacher.initStudent();
        teacher.educationStudent(teacher.mNativePtr);
    }


    @Override
    protected void onDestroy() {
        if(null != teacher){
            teacher.releaseStudent(teacher.mNativePtr);
            teacher = null;
        }
        super.onDestroy();
    }
}

新建一个java类:
Teacher.java

public class Teacher {

    public long mNativePtr = 0;

    /**
     * 初始化一个学生，并将指针地址保存在mNativePtr变量中
     */
    public native void initStudent();

    /**
     * 根据学生的指针地址发起个性化教育
     * @param studentPtr
     */
    public native void educationStudent(long studentPtr);

    /**
     * 释放学生对象，很关键的一步，否则就是可怕的内存泄漏
     * @param studentPtr
     */
    public native void releaseStudent(long studentPtr);
}

新建C++对象类：

Student.h

#ifndef GROWING_STUDENT_H
#define GROWING_STUDENT_H


class Student {

public:
    char *name = nullptr;
    int age = 0;

    Student();
    ~Student();

};

#endif //GROWING_STUDENT_H

Student.cpp

#include "Student.h"

Student::Student() {

}

Student::~Student() {

}

native-lib.cpp

extern "C"
JNIEXPORT void JNICALL
Java_com_flyer_bspatchupdate_jni_Teacher_initStudent(JNIEnv *env, jobject thiz) {
    Student *student = new Student;
    student->age = 18;
    student->name = "我是一名学生，我叫小明";
    // JNI 设置Java变量
    jclass jc = env->GetObjectClass(thiz);
    jfieldID jf = env->GetFieldID(jc, "mNativePtr", "J");
    env->SetLongField(thiz, jf, (jlong)student);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_flyer_bspatchupdate_jni_Teacher_educationStudent(JNIEnv *env, jobject thiz,
                                                          jlong student_ptr) {

    if (0 != student_ptr) {
        Student *student = (Student*)student_ptr;
        student->age = student->age + 1;
        student->name;
    }
}

extern "C"
JNIEXPORT void JNICALL
Java_com_flyer_bspatchupdate_jni_Teacher_releaseStudent(JNIEnv *env, jobject thiz,
                                                        jlong student_ptr) {

    if (0 != student_ptr) {
        Student *student = (Student*)student_ptr;
        delete student;
    }
}

重要的注释已经写了，使用lldb调试发现在类Teacher的educationStudent方法和releaseStudent方法中获取到的确是同一个对象。

能不能另辟蹊径

其实所谓的Java对象保存C或者C++对象就是为了建立Java对象与C或者C++对象的唯一对应关系，方便在下次JNI入口函数中能根据Java传递的对象获取到原来已生成的C或C++对象而已。
那么在我们学习过的数据结构中有没有这样的一种一一对应的映射的数据结构呢？如果有怎么利用起来呢？如果没有我能造一个轮子不？

我们程序员都说不要把时间浪费在造轮子之上，但是这是有前提的，不要重复造轮子这一说法在实际生产中很实用，但是却不适合放在我们学习的过程中。
我们在实际的项目中当然是建议使用业界成熟的普遍通用的轮子，这样能让我们把精力更多地放在我们的业务之上，做出更优秀的产品。

但是如果我们在学习的过程中如果不去模仿着造轮子，不去瞎搞折腾一下，你怎么知道原来知识还能这样子玩，怎么知道这个轮子能不能优化得更好呢？

关注我，一起进步，人生不止coding！！！