一起养成写作习惯！这是我参与「日新计划 4 月更文挑战」的第2天，点击查看活动详情。
序列化
将实例的状态转换为可以存储或传输的形式的过程。
Objecandroid是什么手机牌子tOutputStream
构造函数
public ObjectOutputStream(OutputStream out) throws IOException {
verifySubclass();
bout = new BlockDataOutputStream(out);//用于写入文件的Stream
handles = new HandleTable(10, (float) 3.00);
subs = new ReplaceTable(10, (float) 3.00);
enableOverride = false;
writeStreamHeader(); //开始写入魔数和版本号
bout.setBlockDataMode(true);
if (extendedDebugInfo) {
debugInfoStack = new DebugTraceInfoStack();
} else {
debugInfoStack = null;
}
}
write二进制Object方法
public final void writeObject(Object obj) throws IOException {
if (enableOverride) {
writeObjectOverride(obj);
return;
}
try {
writeObject0(obj, false);
} catch (IOException ex) {
if (depth == 0) {
try {
writeFatalException(ex);
} catch (IOException ex2) {
}
}
throw ex;
}
}
调用writeObject0方法
private void writeObject0(Object obj, boolean unshared)
throws IOException
{
。。。
//创建出来一个原始数据的描述信息的实例
desc = ObjectStreamClass.lookup(cl, true);
。。。
//根据类型信息将实例信息写入输出流
if (obj instanceof Class) {
writeClass((Class) obj, unshared);
} else if (obj instanceof ObjectStreamClass) {
writeClassDesc((ObjectStreamClass) obj, unshared);
// END Android-changed: Make Class and ObjectStreamClass replaceable.
} 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) {
writeOrdinaryObject(obj, desc, unshared);
} else {
if (extendedDebugInfo) {
throw new NotSerializableException(
cl.getName() + "n" + debugInfoStack.toString());
} else {
throw new NotSerializableException(cl.getName());
}
}
}
ObjectStreamClass的创建过程
static ObjectStreamClass lookup(Class<?> cl, boolean all) {
...
Reference<?> ref = Caches.localDescs.get(key);//读取缓存
Object entry = null;
if (ref != null) {
entry = ref.get();
}
EntryFuture future = null;
if (entry == null) {
EntryFuture newEntry = new EntryFuture();
Reference<?> newRef = new SoftReference<>(newEntry);
do {
if (ref != null) {
Caches.localDescs.remove(key, ref);
}
ref = Caches.localDescs.putIfAbsent(key, newRef);
if (ref != null) {
entry = ref.get();
}
} while (ref != null && entry == null);
if (entry == null) {
future = newEntry;
}
}
if (entry instanceof ObjectStreamClass) { // check common case first
return (ObjectStreamClass) entry;
}
if (entry instanceof EntryFuture) {
future = (EntryFuture) entry;
if (future.getOwner() == Thread.currentThread()) {
entry = null;
} else {
entry = future.get();
}
}
//没有缓存的情况
if (entry == null) {
try {
entry = new ObjectStreamClass(cl);
} catch (Throwable th) {
entry = th;
}
if (future.set(entry)) {
Caches.localDescs.put(key, new SoftReference<Object>(entry));
} else {
entry = future.get();
}
}
if (entry instanceof ObjectStreamClass) {
return (ObjectStreamClass) entry;
} else if (entry instanceof RuntimeException) {
throw (RuntimeException) entry;
} else if (entry instanceof Error) {
throw (Error) entry;
} else {
throw new InternalError("unexpected entry: " + entry);
}
}
进入ObjectStreamClass构造函数
private ObjectStreamClass(final Class<?> cl) {
this.cl = cl;
...
name = cl.getName();//反射获取
isProxy = Proxy.isProxyClass(cl);
isEnum = Enum.class.isAssignableFrom(cl);
serializable = Serializable.class.isAssignableFrom(cl);
externalizable = Externalizable.class.isAssignableFrom(cl);
Class<?> superCl = cl.getSuperclass();
superDesc = (superCl != null) ? lookup(superCl, false) : null;
...
suid = getDeclaredSUID(cl);
fields = getSerialFields(cl);
computeFieldOffsets();
initialized = true;
}
读取属性中使用反射
private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {
Field[] clFields = cl.getDeclaredFields();
ArrayList<ObjectStreamField> list = new ArrayList<>();
int mask = Modifier.STATIC | Modifier.TRANSIENT;
for (int i = 0; i < clFields.length; i++) {
if ((clFields[i].getModifiers() & mask) == 0) {
list.add(new ObjectStreamField(clFields[i], false, true));
}
}
int size = list.size();
return (size == 0) ? NO_FIELDS :
list.toArray(new ObjectStreamField[size]);
}
Parcelablkotlin面试题e
Kotlin 有一个Parceliz二进制亡者列车e注解可以帮我们生成实现Parcelable之后需要写的代码
- 对kotlin怎么读象自行实现出入口方法，避免对类结构的反射
- 二进制流存储在连续内存中，占用空间更小
- 牺牲易用性（可以通过Parcelize弥补），换取极致的性能
Serializable
- 用反射获取类的结构和属性信息，过程中会产生中间信息
- 有缓存结构，在解析相同类型的情况下，能复用缓存
- 性能在二进制转换器可接受的范围内，易用性比较好
Intent传值场景
进入Pjava模拟器arcel.java类中的writeSerializable
Serializable是先通过ObjectOutp二进制转化为十进制utStream，把对象转成ByteArray，再通过writeByteArray写入Parcel
public final void writeSerializable(@Nullable Serializable s) {
if (s == null) {
writeString(null);
return;
}
String name = s.getClass().getName();
writeString(name);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(s);
oos.close();
writeByteArray(baos.toByteArray());
} catch (IOException ioe) {
throw new RuntimeException("Parcelable encountered " +
"IOException writing serializable object (name = " + name +
")", ioe);
}
}
Parcelable 调用对象内部实现的writeToParcel方法中的逻辑，通过一些write方法直接写入Parcel
public static void writeToParcel(@Nullable CharSequence cs, @NonNull Parcel p,
int parcelableFlags) {
if (cs instanceof Spanned) {
p.writeInt(0);
p.writeString8(cs.toString());
Spanned sp = (Spanned) cs;
Object[] os = sp.getSpans(0, cs.length(), Object.class);
for (int i = 0; i < os.length; i++) {
Object o = os[i];
Object prop = os[i];
if (prop instanceof CharacterStyle) {
prop = ((CharacterStyle) prop).getUnderlying();
}
if (prop instanceof ParcelableSpan) {
final ParcelableSpan ps = (ParcelableSpan) prop;
final int spanTypeId = ps.getSpanTypeIdInternal();
if (spanTypeId < FIRST_SPAN || spanTypeId > LAST_SPAN) {
Log.e(TAG, "External class "" + ps.getClass().getSimpleName()
+ "" is attempting to use the frameworks-only ParcelableSpan"
+ " interface");
} else {
p.writeInt(spanTypeId);
ps.writeToParcelInternal(p, parcelableFlags);
writeWhere(p, sp, o);
}
}
}
p.writeInt(0);
} else {
p.writeInt(1);
if (cs != null) {
p.writeString8(cs.toString());
} else {
p.writeString8(null);
}
}
}
由于ObjectSt二进制计算器reamClass存在缓存机制，在一次序列化过程中，如果涉及大量相同类的不同实例化，Serializable的性能会存在优势。
