序列化的过程

序列化：

将数据结构或对象转换成二进制的过程。

序列化的用途： 网络上，跨进程

序列化方案：json xml protobuf serializable（java） percelable（Android独有）....

持久化：

把数据结构或对象存储起来 硬盘

如何选择合理的序列化方案。

Serializable学习：

//里面没有任何方法，就是一个标志。

public interface Serializable { }

public interface Externalizable extends java.io.Serializable {

    void writeExternal(ObjectOutput out) throws IOException;

    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

}

案例一

   
    /*
      如果没有实现Serializable，执行就会报错
      Caused by: java.io.NotSerializableException: 
                 com.android.serializable.SerializableTest$User
     */
    static class User  { //定义非基本数据类型的对象，不实现序列化
        private String mName;
        private int mAge;
        public User(String name, int age) {
            mName = name;
            mAge = age;
        }
        @Override
        public String toString() {
            return "User{" +
                    "mName='" + mName + '\'' +
                    ", mAge=" + mAge +
                    '}';
        }
    }

//对它进行写出操作，path为磁盘路径
outputStream = new ObjectOutputStream(new FileOutputStream(path));
outputStream.writeObject(object);

//对它进行读入操作
inputStream = new ObjectInputStream(new FileInputStream(path));
 return inputStream.readObject();

在上面的案例可以看出当中就算user实现了Serializable接口，也要自己使用对象的IO流（ObjectOutput，ObjectInput ）辅助实现序列化。

  static class User implements Externalizable {
        private String mName;
        private int mAge;

        public User(){} //使用Externalizable 必要要有无参构造函数

        public User(String name, int age) {
            mName = name;
            mAge = age;
        }
        @Override
        public String toString() {
            return "User{" +
                    "mName='" + mName + '\'' +
                    ", mAge=" + mAge +
                    '}';
        }
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            //方便指定哪些成员变量需要序列化，哪些成员变量不需要序列化
            out.writeObject(mName);
            out.writeInt(mAge);
        }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            mName = (String) in.readObject();
            mAge = in.readInt();
        }
    }


 private static void externalizableTest(){
        User user = new User("fw123",18);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = null;
        byte[] userDate = null;
        try {
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(user);
            userDate = byteArrayOutputStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }

        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream = new ObjectInputStream(new ByteArrayInputStream(userDate));
            User object = (User) objectInputStream.readObject();
            System.out.println("fw123 object: " + object);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

上面必须要注意的是：使用Externalizable 必须要有无参构造函数。

问题一 serialVersionUID的作用：

上面的两个案例都没有定义常量，可是可以进行正常完成的：

private static final long serialVersionUID = 7579060052569229166L;

既然没有serialVersionUID也没报错，那这个有什么作用吗？

1.作用将对象A进行序列化，2 .修改A，3.反序列化A。 如果有了serialVersionUID将不会报错。

问题二  序列化时，你希望某些成员变量不需要序列化，你如何实现昵？

就是将这个变量定义为静态或者瞬态(trasient)变量。反序列化以后，被这个修饰的变量打印出来为null。我自己测试静态的变量是可以反序列化，这里有问题？？？

// 静态成员变量属于类不属于对象，所以不会参与序列化 ( 对象序列化保存的是对象的 “ 状态 ” ，也

就是它的成员变量，因此序列化不会关注静态变量 )

问题三， 如果类中的一个成员未实现可序列化接口，会发生什么？

运行时会报NotSerializableException异常。

问题四 如何自定义序列化过程，

在类中写下面两个函数就可以了。 

 private void writeObject(ObjectOutputStream out) throws IOException{}

 private void readObject(ObjectInputStream in) throws IOException{}

如果父类可以序列化，那么它的子类也是可以序列化的。如果子类不想序列化，就可以复写上面的方法抛出异常就可以了。

Serializable源码分析：

首先：
ObjectOutputStream.java#writeObject(Object obj)
--->writeObject0(Object obj, boolean unshared)
--->} else if (obj instanceof Serializable) {
   writeOrdinaryObject(obj, desc, unshared);}
-->
if (desc.isExternalizable() && !desc.isProxy()) {
     writeExternalData((Externalizable) obj);//是不是实现Externalizable
 } else {
   writeSerialData(obj, desc);
 }
--writeString((String) obj, unshared);//一层一层往下走，直到最后的对象是基本数据类型


在writeSerialData中：
 
    private void writeSerialData(Object obj, ObjectStreamClass desc)
         
    {
      
            if (slotDesc.hasWriteObjectMethod()) {//如果有自定义WriteObject函数，将走这里
              
             slotDesc.invokeWriteObject(obj, this);

            } else {
                defaultWriteFields(obj, slotDesc);// 没有自定义WriteObject，将走这里
            }
        }
    }

在使用为什么需要无参构造函数：
在ObjectInputStream#readObject()--》readObject0-》readOrdinaryObject(unshared)
---》
try {
    obj = desc.isInstantiable() ? desc.newInstance() : null;
} catch (Exception ex) {
     throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
}

1.反序列化后的对象，不需要调用构造函数重新构造。

2.序列化前后的对象是地址是不一样的，是深拷贝关系，但是枚举类型是一样。

3.Bundle的内部有变量mMap（ArrayMap<String, Object>）这个比Map的存储大小有优化，

4.