Android数据序列化总结

embedded/2024/12/23 1:52:47/

Android数据序列化总结

什么是序列化

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。
二进制序列化保持类型保真度，这对于在应用程序的不同调用之间保留对象的状态很有用。例如，通过将对象序列化到剪贴板，可在不同的应用程序之间共享对象。您可以将对象序列化到流、磁盘、内存和网络等等。远程处理使用序列化“通过值”在计算机或应用程序域之间传递对象。

简单地说，“序列化”就是将运行时的对象状态转换成二进制，然后保存到流、内存或者通过网络传输给其他端。
在安卓开发中，我们在组件中传递数据时常常使用 Intent 传输数据时需要传递 Serializable 或者 Parcelable 的数据，比如 Intent.putExtra 方法：

public Intent putExtra(String name, Parcelable value) {...}
public Intent putExtra(String name, Serializable value) {...}

也会使用 Binder 传递数据。

Serializable 接口

Serializable 是 Java 提供的序列化接口，它是一个空接口:

public interface Serializable {
}

Serializable 用来标识当前类可以被 ObjectOutputStream 序列化，以及被 ObjectInputStream 反序列化。
Serializable 有以下几个特点：

  • 可序列化类中，未实现 Serializable 的属性状态无法被序列化/反序列化
  • 也就是说，反序列化一个类的过程中，它的非可序列化的属性将会调用无参构造函数重新创建
  • 因此这个属性的无参构造函数必须可以访问，否者运行时会报错
  • 一个实现序列化的类，它的子类也是可序列化的

下面是一个实现了 Serializable 的实体类：

public class GroupBean implements Serializable {private static final long serialVersionUID = 8829975621220483374L;private String mName;private List<String> mMemberNameList;public GroupBean() {}public String getName() {return mName;}public void setName(String name) {mName = name;}public List<String> getMemberNameList() {return mMemberNameList;}public void setMemberNameList(List<String> memberNameList) {mMemberNameList = memberNameList;}
}

可以看到实现 Serializable 的实现非常简单，除了实体内容外只要创建一个 serialVersionUID 属性就好。

serialVersionUID

从名字就可以看出来，这个 serialVersionUID ，有些类似我们平时的接口版本号，在运行时这个版本号唯一标识了一个可序列化的类。

也就是说，一个类序列化时，运行时会保存它的版本号，然后在反序列化时检查你要反序列化成的对象版本号是否一致，不一致的话就会报错：·InvalidClassException。

如果我们不自己创建这个版本号，序列化过程中运行时会根据类的许多特点计算出一个默认版本号。然而只要你对这个类修改了一点点，这个版本号就会改变。这种情况如果发生在序列化之后，反序列化时就会导致上面说的错误。

因此 JVM 规范强烈 建议我们手动声明一个版本号，这个数字可以是随机的，只要固定不变就可以。同时最好是 private 和 final 的，尽量保证不变。

此外，序列化过程中不会保存 static 和 transient 修饰的属性，前者很好理解，因为静态属性是与类管理的，不属于对象状态；而后者则是 Java 的关键字，专门用来标识不序列化的属性。

默认实现 Serializable 不会自动创建 serialVersionUID 属性，为了提示我们及时创建 serialVersionUID ，可以在设置中搜索 serializable 然后选择下图所示的几个选项，为那些没有声明 serialVersionUID 属性的类以及内部类添加一个警告:
setting->Editor->Inspections->搜索serializable->勾选:

  • Serializable class without’readObject()’ and ‘writeObject()’
  • Serializable class without’seriaVersionUID’
  • Serializable not-‘static’ inner class with not-Serializable outer class
  • Serializable object implicitly stores non-Serializable Object

这样当我们创建一个类不声明 UID 属性时，类名上就会有黄黄的警告,鼠标放上去就会显示警告内容：

