Java 反序列化之readObejct分析

Delina

原文链接：Java 反序列化之readObejct分析
前言

之前介绍 java反序列化的时候已经对readObject有了一个大概的了解，知道Java在将字节数据反序列化为Java对象的时候会调用流对象的readObject。

本文较长，可以直接拉到尾部，查看readObject的执行流程图

readObject 分析

例子 ：Java 反序列化-开篇中第一个代码

1. import java.io.*;
   
2. 
   
3. public class test{
   
4.     public static void main(String args[]) throws Exception{
   
5.         //定义myObj对象
   
6.         MyObject myObj = new MyObject();
   
7.         myObj.name = "hi";
   
8.         //创建一个包含对象进行反序列化信息的”object”数据文件
   
9.         FileOutputStream fos = new FileOutputStream("object");
   
10.         ObjectOutputStream os = new ObjectOutputStream(fos);
    
11.         //writeObject()方法将myObj对象写入object文件
    
12.         os.writeObject(myObj);
    
13.         os.close();
    
14.         //从文件中反序列化obj对象
    
15.         FileInputStream fis = new FileInputStream("object");
    
16.         ObjectInputStream ois = new ObjectInputStream(fis);
    
17.         //恢复对象
    
18.         MyObject objectFromDisk = (MyObject)ois.readObject();
    
19.         System.out.println(objectFromDisk.name);
    
20.         ois.close();
    
21.     }
    
22. }
    
23. 
    
24. class MyObject implements Serializable {
    
25.     public String name;
    
26.     //重写readObject()方法
    
27.     private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{
    
28.         //执行默认的readObject()方法
    
29.         in.defaultReadObject();
    
30.         //执行打开计算器程序命令
    
31.         Runtime.getRuntime().exec("open -a Calculator");
    
32.     }
    
33. }

复制代码

从ObjectInputStream.readObject()跟进代码

1. public final Object readObject()
   
2.     throws IOException, ClassNotFoundException {
   
3.     return readObject(Object.class);
   
4. }

复制代码

这里直接 返回了 readObject(Object.class) 继续跟进

1. private final Object readObject(Class<?> type)
   
2.         throws IOException, ClassNotFoundException
   
3.     {
   
4.         if (enableOverride) {
   
5.             return readObjectOverride();
   
6.         }
   
7. 
   
8.         if (! (type == Object.class || type == String.class))
   
9.             throw new AssertionError("internal error");
   
10. 
    
11.         // if nested read, passHandle contains handle of enclosing object
    
12.         int outerHandle = passHandle;
    
13.         try {
    
14.             Object obj = readObject0(type, false);
    
15.             handles.markDependency(outerHandle, passHandle);
    
16.             ClassNotFoundException ex = handles.lookupException(passHandle);
    
17.             if (ex != null) {
    
18.                 throw ex;
    
19.             }
    
20.             if (depth == 0) {
    
21.                 vlist.doCallbacks();
    
22.             }
    
23.             return obj;
    
24.         } finally {
    
25.             passHandle = outerHandle;
    
26.             if (closed && depth == 0) {
    
27.                 clear();
    
28.             }
    
29.         }
    
30.     }

复制代码

开头先判断 enableOverride ，如果为true 调用readObjectOverride() 而不是readObject()

1. public ObjectInputStream(InputStream in) throws IOException {
   
2.     ...
   
3.     enableOverride = false;
   
4.     ...
   
5. }

复制代码

只有在构造函数实例化时不带参数，才能使enableOverride 为 true

1. protected ObjectInputStream() throws IOException, SecurityException {
   
2.     ...
   
3.     enableOverride = true;
   
4. }

复制代码

当 enableOverride 为true时，跟进readObjectOverride 函数

1. protected Object readObjectOverride()
   
2.     throws IOException, ClassNotFoundException
   
3. {
   
4.     return null;
   
5. }

复制代码

我们的实例化方法ObjectInputStream 是有参数的，所以不会进入readObjectOverride,继续往下分析Object obj = readObject0(type, false);从readObject0跟进去

