落叶

闪存 Android 存储优化系列专题 SharedPreferences 系列 《Android 之不要滥用 SharedPreferences》 《Android 之不要滥用 SharedPreferences（2）— 数据丢失》 ContentProvider 系列（待更） 《Android 存储选项之 ContentProvider 启动存在的暗坑》 《Android 存储选项之 ContentProvider 深入分析》 对象序列化系列 《Android 对象序列化之你不知道的 Serializable》 《Android 对象序列化之 Parcelable 取代 Serializable ?》 《Android 对象序列化之追求性能完美的 Serial》 数据序列化系列（待更） 《Android 数据序列化之 JSON》 《Android 数据序列化之 Protocol Buffer 使用》 《Android 数据序列化之 Protocol Buffer 源码分析》 SQLite 存储系列 《Android 存储选项之 SQLiteDatabase 创建过程源码分析》 《Android 存储选项之 SQLiteDatabase 源码分析》 《数据库连接池 SQLiteConnectionPool 源码分析》 《SQLiteDatabase 启用事务源码分析》 《SQLite 数据库 WAL 模式工作原理简介》 《SQLite 数据库锁机制与事务简介》 《SQLite 数据库优化那些事儿》 前言 对象序列化系列，主要内容包括：Java 原生提供的 Serializable ，更加适合 Android 平台轻量且高效的 Parcelable，以及追求性能完美的 Serial。该系列内容主要结合源码的角度分析它们各自的优缺点以及合适的使用场景。 今天先来聊聊 Java 原生提供的 Serializable 对象序列化机制，本文不是与大家一起探讨关于 Serializable 的具体使用，相信关于 Serializable 大家肯定也不会感到陌生，Serializable 是 Java 原生的序列化机制，在 Android 中也有被广泛使用。我们可以通过 Serializable 将对象持久化存储，也可以通过 Bundle 传递 Serializable 的序列化数据。 Serializable 简单实现背后包含着复杂的计算逻辑，本文也将结合源码角度深入分析 Serializable 背后实现原理。 序列化/反序列化 什么是对象序列化 大家是否有思考过，什么是序列化？应用程序中的对象存储在内存中，如果此时我们想把对象存储下来或者在网络上传输，这个时候就需要用到对象的序列化和反序列化。 对象序列化就是把一个 Object 对象的所有信息表示成一个字节序列，这包括 Class 信息、继承关系、访问权限、变量类型以及数值信息等。 数据存储不一定就是将数据存放到磁盘中，比如放到内存中、通过网络传输也可以算是存储的一种形式。或者我们也可以把这个过程叫做对象或者数据的序列化。 Serializable 简单使用 “好像我们只需要简单实现 Serializable 接口，它就可以完成序列化/反序列化工作了”， 那它是如何工作的呢？实际上 Serializalbe 这种简单机制是通过牺牲掉执行性能为代价换来的，也就是在时间开销和使用成本的权衡上，Serializable 机制选择是使用成本优先。 public final class Person implements Serializable { private String name; private int age; private String like; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getLike() { return like; } public void setLike(String like) { this.like = like; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + ''' + ", age=" + age + ", like='" + like + ''' + '}'; } } 使用 ObjectOutputStream 将 Person 对象序列化到磁盘： public void testWritePersonObject() { Person person; ObjectOutputStream out = null; try { out = new ObjectOutputStream(openFileOutput("person", Context.MODE_PRIVATE)); person = new Person(); out.writeObject(person); } catch (IOException e) { e.printStackTrace(); } finally { IOUtil.close(out); } } 整个使用过程是不是非常简单？虽然 Serializable 使用真的非常简单，但是也有一些需要注意的事项。另外它还有一些进阶的使用技巧。文中也会详细介绍到，并且最后也会给大家总结出该部分内容。 Serializable 背后实现原理 ObjectOutputStream 和 ObjectInputStream 不知道大家是否跟我一样，在最初使用 Serializable 时是否会有这样的疑问：“我们只需要实现这个接口，好像什么都不用管了，那它是如何实现序列化的呢？” 实际上 Serializable 的实现原理分别在 ObjectOutputStream 和 ObjectInputStream 中（本文主要给大家介绍序列化过程），整个序列化过程使用了大量反射和临时变量，而且在序列化对象的时候，不仅会序列化当前对象本身，还需要递归序列化对应引用的其他对象。 先来看下 ObjectObjectStream 的构造方法： public ObjectOutputStream(OutputStream out) throws IOException { //检查继承权限 verifySubclass(); //构造一个BlockDataOutputStream用于向out写入序列化数据 bout = new BlockDataOutputStream(out); //构造一个大小为10，负载因子为3的HandleTable和ReplaceTable handles = new HandleTable(10, (float) 3.00); subs = new ReplaceTable(10, (float) 3.00); //有参构造方法默认为false, enableOverride = false; writeStreamHeader(); //将缓存模式打开，写入数据时先写入缓冲区 bout.setBlockDataMode(true); if (extendedDebugInfo) { debugInfoStack = new DebugTraceInfoStack(); } else { debugInfoStack = null; } } 我们从上面例子中 ObjectOutputStream writeObject 方法开始说起： public final void writeObject(Object obj) throws IOException { if (enableOverride) { //这里判断是否需要重写writeObject() //如果使用无参构造方法创建，该变量默认为true，此时必须重写writeObject() //此时实际需要重写的方法为：writeObjectOverride，否则抛出异常 writeObjectOverride(obj); return; } try { //执行writeObject0() writeObject0(obj, false); } catch (IOException ex) { if (depth == 0) { try { writeFatalException(ex); } catch (IOException ex2) {} } throw ex; } } 在 writeObject 方法中首先判断当前是否重写了 writeObject 方法，如果我们使用无参构造方法创建 ObjectOutStream 实例，此时必须重写该方法（实际重写的是 writeObjectOverride 方法），否则会抛出异常。 接着跟踪 writeObject0 方法： private void writeObject0(Object obj, boolean unshared) throws IOException { boolean oldMode = bout.setBlockDataMode(false); depth++; try { int h; //处理以前写过和不可替换的对象 //如果obj为null,此时一定返回null if ((obj = subs.lookup(obj)) == null) { writeNull(); return; } else if (!unshared && (h = handles.lookup(obj)) != -1) { writeHandle(h); return; } Object orig = obj; Class cl = obj.getClass(); ObjectStreamClass desc; Class repCl; //创建ObjectStreamClass实例 //ObjectStreamClass表示序列化对象的class详细信息 desc = ObjectStreamClass.lookup(cl, true); if (desc.hasWriteReplaceMethod() && (obj = desc.invokeWriteReplace(obj)) != null && (repCl = obj.getClass()) != cl) { //如果实现了writeReplace方法替换掉原写入对象 与 //该方法返回对象不为null 与 //返回对象类型不是当前序列化类型 cl = repCl; //生成替换对象类型的ObjectStreamClass desc = ObjectStreamClass.lookup(cl, true); } if (enableReplace) { //如果通过enableReplaceObject()方法设置enablReplace //此时回调replaceObject，需要子类重写，否则返回与上述obj一致。 //这里是继承ObjectOutputStream之后重写了replaceObject方法 Object rep = replaceObject(obj); if (rep != obj && rep != null) { cl = rep.getClass(); desc = ObjectStreamClass.lookup(cl, true); } //重新赋值要序列化的对象 obj = rep; } if (obj != orig) { //如果替换了原序列化对象 subs.assign(orig, obj); if (obj == null) { writeNull(); return; } else if (!unshared && (h = handles.lookup(obj)) != -1) { writeHandle(h); return; } } // remaining cases // BEGIN Android-changed if (obj instanceof Class) { writeClass((Class) obj, unshared); } else if (obj instanceof ObjectStreamClass) { writeClassDesc((ObjectStreamClass) obj, unshared); // END Android-changed } else if (obj instanceof String) { writeString((String) obj, unshared); } else if (cl.isArray()) { writeArray(obj, desc, unshared); } else if (obj instanceof Enum) { writeEnum((Enum) obj, desc, unshared); } else if (obj instanceof Serializable) { //我们只看实现 Serializable 序列化过程 writeOrdinaryObject(obj, desc, unshared); } else { if (extendedDebugInfo) { throw new NotSerializableException( cl.getName() + "n" + debugInfoStack.toString()); } else { throw new NotSerializableException(cl.getName()); } } } finally { depth--; bout.setBlockDataMode(oldMode); } } 该方法中我们重点关心 desc = ObjectStreamClass.lookup 和 writeOrdinaryObject 两个方法。 首先看 ObjectStreamClass.lookup 方法：它返回 ObjectStreamClass 实例，ObjectStreamClass 保存了要序列化对象的 Class 相关信息：Class 名称、serialVersionUID、实现了 Serializable 还是 Externalizable 接口，是否自行实现了 writeObject 和 readObject 方法等内容。每个序列化对象类型对应一个 ObjectStreamClass 实例。 static ObjectStreamClass lookup(Class cl, boolean all) { if (!(all || Serializable.class.isAssignableFrom(cl))) { //all在ObjectOutStream中默认传递true //判断对象类型是否实现了Serializable接口 //如果all=false 与 未实现Serializable接口则直接return。 return null; } //清除失去Class引用的对应ObjectStreamClass实例缓存 //不过这在Android好像并不能生效，因为在Android JVM 中类是不可以被卸载的 processQueue(Caches.localDescsQueue, Caches.localDescs); //将写入对象类交给弱引用持有，WeakClassKey继承自WeakReference WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue); //根据类对象获取是否存在缓存的EntryFutrue或ObjectStreamClass //这里可能大家会有疑问，每次new WeakClassKey() 作为key？实际上它内部使用 //Class作为hash值的计算 Reference ref = Caches.localDescs.get(key); Object entry = null; if (ref != null) { //如果引用不为null，获取引用的实际类型 //在Android中只要是之前缓存过，则该ref永远不为null（Class 不可以被卸载） //获取该ref引用的对象 entry = ref.get(); } EntryFuture future = null; //如果引用的对象已经被回收 if (entry == null) { //创建EntryFuture，并使用软引用关联。 EntryFuture newEntry = new EntryFuture(); Reference newRef = new SoftReference<>(newEntry); do { if (ref != null) { //此时实际的引用对象已经被回收了，故ref引用就没有用了 //从缓存中删除该键值对 Caches.localDescs.remove(key, ref); } //localDescs是ConcurrentHashMap, //putIfAbsent()方法，不存在该key就添加进去，返回null //如果存在就返回之前的Reference。 ref = Caches.localDescs.putIfAbsent(key, newRef); if (ref != null) { entry = ref.get(); } //这里是要保证该key(Class)对应的Reference中持有的对象没有被回收 } while (ref != null && entry == null); if (entry == null) { //如果entry为null，此时future就是新创建的EntryFuture future = newEntry; } } if (entry instanceof ObjectStreamClass) { //如果拿到的是ObjectStreamClass，直接返回 return (ObjectStreamClass) entry; } if (entry instanceof EntryFuture) { //如果拿到的是EntryFuture future = (EntryFuture) entry; if (future.getOwner() == Thread.currentThread()) { //如果创建这个EntryFuture线程就是当前线程 //意思就是当前新创建的这个EntryFuture //这里实际判断该future是否是刚创建的newEntry entry = null; } else { //否则就获取之前的set的 entry = future.get(); } } if (entry == null) { try { //如果是新创建的future，此时就创建新的ObjectStreamClass entry = new ObjectStreamClass(cl); } catch (Throwable th) { entry = th; } if (future.set(entry)) { //EntryFuture中没有关联过entry //关联，并缓存为当前key对应引用关系 Caches.localDescs.put(key, new SoftReference