GroupBean’ does not define a ‘serialVersionUID’ field less… (Ctrl+F1) 
Reports any Serializable classes which do not provide a serialVersionUID field. Without a serialVersionUID field, any change to a class will make previously serialized versions unreadable.

这时我们按代码提示快捷键就可以生成 serialVersionUID 了。

序列化与反序列化 Serializable

Serializable 的序列化与反序列化分别通过 ObjectOutputStream 和 ObjectInputStream 进行，实例代码如下：

*** 序列化对象** @param obj* @param path* @return*/
synchronized public static boolean saveObject(Object obj, String path) {if (obj == null) {return false;}ObjectOutputStream oos = null;try {oos = new ObjectOutputStream(new FileOutputStream(path));oos.writeObject(obj);oos.close();return true;} catch (IOException e) {e.printStackTrace();} finally {if (oos != null) {try {oos.close();} catch (IOException e) {e.printStackTrace();}}}return false;
}/*** 反序列化对象** @param path* @param <T>* @return*/
@SuppressWarnings("unchecked ")
synchronized public static <T> T readObject(String path) {ObjectInputStream ojs = null;try {ojs = new ObjectInputStream(new FileInputStream(path));return (T) ojs.readObject();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();} finally {close(ojs);}return null;
}

Parcelable 接口

Parcelable 是 Android 特有的序列化接口：

public interface Parcelable {//writeToParcel() 方法中的参数，用于标识当前对象作为返回值返回//有些实现类可能会在这时释放其中的资源public static final int PARCELABLE_WRITE_RETURN_VALUE = 0x0001;//writeToParcel() 方法中的第二个参数，它标识父对象会管理内部状态中重复的数据public static final int PARCELABLE_ELIDE_DUPLICATES = 0x0002;//用于 describeContents() 方法的位掩码，每一位都代表着一种对象类型public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001;//描述当前 Parcelable 实例的对象类型//比如说，如果对象中有文件描述符，这个方法就会返回上面的 CONTENTS_FILE_DESCRIPTOR//其他情况会返回一个位掩码public int describeContents();//将对象转换成一个 Parcel 对象//参数中 dest 表示要写入的 Parcel 对象//flags 表示这个对象将如何写入public void writeToParcel(Parcel dest, int flags);//实现类必须有一个 Creator 属性，用于反序列化，将 Parcel 对象转换为 Parcelable public interface Creator<T> {public T createFromParcel(Parcel source);public T[] newArray(int size);}//对象创建时提供的一个创建器public interface ClassLoaderCreator<T> extends Creator<T> {//使用类加载器和之前序列化成的 Parcel 对象反序列化一个对象public T createFromParcel(Parcel source, ClassLoader loader);}
}

实现了 Parcelable 接口的类在序列化和反序列化时会被转换为 Parcel 类型的数据 。
Parcel 是一个载体，它可以包含数据或者对象引用，然后通过 IBinder 在进程间传递。
实现 Parcelable 接口的类必须有一个 CREATOR 类型的静态变量，下面是一个实例：