1. private Object readObject0(Class<?> type, boolean unshared) throws IOException {
   
2.     boolean oldMode = bin.getBlockDataMode();
   
3.     if (oldMode) {
   
4.         int remain = bin.currentBlockRemaining();
   
5.         if (remain > 0) {
   
6.             throw new OptionalDataException(remain);
   
7.         } else if (defaultDataEnd) {
   
8.             /*
   
9.              * Fix for 4360508: stream is currently at the end of a field
   
10.              * value block written via default serialization; since there
    
11.              * is no terminating TC_ENDBLOCKDATA tag, simulate
    
12.              * end-of-custom-data behavior explicitly.
    
13.              */
    
14.             throw new OptionalDataException(true);
    
15.         }
    
16.         bin.setBlockDataMode(false);
    
17.     }
    
18. 
    
19.     byte tc;
    
20.     while ((tc = bin.peekByte()) == TC_RESET) {
    
21.         bin.readByte();
    
22.         handleReset();
    
23.     }
    
24. 
    
25.     depth++;
    
26.     totalObjectRefs++;
    
27.     try {
    
28.         switch (tc) {
    
29.             case TC_NULL:
    
30.                 return readNull();
    
31. 
    
32.             case TC_REFERENCE:
    
33.                 // check the type of the existing object
    
34.                 return type.cast(readHandle(unshared));
    
35. 
    
36.             case TC_CLASS:
    
37.                 if (type == String.class) {
    
38.                     throw new ClassCastException("Cannot cast a class to java.lang.String");
    
39.                 }
    
40.                 return readClass(unshared);
    
41. 
    
42.             case TC_CLASSDESC:
    
43.             case TC_PROXYCLASSDESC:
    
44.                 if (type == String.class) {
    
45.                     throw new ClassCastException("Cannot cast a class to java.lang.String");
    
46.                 }
    
47.                 return readClassDesc(unshared);
    
48. 
    
49.             case TC_STRING:
    
50.             case TC_LONGSTRING:
    
51.                 return checkResolve(readString(unshared));
    
52. 
    
53.             case TC_ARRAY:
    
54.                 if (type == String.class) {
    
55.                     throw new ClassCastException("Cannot cast an array to java.lang.String");
    
56.                 }
    
57.                 return checkResolve(readArray(unshared));
    
58. 
    
59.             case TC_ENUM:
    
60.                 if (type == String.class) {
    
61.                     throw new ClassCastException("Cannot cast an enum to java.lang.String");
    
62.                 }
    
63.                 return checkResolve(readEnum(unshared));
    
64. 
    
65.             case TC_OBJECT:
    
66.                 if (type == String.class) {
    
67.                     throw new ClassCastException("Cannot cast an object to java.lang.String");
    
68.                 }
    
69.                 return checkResolve(readOrdinaryObject(unshared));
    
70. 
    
71.             case TC_EXCEPTION:
    
72.                 if (type == String.class) {
    
73.                     throw new ClassCastException("Cannot cast an exception to java.lang.String");
    
74.                 }
    
75.                 IOException ex = readFatalException();
    
76.                 throw new WriteAbortedException("writing aborted", ex);
    
77. 
    
78.             case TC_BLOCKDATA:
    
79.             case TC_BLOCKDATALONG:
    
80.                 if (oldMode) {
    
81.                     bin.setBlockDataMode(true);
    
82.                     bin.peek();             // force header read
    
83.                     throw new OptionalDataException(
    
84.                         bin.currentBlockRemaining());
    
85.                 } else {
    
86.                     throw new StreamCorruptedException(
    
87.                         "unexpected block data");
    
88.                 }
    
89. 
    
90.             case TC_ENDBLOCKDATA:
    
91.                 if (oldMode) {
    
92.                     throw new OptionalDataException(true);
    
93.                 } else {
    
94.                     throw new StreamCorruptedException(
    
95.                         "unexpected end of block data");
    
96.                 }
    
97. 
    
98.             default:
    
99.                 throw new StreamCorruptedException(
    
100.                     String.format("invalid type code: %02X", tc));
     
101.         }
     
102.     } finally {
     
103.         depth--;
     
104.         bin.setBlockDataMode(oldMode);
     
105.     }
     
106. }

复制代码

这个readObject0是底层readObject 的实现，开头的bin没有在函数中生成，跟一下bin

