序列化

量子计算9 · 发表于 2021-10-26 07:44

序列化

计算机中最原始的数据就是0和1，有电才能驱动计算机运行，1和0对应电的正负，易经有太极生两仪，两仪生四象，四象生八卦，八卦衍万物，所以0和1可衍生万物，万物皆对象，那这对象怎么保存，最简单就是保存0和1就行，对象转变成0和1就是序列化，0和1转成对象就是反序列化

存储数据和传输数据

简单举的例子：

存储：在java中的面向对象编程中，数据通常是用一个字段表示，如名字name=张三，字段为name,value为张三，这个字段在一个类对象中，计算机并不认得这个对象，持久保存"张三"就需要把这个对象序列化成2进制串保存在硬盘上。

传输：传输和存储是一样的，上面说的存储就是内存传硬盘，另一种场景，两台计算机之间传输数据，序列化后的数据是0和1的2进制串，假如两台计算机连着一根金属线，在这跟金属线上通电与断电表示1或0，这样另一台计算机得到2进制串后进行反序列化，就可以得到内容相同的对象了。

序列化故名思意就是按序排列变化，"序"就是某种协议，按这种协议排列变成另一种形态

简单的概括

以上得知序列化是将一个对象中的数据保存或传输，切入点就是这个对象，怎么样使这个对象能被序列化？

Serializable：可序列化的