public class ParcelableGroupBean implements Parcelable {private String mName;private List<String> mMemberNameList;private User mUser;/*** 需要我们手动创建的构造函数* @param name* @param memberNameList* @param user*/public ParcelableGroupBean(String name, List<String> memberNameList, User user) {mName = name;mMemberNameList = memberNameList;mUser = user;}/*** 1.内容描述* @return*/@Overridepublic int describeContents() {//几乎都返回 0，除非当前对象中存在文件描述符时为 1return 0;}/*** 2.序列化* @param dest* @param flags 0 或者 1*/@Overridepublic void writeToParcel(Parcel dest, int flags) {dest.writeString(mName);dest.writeStringList(mMemberNameList);dest.writeParcelable(mUser, flags);}/*** 3.反序列化*/public static final Creator<ParcelableGroupBean> CREATOR = new Creator<ParcelableGroupBean>() {/*** 反序列创建对象* @param in* @return*/@Overridepublic ParcelableGroupBean createFromParcel(Parcel in) {return new ParcelableGroupBean(in);}/*** 反序列创建对象数组* @param size* @return*/@Overridepublic ParcelableGroupBean[] newArray(int size) {return new ParcelableGroupBean[size];}};/*** 4.自动创建的的构造器，使用反序列化得到的 Parcel 构造对象* @param in*/protected ParcelableGroupBean(Parcel in) {mName = in.readString();mMemberNameList = in.createStringArrayList();//反序列化时，如果熟悉也是 Parcelable 的类，需要使用它的类加载器作为参数，否则报错无法找到类mUser = in.readParcelable(User.class.getClassLoader());}}
Parcelable原理

Parcelable具体的写入（dest.writeInt(mAge);）与读取（gril.mAge = in.readInt();）都是针对Parcel对象进行的操作，下面贴出的是Parcle 读写int类型数据的定义。


public final class Parcel {....../*** Write an integer value into the parcel at the current dataPosition(),* growing dataCapacity() if needed.*/public final native void writeInt(int val);/*** Read an integer value from the parcel at the current dataPosition().*/public final native int readInt();......
}

从上面代码可以看出都是native方法说明都是使用JNI，其具体位置在frameworks/base/core/jni/android_util_Binder.cpp ，以下也仅以int类型读写为例

static void android_os_Parcel_writeInt(JNIEnv* env, jobject clazz, jint val)
{Parcel* parcel = parcelForJavaObject(env, clazz);if (parcel != NULL) {const status_t err = parcel->writeInt32(val);if (err != NO_ERROR) {jniThrowException(env, "java/lang/OutOfMemoryError", NULL);}}
}static jint android_os_Parcel_readInt(JNIEnv* env, jobject clazz)
{Parcel* parcel = parcelForJavaObject(env, clazz);if (parcel != NULL) {return parcel->readInt32();}return 0;
}

从上面可以看出都会调用Parcel实现且分别调用writeInt32与readInt32函数，接着来看看具体实现。位置：/system/frameworks/base/libs/binder/Parcel.cpp

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(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;
}status_t Parcel::readInt32(int32_t *pArg) const
{return readAligned(pArg);
}template<class T>
status_t Parcel::readAligned(T *pArg) const {COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(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;}
}

基本的思路总结一下：

  1. 整个读写全是在内存中进行，主要是通过malloc()、realloc()、memcpy()等内存操作进行，所以效率比JAVA序列化中使用外部存储器会高很多；
  2. 读写时是4字节对齐的，可以看到#define PAD_SIZE(s) (((s)+3)&~3)这句宏定义就是在做这件事情；
  3. 如果预分配的空间不够时newSize = ((mDataSize+len)*3)/2;会一次多分配50%；
  4. 对于普通数据，使用的是mData内存地址，对于IBinder类型的数据以及FileDescriptor使用的是mObjects内存地址。后者是通过flatten_binder()和unflatten_binder()实现的，目的是反序列化时读出的对象就是原对象而不用重新new一个新对象。
问题
  1. 任何实体类都需要复写Parcelable接口吗？
  2. 如果子类新增属性，需要复写父类writeToParcel与CREATOR吗？
  3. writeToParcel 与 createFromParcel 对变量的读写前后顺序可以不一致吗，会出现什么结果？
  4. 读写Parcelable对象（写操作dest.writeParcelable(obj, flags); 读操作in.readParcelable(ObjectA.class.getClassLoader()); ）
  5. 读写Parcelable对象数组

总结

可以看到，Serializable 的使用比较简单，创建一个版本号即可；而 Parcelable 则相对复杂一些，会有四个方法需要实现。

一般在保存数据到 SD 卡或者网络传输时建议使用 Serializable 即可，虽然效率差一些，好在使用方便。

而在运行时数据传递时建议使用 Parcelable，比如 Intent，Bundle 等，Android 底层做了优化处理，效率很高。

参考