1. public ObjectInputStream(InputStream in) throws IOException {
   
2.     ...
   
3.     bin = new BlockDataInputStream(in);
   
4.     ...
   
5.     bin.setBlockDataMode(true);
   
6. }

复制代码

bin是在ObjectInputStream初始化的时候生成的，现在还不知道bin的用处，继续跟BlockDataInputStream
BlockDataInputStream是ObjectInputStream 块数据输入流，用来完成对序列化Stream的读取，其分为两种模式：Default mode 和Block mode ，默认关闭Block mode
回到上层代码，如果采用块数据模式，bin.getBlockDataMode()就为true 否则为false
如果是块数据模式，就检测当前数据块中剩余未消耗的字节数，如果不是就跑出错误，然后就就转到defalutDataEnd，重新设置块数据模式为false

1. byte tc;
   
2. while ((tc = bin.peekByte()) == TC_RESET) {
   
3.     bin.readByte();
   
4.     handleReset();
   
5. }

复制代码

继续分析readObject0中这一部分代码，tc 会获取流的下一个字节值
继续分析遇到switch判断，通过调试或者分析生成的序列化文件object可以知道tc会走到TC_OBJECT这个分支

1. case TC_OBJECT:
   
2.     if (type == String.class) {
   
3.         throw new ClassCastException("Cannot cast an object to java.lang.String");
   
4.     }
   
5.     return checkResolve(readOrdinaryObject(unshared));

复制代码

跟进readOrdinaryObject(unshared)

1. private Object readOrdinaryObject(boolean unshared)
   
2.     throws IOException
   
3. {
   
4.     if (bin.readByte() != TC_OBJECT) {
   
5.         throw new InternalError();
   
6.     }
   
7. 
   
8.     ObjectStreamClass desc = readClassDesc(false);
   
9.     desc.checkDeserialize();
   
10. 
    
11.     Class<?> cl = desc.forClass();
    
12.     if (cl == String.class || cl == Class.class
    
13.             || cl == ObjectStreamClass.class) {
    
14.         throw new InvalidClassException("invalid class descriptor");
    
15.     }
    
16. 
    
17.     Object obj;
    
18.     try {
    
19.         obj = desc.isInstantiable() ? desc.newInstance() : null;
    
20.     } catch (Exception ex) {
    
21.         throw (IOException) new InvalidClassException(
    
22.             desc.forClass().getName(),
    
23.             "unable to create instance").initCause(ex);
    
24.     }
    
25. 
    
26.     passHandle = handles.assign(unshared ? unsharedMarker : obj);
    
27.     ClassNotFoundException resolveEx = desc.getResolveException();
    
28.     if (resolveEx != null) {
    
29.         handles.markException(passHandle, resolveEx);
    
30.     }
    
31. 
    
32.     if (desc.isExternalizable()) {
    
33.         readExternalData((Externalizable) obj, desc);
    
34.     } else {
    
35.         readSerialData(obj, desc);
    
36.     }
    
37. 
    
38.     handles.finish(passHandle);
    
39. 
    
40.     if (obj != null &&
    
41.         handles.lookupException(passHandle) == null &&
    
42.         desc.hasReadResolveMethod())
    
43.     {
    
44.         Object rep = desc.invokeReadResolve(obj);
    
45.         if (unshared && rep.getClass().isArray()) {
    
46.             rep = cloneArray(rep);
    
47.         }
    
48.         if (rep != obj) {
    
49.             // Filter the replacement object
    
50.             if (rep != null) {
    
51.                 if (rep.getClass().isArray()) {
    
52.                     filterCheck(rep.getClass(), Array.getLength(rep));
    
53.                 } else {
    
54.                     filterCheck(rep.getClass(), -1);
    
55.                 }
    
56.             }
    
57.             handles.setObject(passHandle, obj = rep);
    
58.         }
    
59.     }
    
60. 
    
61.     return obj;
    
62. }

复制代码

开头先做了简单的判断，之后调用方法readClassDesc

1. private ObjectStreamClass readClassDesc(boolean unshared)
   
2.         throws IOException
   
