Android Parcelable对象序列化到磁盘以及反序列化

前言：抱着最起码的要求尽力去做好每一件事 ！ ——秋不白

内容如题，仅个人探讨，以下代码都测试通过。

        记录一次面试经历：面试官问到Serializable和Parcelable 的主要区别是什么，我说把知道的说了一遍，效率，S属于java api，P属于Android ，以及序列化的使用场景。他说不对，然后说S是系列化到磁盘，P是序列化到内存。我就百思不得其姐，决定好好研究一下。

     查找资料 以及根据AS自动生成的代码，可以理解，Parcelable的序列化和反序列化操作实际是，Parcel内部包装了可序列化的数据，也就是说序列化的时候，将数据放入，parcel的write方法,反序列化是通过CREATOR来完成的，通过获取当前线程的上下文加载器，并通过parcel的read方法，来完成反序列化操作。代码如下

Person 实体类

/**
 * Desc:
 *
 * @author: RedRose
 * Date: 2019/5/3
 * Email: yinsxi@163.com
 */

public class Person implements Parcelable {
    private int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    private Person(Parcel in) {
        age = in.readInt();
        name = in.readString();
    }

    public static final Creator<Person> CREATOR = new Creator<Person>() {
        @Override
        public Person createFromParcel(Parcel in) {
            return new Person(in);
        }

        @Override
        public Person[] newArray(int size) {
            return new Person[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

具体的序列化和反序列化

              //将parcelable 对象序列化到磁盘
            case R.id.testParcelable:
                File file = new File(PathUtil.getAppDocPath() + "testParcelable.txt");
                try {
                    if (!file.exists()) {
                        file.createNewFile();
                    }
                    Person p = new Person(1, "XueQin");
                    FileOutputStream out = (new FileOutputStream(file));
                    BufferedOutputStream bos = new BufferedOutputStream(out);
                    Parcel parcel = Parcel.obtain();
                    parcel.writeParcelable(p,0);
                    bos.write(parcel.marshall());
                    bos.flush();
                    bos.close();
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                break;
                //反序列化parcelable对象
            case R.id.readParcelable:
                try {
                    File file2 = new File(PathUtil.getAppDocPath() + "testParcelable.txt");
                    FileInputStream in = new FileInputStream(file2);
                    byte[] bytes = new byte[in.available()];
                    in.read(bytes);
                    Parcel parcel = Parcel.obtain();
                    parcel.unmarshall(bytes, 0, bytes.length);
                    parcel.setDataPosition(0);
                    Person person = parcel.readParcelable(Thread.currentThread().getContextClassLoader());
                    in.close();
                    LogUtils.e(TAG, person.toString());
                } catch (IOException e) {
                    e.printStackTrace();
                }
                break;

以及parcel的readParcelable的源码，可以参考下，通过当前线程的上下文类加载器获取到CREAOR对象。

  @SuppressWarnings("unchecked")
    public final <T extends Parcelable> T readParcelable(ClassLoader loader) {
        Parcelable.Creator<?> creator = readParcelableCreator(loader);
        if (creator == null) {
            return null;
        }
        if (creator instanceof Parcelable.ClassLoaderCreator<?>) {
          Parcelable.ClassLoaderCreator<?> classLoaderCreator =
              (Parcelable.ClassLoaderCreator<?>) creator;
          return (T) classLoaderCreator.createFromParcel(this, loader);
        }
        return (T) creator.createFromParcel(this);
    }

总结：知识如浩瀚的海洋，加油吧，我们一起。