JNI基础 - 从学Parcel源码开始

1、Parcelable和Serializable的异同

我们知道在Java应用程序当中对类进行序列化操作只需要实现Serializable接口就可以，由系统来完成序列化和反序列化操作。但是在Android中序列化操作有另外一种方式来完成，那就是实现Parcelable接口。Parcelable的性能要强于Serializable，因此在绝大多数的情况下，Android还是推荐使用Parcelable来完成对类的序列化操作的。

Parcelable和Serializable的性能对比如下所述：

• 后者在序列化操作的时候会产生大量的临时变量，(原因是使用了反射机制)从而导致GC的频繁调用，因此在性能上会稍微逊色。

• Parcelable是以Ibinder作为信息载体的，在内存上的开销比较小，因此在内存之间进行数据传递的时Android推荐使用Parcelable。

• 在读写数据的时候，Parcelable是在内存中直接进行读写，而Serializable是通过使用IO流的形式将数据读写入在硬盘上。

2、浅析Parcel源码

public final class Parcel {
    // 保存的是 c++ 层的 Parcel.cpp 对象的指针地址
    private long mNativePtr; // used by native code

    private Parcel(long nativePtr) {
        if (DEBUG_RECYCLE) {
            mStack = new RuntimeException();
        }
        init(nativePtr);
    }

    private void init(long nativePtr) {
        if (nativePtr != 0) {
            mNativePtr = nativePtr;
            mOwnsNativeParcelObject = false;
        } else {
            mNativePtr = nativeCreate();
            mOwnsNativeParcelObject = true;
        }
    }

    /**
     * Write an integer value into the parcel at the current dataPosition(),
     * growing dataCapacity() if needed.
     */
    public final void writeInt(int val) {
        nativeWriteInt(mNativePtr, val);
    }

    /**
     * Read an integer value from the parcel at the current dataPosition().
     */
    public final int readInt() {
        return nativeReadInt(mNativePtr);
    }
    // 创建 Parcel.cpp 返回 jlong
    private static native long nativeCreate();
    // 写入 int 数据
    private static native void nativeWriteInt(long nativePtr, int val);
    // 读 int 数据
    private static native int nativeReadInt(long nativePtr);
}

// 创建 Parcel ，返回指针地址给 java 层
static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
{
    Parcel* parcel = new Parcel();
    return reinterpret_cast(parcel);
}

// 通过指针地址获取 c++ 层的对象，然后进行操作
static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) {
    Parcel* parcel = reinterpret_cast(nativePtr);
    if (parcel != NULL) {
        const status_t err = parcel->writeInt32(val);
        if (err != NO_ERROR) {
            signalExceptionForError(env, clazz, err);
        }
    }
}

status_t Parcel::writeInt32(int32_t val)
{
    return writeAligned(val);
}

template
status_t Parcel::writeAligned(T val) {
    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE_UNSAFE(sizeof(T)) == sizeof(T));
    // 判断大小有没有超过
    if ((mDataPos+sizeof(val)) <= mDataCapacity) {
restart_write:
        // 往内存上写入数据
        *reinterpret_cast(mData+mDataPos) = val;
        // 返回写入成功
        return finishWrite(sizeof(val));
    }
    // 返回错误
    status_t err = growData(sizeof(val));
    if (err == NO_ERROR) goto restart_write;
    return err;
}

int32_t Parcel::readInt32() const
{
    return readAligned();
}

template
T Parcel::readAligned() const {
    T result;
    if (readAligned(&result) != NO_ERROR) {
        result = 0;
    }
    return result;
}

template
status_t Parcel::readAligned(T *pArg) const {
    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE_UNSAFE(sizeof(T)) == sizeof(T));
    // 有没有超出
    if ((mDataPos+sizeof(T)) <= mDataSize) {
        // 去除当前内存上的值
        const void* data = mData+mDataPos;
        // 当前累加往后逻动
        mDataPos += sizeof(T);
        // 取出来并赋值
        *pArg =  *reinterpret_cast(data);
        return NO_ERROR;
    } else {
        return NOT_ENOUGH_DATA;
    }
}

Parcel 其实就是在 native 层开辟了一块内存，然后按照一定的顺序往这块内存里面写数据。当我需要取数据的时候，我们按照原来写的顺序取出来就可以了。写的顺序和取的顺序必须保持一致，不然肯定会出错。

接下来手动简单实现一下，既能学习JNI的知识又能加深印象。