3. {
   
4.         byte tc = bin.peekByte();
   
5.         ObjectStreamClass descriptor;
   
6.         switch (tc) {
   
7.             case TC_NULL:
   
8.                 descriptor = (ObjectStreamClass) readNull();
   
9.                 break;
   
10.             case TC_REFERENCE:
    
11.                 descriptor = (ObjectStreamClass) readHandle(unshared);
    
12.                 // Should only reference initialized class descriptors
    
13.                 descriptor.checkInitialized();
    
14.                 break;
    
15.             case TC_PROXYCLASSDESC:
    
16.                 descriptor = readProxyDesc(unshared);
    
17.                 break;
    
18.             case TC_CLASSDESC:
    
19.                 descriptor = readNonProxyDesc(unshared);
    
20.                 break;
    
21.             default:
    
22.                 throw new StreamCorruptedException(
    
23.                     String.format("invalid type code: %02X", tc));
    
24.         }
    
25.         if (descriptor != null) {
    
26.             validateDescriptor(descriptor);
    
27.         }
    
28.         return descriptor;
    
29.     }

复制代码

读取并返回类描述符，在文件格式分析那篇文章中，分析了object的文件格式，读到的第一个Byte是 0x72，用来描述类的结构，类名，成员类型等
跟进去descriptor = readNonProxyDesc(unshared)

1. private ObjectStreamClass readNonProxyDesc(boolean unshared)
   
2.     throws IOException
   
3. {
   
4.     if (bin.readByte() != TC_CLASSDESC) {
   
5.         throw new InternalError();
   
6.     }
   
7. 
   
8.     ObjectStreamClass desc = new ObjectStreamClass();
   
9.     int descHandle = handles.assign(unshared ? unsharedMarker : desc);
   
10.     passHandle = NULL_HANDLE;
    
11. 
    
12.     ObjectStreamClass readDesc = null;
    
13.     try {
    
14.         readDesc = readClassDescriptor();
    
15.     } catch (ClassNotFoundException ex) {
    
16.         throw (IOException) new InvalidClassException(
    
17.             "failed to read class descriptor").initCause(ex);
    
18.     }
    
19. 
    
20.     Class<?> cl = null;
    
21.     ClassNotFoundException resolveEx = null;
    
22.     bin.setBlockDataMode(true);
    
23.     final boolean checksRequired = isCustomSubclass();
    
24.     try {
    
25.         if ((cl = resolveClass(readDesc)) == null) {
    
26.             resolveEx = new ClassNotFoundException("null class");
    
27.         } else if (checksRequired) {
    
28.             ReflectUtil.checkPackageAccess(cl);
    
29.         }
    
30.     } catch (ClassNotFoundException ex) {
    
31.         resolveEx = ex;
    
32.     }
    
33. 
    
34.     // Call filterCheck on the class before reading anything else
    
35.     filterCheck(cl, -1);
    
36. 
    
37.     skipCustomData();
    
38. 
    
39.     try {
    
40.         totalObjectRefs++;
    
41.         depth++;
    
42.         desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));
    
43.     } finally {
    
44.         depth--;
    
45.     }
    
46. 
    
47.     handles.finish(descHandle);
    
48.     passHandle = descHandle;
    
49. 
    
50.     return desc;
    
51. }

复制代码

读入并返回非动态代理类的类描述符,首先初始化ObjectStreamClass给desc，然后通过readClassDescriptor()去初始化ObjectStreamClass，在通过readNonProxy(this)来读取非代理类描述符信息

1. void readNonProxy(ObjectInputStream in)
   
2.     throws IOException, ClassNotFoundException
   
