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<jlong>(parcel);
}
// 通过指针地址获取 c++ 层的对象，然后进行操作
static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) {
Parcel* parcel = reinterpret_cast<Parcel*>(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<class T>
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<T*>(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<int32_t>();
}
template<class T>
T Parcel::readAligned() const {
T result;
if (readAligned(&result) != NO_ERROR) {
result = 0;
}
return result;
}
template<class T>
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<const T*>(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 <malloc.h>
#include <stdio.h>
class Parcel {
private:
char *mData;
int mDataPos;
public:
Parcel() {
mData = (char *) malloc(1024);
mDataPos = 0;
}
~ Parcel() {
free(mData);
}
void writeInt(int value) {
*reinterpret_cast<int *>(mData + mDataPos) = value;
mDataPos += sizeof(value);
}
int readInt() {
int result = *reinterpret_cast<int *>(mData + mDataPos);
mDataPos += sizeof(int);
return result;
}
void setDataPosition(int pos) {
mDataPos = pos;
}
};
#endif //NDKSAMPLE_PARCEL_H
最后是写Native-lib.cpp代码：
#include <jni.h>
#include <string>
#include <android/log.h>
#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<jlong>(parcel);
}
void jni_nativeWriteInt(JNIEnv *env, jobject jobject1,jlong nativePtr, jint value) {
Parcel *parcel = reinterpret_cast<Parcel *>(nativePtr);
parcel->writeInt(value);
}
jint jni_nativeReadInt(JNIEnv *env, jobject jobject1,jlong nativePtr) {
Parcel *parcel = reinterpret_cast<Parcel *>(nativePtr);
return parcel->readInt();
}
void jni_nativeSetDataPosition(JNIEnv *env, jobject jobject1,jlong nativePtr, jint pos) {
Parcel *parcel = reinterpret_cast<Parcel *>(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代码使用了动态注册的写法，如有不了解的请先自行百度，我将在下次补充。
撒花，谢谢大家的阅读。