Serializable是一个空接口，中文意思使可序列化的，意思使实现了这个接口的javaBean类可以序列化成2进制串，使用ObjectOutputStream 序列化，ObjectInputStream 反序列化。
public class SPerson implements Serializable {//serialVersionUID 是 Java 为每个序列化类产生的版本标识，可用来保证在反序列时，发送方发送的和接受方接收的是可兼容的对象。如果接收方接收的类的 //serialVersionUID 与发送方发送的 serialVersionUID 不一致，进行反序列时会抛出 InvalidClassException // private static final long serialVersionUID = 2088008379212083287L; private String name; private int age;}public class SerializeableTest { public static void main(String[] args){ SPerson sPerson1 =new SPerson(); sPerson1.setName("张三"); sPerson1.setAge(18); System.out.println("serializable="+ sPerson1.getName()+"--"+ sPerson1.getAge()); try { ByteArrayOutputStream baos=new ByteArrayOutputStream(); ObjectOutputStream oos=new ObjectOutputStream(baos); oos.writeObject(sPerson1); byte[] bs2= baos.toByteArray(); System.out.println("serializable序列化后="+ Arrays.toString(bs2)); ObjectInputStream ojis=new ObjectInputStream(new ByteArrayInputStream(bs2)); SPerson sPerson2 = (SPerson) ojis.readObject(); System.out.println("serializable反序列化="+ sPerson2.getName()+"--"+ sPerson2.getAge()); } catch (Exception e) { e.printStackTrace(); } }}
打印结果：

serializable=张三--18
serializable序列化后=[-84, -19, 0, 5, 115, 114, 0, 39, 99, 111, 109, 46, 100, 98, 102, 46, 106, 97, 118, 97, 115, 116, 117, 100, 121, 46, 115, 101, 114, 105, 97, 108, 105, 122, 97, 116, 105, 111, 110, 46, 83, 80, 101, 114, 115, 111, 110, 28, -6, 24, -114, -30, -7, -80, 87, 2, 0, 2, 73, 0, 3, 97, 103, 101, 76, 0, 4, 110, 97, 109, 101, 116, 0, 18, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 120, 112, 0, 0, 0, 18, 116, 0, 6, -27, -68, -96, -28, -72, -119]
serializable反序列化=张三--18

Serializable 有以下几个特点：

坑点：
  SPerson sPerson1 =new SPerson();       sPerson1.setName("张三");       sPerson1.setAge(18);ByteArrayOutputStream baos=new ByteArrayOutputStream();ObjectOutputStream oos=new ObjectOutputStream(baos);oos.writeObject(sPerson1);sPerson1.setName("李四");//oos.writeUnshared(sPerson1);不共享oos.writeObject(sPerson1);共享  ObjectInputStream ojis=new ObjectInputStream(new ByteArrayInputStream(bs2));          SPerson sPerson2 = (SPerson) ojis.readObject();          SPerson sPerson3 = (SPerson) ojis.readObject();//以上是想保存一个李四18，设置李四后调用oos.writeObject(sPerson1) 反序列化出来的是两个张三，得用oos.writeUnshared(sPerson1)；
Parcelable 可打包的

Parcelable是Android为我们提供的序列化的接口,Parcelable相对于Serializable的使用相对复杂一些,但Parcelable的效率相对Serializable也高很多,Parcelable vs Serializable 号称快10倍的效率

Parcelable是Android SDK提供的，它是基于内存的，由于内存读写速度高于硬盘，因此Android中的跨进程对象的传递一般使用Parcelable
public class PPerson implements Parcelable { private String name; private int age;//反序列化时构建对象，序列化的数据包在Parcel中，Parcel就是包裹的意思 protected PPerson(Parcel in) {       name = in.readString();       age = in.readInt(); }//构建器，构造一个PPerson对象和PPerson数组对象 public static final Creator<PPerson> CREATOR = new Creator<PPerson>() {       @Override       public PPerson createFromParcel(Parcel in) {          return new PPerson(in);       }       @Override       public PPerson[] newArray(int size) {          return new PPerson[size];       } };//描述包含在这个 Parcelable 实例的封送表示中的特殊对象的种类。例如，如果对象将在 {@link writeToParcel(Parcel, int)} 的输出中包含文件描述符，则此方法的返回值必须包含 {@link CONTENTS_FILE_DESCRIPTOR} 位。 @return 一个位掩码，指示由此 Parcelable 对象实例编组的一组特殊对象类型。 @Override public int describeContents() {       return 0; }//将数据打包到Parcel @Override public void writeToParcel(Parcel dest, int flags) {       dest.writeString(name);       dest.writeInt(age); }}
Android也是基于linux，进程之间内存不共享，因此进程之间的信息传递需要序列化与反序列化，通常在四大组件之间传递对象需要将对象序列化，启动一个Activity交给AMS完成，AMS全名ActivityManagerService,是系统服务，是另一个进程，这里就得序列化了，关于启动四大组件是比较复杂得流程，可以看看下面的文章

startActivity启动过程分析：http://gityuan.com/2016/03/12/start-activity/

Android中Intent/Bundle的通信原理及大小限制

速度快，比如两个Activity之间传递，Activity用于页面展示，速度一定得快，其次数据量也不能过大，大数据传输，肯定会导致速度变慢，能感觉页面明显切换得慢了，数据过大时会报一个错误，

Intent 中的 Bundle 是使用 Binder 机制进行数据传送的。能使用的 Binder 的缓冲区是有大小限制的（有些手机是 2 M），而一个进程默认有 16 个 Binder 线程，所以一个线程能占用的缓冲区就更小了（有人以前做过测试，大约一个线程可以占用 128 KB）。所以当你看到 The Binder transaction failed because it was too large 这类 TransactionTooLargeException 异常时，你应该知道怎么解决了

怎么实现跨进程通信，通过AIDL快速生成代码,下面是生成的部分代码
@Override public void addPerson(com.dbf.studyandtest.myaidl.Person person) throws android.os.RemoteException{ //先获得传入和传出的打包对象Parcel，看到obtain应该是用了享元模式，与handler传消息的message一样，对象频繁使用，减少new,重复利用已经new好的对象  android.os.Parcel _data = android.os.Parcel.obtain();//传入数据，就是给另一个进程的数据  android.os.Parcel _reply = android.os.Parcel.obtain();//传出数据，就是另一个进程回传的数据  try { _data.writeInterfaceToken(DESCRIPTOR); if ((person!=null)) {    _data.writeInt(1);    person.writeToParcel(_data, 0);//将数据写入Parcel，可以看到我们实现Parcelable的类，调用的是native方法 } else {    _data.writeInt(0); } boolean _status = mRemote.transact(Stub.TRANSACTION_addPerson, _data, _reply, 0); if (!_status && getDefaultImpl() != null) {    getDefaultImpl().addPerson(person);    return; } _reply.readException(); if ((0!=_reply.readInt())) {    person.readFromParcel(_reply);//从Parcel读出数据，可以看到我们实现Parcelable的类，也是调用native方法 }  }  finally {    //最后释放 _reply.recycle(); _data.recycle();  }}
linux中分用户空间和内核空间，先从用户空间其中一个进程cp到内核空间，再从内核空间映射到用户空间的另一个进程，想要达到这个目的要继承Binder实现IInterface，代码形式都是固定的，所以有了AIDL,Android Interface Definition Language,即Android接口定义语言
Parcelable与Serializable的性能比较

Serializable性能分析

Serializable是Java中的序列化接口，其使用起来简单但开销较大（因为Serializable在序列化过程中使用了反射机制，故而会产生大量的临时变量，从而导致频繁的GC），并且在读写数据过程中，它是通过IO流的形式将数据写入到硬盘或者传输到网络上。
Parcelable性能分析

Parcelable则是以IBinder作为信息载体，在内存上开销比较小，因此在内存之间进行数据传递时，推荐使用Parcelable,而Parcelable对数据进行持久化或者网络传输时操作复杂，一般这个时候推荐使用Serializable。
性能比较总结描述

首先Parcelable的性能要强于Serializable的原因我需要简单的阐述一下

在读写数据的时候,Parcelable是在内存中直接进行读写,而Serializable是通过使用IO流的形式将数据读写入在硬盘上.
但是：虽然Parcelable的性能要强于Serializable,但是仍然有特殊的情况需要使用Serializable,而不去使用Parcelable,因为Parcelable无法将数据进行持久化,因此在将数据保存在磁盘的时候,仍然需要使用后者,因为前者无法很好的将数据进行持久化.(原因是在不同的Android版本当中,Parcelable可能会不同,因此数据的持久化方面仍然是使用Serializable)

Protobuf

一、配置protobuf

插件github地址：https://github.com/google/protobuf-gradle-plugin

1.在项目根目录的build.gradle中配置：
dependencies { classpath 'com.android.tools.build:gradle:4.1.2' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.17'//protobuf插件}
2.在模块中的build.gradle中配置：
apply plugin: 'com.android.application'apply plugin: 'kotlin-android'apply plugin: 'kotlin-android-extensions'apply plugin: 'com.google.protobuf'//protobuf插件android { ...       sourceSets {       main {          java {          srcDir 'src/main/java'          }          proto {             srcDir 'src/main/proto'//添加protobuf目录，在里面编写需要序列化的文件          }       }       }}protobuf { //配置protoc编译器 protoc {       artifact = 'com.google.protobuf:protoc:3.8.0'//这里的版本跟斜面依赖的版本一致 } //这里配置生成目录，编译后会在build的目录下生成对应的java文件 generateProtoTasks {       all().each { task ->          task.builtins {             remove java          }          task.builtins {             java {}          }       } }}dependencies { implementation 'com.google.protobuf:protobuf-java:3.8.0'}
3.Settings  Plugins  搜索安装 Protobuf Support 插件，装好后可以识别出.proto文件

二、编写protobuf

.proto文件编写 github地址：https://github.com/protocolbuffers/protobuf

proto3本版本java:https://developers.google.com/protocol-buffers/docs/proto3

例子：
syntax = "proto3";//版本之前有proto2//package tutorial;/**java_multiple_files = true选项可以生成单独的.java每个生成的类的文件（而不是.java为包装类生成单个文件的遗留行为，使用包装类作为外部类，并将所有其他类嵌套在包装类中）。 */option java_multiple_files = true;/** java_package指定生成的类应该使用的 Java 包名称。如果您没有明确指定，它只是匹配package声明给出的包名，但这些名称通常不是合适的 Java 包名（因为它们通常不以域名开头）。 */option java_package = "com.dbf.studyandtest.proto";/**java_outer_classname选项定义将表示此文件的包装类的类名。如果你不java_outer_classname明确给出a ，它会通过将文件名转换为大写驼峰来生成。例如，默认情况下，“my_proto.proto”将使用“MyProto”作为包装类名称。 */option java_outer_classname = "_Person";message Person{  /**每个元素上的“= 1”、“= 2”标记标识字段在二进制编码中使用的唯一“标签”。  标记数字 1-15 需要比更高数字少一个字节来编码，因此作为一种优化，您可以决定将这些标记用于常用或重复的元素，  而将标记 16 和更高的标记用于不太常用的可选元素。重复字段中的每个元素都需要重新编码标签编号，因此重复字段特别适合这种优化。 */  //指定字段的类型定义字段的编号，在Protocol Buffers中，字段的编号非常重要，字段名仅仅是作为参考和生成代码用。需要注意的是字段的编号区间范围，其中19000 ～ 19999被Protocol Buffers作为保留字段  string name = 1;  int32  age  = 2;//  message Home{// string address = 1;//  }//  Home home = 3;}//message Family {//  Person person = 1;//}
Make project 一下自动生成代码
/** * Protobuf type {@code Person} */public  final class Person extends com.google.protobuf.GeneratedMessageV3 implements PersonOrBuilder {//省略600多行代码}
与Serializable对比
public static void main(String[] args) throws  Exception{ Person person = Person.newBuilder().setName("张三").setAge(18).build(); System.out.println("protobuf="+person.getName()+"--"+person.getAge()); //序列化 byte[] bs=person.toByteArray(); System.out.println("protobuf序列化后="+Arrays.toString(bs)); Person person2=Person.parseFrom(bs); System.out.println("protobuf反序列化="+person2.getName()+"--"+person2.getAge()); System.out.println("\n----------------分割线-------------\n"); SPerson sPerson1 =new SPerson(); sPerson1.setName("张三"); sPerson1.setAge(18); System.out.println("serializable="+ sPerson1.getName()+"--"+ sPerson1.getAge()); try {       ByteArrayOutputStream baos=new ByteArrayOutputStream();       ObjectOutputStream oos=new ObjectOutputStream(baos);       oos.writeObject(sPerson1);       byte[] bs2=  baos.toByteArray();       System.out.println("serializable序列化后="+Arrays.toString(bs2));       ObjectInputStream ojis=new ObjectInputStream(new ByteArrayInputStream(bs2));       SPerson sPerson2 = (SPerson) ojis.readObject();       System.out.println("serializable反序列化="+ sPerson2.getName()+"--"+ sPerson2.getAge()); } catch (Exception e) {       e.printStackTrace(); }}
打印结果：

protobuf=张三--18
protobuf序列化后=[10, 6, -27, -68, -96, -28, -72, -119, 16, 18]
protobuf反序列化=张三--18

----------------分割线-------------

serializable=张三--18
serializable序列化后=[-84, -19, 0, 5, 115, 114, 0, 39, 99, 111, 109, 46, 100, 98, 102, 46, 106, 97, 118, 97, 115, 116, 117, 100, 121, 46, 115, 101, 114, 105, 97, 108, 105, 122, 97, 116, 105, 111, 110, 46, 83, 80, 101, 114, 115, 111, 110, 28, -6, 24, -114, -30, -7, -80, 87, 2, 0, 2, 73, 0, 3, 97, 103, 101, 76, 0, 4, 110, 97, 109, 101, 116, 0, 18, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 120, 112, 0, 0, 0, 18, 116, 0, 6, -27, -68, -96, -28, -72, -119]
serializable反序列化=张三--18

		自动登录	找回密码
密码			立即注册