3. {
   
4.     name = in.readUTF();
   
5.     suid = Long.valueOf(in.readLong());
   
6.     isProxy = false;
   
7. 
   
8.     byte flags = in.readByte();
   
9.     hasWriteObjectData =
   
10.         ((flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0);
    
11.     hasBlockExternalData =
    
12.         ((flags & ObjectStreamConstants.SC_BLOCK_DATA) != 0);
    
13.     externalizable =
    
14.         ((flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0);
    
15.     boolean sflag =
    
16.         ((flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0);
    
17.     if (externalizable && sflag) {
    
18.         throw new InvalidClassException(
    
19.             name, "serializable and externalizable flags conflict");
    
20.     }
    
21.     serializable = externalizable || sflag;
    
22.     isEnum = ((flags & ObjectStreamConstants.SC_ENUM) != 0);
    
23.     if (isEnum && suid.longValue() != 0L) {
    
24.         throw new InvalidClassException(name,
    
25.             "enum descriptor has non-zero serialVersionUID: " + suid);
    
26.     }
    
27. 
    
28.     int numFields = in.readShort();
    
29.     if (isEnum && numFields != 0) {
    
30.         throw new InvalidClassException(name,
    
31.             "enum descriptor has non-zero field count: " + numFields);
    
32.     }
    
33.     fields = (numFields > 0) ?
    
34.         new ObjectStreamField[numFields] : NO_FIELDS;
    
35.     for (int i = 0; i < numFields; i++) {
    
36.         char tcode = (char) in.readByte();
    
37.         String fname = in.readUTF();
    
38.         String signature = ((tcode == 'L') || (tcode == '[')) ?
    
39.             in.readTypeString() : new String(new char[] { tcode });
    
40.         try {
    
41.             fields[i] = new ObjectStreamField(fname, signature, false);
    
42.         } catch (RuntimeException e) {
    
43.             throw (IOException) new InvalidClassException(name,
    
44.                 "invalid descriptor for field " + fname).initCause(e);
    
45.         }
    
46.     }
    
47.     computeFieldOffsets();
    
48. }

复制代码

从这里就是对输入流进行细致的判断读取了，

name 就是 class descriptor的class name

suid 就是 serialVersionUID 用来验证该类是否被修改过的验证码,至于serialversionUID是怎么生成的 可以在我java 反序列化writeObject分析中查看

readNonProxy()初始化类名，suid之后，readClassDescriptor将得到的类描述符返回后，继续往下分析

1. private ObjectStreamClass readNonProxyDesc(boolean unshared)
   
2.     throws IOException
   
3.     ...
   
4. 
   
5.     Class<?> cl = null;
   
6.     ClassNotFoundException resolveEx = null;
   
7.     bin.setBlockDataMode(true);
   
8.     final boolean checksRequired = isCustomSubclass();
   
9.     try {
   
10.         if ((cl = resolveClass(readDesc)) == null) {
    
11.             resolveEx = new ClassNotFoundException("null class");
    
12.         } else if (checksRequired) {
    
13.             ReflectUtil.checkPackageAccess(cl);
    
14.         }
    
15.     } catch (ClassNotFoundException ex) {
    
16.         resolveEx = ex;
    
17.     }
    
18. 
    
19.     // Call filterCheck on the class before reading anything else
    
20.     filterCheck(cl, -1);
    
21. 
    
22.     skipCustomData();
    
23. 
    
24.     try {
    
25.         totalObjectRefs++;
    
26.         depth++;
    
27.         desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));
    
28.     } finally {
    
29.         depth--;
    
30.     }
    
31. 
    
32.     handles.finish(descHandle);
    
33.     passHandle = descHandle;
    
34. 
    
35.     return desc;
    
36. }

复制代码

类描述符信息 readDesc传入了resolveClass

1. protected Class<?> resolveClass(ObjectStreamClass desc)
   
2.     throws IOException, ClassNotFoundException
   
3. {
   
4.     String name = desc.getName();
   
5.     try {
   
6.         return Class.forName(name, false, latestUserDefinedLoader());
   
7.     } catch (ClassNotFoundException ex) {
   
8.         Class<?> cl = primClasses.get(name);
   
9.         if (cl != null) {
   
10.             return cl;
    
11.         } else {
    
12.             throw ex;
    
13.         }
    
14.     }
    
15. }

复制代码

这个方法 加载与指定流描述符等价的局部类，也就是通过java反射获取当前描述的类别信息。

Java 反射 具体参见 《Java 反射》

在运行时动态的创建对象并调用其属性，不需要在编译期知道运行的对象是谁

调用filterCheck检查获得的描述符cl

1. private void filterCheck(Class<?> clazz, int arrayLength)
   