3、实践

现在我们新建一个Parcel类,里面有四个native方法。

//  找到Parcel.class,使用“javap -s Parcel”查看方法签名 
public class Parcel {
    private static long mNativePtr = 0;

    static {
        System.loadLibrary("ndksample");
        mNativePtr = nativeCreate();
    }

    void writeInt(int value) {
        nativeWriteInt(mNativePtr, value);
    }

    int readInt() {
        return nativeReadInt(mNativePtr);
    }

    void setDataPosition(int pos) {
        nativeSetDataPosition(mNativePtr, pos);
    }

    static native long nativeCreate();

    native void nativeWriteInt(long nativePtr, int value);

    native int nativeReadInt(long nativePtr);

    native void nativeSetDataPosition(long nativePtr, int pos);
}

接下来写JNI部分，首先是Parcel.h。

#ifndef NDKSAMPLE_PARCEL_H
#define NDKSAMPLE_PARCEL_H
#include 
#include 
class Parcel {
private:
    char *mData;
    int mDataPos;

public:
    Parcel() {
        mData = (char *) malloc(1024);
        mDataPos = 0;
    }

    ~ Parcel() {
        free(mData);
    }

    void writeInt(int value) {
        *reinterpret_cast(mData + mDataPos) = value;
        mDataPos += sizeof(value);
    }

    int readInt() {
        int result = *reinterpret_cast(mData + mDataPos);
        mDataPos += sizeof(int);
        return result;
    }

    void setDataPosition(int pos) {
        mDataPos = pos;
    }

};
#endif //NDKSAMPLE_PARCEL_H

最后是写Native-lib.cpp代码：

#include 
#include 
#include 
#include "Parcel.h"
#define TAG    "@@" 
#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,TAG,__VA_ARGS__) 

jlong jni_nativeCreate(JNIEnv *env, jobject jobject1) {
    Parcel *parcel = new Parcel();
    return reinterpret_cast(parcel);
}

void jni_nativeWriteInt(JNIEnv *env, jobject jobject1,jlong nativePtr, jint value) {
    Parcel *parcel = reinterpret_cast(nativePtr);
    parcel->writeInt(value);
}

jint jni_nativeReadInt(JNIEnv *env, jobject jobject1,jlong nativePtr) {
    Parcel *parcel = reinterpret_cast(nativePtr);
    return parcel->readInt();
}


void jni_nativeSetDataPosition(JNIEnv *env, jobject jobject1,jlong nativePtr, jint pos) {
    Parcel *parcel = reinterpret_cast(nativePtr);
    parcel->setDataPosition(pos);

}


//  第一个参数a 是java native方法名，
//  第二个参数 是native方法参数,括号里面是传入参的类型，外边的是返回值类型，
//  第三个参数 是c/c++方法名。
static const JNINativeMethod nativeMethod[] = {
        {"nativeCreate",          "()J",   (void *) jni_nativeCreate},
        {"nativeWriteInt",        "(JI)V", (void *) jni_nativeWriteInt},
        {"nativeReadInt",         "(J)I",  (void *) jni_nativeReadInt},
        {"nativeSetDataPosition", "(JI)V", (void *) jni_nativeSetDataPosition}

};

static int registNativeMethod(JNIEnv *env) {
    int result = -1;

    jclass class_text = env->FindClass("com.dawn.ndksample.Parcel");
    if (env->RegisterNatives(class_text, nativeMethod,
                             sizeof(nativeMethod) / sizeof(nativeMethod[0])) == JNI_OK) {
        result = 0;
    }
    return result;
}

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    int result = -1;

    if (vm->GetEnv((void **) &env, JNI_VERSION_1_1) == JNI_OK) {
        if (registNativeMethod(env) == JNI_OK) {
            result = JNI_VERSION_1_6;
        }
        return result;
    }
}

验证：

public class MainActivity extends AppCompatActivity {
    
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Parcel parcel = new Parcel();
        parcel.writeInt(123);
        parcel.writeInt(456);
        parcel.setDataPosition(0);
        int result = parcel.readInt();
        int result2 = parcel.readInt();
        Log.d("@@","result:"+result+",result2:"+result2);
    }
    
    // 输出结果 >>>  result:123,result2:456
    
}

P.S. 上面的cpp代码使用了动态注册的写法，如有不了解的请先自行百度，我将在下次补充。

撒花，谢谢大家的阅读。