  • 《探索Android中的Parcel机制（上）》
  • 《探索Android中的Parcel机制（下）》
  • 《C 语言的数据序列化 （C语言实现序列化机制的思路）
  • 《Android中的Parcel是什么》
  • 《Android开发：什么是Parcel(2)》

http://www.ppmy.cn/embedded/114611.html

相关文章

SpringBoot Admin调整类的日志级别

SpringBoot Admin调整类的日志级别

进入 SpringBoot Admin &#xff0c;通过服务名称&#xff0c; 找到服务后。 点击 “日志” – “日志配置” &#xff0c;输入类名&#xff0c;即可调整 这个类的日志级别。
阅读更多...
2024华为杯研赛E题保姆级教程思路分析

2024华为杯研赛E题保姆级教程思路分析

E题题目&#xff1a;高速公路应急车道紧急启用模型 今年的E题设计到图像/视频处理&#xff0c;实际上&#xff0c;E题的难度相对来说较低&#xff0c;大家不用畏惧视频的处理&#xff0c;被这个吓到。实际上&#xff0c;这个不难&#xff0c;解决了视频的处理问题&#xff0c;…
阅读更多...
数据结构day1

数据结构day1

1、p 和 "hello,world"存储在内存哪个区域&#xff1f; int main() { char *p "hello,world"; return 0; } p在栈区&#xff0c;因为p是一个局部变量。"hello,world"在只读区域&#xff08;.ro段&#xff09;&#xff0c;因为"hello,world…
阅读更多...
Linux环境基础开发工具---vim

Linux环境基础开发工具---vim

1.快速的介绍一下vim vim是一款多模式的编辑器&#xff0c;里面有很多子命令&#xff0c;来实现代码编写操作。 2.vim的模式 vim一共有三种模式&#xff1a;底行模式&#xff0c;命令模式&#xff0c;插入模式。 2.1vim模式之间的切换 2.2 谈论常见的模式---命令模式&#xf…
阅读更多...
弃置区原因

弃置区原因

线性卷积&#xff0c;不用担心滤波器周期化的情况。圆周卷积在一周期内&#xff0c;一定有所有的点&#xff0c;所以信号进来的时候&#xff0c;剩下的信号一定在周期内&#xff0c;导致卷积结果不正确。 补零的圆周卷积就是为了&#xff0c;信号进来的时候&#xff0c;让其他的…
阅读更多...
React【1】【ref常用法】

React【1】【ref常用法】

文章目录 前言用途1. 储存2. 储存dom句柄ref 前言 react组件每次调用setState的时候都会重新执行函数组件或者class组件 用途 1. 储存 每次调用setState时&#xff0c;组件函数都会重新执行。下面这种情况点击提交后&#xff0c;再点击取消&#xff0c;会发现定时器trimId1仍…
阅读更多...
【Vue系列四】—Vue学习历程的知识分享！

【Vue系列四】—Vue学习历程的知识分享！

前言 本篇讲述Vue中路由的使用 一、路由 路由就是一种对应关系 之前的后端渲染&#xff08;存在性能问题&#xff09; Ajax 前端渲染&#xff08;性能ok&#xff0c;但是不支持浏览器的前进后退操作&#xff09; SPA&#xff08;Single Page Application&#xff09;单页应…
阅读更多...
练习题 - Django 4.x Models Meta 元数据选项

练习题 - Django 4.x Models Meta 元数据选项

在 Django 中&#xff0c;Meta 类是模型定义的一部分&#xff0c;用于配置模型的各种行为特性。通过使用 Meta 元数据选项&#xff0c;开发者可以控制模型的排序、权限、数据库表名等属性&#xff0c;提供了灵活性和定制化。在实际的 web 应用开发中&#xff0c;合理配置 Meta …
阅读更多...
最新文章

Copyright @ 2022~2023