2.         throws InvalidClassException {
   
3.     if (serialFilter != null) {
   
4.         RuntimeException ex = null;
   
5.         ObjectInputFilter.Status status;
   
6.         // Info about the stream is not available if overridden by subclass, return 0
   
7.         long bytesRead = (bin == null) ? 0 : bin.getBytesRead();
   
8.         try {
   
9.             status = serialFilter.checkInput(new FilterValues(clazz, arrayLength,
   
10.                     totalObjectRefs, depth, bytesRead));
    
11.         } catch (RuntimeException e) {
    
12.             // Preventive interception of an exception to log
    
13.             status = ObjectInputFilter.Status.REJECTED;
    
14.             ex = e;
    
15.         }
    
16.         if (status == null  ||
    
17.                 status == ObjectInputFilter.Status.REJECTED) {
    
18.             // Debug logging of filter checks that fail
    
19.             if (Logging.infoLogger != null) {
    
20.                 Logging.infoLogger.info(
    
21.                         "ObjectInputFilter {0}: {1}, array length: {2}, nRefs: {3}, depth: {4}, bytes: {5}, ex: {6}",
    
22.                         status, clazz, arrayLength, totalObjectRefs, depth, bytesRead,
    
23.                         Objects.toString(ex, "n/a"));
    
24.             }
    
25.             InvalidClassException ice = new InvalidClassException("filter status: " + status);
    
26.             ice.initCause(ex);
    
27.             throw ice;
    
28.         } else {
    
29.             // Trace logging for those that succeed
    
30.             if (Logging.traceLogger != null) {
    
31.                 Logging.traceLogger.finer(
    
32.                         "ObjectInputFilter {0}: {1}, array length: {2}, nRefs: {3}, depth: {4}, bytes: {5}, ex: {6}",
    
33.                         status, clazz, arrayLength, totalObjectRefs, depth, bytesRead,
    
34.                         Objects.toString(ex, "n/a"));
    
35.             }
    
36.         }
    
37.     }
    
38. }

复制代码

serialFilter是在objectInputStream初始化时生成的

当serialFilter存在时，会对信息流进行检测，如果没有通过返回报错

检查结束后，继续回到readNonProxyDesc()

1. private ObjectStreamClass readNonProxyDesc(boolean unshared)
   
2.     throws IOException
   
3. {
   
4.     ...
   
5. 
   
6.     skipCustomData();
   
7. 
   
8.     try {
   
9.         totalObjectRefs++;
   
10.         depth++;
    
11.         desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));
    
12.     } finally {
    
13.         depth--;
    
14.     }
    
15. 
    
16.     handles.finish(descHandle);
    
17.     passHandle = descHandle;
    
18. 
    
19.     return desc;
    
20. }

复制代码

跟进skipCustmoData()

1. private void skipCustomData() throws IOException {
   
2.     int oldHandle = passHandle;
   
3.     for (;;) {
   
4.         if (bin.getBlockDataMode()) {
   
5.             bin.skipBlockData();
   
6.             bin.setBlockDataMode(false);
   
7.         }
   
8.         switch (bin.peekByte()) {
   
9.             case TC_BLOCKDATA:
   
10.             case TC_BLOCKDATALONG:
    
11.                 bin.setBlockDataMode(true);
    
12.                 break;
    
13. 
    
14.             case TC_ENDBLOCKDATA:
    
15.                 bin.readByte();
    
16.                 passHandle = oldHandle;
    
17.                 return;
    
18. 
    
19.             default:
    
20.                 readObject0(Object.class, false);
    
21.                 break;
    
22.         }
    
23.     }
    
24. }

复制代码

跳过所有块数据和对象，直到遇到TC_ENDBLOCKDATA

继续分析readNonPorxyDesc,跟进initNonPorxy

1. void initNonProxy(ObjectStreamClass model,
   
2.                   Class<?> cl,
   
3.                   ClassNotFoundException resolveEx,
   
4.                   ObjectStreamClass superDesc)
   
5.     throws InvalidClassException
   
6. {
   
7.      long suid = Long.valueOf(model.getSerialVersionUID());
   
8.         ObjectStreamClass osc = null;
   
9.         if (cl != null) {
   
10.             osc = lookup(cl, true);
    
11.             if (osc.isProxy) {
    
12.                 throw new InvalidClassException(
    
13.                         "cannot bind non-proxy descriptor to a proxy class");
    
14.             }
    
15.             if (model.isEnum != osc.isEnum) {
    
16.                 throw new InvalidClassException(model.isEnum ?
    
17.                         "cannot bind enum descriptor to a non-enum class" :
    
18.                         "cannot bind non-enum descriptor to an enum class");
    
19.             }
    
20. 
    
21.             if (model.serializable == osc.serializable &&
    
22.                     !cl.isArray() &&
    
23.                     suid != osc.getSerialVersionUID()) {
    
24.                 throw new InvalidClassException(osc.name,
    
25.                         "local class incompatible: " +
    
26.                                 "stream classdesc serialVersionUID = " + suid +
    
27.                                 ", local class serialVersionUID = " +
    
28.                                 osc.getSerialVersionUID());
    
29.             }
    
30. 
    
31.             if (!classNamesEqual(model.name, osc.name)) {
    
32.                 throw new InvalidClassException(osc.name,
    
33.                         "local class name incompatible with stream class " +
    
34.                                 "name "" + model.name + """);
    
35.             }
    
36. 
    
37.             if (!model.isEnum) {
    
38.                 if ((model.serializable == osc.serializable) &&
    
39.                         (model.externalizable != osc.externalizable)) {
    
40.                     throw new InvalidClassException(osc.name,
    
41.                             "Serializable incompatible with Externalizable");
    
42.                 }
    
43. 
    
44.                 if ((model.serializable != osc.serializable) ||
    
45.                         (model.externalizable != osc.externalizable) ||
    
46.                         !(model.serializable || model.externalizable)) {
    
47.                     deserializeEx = new ExceptionInfo(
    
48.                             osc.name, "class invalid for deserialization");
    
49.                 }
    
50.             }
    
51.         }
    
52. 
    
53.     this.cl = cl;
    
54.     this.resolveEx = resolveEx;
    
55.     this.superDesc = superDesc;
    
56.     name = model.name;
    
57.     this.suid = suid;
    
58.     isProxy = false;
    
59.     isEnum = model.isEnum;
    
60.     serializable = model.serializable;
    
61.     externalizable = model.externalizable;
    
62.     hasBlockExternalData = model.hasBlockExternalData;
    
63.     hasWriteObjectData = model.hasWriteObjectData;
    
64.     fields = model.fields;
    
65.     primDataSize = model.primDataSize;
    
66.     numObjFields = model.numObjFields;
    
67. 
    
68.     if (osc != null) {
    
69.         localDesc = osc;
    
70.         writeObjectMethod = localDesc.writeObjectMethod;
    
71.         readObjectMethod = localDesc.readObjectMethod;
    
72.         readObjectNoDataMethod = localDesc.readObjectNoDataMethod;
    
73.         writeReplaceMethod = localDesc.writeReplaceMethod;
    
74.         readResolveMethod = localDesc.readResolveMethod;
    
75.         if (deserializeEx == null) {
    
76.             deserializeEx = localDesc.deserializeEx;
    
77.         }
    
78.         domains = localDesc.domains;
    
79.         cons = localDesc.cons;
    
80.     }
    
81. 
    
82.     fieldRefl = getReflector(fields, localDesc);
    
83.     // reassign to matched fields so as to reflect local unshared settings
    
84.     fields = fieldRefl.getFields();
    
85.     initialized = true;
    
86. }

复制代码

这个方法会使用readDesc来初始化Desc,所以开头先检查readDesc的正确性使用本地直接new的描述 与model也就是readDesc里的内容进行判断，如果不同就抛出错误
继续往下看initNonProxy()
把localDesc中的属性复制到当前描述的属性上，接着将这个return 给readClassDesc的validateDescriptor

1. if (descriptor != null) {
   
2.     validateDescriptor(descriptor);
   
3. }

复制代码

检查结束后，通过就return 到readOrdinaryObject

1. private Object readOrdinaryObject(boolean unshared)
   
2.     throws IOException
   
3. {
   
4.     ...
   
5. 
   
6.     ObjectStreamClass desc = readClassDesc(false);
   
7.     desc.checkDeserialize();
   
8. 
   
9.     ...
   
10.     Object obj;
    
11.     try {
    
12.         obj = desc.isInstantiable() ? desc.newInstance() : null;
    
13.     } catch (Exception ex) {
    
14.         throw (IOException) new InvalidClassException(
    
15.             desc.forClass().getName(),
    
16.             "unable to create instance").initCause(ex);
    
17.     }
    
18. 
    
19.     ...
    
20. 
    
21.     if (desc.isExternalizable()) {
    
22.         readExternalData((Externalizable) obj, desc);
    
23.     } else {
    
24.         readSerialData(obj, desc);
    
25.     }
    
26. 
    
27.     ...
    
28. }

复制代码

看到对返回的desc进行反序列化检查checkDeserialize()

往下继续走

desc.newInstance()就是刚才的构造函数生成的组件

接着，当desc不是Externalizable()就会触发else的readSerialData

1. private void readSerialData(Object obj, ObjectStreamClass desc)
   
2.     throws IOException
   
3. {
   
4.     ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
   
5.     for (int i = 0; i < slots.length; i++) {
   
6.         ObjectStreamClass slotDesc = slots[i].desc;
   
7. 
   
8.         if (slots[i].hasData) {
   
9.             if (obj == null || handles.lookupException(passHandle) != null) {
   
10.                 defaultReadFields(null, slotDesc); // skip field values
    
11.             } else if (slotDesc.hasReadObjectMethod()) {
    
12.                 ThreadDeath t = null;
    
13.                 boolean reset = false;
    
14.                 SerialCallbackContext oldContext = curContext;
    
15.                 if (oldContext != null)
    
16.                     oldContext.check();
    
17.                 try {
    
18.                     curContext = new SerialCallbackContext(obj, slotDesc);
    
19. 
    
20.                     bin.setBlockDataMode(true);
    
21.                     slotDesc.invokeReadObject(obj, this);
    
22.                 } catch (ClassNotFoundException ex) {
    
23.                     /*
    
24.                      * In most cases, the handle table has already
    
25.                      * propagated a CNFException to passHandle at this
    
26.                      * point; this mark call is included to address cases
    
27.                      * where the custom readObject method has cons'ed and
    
28.                      * thrown a new CNFException of its own.
    
29.                      */
    
30.                     handles.markException(passHandle, ex);
    
31.                 } finally {
    
32.                     do {
    
33.                         try {
    
34.                             curContext.setUsed();
    
35.                             if (oldContext!= null)
    
36.                                 oldContext.check();
    
37.                             curContext = oldContext;
    
38.                             reset = true;
    
39.                         } catch (ThreadDeath x) {
    
40.                             t = x;  // defer until reset is true
    
41.                         }
    
42.                     } while (!reset);
    
43.                     if (t != null)
    
44.                         throw t;
    
45.                 }
    
46. 
    
47.                 /*
    
48.                  * defaultDataEnd may have been set indirectly by custom
    
49.                  * readObject() method when calling defaultReadObject() or
    
50.                  * readFields(); clear it to restore normal read behavior.
    
51.                  */
    
52.                 defaultDataEnd = false;
    
53.             } else {
    
54.                 defaultReadFields(obj, slotDesc);
    
55.                 }
    
56.     ...
    
57.         }

复制代码

这里先进行判断，当我们没有重写readObject那么就调用defaultReadFilelds,否则调用slotDesc.invokeReadObject(obj,this)

1. void invokeReadObject(Object obj, ObjectInputStream in)
   
2.     throws ClassNotFoundException, IOException,
   
3.            UnsupportedOperationException
   
4. {
   
5.     requireInitialized();
   
6.     if (readObjectMethod != null) {
   
7.         try {
   
8.             readObjectMethod.invoke(obj, new Object[]{ in });
   
9.         } catch (InvocationTargetException ex) {
   
10.             Throwable th = ex.getTargetException();
    
11.             if (th instanceof ClassNotFoundException) {
    
12.                 throw (ClassNotFoundException) th;
    
13.             } else if (th instanceof IOException) {
    
14.                 throw (IOException) th;
    
15.             } else {
    
16.                 throwMiscException(th);
    
17.             }
    
18.         } catch (IllegalAccessException ex) {
    
19.             // should not occur, as access checks have been suppressed
    
20.             throw new InternalError(ex);
    
21.         }
    
22.     } else {
    
23.         throw new UnsupportedOperationException();
    
24.     }
    
25. }

复制代码

读取我们重写的readObject可以看到readObjectMethod.invoke(obj, new Object[]{ in });
这里的readObjectMethod就是我们自写的readObject方法

​

readObject 执行流程​

---

Java 反序列化之 readObject 分析
​