devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

20.Java序列化【草案二】_getclasssignature failed with error 21 l

作者：菜鸟追梦旅行 | 2024-03-06 22:05:44

赞

踩

getclasssignature failed with error 21 l

（从09年回到重庆过后，就一直在工作，时间长了惰性就慢慢起来了，公司的项目从09年忙到了现在，一直没有时间来梳理自己的东西，CSDN的Blog似乎都荒废了，不知道现在还能否坚持把Blog完成，希望有一个新的开始吧！如果读者有问题还是可直接发邮件到silentbalanceyh@126.com，我也仅仅只是想把看的、写的、学的东西总结起来，让自己有个比较完整的学习记录。本文主要针对Java的序列化相关知识，先不涉及XML序列化和Json序列化的内容，这部分内容以后再议。着色的目的是强调重点和关键的概念以及防止读者通篇阅读的视觉疲劳，也是个人的写作风格，不习惯的读者请见谅！）

本章目录：

1.Java中的序列化

2.序列化原理和算法——基础数据

3.深入序列化规范

4.源码分析

----ObjectStreamField

----ObjectStreamClass

----ObjectOutputStream

----ObjectInputStream

5.序列化原理和算法——面向对象


4.源码分析

　　【本章节的内容主要做的是源码分析，分析过程的概念性内容都是基于个人的理解，仅仅提供给读者参考，我尽可能在分析过程中保证这些概念性内容的准确性】

　　前边的章节已经辅助读者解读了JVM的规范以及提供了比较详细的示例，这个章节主要完成下边三个目标：

  • 详细分析Java序列化中使用的几个核心类的源代码，通过其内部执行流程换一种角度来看看Java序列化的知识；
  • 针对JVM的序列化规范中的一些疑点提供示例来加以证明，进行规范的深入理解；
  • 提供Java序列化中和面向对象、最佳实践的相关内容
　　前几个章节的示例多次提到了Java序列化中的几个核心的类，这个章节主要看看下边2个类【蓝色部分】的源代码：
  • ObjectStreamField
  • ObjectStreamClass
  • ObjectOutputStream
  • ObjectInputStream
　　i.ObjectStreamField源代码分析
　　这个类主要用来提取序列化过程中某个对象内的字段【成员属性】元数据信息，包括字段的类型、类型代码、签名等，为了让读者阅读该类源代码方便，我把代码拆开来解析，让读者更容易理解代码逻辑【下边代码中：成员函数、函数、方法基本属于同一概念，请读者谅解】。
　　1）类定义： 
public class ObjectStreamField implements Comparable<Object>
　　该类实现了接口Comparable<T>，这个接口主要用于“对象比较”，一旦实现了这个接口过后就必须实现接口中的方法compareTo，先看看在ObjectStreamField类中的compareTo的实现：
　　compareTo： 
  1.     public int compareTo(Object obj) {
  2.         ObjectStreamField other = (ObjectStreamField) obj;
  3.         boolean isPrim = isPrimitive();
  4.         if (isPrim != other.isPrimitive()) {
  5.             return isPrim ? -1 : 1;
  6.         }
  7.         return name.compareTo(other.name);
  8.     }
　　相信读者还记得前边在解析规范和示例的时候提到了一个词语——字典序，这个词语就是实现Comparable<T>接口以及上边这段代码存在的原因。这里再复习下Java对象中成员属性的二进制序列的生成规则：先根据字典序把基础类型的成员属性按属性名顺序排列，然后根据字典序把对象类型的成员属性按属性名顺序排列。从上边的函数可以知道：
  1. 两个成员属性在比较的时候分为两个维度进行比较：基础类型的数据只能和基础类型的数据进行比较，对象类型的数据只能和对象类型的数据进行比较；
  2. 两个成员属性在比较的时候，最终调用的是String类型的compareTo成员函数来比较成员属性的属性名；
  3. 若返回-1则表示当前对象排在传入对象之前，为0则表示顺序不变，为1则表示当前对象应该排在传入对象之后；
　　isPrimitive：
　　在比较两个字段的名称进行字典序排列的时候，compareTo方法调用了isPrimitive成员函数，该成员函数的定义如下： 
  1.     public boolean isPrimitive() {
  2.         char tcode = signature.charAt(0);
  3.         return ((tcode != 'L') && (tcode != '['));
  4.     }
　　ObjectStreamField类的实例描述了序列化的对象中成员属性的元数据信息，上边的这个方法用于判断当前描述的成员属性是一个基础类型的数据还是一个对象类型的数据，若当前描述的成员属性是基础类型这个函数返回true，反之返回false。该成员函数判断数据类型的方式是使用的签名中的类型代码来判断，前文多次提到类型代码的概念，目前可以知道对象类型的数据只有两种类型代码——数组array【[】和对象object【L】。
　　2）成员属性：
　　ObjectStreamField类中定义了6个成员属性：
 
  1.     /** field name */
  2.     private final String name;
  3.     /** canonical JVM signature of field type */
  4.     private final String signature;
  5.     /** field type (Object.class if unknown non-primitive type) */
  6.     private final Class<?> type;
  7.     /** whether or not to (de)serialize field values as unshared */
  8.     private final boolean unshared;
  9.     /** corresponding reflective field object, if any */
  10.     private final Field field;
  11.     /** offset of field value in enclosing field group */
  12.     private int offset = 0;
　　这6个成员属性的含义如下：
  • name——java.lang.String
    该属性描述了序列化的成员属性的名称；
  • signature——java.lang.String
    该属性描述了JVM中成员属性的类型签名，注：成员属性的类型、类型代码、类型签名不是同一个概念，这三个概念在下文会加以区分；
  • type——java.lang.Class<?>
    该属性描述了成员属性的类型；
  • unshared——boolean
    该属性标识了当前成员属性是否具有“unshared”的语义，“unshared”的对象在规范的解析中提到过，这里不重复；
  • field——java.lang.reflect.Field
    该属性描述了当前成员属性的JVM级别的元数据信息，在序列化提取成员属性的元数据信息时，会使用Java语言中的“反射”，该成员的类型是java.lang.reflect.Field；
  • offset——int
    在序列化的过程中，当一个对象的成员属性个数超过一个时，JVM会将会把所有的成员属性打包成一个“组”来操作，而offset就是这个组中当前描述的成员属性的偏移量，上层的ObjectStreamClass在调用当前这个成员属性的时候就使用偏移量进行引用定位操作；
　　注意上边成员属性的定义，除了offset偏移量以外，其他几个成员属性的定义中都加入了final关键字，也就是说name、signature、type、unshared、field五个成员属性只能在构造函数中执行初始化，而且一旦初始化过后：基础数据不能更改，对象数据的引用不可再指向其他对象。从设计上讲该类中这五个属性不会有set*前缀的Java Bean规范标准方法，因为成员是final的，即使提供了set*前缀的方法也无济于事，而六个成员属性中offset还拥有默认值0，也就是说在元数据中若使用偏移量遍历一个类的成员属性的时候，其偏移量应该和数组的索引规范保持一致，起始值都从0开始，而不是1，如果索引非法则返回-1【Unsafe.INVALID_FIELD_OFFSET】。
　　区分成员属性的类型、类型代码、类型签名：这三个概念这里希望读者通过其格式加以区分【以String类型为例】。
　　类型——Java的成员属性的类型一般对应的Java数据类型为Class<?>，它也可以使用格式“String.class”表示，如果是引用可以使用Class<String>进行定义，这是直接基于JVM级别的类型，一般这种数据会提供给JVM用来执行“反射”等操作； 
		Class<String> cs = String.class;
　　类型代码——类型代码的数据也是用于JVM判断成员属性数据类型的一种方式，但类型代码的Java数据类型是char，比如‘L’，它一般通过一个字符来判断当前的Java数据类型，序列化时它会把这个字符转换成二进制数据；
　　类型签名——后边有例子讲解JVM如何处理类型签名，类型签名本身的Java数据类型是一个String类型，比如：‘Ljava/lang/String;’，它和类型代码一样可以用于JVM判断成员属性的数据类型，但是不仅仅如此，JVM在处理类型签名的时候，针对成员属性、成员函数、类本身都可以使用统一的方式来区分，在JVM里面类型签名相当于类型的唯一标识，它的使用范围比类型代码更加广阔；
　　3）Java Bean规范方法：
　　针对上边的五个成员属性，该类提供了五个成员属性的Get/Set方法，设置/获取函数：
　　Get方法定义清单： 
  1. public String getName() {
  2.     return name;
  3. }
  4. String getSignature() {
  5.     return signature;
  6. }
  7. public Class<?> getType() {
  8.     return type;
  9. }
  10. public boolean isUnshared() {
  11.     return unshared;
  12. }
  13. Field getField() {
  14.     return field;
  15. }
  16. public int getOffset() {
  17.     return offset;
  18. }
　　Set方法定义清单： 
  1. protected void setOffset(int offset) {
  2.     this.offset = offset;
  3. }
　　注意这几个方法的访问控制修饰符，setOffset方法的修饰符是protected，意味着这个方法只能在本类以及子类可以调用；而getField和getSignature两个方法的修饰符都是默认default域，只能在java.io的包中可以调用这两个方法。可以这样去理解，通过java.io包之外的类针对成员属性进行元数据提取的时候，只能通过几个基本方法获取到这个成员属性的名称、类型、偏移量，禁用“反射”【getField不可用】，也就是说Java语言中虽然序列化是可扩展的，但是严格限制了其扩展的方式。
　　4）构造函数：
　　接下来仔细看看ObjectStreamField的四个构造函数的执行逻辑：
　　两个public的构造函数内容如下： 
  1. public ObjectStreamField(String name, Class<?> type) {
  2.     this(name, type, false);
  3. }
  4. public ObjectStreamField(String name, Class<?> type, boolean unshared) {
  5.     if (name == null) {
  6.         throw new NullPointerException();
  7.     }
  8.     this.name = name;
  9.     this.type = type;
  10.     this.unshared = unshared;
  11.     signature = getClassSignature(type).intern();
  12.     field = null;
  13. }
  • 第一个构造函数调用了第二个构造函数的内容，其中第三个参数传入的是false，也就是说默认情况下通过两参构造ObjectStreamField的时候，构造的是一个非"unshared"的成员属性，从序列化的原理上来讲【前一章规范中已经注明】，不论是类还是字段，"unshared"的状态下JVM都会为其创建新的元数据信息，而默认情况下是共享元数据信息的，在生成二进制序列的时候并不为每一个成员属性或者类单独创建元数据信息；
  • 使用public构造函数的时候，基本成员属性【字段】中，field属性的初始化值为null；而name、type、unshared都是传入的；比较特殊的属性是signature，它的初始值是使用的getClassSignature方法来获取的；
　　注意这两个构造函数，这两个构造函数提供了一个快速创建成员属性【字段】元数据的构造方式，但它并没为field赋值，也就是说除了字段的名称、类型、“unshared”的状态以及签名以外，这两个构造函数没有实质性的赋值——可以理解成这两个构造函数都处于“半构造”的状态，它还需要进一步构造才能获取针对字段的完整元数据【ObjectStreamField】，当然有可能field本身对元数据的提取没有影响，这里这种构造方法的定义可能是出于设计上的考虑。
　　两个default默认域的构造函数如下： 
  1.     ObjectStreamField(String name, String signature, boolean unshared) {
  2.         if (name == null) {
  3.             throw new NullPointerException();
  4.         }
  5.         this.name = name;
  6.         this.signature = signature.intern();
  7.         this.unshared = unshared;
  8.         field = null;
  9.  
  10.         switch (signature.charAt(0)) {
  11.             case 'Z': type = Boolean.TYPE; break;
  12.             case 'B': type = Byte.TYPE; break;
  13.             case 'C': type = Character.TYPE; break;
  14.             case 'S': type = Short.TYPE; break;
  15.             case 'I': type = Integer.TYPE; break;
  16.             case 'J': type = Long.TYPE; break;
  17.             case 'F': type = Float.TYPE; break;
  18.             case 'D': type = Double.TYPE; break;
  19.             case 'L':
  20.             case '[': type = Object.class; break;
  21.             default: throw new IllegalArgumentException("illegal signature");
  22.         }
  23.     }
  24.     ObjectStreamField(Field field, boolean unshared, boolean showType) {
  25.         this.field = field;
  26.         this.unshared = unshared;
  27.         name = field.getName();
  28.         Class<?> ftype = field.getType();
  29.         type = (showType || ftype.isPrimitive()) ? ftype : Object.class;
  30.         signature = getClassSignature(ftype).intern();
  31.     }
  • 两个default域的构造函数不存在相互调用关系，和public的两个构造函数的相互调用关系不一样；
  • 第一个default域的构造函数中，name、signature、unshared都是直接传入的，field直接设置为null，没有经过复杂的运算；而type使用了Java序列化中的类型代码【Type Code】的映射转换，在第三章的序列化规范中可以看到每一个成员属性都有固定的Type Code，而在构造一个ObjectStreamField的时候，其type属性的运算是根据Type Code的值来换算的；若获取的Type Code不对则直接抛出IllegalArgumentException的异常；
  • 第二个default域的构造函数中，field、unshared两个成员属性是直接传入的，name属性从field中提取，而signature是通过当前传入的field的类型作为getClassSignature方法的参数计算获取；showType在这个构造函数中主要是为了序列化实现的兼容性而考虑——如果当前成员属性是一个基础类型的数据【isPrimitive方法返回true】，它将直接返回基础数据的类型；若showType传入的值也是true，那么即使不检查成员属性的类型也会返回，这种情况用于对象类型的获取。推测type运算的正常逻辑如下：
    -- 如果当前字段是一个基础类型，则返回基础类型的getType的值；
    -- 如果当前字段是一个自定义对象类型，则返回对象类型的getType的值；
    -- 以上两者都不是的情况，返回Object.class；
　　分析上述的四个构造函数，只有最后一个函数为field成员属性赋值了，也就是说只有最后一个函数是提供了完整构造过程的构造函数，但是因为前三个构造函数有type成员属性在，所以这种非完整的构造块在设计上应该有它自己的理由。这一点的话希望读者在实际开发过程多思考去理解，其实ObjectStreamField常用的外部API会和serialPersistentFields的重写有关，重写它的时候会构造一个ObjectStreamField[]的类型。
　　5）String类的intern方法：
　　在上边的构造函数中，多次调用了String类的intern方法，这个方法的主要用法为：在构造一个新的字符串的时候，会先在常量池中检测该String对象是否存在【存在与否调用String对象的equals函数】，如果已经存在这样的String对象则直接从常量池中返回该字符串，否则的话新的字符串对象会被加入到常量池，最终会返回新加入的String对象的引用。
　　从上边的解读可以知道，在序列化解析成员属性的元数据的时候，其成员属性的类型签名通过String类的intern方法保证了唯一性，比如有两个String类型的对象obj1和obj2，它们的类型签名是一致的，而在构造ObjectStreamField的过程中，这个签名也具有唯一性——简单讲：同样类型的成员属性共享类型签名。
　　6）getClassSignature(Class<?>)
　　ObjectStreamField中拥有一个私有静态方法，用于计算当前成员属性的类型签名，其定义如下： 
  1.     private static String getClassSignature(Class<?> cl) {
  2.         StringBuilder sbuf = new StringBuilder();
  3.         while (cl.isArray()) {
  4.             sbuf.append('[');
  5.             cl = cl.getComponentType();
  6.         }
  7.         if (cl.isPrimitive()) {
  8.             if (cl == Integer.TYPE) {
  9.                 sbuf.append('I');
  10.             } else if (cl == Byte.TYPE) {
  11.                 sbuf.append('B');
  12.             } else if (cl == Long.TYPE) {
  13.                 sbuf.append('J');
  14.             } else if (cl == Float.TYPE) {
  15.                 sbuf.append('F');
  16.             } else if (cl == Double.TYPE) {
  17.                 sbuf.append('D');
  18.             } else if (cl == Short.TYPE) {
  19.                 sbuf.append('S');
  20.             } else if (cl == Character.TYPE) {
  21.                 sbuf.append('C');
  22.             } else if (cl == Boolean.TYPE) {
  23.                 sbuf.append('Z');
  24.             } else if (cl == Void.TYPE) {
  25.                 sbuf.append('V');
  26.             } else {
  27.                 throw new InternalError();
  28.             }
  29.         } else {
  30.             sbuf.append('L' + cl.getName().replace('.', '/') + ';');
  31.         }
  32.         return sbuf.toString();
  33.     }
　　这个函数的返回值会是什么内容呢【涉及类型签名的格式】？先看一个例子： 
  1. package org.susan.java.serial;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. public class FieldSignature {
  7. 	public static String getClassSignature(Class<?> cl) {
  8.         StringBuilder sbuf = new StringBuilder();
  9.         while (cl.isArray()) {
  10.             sbuf.append('[');
  11.             cl = cl.getComponentType();
  12.         }
  13.         if (cl.isPrimitive()) {
  14.             if (cl == Integer.TYPE) {
  15.                 sbuf.append('I');
  16.             } else if (cl == Byte.TYPE) {
  17.                 sbuf.append('B');
  18.             } else if (cl == Long.TYPE) {
  19.                 sbuf.append('J');
  20.             } else if (cl == Float.TYPE) {
  21.                 sbuf.append('F');
  22.             } else if (cl == Double.TYPE) {
  23.                 sbuf.append('D');
  24.             } else if (cl == Short.TYPE) {
  25.                 sbuf.append('S');
  26.             } else if (cl == Character.TYPE) {
  27.                 sbuf.append('C');
  28.             } else if (cl == Boolean.TYPE) {
  29.                 sbuf.append('Z');
  30.             } else if (cl == Void.TYPE) {
  31.                 sbuf.append('V');
  32.             } else {
  33.                 throw new InternalError();
  34.             }
  35.         } else {
  36.             sbuf.append('L' + cl.getName().replace('.', '/') + ';');
  37.         }
  38.         return sbuf.toString();
  39.     }
  40. 	public static void main(String args[]){
  41. 		// void类型
  42. 		System.out.println(FieldSignature.getClassSignature(void.class));
  43. 		// 基础类型
  44. 		System.out.println(FieldSignature.getClassSignature(int.class));
  45. 		// 基础封装类型
  46. 		System.out.println(FieldSignature.getClassSignature(Integer.class));
  47. 		// 自定义对象类型
  48. 		System.out.println(FieldSignature.getClassSignature(FieldSignature.class));
  49. 		// String类型
  50. 		System.out.println(FieldSignature.getClassSignature(String.class));
  51. 		// 数组类型
  52. 		int[] arr = new int[2];
  53. 		System.out.println(FieldSignature.getClassSignature(arr.getClass()));
  54. 		// 对象数组
  55. 		FieldSignature[] signs = new FieldSignature[4];
  56. 		System.out.println(FieldSignature.getClassSignature(signs.getClass()));
  57. 		// 对象集合
  58. 		List<FieldSignature> list = new ArrayList<FieldSignature>();	
  59. 		System.out.println(FieldSignature.getClassSignature(list.getClass()));
  60. 	}
  61. }
　　上边这段代码的输出如下：
V
I
Ljava/lang/Integer;
Lorg/susan/java/serial/FieldSignature;
Ljava/lang/String;
[I
[Lorg/susan/java/serial/FieldSignature;
Ljava/util/ArrayList;
　　从这样的一段代码基本可以推测成员属性的类型签名的格式：
  • Java中有一个特殊的Class类型——Void.class，这个Class的构造函数是私有的，所以它不具有实例，除了上边的void.class【Void.class等价】可以直接使用，而成员属性是不具有这个类型的；但是这里的解析仅仅只涉及了成员属性的签名，没有涉及成员函数的签名，成员函数的签名中函数的返回值是可以返回void类型的，也就是它的返回值类型可以是Void.class。
  • 所有的基础数据类型，其类型签名就是一个固定的字符串，类似：I、B、J、F、D、S、C、Z等，如果基础类型的成员属性不属于上述八种类型中的任何一种，同样也不是V表示的void类型，则抛出InternalError的错误；
  • 所有的数组使用的签名第一个字符为[符号，紧随其后的是数组中元素的类型签名， 对比上边的arr数组和signs数组的签名，它们一个是int[]类型，另外一个是FieldSignature[]的类型，看看输出就知道其元素签名的区别；从区别中可以知道的是所有对象数组的签名也具有唯一性，它的类型签名的前缀为[L；
  • 所有的对象签名都是以L开始，后边跟上一个固定格式来描述该对象的类型，这个固定格式一般是对象的类全名替换'.'为‘/’，然后加上';'的后缀；
  • 最后有一点容易忽略：只要是非基础类型【包括非基础类型的数组】，其签名的末尾都会有分号作为结束标识；
　　7）getTypeCode、getTypeString以及isUnshared
　　到这里ObjectStreamField就仅仅只剩下三个函数了，这三个函数中最后一个isUnshared函数这里不解析，看看另外两个函数：
　　getTypeCode： 
  1.     public char getTypeCode() {
  2.         return signature.charAt(0);
  3.     }
　　在前边分析二进制序列和解读序列化规范的时候，多次提到了Type Code这个概念，那么到这里Type Code面纱也被揭开了，实际上Type Code的取值内容就是根据成员属性的类型签名进行运算的：它的值是类型签名的第一个字符；
　　getTypeString： 
  1.     public String getTypeString() {
  2.         return isPrimitive() ? null : signature;
  3.     }
　　从getTypeString的函数可以知道：在序列化过程中，基础数据类型【不包含封装类型，封装类型本身是Object的子类】是不会包含类型的描述的，看看JVM中字节流的语法：
primitiveDesc:
　　prim_typecode fieldName
objectDesc:
　　obj_typecode fieldName className1
　　从上边的字节流语法可以知道，getTypeString这个方法是为className1这段语法量身订造的方法，这里的className1实际值就是成员属性的类型签名；

　　ii.ObjectStreamClass源码分析
　　前一个章节分析了ObjectStreamField的源代码，这个章节将要分析一个更加复杂的类：ObjectStreamClass，这个类主要用来提取序列化过程中某个对象所属类的元数据信息，对象所属类包含的元数据信息比起它的成员属性包含的元数据信息要复杂许多。序列化在解析类以及类中定义的成员属性的时候使用了下边这种结构：
ObjectStreamClass --ObjectStreamField[]
　　针对Class的元数据而言使用ObjectStreamClass作为元数据的存储容器，针对Class中的成员属性对应的元数据信息而言使用ObjectStreamField[]作为元数据的存储容器，而字段元数据的数组中的每一个元素类型对应的都是ObjectStreamField类型，它提取了单个成员属性的元数据信息。
　　1）类定义： 
public class ObjectStreamClass implements Serializable
　　该类实现了接口Serializable，也就是说这个类本身就包含了“可序列化”的语义，可以这样理解，Java在序列化一个对象的时候，会先提取出这个对象的元数据信息，通过这个对象生成对应的ObjectStreamClass对象，而ObjectStreamClass对象主要描述了当前序列化对象所属类的元数据信息。
　　2）内部类：
　　ObjectStreamClass中定义了许多内部类，其内部类的所有定义如下： 
  1. private static class Caches
  2. private static class ExceptionInfo
  3. private static class EntryFuture
  4. static class ClassDataSlot
  5. private static class MemberSignature
  6. private static class FieldReflector
  7. private static class FieldReflectorKey extends WeakReference<Class<?>>
  8. static class WeakClassKey extends WeakReference<Class<?>>
　　在分析ObjectStreamClass本身的源代码之前先看看每一个内部类的作用：
　　Caches类【缓存类】：
　　这个类中只定义了四个固定的属性，该类的完整定义如下： 
  1.     private static class Caches {
  2.         /** cache mapping local classes -> descriptors */
  3.         static final ConcurrentMap<WeakClassKey,Reference<?>> localDescs =
  4.             new ConcurrentHashMap<>();
  5.         /** cache mapping field group/local desc pairs -> field reflectors */
  6.         static final ConcurrentMap<FieldReflectorKey,Reference<?>> reflectors =
  7.             new ConcurrentHashMap<>();
  8.         /** queue for WeakReferences to local classes */
  9.         private static final ReferenceQueue<Class<?>> localDescsQueue =
  10.             new ReferenceQueue<>();
  11.         /** queue for WeakReferences to field reflectors keys */
  12.         private static final ReferenceQueue<Class<?>> reflectorsQueue =
  13.             new ReferenceQueue<>();
  14.     }
　　【*：这里的泛型语法new T<>()是JDK 1.7中的语法】这个类属于缓存类，它定义了四个成员：
　　localDescsQueue和reflectorsQueue两个成员是私有的静态成员，数据结构类型为“队列”；因为这两个成员属性加了final修饰，也就是说这两个引用的对象一旦初始化过后，引用不能指向新对象，它们具有JVM级别的唯一性；因为类中加入了private修饰，所以这两个成员不能在外部使用，只能在ObjectStreamClass内使用；又因为这两个成员使用了static修饰，属于静态成员，它们不属于对象而属于类；这两个成员的使用涉及了Java中的弱引用【Weak Reference】，它所定义的两个队列为两个弱引用的队列；localDescsQueue中存储的成员是本地类的类描述符成员，但是它只保存了类描述符成员对应的Key值【WeakClassKey类型】，reflectorsQueue中的成员虽然也是Class<?>的类型，但使用时应该用做FieldReflectorKey类型的队列容器，它可以用于引用FieldReflector对象，针对每一个类的分析而言它拥有一个FieldReflector来分析类中字段的元数据。
　　localDescs和reflectors的两个成员是默认default域的静态成员，类型为“哈希表映射”，同样也加入了final修饰，也就是说这两个成员同样具有JVM级别的唯一性，不仅仅如此，这两个成员充当了缓存的作用；localDescs成员的哈希表键为一个WeakClassKey类型，它的值为一个抽象类型Reference<?>，这个抽象类为SoftReference【软引用】和WeakReference【弱引用】的父类，它指向了WeakClassKey对应的类描述符对象；reflectors成员的哈希表键为FieldReflectorKey类型，它的值同样为一个抽象类型Reference<?>，它指向了FieldReflectorKey对应的字段描述信息。
　　结合上边的定义，这四个成员可以用下边的图进行结构解析，希望读者理解Caches中四个成员的关系：

　　【*：Caches类定义了两部分内容：第一部分是和类描述信息有关的，第二部分是和字段信息有关的，这两部分内容各自包含了一个队列容器和哈希表，它们都具有唯一性。至于为什么使用软引用、弱引用在后边分析的时候希望可以给出答案。使用ConcurrentMap的目的是为了保证序列化时的性能、可伸缩性以及并发操作】。
　　简单提及一下ConcurrentMap的知识点：
　　ConcurrentMap的主要子类是ConcurrentHashMap，该对象中包含了多个segment，而每一个segment中都包含了一个Entity的数组，而它的使用过程中比普通的HashMap多了一个segment类，segment类继承于ReentrantLock类，也就是说它实际上是一个锁。当多个线程操作ConcurrentHashMap时，JVM不会完全锁住这个map，而是锁住一个segment，这种情况下就提高了并发的效率。它的优缺点：
　　优点——由于是对对应的segment加锁，不是锁定整个map，并发性得到提高，能够直接提高插入、检索以及移除操作的可伸缩性；
　　缺点——当遍历map中的元素时，需要获取所有segment的锁，使用遍历会很慢。锁的增多占用了系统的资源，当调用针对整个集合的方法，比如isEmpty或size的实现更加困难，而且结果可能会有错误的风险。
　　ExceptionInfo类【异常类】：
　　该类中只包含了一个异常类的基本类名和异常信息，它的完整定义如下： 
  1.     private static class ExceptionInfo {
  2.         private final String className;
  3.         private final String message;
  4.  
  5.         ExceptionInfo(String cn, String msg) {
  6.             className = cn;
  7.             message = msg;
  8.         }
  9.  
  10.         /**
  11.          * Returns (does not throw) an InvalidClassException instance created
  12.          * from the information in this object, suitable for being thrown by
  13.          * the caller.
  14.          */
  15.         InvalidClassException newInvalidClassException() {
  16.             return new InvalidClassException(className, message);
  17.         }
  18.     }
　　这个类中主要包含了两个成员属性：className和message，这个类主要用于检测InvalidClassException异常，className和message两个成员属性都包含了final修饰符，这个类的所有实例都是不可变的，而且它们会共享一个ObjectStreamClass对象，而该类中会根据className和message两个成员属性生成一个新的InvalidClassException对象。在ObjectStreamClass检测被解析的类时，如果出错会抛出该异常信息，ExceptionInfo和一般的异常定义不一样，它并没有从Exception类中继承来定义异常，而是直接通过调用newInvalidClassException方法生成一个新的异常，而且这个异常信息会根据成员属性className和message中存储的数据来生成。
　　EntryFuture类
　　该类用于在已经初始化的进程中从一个进程入口去检索类描述符以及字段反射器的相关信息，当一个内部调用者从一个进程内的另外线程去获取一个EntryFuture实例的时候，它应该调用EntryFuture的get方法，这个方法将会返回这个实例本身，EntryFuture实例本身使用了线程同步的方法定义。先看看这个类的整体定义： 
  1.     private static class EntryFuture {
  2.  
  3.         private static final Object unset = new Object();
  4.         private final Thread owner = Thread.currentThread();
  5.         private Object entry = unset;
  6.  
  7.         /**
  8.          * Attempts to set the value contained by this EntryFuture.  If the
  9.          * EntryFuture's value has not been set already, then the value is
  10.          * saved, any callers blocked in the get() method are notified, and
  11.          * true is returned.  If the value has already been set, then no saving
  12.          * or notification occurs, and false is returned.
  13.          */
  14.         synchronized boolean set(Object entry) {
  15.             if (this.entry != unset) {
  16.                 return false;
  17.             }
  18.             this.entry = entry;
  19.             notifyAll();
  20.             return true;
  21.         }
  22.  
  23.         /**
  24.          * Returns the value contained by this EntryFuture, blocking if
  25.          * necessary until a value is set.
  26.          */
  27.         synchronized Object get() {
  28.             boolean interrupted = false;
  29.             while (entry == unset) {
  30.                 try {
  31.                     wait();
  32.                 } catch (InterruptedException ex) {
  33.                     interrupted = true;
  34.                 }
  35.             }
  36.             if (interrupted) {
  37.                 AccessController.doPrivileged(
  38.                     new PrivilegedAction<Void>() {
  39.                         public Void run() {
  40.                             Thread.currentThread().interrupt();
  41.                             return null;
  42.                         }
  43.                     }
  44.                 );
  45.             }
  46.             return entry;
  47.         }
  48.  
  49.         /**
  50.          * Returns the thread that created this EntryFuture.
  51.          */
  52.         Thread getOwner() {
  53.             return owner;
  54.         }
  55.     }
　　注意这个类：这个类中的EntryFuture实例是隶属于一个Java线程的，而每一个EntryFuture实例都拥有一个Owner线程，从这个类的set方法可以知道，EntryFuture中的entry只能被设置一次，一旦设置过后再调用set方法将会返回false。实际上EntryFuture是针对ObjectStreamClass中被解析类的实例的一个封装，主要目的是为了解决多线程环境的序列化问题而存在的。在代码中，如果需要创建一个被解析类的实例，会先创建一个EntryFuture的实例，然后通过EntryFuture实例去获取被解析类的实例，通过这种方式的操作可以保证在多线程环境中被解析类实例的线程安全性——从设计上来讲这个类的存在是必须的。不仅仅如此，从代码细节可以发现，在获取一个被解析类的实例时【调用get方法】，系统调用了Java中的访问控制器检测了代码的执行权限。
　　【*：在分析ObjectStreamClass源代码之前，先解析里面的Class定义，其目的是为了知道ObjectStreamClass中拥有多少内部类，从这些内部类的定义可以知道它们大部分的修饰符都是private的，所以只能在ObjectStreamClass中使用，了解了它们过后分析ObjectStreamClass就相对简单许多。】
　　ClassDataSlot类：
　　这个类主要用来描述已经分配的类描述符数据中可序列化对象的部分类描述信息，如果hasData的值为false，则表示对象的可序列化形式【JVM规范中已经说明，前一个章节的第4部分：类描述符中有说明】不包含和类描述符相关到数据信息。 
  1.     static class ClassDataSlot {
  2.  
  3.         /** class descriptor "occupying" this slot */
  4.         final ObjectStreamClass desc;
  5.         /** true if serialized form includes data for this slot's descriptor */
  6.         final boolean hasData;
  7.  
  8.         ClassDataSlot(ObjectStreamClass desc, boolean hasData) {
  9.             this.desc = desc;
  10.             this.hasData = hasData;
  11.         }
  12.     }
　　从该类的定义可以看到它包含了两个成员，成员hasData前边已经说过，另外一个成员desc描述了这个类和主类ObjectStreamClass的从属关系。思考一下，为什么会需要这种从属关系？请读者随时注意ObjectStreamClass的运行环境，它的运行环境包含两部分，所有静态成员是在“类环境”中运行的，而实例的运行环境则是“对象环境”，ClassDataSlot实际上是对ObjectStreamClass的一种封装，它的这种封装可以保证在处理类的元数据过程中更加有序，相当于在读写类的元数据时多抽象了一层来执行庞大的管理操作。
　　MemberSignature类【成员签名类】：
　　这个类主要提供给ObjectStreamClass在计算serialVersionUID字段时，用来运算以及缓存成员属性、构造函数、成员方法的签名信息。 
  1.     private static class MemberSignature {
  2.  
  3.         public final Member member;
  4.         public final String name;
  5.         public final String signature;
  6.  
  7.         public MemberSignature(Field field) {
  8.             member = field;
  9.             name = field.getName();
  10.             signature = getClassSignature(field.getType());
  11.         }
  12.  
  13.         public MemberSignature(Constructor cons) {
  14.             member = cons;
  15.             name = cons.getName();
  16.             signature = getMethodSignature(
  17.                 cons.getParameterTypes(), Void.TYPE);
  18.         }
  19.  
  20.         public MemberSignature(Method meth) {
  21.             member = meth;
  22.             name = meth.getName();
  23.             signature = getMethodSignature(
  24.                 meth.getParameterTypes(), meth.getReturnType());
  25.         }
  26.     }
　　该类有三个成员属性member、name、signature，member会使用Java的“反射”来分析成员的JVM级别的元数据信息，name为成员名称，signature为成员的签名信息，它的构造函数有三个【分别处理成员属性、构造函数、成员函数三种情况】： 
  1. public MemberSignature(Field field)
  2. public MemberSignature(Constructor cons)
  3. public MemberSignature(Method meth)
　　Field单参数构造函数调用了私有成员函数getClassSignature，这个函数和ObjectStreamField中的成员函数是一样的，这里不再重复；
　　Constructor和Method单参数构造函数都调用了私有成员函数getMethodSignature，先看看这个函数的定义：
 
  1.     private static String getMethodSignature(Class<?>[] paramTypes,
  2.                                              Class<?> retType)
  3.     {
  4.         StringBuilder sbuf = new StringBuilder();
  5.         sbuf.append('(');
  6.         for (int i = 0; i < paramTypes.length; i++) {
  7.             sbuf.append(getClassSignature(paramTypes[i]));
  8.         }
  9.         sbuf.append(')');
  10.         sbuf.append(getClassSignature(retType));
  11.         return sbuf.toString();
  12.     }
　　同样通过一个例子来看看getMethodSignature函数的输出内容：
 
  1. package org.susan.java.serial;
  2.  
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Method;
  5.  
  6. public class MethodSignature {
  7. 	public static String getMethodSignature(Class<?>[] paramTypes,
  8. 			Class<?> retType) {
  9. 		StringBuilder sbuf = new StringBuilder();
  10. 		sbuf.append('(');
  11. 		for (int i = 0; i < paramTypes.length; i++) {
  12. 			sbuf.append(FieldSignature.getClassSignature(paramTypes[i]));
  13. 		}
  14. 		sbuf.append(')');
  15. 		sbuf.append(FieldSignature.getClassSignature(retType));
  16. 		return sbuf.toString();
  17. 	}
  18. 	public static void main(String args[]){
  19. 		// 构造函数签名
  20. 		Constructor<?>[] cons = MethodTest.class.getDeclaredConstructors();
  21. 		for( Constructor<?> con: cons){
  22. 			System.out.println("==>" + con.getName());
  23. 			System.out.println(getMethodSignature(con.getParameterTypes(),Void.TYPE));
  24. 		}
  25. 		// 方法签名
  26. 		Method[] methods = MethodTest.class.getDeclaredMethods();
  27. 		for( Method method: methods){
  28. 			System.out.println("==>" + method.getName());
  29. 			System.out.println(getMethodSignature(method.getParameterTypes(),method.getReturnType()));
  30. 		}
  31. 	}
  32. }
  33.  
  34. class MethodTest{
  35. 	private int age;
  36. 	private String name;
  37. 	public MethodTest(int age, String name){
  38. 		this.age = age;
  39. 		this.name = name;
  40. 	}
  41. 	public MethodTest(int age){
  42. 		this(age,"Unknown");
  43. 	}
  44. 	public String buildTemplate(String prefix){
  45. 		return prefix + " " + this.name + ", you are " + this.age + " now.";
  46. 	}
  47. 	public void buildHello(){
  48. 		String template = buildTemplate("Hello");
  49. 		System.out.println(template);
  50. 	}
  51. }
　　上边的示例输出信息如下：
==>org.susan.java.serial.MethodTest
(ILjava/lang/String;)V
==>org.susan.java.serial.MethodTest
(I)V
==>buildHello
()V
==>buildTemplate
(Ljava/lang/String;)Ljava/lang/String;
　　请读者仔细去理解方法签名的格式，在理解方法签名的时候需要结合前面提到的getClassSignature方法来理解，因为不论是构造函数还是成员函数参数、返回值都调用了getClassSignature方法来生成对应的类型签名，到这里相信不用解析读者就知道为什么在getClassSignature签名的时候会有一个针对void类型的判断，虽然成员属性的签名中不会包含void类型，但成员函数的返回值可能会出现void类型，所以有了类型代码'V'出现。MemberSignature类主要目的是针对类中成员属性进行了封装，使用统一的格式进行管理，它在处理成员时使用了Java反射中的Member接口，这个接口比起可实例化的Field、Method、Constructor而言更加抽象，所以该类在成员属性这个级别抽象了一级出来用来解析三种不同类型的成员属性，则它的这种封装其数据本身描述了“成员属性的元数据”。
　　FieldRelfectorKey、WeakClassKey
　　因为FieldReflector类相对比较复杂，在解析这个类之前先看看FieldRelfectorKey和WeakClassKey，早在上边的Caches类中已经提到两个哈希表的键值一个类型是WeakClassKey【localDescs】，一个类型是FieldReflectorKey【reflectors】，先看看两个类各自的源码定义：
　　FieldRelfectorKey的定义如下： 
  1.     private static class FieldReflectorKey extends WeakReference<Class<?>> {
  2.  
  3.         private final String sigs;
  4.         private final int hash;
  5.         private final boolean nullClass;
  6.  
  7.         FieldReflectorKey(Class<?> cl, ObjectStreamField[] fields,
  8.                           ReferenceQueue<Class<?>> queue)
  9.         {
  10.             super(cl, queue);
  11.             nullClass = (cl == null);
  12.             StringBuilder sbuf = new StringBuilder();
  13.             for (int i = 0; i < fields.length; i++) {
  14.                 ObjectStreamField f = fields[i];
  15.                 sbuf.append(f.getName()).append(f.getSignature());
  16.             }
  17.             sigs = sbuf.toString();
  18.             hash = System.identityHashCode(cl) + sigs.hashCode();
  19.         }
  20.  
  21.         public int hashCode() {
  22.             return hash;
  23.         }
  24.  
  25.         public boolean equals(Object obj) {
  26.             if (obj == this) {
  27.                 return true;
  28.             }
  29.  
  30.             if (obj instanceof FieldReflectorKey) {
  31.                 FieldReflectorKey other = (FieldReflectorKey) obj;
  32.                 Class<?> referent;
  33.                 return (nullClass ? other.nullClass
  34.                                   : ((referent = get()) != null) &&
  35.                                     (referent == other.get())) &&
  36.                     sigs.equals(other.sigs);
  37.             } else {
  38.                 return false;
  39.             }
  40.         }
  41.     }
　　这个类主要在缓存表中提供了一个哈希表键，如果两个引用指向了同一个类，则它们为相同的键，也就是说缓存中的同一个特本地类描述符在系统中应该只出现一次。关于FieldReflectorKey的详细定义这里就不解析重写的hashCode和equals方法了，主要看看这个类的定义和构造函数。该类拥有一个父类WeakReference<Class<?>>，也就是说这个类的实例引用是Java中的弱引用，看看它的构造函数中的主要逻辑：
  1. 调用父类WeakReference的构造函数；
  2. 如果传入的第一个参数cl为null，则将成员函数nullClass设置成true，该成员函数是一个标识，判断传入的类是否为null；
  3. 分析第二个参数fields生成传入Class的整体字段签名；
  4. 将整体字段签名赋值给成员属性sigs；
  5. 计算签名过后的hash值，根据传入的Class的hashCode以及签名sigs的hashCode计算；
　　这个类中的sigs和hash值很重要，实际上在重写的equals和hashCode方法中，判断两个FieldReflectorKey实例指向的Class是否相同使用的判断依据就是sigs属性以及hash值，这两个值在FieldReflectorKey中是固定算法的，而且它计算源是根据构造函数中的传入Class来计算的，所以仅仅针对同一个Class而言这两个值是相等的。
　　WeakClassKey的定义如下： 
  1.     static class WeakClassKey extends WeakReference<Class<?>> {
  2.         /**
  3.          * saved value of the referent's identity hash code, to maintain
  4.          * a consistent hash code after the referent has been cleared
  5.          */
  6.         private final int hash;
  7.  
  8.         /**
  9.          * Create a new WeakClassKey to the given object, registered
  10.          * with a queue.
  11.          */
  12.         WeakClassKey(Class<?> cl, ReferenceQueue<Class<?>> refQueue) {
  13.             super(cl, refQueue);
  14.             hash = System.identityHashCode(cl);
  15.         }
  16.  
  17.         /**
  18.          * Returns the identity hash code of the original referent.
  19.          */
  20.         public int hashCode() {
  21.             return hash;
  22.         }
  23.  
  24.         /**
  25.          * Returns true if the given object is this identical
  26.          * WeakClassKey instance, or, if this object's referent has not
  27.          * been cleared, if the given object is another WeakClassKey
  28.          * instance with the identical non-null referent as this one.
  29.          */
  30.         public boolean equals(Object obj) {
  31.             if (obj == this) {
  32.                 return true;
  33.             }
  34.  
  35.             if (obj instanceof WeakClassKey) {
  36.                 Object referent = get();
  37.                 return (referent != null) &&
  38.                        (referent == ((WeakClassKey) obj).get());
  39.             } else {
  40.                 return false;
  41.             }
  42.         }
  43.     }
　　这个类作为缓存中哈希表的键值而言只是比FieldReflectorKey少了sigs以及nullClass属性，这里就不重复分析了，细心的读者理解了FieldReflectorKey过后自然就明白这个类了。
　　FieldReflector
　　最后一起来看看FieldReflector类，这个类是ObjectStreamClass中最复杂的一个内部类，这个类主要用于针对序列化中对象的可序列化字段进行分析，它为每一个被解析的类提供了一个FieldReflector来分析该类中的所有字段信息，它操作的核心数据结构为ObjectStreamField[]类型。因为它的结构复杂所以在本文分析的时候同样使用拆分的方式拆开来看这个类的结构。
　　FieldReflector的成员属性定义如下： 
  1.         /** handle for performing unsafe operations */
  2.         private static final Unsafe unsafe = Unsafe.getUnsafe();
  3.         /** fields to operate on */
  4.         private final ObjectStreamField[] fields;
  5.         /** number of primitive fields */
  6.         private final int numPrimFields;
  7.         /** unsafe field keys for reading fields - may contain dupes */
  8.         private final long[] readKeys;
  9.         /** unsafe fields keys for writing fields - no dupes */
  10.         private final long[] writeKeys;
  11.         /** field data offsets */
  12.         private final int[] offsets;
  13.         /** field type codes */
  14.         private final char[] typeCodes;
  15.         /** field types */
  16.         private final Class<?>[] types;
　　先看看这个内部类中的所有成员：
  • unsafe——sun.misc.Unsafe
    该成员主要用于处理一些不安全的操作，这个操作偏向于CAS硬件原语级别【后边会讲到】，而不是单纯的Java语言级的内容；
  • fields——java.io.ObjectStreamField[]
    fields成员用于描述当前的ObjectStreamClass中的成员属性描述集合，前边已经讲过ObjectStreamField类可以分析成员属性得到它对应的元数据信息，而fields成员属性保存了当前分析的类对应的所有成员属性的元数据信息，它是一个数组结构，每一个元素都对应了成员属性的元数据描述信息，且不会重复。
  • numPrimFIelds——int
    该属性描述了当前ObjectStreamClass中基础类型的成员属性的数量；
  • readKeys——long[]
    针对不安全的字段的读取提供的键值，这个键值可能包含了重复值【CAS原语级别】；
  • writeKeys——long[]
    针对不安全的字段的写入提供的键值，这个键值不包含重复值【CAS原语级别】；
  • offsets——int[]
    前边在分析ObjectStreamField的时候讲过，在序列化分析一个类中定义的成员属性的时候，依靠偏移量来读取每一个成员属性，而FieldReflector是针对当前Class的所有成员属性进行分析的类，所以它会有一个偏移量的集合，offsets就是保存偏移量的数组；
  • typeCodes——char[]
    typeCodes数组包含了一个Class中所有成员属性的类型代码的集合；
  • types——java.lang.Class<?>[]
    types数组包含了一个Class中所有成员属性的类型的集合；
　　getFields方法
　　在FieldReflector类中包含了一个getFields方法，用于获取所有的字段元数据信息【ObjectStreamField[]类型】，它的定义如下： 
  1.         ObjectStreamField[] getFields() {
  2.             return fields;
  3.         }
　　这个方法会获得当前ObjectStreamClass类中所有分析的字段元数据信息，比如shared/unshared、字段类型、字段值等。
　　set/get特殊方法
　　除了上边的方法以外，这个类中还定义了四个特殊方法，这四个方法的定义如下【不提供实现源代码】： 
  1.         void getPrimFieldValues(Object obj, byte[] buf) {...}
  2.         void setPrimFieldValues(Object obj, byte[] buf) {...}
  3.         void getObjFieldValues(Object obj, Object[] vals) {...}
  4.         void setObjFieldValues(Object obj, Object[] vals) {...}　　
　　阅读的时候注意上边的get*类型的方法，所有get*方法的返回值都是void的，这和常用的get*方法不太一样。
　　getPrimFieldValues方法主要用于基础类型字段的序列化，它在执行之前会确保FieldReflector获取的类描述符已经通过了checkDefaultSerialize()序列化的检测，如果当前数组中不包含任何可读取的键值，则其值应该和Unsafe.INVALID_FIELD_OFFSET相等。这个方法会使用readKeys、offsets、typeCodes成员，主要用于将序列化过后的基础类型字段写入到buf字节缓冲区中；
　　setPrimFieldValues方法是对应get方法的逆方法，它主要用于基础类型字段的反序列化操作，它会先从writeKeys中去获取字段对应的键值，如果出现了Unsafe.INVALID_FIELD_OFFSET的键值直接放弃该字段的设置行为。这个方法会使用writeKeys、offsets、typeCodes成员，它主要用于将读取的字节数据写入到当前传入的对象中，设置该对象对应的成员属性的值；
　　getObjFieldValues方法和setObjFieldValues方法在这里就不重复了，它们和上边提到的两个方法的用法是一致的，唯一的不同是它们的操作对象是Java中的对象类型的字段而不是基础类型的字段；
　　注意这里的writeKeys和readKeys方法，从前文中读者可以知道一般写操作是：把Java对象的状态转换成字节流，而读操作是：把字节流中的数据恢复成Java对象。但从源代码中可以知道这里的读写概念相反，writeKeys负责将字节流中的数据写入到Java对象，而readKeys负责将Java对象中的字段值读取出来反向写入到字节流中；为什么会这样呢？因为操作对象不一样，前文提到的序列化反序列化的操作对象是目标介质比如文件，而这里的writeKeys和readKeys的操作对象是Java对象，因为它们的操作对象刚好是“逆向”的，所以才会出现这样的的情况，请读者仔细分析理解。

　　这里还有一个容易混淆的内容是sun.misc.Unsafe类，简单讲讲这个类的作用以及代码中出现的INVALID_FIELD_OFFSET的含义：
　　参考：http://en.wikipedia.org/wiki/Compare-and-swap
　　CAS【Compare And Swap】——简单讲它表示比较并交换的算法，属于计算机原子级别的操作，主要用于处理器支持并发提供的原子级操作的测试，通常在计算机的位级别运行该操作，CAS操作包含了三个操作数：内存位置（V）、预期原值（A）和新值（B）。如果内存位置的值与预期原值相匹配，则处理器会自动将该位置的值更新成新值，否则处理器不做任何操作。无论哪种情况它都会在CAS指令之前返回该内存位置的值，一些特殊情况下它会返回CAS是否成功的标记，而不会提取这个位置的值。CAS有效地说明了“我认为位置V应该包含值A，如果包含该值则将B放到这个位置，否则不去更改该位置，只是告诉自己这个位置现在的值即可。”
　　CAS用于同步方式的时候，会从地址V读取值A、执行多步计算来获得新值B，然后使用CAS将V的值从A更新为B，如果V处的值没有同时更改，则CAS操作成功。类似于CAS的指令允许算法执行读-修改-写操作，而不需要害怕其他线程同时修改变量，因为如果其他线程修改变量则CAS会检测它并且失败，该算法可以对操作重新计算。CAS最大的价值是可以在硬件中实现，并且在大多数处理器中是一种轻量级的实现。
　　Java的并发包java.util.concurrent中大量使用了CAS操作，而涉及到并发的地方都会去调用Unsafe类，也就是说Java语言中针对CAS原子级别的操作都使用sun.misc.Unsafe类实现，这个类中包含了许多native的方法，而且是未开源的，这里就不去了解Unsafe类的源代码了。INVALID_FIELD_OFFSET的值为-1，实际上Java在底层访问一个类的时候，它在调用成员属性时都是用偏移量操作的，而类定义中的第一个字段偏移量应该是0，如果一个类中的字段不匹配或者找不到的情况就返回INVALID_FIELD_OFFSET，即返回-1告诉JVM针对当前这个类执行的字段操作是不合法的。
　　FieldReflector的构造函数定义如下： 
  1.         FieldReflector(ObjectStreamField[] fields) {
  2.             this.fields = fields;
  3.             int nfields = fields.length;
  4.             readKeys = new long[nfields];
  5.             writeKeys = new long[nfields];
  6.             offsets = new int[nfields];
  7.             typeCodes = new char[nfields];
  8.             ArrayList<Class<?>> typeList = new ArrayList<>();
  9.             Set<Long> usedKeys = new HashSet<>();
  10.  
  11.  
  12.             for (int i = 0; i < nfields; i++) {
  13.                 ObjectStreamField f = fields[i];
  14.                 Field rf = f.getField();
  15.                 long key = (rf != null) ?
  16.                     unsafe.objectFieldOffset(rf) : Unsafe.INVALID_FIELD_OFFSET;
  17.                 readKeys[i] = key;
  18.                 writeKeys[i] = usedKeys.add(key) ?
  19.                     key : Unsafe.INVALID_FIELD_OFFSET;
  20.                 offsets[i] = f.getOffset();
  21.                 typeCodes[i] = f.getTypeCode();
  22.                 if (!f.isPrimitive()) {
  23.                     typeList.add((rf != null) ? rf.getType() : null);
  24.                 }
  25.             }
  26.  
  27.             types = typeList.toArray(new Class<?>[typeList.size()]);
  28.             numPrimFields = nfields - types.length;
  29.         }
　　FieldReflector主要用来分析成员属性的元数据，该类的构造函数参数类型为ObjectStreamFields[]，而FieldReflector的构造会初始化它的成员属性，例如readKeys、writeKeys、offsets、typeCodes等。因为FieldReflector需要去分析一个ObjectStreamClass中所有的成员属性信息，这里初始化的时候，其成员属性大部分都是数组类型，那么这里会隐含一个概念：FieldReflector在分析每一个成员属性的时候，使用的方式是索引的统一访问——举个例子：如果它分析的成员属性的索引为offset[3]，则对应这个成员属性的其他信息为：readKeys[3]、writeKeys[3]、typeCodes[3]。上边的函数做的就是这样的构建过程，有了这个概念基础读者理解上边源代码就更加容易了。
　　本文到这里ObjectStreamClass中的内部类的分析就结束了，接下来带领读者一起去分析ObjectStreamClass主类的相关内容。
　　3）native操作：
　　ObjectStreamClass中包含了几个本地方法【native】的定义，其定义包含如下： 
  1. private static native void initNative();
  2. static {
  3.     initNative();
  4. }
  5. private native static boolean hasStaticInitializer(Class<?> cl);
　　上边两个方法在源代码中并没定义在一起，分析的时候为了阅读方便就放在一起来解析。
　　hasStaticInitializer方法主要用于检测传入的类中是否包含了静态初始化方法，如果包含则返回true，反之直接返回false；而initNative()方法的目的就是执行本地方法的“实现初始化”操作，ObjectStreamClass类中的静态初始化块static{}中的内容就是执行initNative()方法【该方法会在ClassLoader载入Java的Class的时候调用initNative方法】——实际上这个地方的initNative方法调用过后，系统底层才会把hasStaticInitializer方法的实现代码初始化，如果不调用initNative方法，当系统在调用hasStaticInitializer方法的时候会因为该方法的实现代码没有初始化而失败，根据Java的语言规定native的方法实现需要使用C语言，所以这里的initNative方法应该是把C语言的实现代码初始化——不过这一切都是我个人的理解，关于这个方法确实没有证据来证明，本文的目的是透析Java序列化，关于native的使用这里就不多说了。
　　4）关于SUID
　　ObjectStreamClass中定义两部分和SUID有关的内容：本身的SUID和针对被解析类的SUID的运算用的成员函数，其自身的serialVersionUID定义如下： 
    private static final long serialVersionUID = -6120832682080437368L;
　　而针对其被解析类对应的SUID定义如下： 
  1.     /** serialVersionUID of represented class (null if not computed yet) */
  2.     private volatile Long suid;
　　获得被解析类的serialVersionUID的方法如下： 
  1.     public long getSerialVersionUID() {
  2.         // REMIND: synchronize instead of relying on volatile?
  3.         if (suid == null) {
  4.             suid = AccessController.doPrivileged(
  5.                 new PrivilegedAction<Long>() {
  6.                     public Long run() {
  7.                         return computeDefaultSUID(cl);
  8.                     }
  9.                 }
  10.             );
  11.         }
  12.         return suid.longValue();
  13.     }
　　这个方法的调用会返回被解析类中定义的serialVersionUID的值，如果被解析类是不可序列化的，则这个值会返回0L。这个方法会调用Java中的AccessController【访问控制器】，它会检查当前的代码是否拥有执行权限，这里的判断主要是查看分析类中是否显示定义了serialVersionUID，如果没有定义则调用computeDefaultSUID方法来计算suid的值。实际上在调用方法getSerialVersionUID方法之前，构造ObjectStreamClass实例的时候会调用方法getDeclaredSUID为suid赋值，该方法的定义如下： 
  1.     private static Long getDeclaredSUID(Class<?> cl) {
  2.         try {
  3.             Field f = cl.getDeclaredField("serialVersionUID");
  4.             int mask = Modifier.STATIC | Modifier.FINAL;
  5.             if ((f.getModifiers() & mask) == mask) {
  6.                 f.setAccessible(true);
  7.                 return Long.valueOf(f.getLong(null));
  8.             }
  9.         } catch (Exception ex) {
  10.         }
  11.         return null;
  12.     }
　　上边方法的代码逻辑很简单：就是获取参数cl【Class<?>类型】中定义的serialVersionUID的值，这个字段的修饰符必须是static和final的，因为这个字段是private修饰，所以会调用setAccessible方法解除该字段的访问控制，从而获得该值。关于SUID最后看一下computeDefaultSUID方法的实现： 
  1.     private static long computeDefaultSUID(Class<?> cl) {
  2.         if (!Serializable.class.isAssignableFrom(cl) || Proxy.isProxyClass(cl))
  3.         {
  4.             return 0L;
  5.         }
  6.  
  7.         try {
  8.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  9.             DataOutputStream dout = new DataOutputStream(bout);
  10.  
  11.             dout.writeUTF(cl.getName());
  12.  
  13.             int classMods = cl.getModifiers() &
  14.                 (Modifier.PUBLIC | Modifier.FINAL |
  15.                  Modifier.INTERFACE | Modifier.ABSTRACT);
  16.  
  17.             /*
  18.              * compensate for javac bug in which ABSTRACT bit was set for an
  19.              * interface only if the interface declared methods
  20.              */
  21.             Method[] methods = cl.getDeclaredMethods();
  22.             if ((classMods & Modifier.INTERFACE) != 0) {
  23.                 classMods = (methods.length > 0) ?
  24.                     (classMods | Modifier.ABSTRACT) :
  25.                     (classMods & ~Modifier.ABSTRACT);
  26.             }
  27.             dout.writeInt(classMods);
  28.  
  29.             if (!cl.isArray()) {
  30.                 /*
  31.                  * compensate for change in 1.2FCS in which
  32.                  * Class.getInterfaces() was modified to return Cloneable and
  33.                  * Serializable for array classes.
  34.                  */
  35.                 Class<?>[] interfaces = cl.getInterfaces();
  36.                 String[] ifaceNames = new String[interfaces.length];
  37.                 for (int i = 0; i < interfaces.length; i++) {
  38.                     ifaceNames[i] = interfaces[i].getName();
  39.                 }
  40.                 Arrays.sort(ifaceNames);
  41.                 for (int i = 0; i < ifaceNames.length; i++) {
  42.                     dout.writeUTF(ifaceNames[i]);
  43.                 }
  44.             }
  45.  
  46.             Field[] fields = cl.getDeclaredFields();
  47.             MemberSignature[] fieldSigs = new MemberSignature[fields.length];
  48.             for (int i = 0; i < fields.length; i++) {
  49.                 fieldSigs[i] = new MemberSignature(fields[i]);
  50.             }
  51.             Arrays.sort(fieldSigs, new Comparator<MemberSignature>() {
  52.                 public int compare(MemberSignature ms1, MemberSignature ms2) {
  53.                     return ms1.name.compareTo(ms2.name);
  54.                 }
  55.             });
  56.             for (int i = 0; i < fieldSigs.length; i++) {
  57.                 MemberSignature sig = fieldSigs[i];
  58.                 int mods = sig.member.getModifiers() &
  59.                     (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
  60.                      Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |
  61.                      Modifier.TRANSIENT);
  62.                 if (((mods & Modifier.PRIVATE) == 0) ||
  63.                     ((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0))
  64.                 {
  65.                     dout.writeUTF(sig.name);
  66.                     dout.writeInt(mods);
  67.                     dout.writeUTF(sig.signature);
  68.                 }
  69.             }
  70.  
  71.             if (hasStaticInitializer(cl)) {
  72.                 dout.writeUTF("<clinit>");
  73.                 dout.writeInt(Modifier.STATIC);
  74.                 dout.writeUTF("()V");
  75.             }
  76.  
  77.             Constructor[] cons = cl.getDeclaredConstructors();
  78.             MemberSignature[] consSigs = new MemberSignature[cons.length];
  79.             for (int i = 0; i < cons.length; i++) {
  80.                 consSigs[i] = new MemberSignature(cons[i]);
  81.             }
  82.             Arrays.sort(consSigs, new Comparator<MemberSignature>() {
  83.                 public int compare(MemberSignature ms1, MemberSignature ms2) {
  84.                     return ms1.signature.compareTo(ms2.signature);
  85.                 }
  86.             });
  87.             for (int i = 0; i < consSigs.length; i++) {
  88.                 MemberSignature sig = consSigs[i];
  89.                 int mods = sig.member.getModifiers() &
  90.                     (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
  91.                      Modifier.STATIC | Modifier.FINAL |
  92.                      Modifier.SYNCHRONIZED | Modifier.NATIVE |
  93.                      Modifier.ABSTRACT | Modifier.STRICT);
  94.                 if ((mods & Modifier.PRIVATE) == 0) {
  95.                     dout.writeUTF("<init>");
  96.                     dout.writeInt(mods);
  97.                     dout.writeUTF(sig.signature.replace('/', '.'));
  98.                 }
  99.             }
  100.  
  101.             MemberSignature[] methSigs = new MemberSignature[methods.length];
  102.             for (int i = 0; i < methods.length; i++) {
  103.                 methSigs[i] = new MemberSignature(methods[i]);
  104.             }
  105.             Arrays.sort(methSigs, new Comparator<MemberSignature>() {
  106.                 public int compare(MemberSignature ms1, MemberSignature ms2) {
  107.                     int comp = ms1.name.compareTo(ms2.name);
  108.                     if (comp == 0) {
  109.                         comp = ms1.signature.compareTo(ms2.signature);
  110.                     }
  111.                     return comp;
  112.                 }
  113.             });
  114.             for (int i = 0; i < methSigs.length; i++) {
  115.                 MemberSignature sig = methSigs[i];
  116.                 int mods = sig.member.getModifiers() &
  117.                     (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
  118.                      Modifier.STATIC | Modifier.FINAL |
  119.                      Modifier.SYNCHRONIZED | Modifier.NATIVE |
  120.                      Modifier.ABSTRACT | Modifier.STRICT);
  121.                 if ((mods & Modifier.PRIVATE) == 0) {
  122.                     dout.writeUTF(sig.name);
  123.                     dout.writeInt(mods);
  124.                     dout.writeUTF(sig.signature.replace('/', '.'));
  125.                 }
  126.             }
  127.  
  128.             dout.flush();
  129.  
  130.             MessageDigest md = MessageDigest.getInstance("SHA");
  131.             byte[] hashBytes = md.digest(bout.toByteArray());
  132.             long hash = 0;
  133.             for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
  134.                 hash = (hash << 8) | (hashBytes[i] & 0xFF);
  135.             }
  136.             return hash;
  137.         } catch (IOException ex) {
  138.             throw new InternalError();
  139.         } catch (NoSuchAlgorithmException ex) {
  140.             throw new SecurityException(ex.getMessage());
  141.         }
  142.     }
　　在分析上述的源代码之前读者先回忆一下上个章节中关于Stream Unique Identifier的讲解，在阅读这个方法到时候尽可能结合上一个章节中JVM序列化规范的讲解对比解读，【】符号内的数字表示上一个章节中字节流序列中项说明中的顺序序号，仔细看看该方法生成SUID的流程：
  1. 先判断当前类是否实现了Serializable接口，如果一个类没有实现了Serializable接口或者是一个动态代理类，则suid的值为0L；
    1.         if (!Serializable.class.isAssignableFrom(cl) || Proxy.isProxyClass(cl))
    2.         {
    3.             return 0L;
    4.         }
  2. 【1】生成suid的时候，先写入类名，写入的时候以字节方式写入，如果是字符串则使用UTF-8的方式编码；
    1. ByteArrayOutputStream bout = new ByteArrayOutputStream();
    2. dout.writeUTF(cl.getName());
  3. 【2】然后写入类的修饰符，使用的是一个32-bit的整数，classMods的计算会先进行计算，提取内容修饰符是public、final、interface、abstract的，至于下边代码后半部分代码在注释中有说明是为了处理javac编译的一个bug而存在；
    1.             int classMods = cl.getModifiers() &
    2.                 (Modifier.PUBLIC | Modifier.FINAL |
    3.                  Modifier.INTERFACE | Modifier.ABSTRACT);
    4.             /*
    5.              * compensate for javac bug in which ABSTRACT bit was set for an
    6.              * interface only if the interface declared methods
    7.              */
    8.             Method[] methods = cl.getDeclaredMethods();
    9.             if ((classMods & Modifier.INTERFACE) != 0) {
    10.                 classMods = (methods.length > 0) ?
    11.                     (classMods | Modifier.ABSTRACT) :
    12.                     (classMods & ~Modifier.ABSTRACT);
    13.             }
    14.             dout.writeInt(classMods);
  4. 【3】按照字典序排列所有实现接口的名称，将这个接口名称写入字节数组，排序使用的方法为Arrays.sort方法，这里会根据cl的getInterfaces方法获取所有当前类实现的接口集，然后通过遍历的方式构造一个按照字典序排列的接口名称数组；
    1.             if (!cl.isArray()) {
    2.                 /*
    3.                  * compensate for change in 1.2FCS in which
    4.                  * Class.getInterfaces() was modified to return Cloneable and
    5.                  * Serializable for array classes.
    6.                  */
    7.                 Class<?>[] interfaces = cl.getInterfaces();
    8.                 String[] ifaceNames = new String[interfaces.length];
    9.                 for (int i = 0; i < interfaces.length; i++) {
    10.                     ifaceNames[i] = interfaces[i].getName();
    11.                 }
    12.                 Arrays.sort(ifaceNames);
    13.                 for (int i = 0; i < ifaceNames.length; i++) {
    14.                     dout.writeUTF(ifaceNames[i]);
    15.                 }
    16.             }
  5. 【4】针对类定义中的每一个字段按字典序写入，写入的时候会先写入字段的名称，然后写入32位整数的字段修饰符，最后写入该字段的签名信息，这个地方会使用MemberSignature类用来分析成员属性的信息；在写入的时候会排除static和transient的字段。注意循环内的判断条件——计算mods时，mods对Member的修饰进行了两次运算，第一次提取修饰符为public、private、protected、static、final、volatile、transient的内容，然后再判断去掉private、static和transient的内容【注意private关键字的出现表示这里提取的信息是非私有的信息】；
    1.             Field[] fields = cl.getDeclaredFields();
    2.             MemberSignature[] fieldSigs = new MemberSignature[fields.length];
    3.             for (int i = 0; i < fields.length; i++) {
    4.                 fieldSigs[i] = new MemberSignature(fields[i]);
    5.             }
    6.             Arrays.sort(fieldSigs, new Comparator<MemberSignature>() {
    7.                 public int compare(MemberSignature ms1, MemberSignature ms2) {
    8.                     return ms1.name.compareTo(ms2.name);
    9.                 }
    10.             });
    11.             for (int i = 0; i < fieldSigs.length; i++) {
    12.                 MemberSignature sig = fieldSigs[i];
    13.                 int mods = sig.member.getModifiers() &
    14.                     (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
    15.                      Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |
    16.                      Modifier.TRANSIENT);
    17.                 if (((mods & Modifier.PRIVATE) == 0) ||
    18.                     ((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0))
    19.                 {
    20.                     dout.writeUTF(sig.name);
    21.                     dout.writeInt(mods);
    22.                     dout.writeUTF(sig.signature);
    23.                 }
    24.             }
  6. 【5】如果当前类中存在静态初始化操作，则写入静态初始化的信息，这里可以看到静态初始化的描述符：JVM序列化规范中提及的<clinit>段；
    1.             if (hasStaticInitializer(cl)) {
    2.                 dout.writeUTF("<clinit>");
    3.                 dout.writeInt(Modifier.STATIC);
    4.                 dout.writeUTF("()V");
    5.             }
  7. 【6】针对非私有的构造函数，写入方法名、方法修饰符和方法签名，这里可以看到构造函数初始化的描述符：JVM序列化规范中提及的<init>段——注意方法必须是非私有的，去掉了PRIVATE的内容；
    1.             Constructor[] cons = cl.getDeclaredConstructors();
    2.             MemberSignature[] consSigs = new MemberSignature[cons.length];
    3.             for (int i = 0; i < cons.length; i++) {
    4.                 consSigs[i] = new MemberSignature(cons[i]);
    5.             }
    6.             Arrays.sort(consSigs, new Comparator<MemberSignature>() {
    7.                 public int compare(MemberSignature ms1, MemberSignature ms2) {
    8.                     return ms1.signature.compareTo(ms2.signature);
    9.                 }
    10.             });
    11.             for (int i = 0; i < consSigs.length; i++) {
    12.                 MemberSignature sig = consSigs[i];
    13.                 int mods = sig.member.getModifiers() &
    14.                     (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
    15.                      Modifier.STATIC | Modifier.FINAL |
    16.                      Modifier.SYNCHRONIZED | Modifier.NATIVE |
    17.                      Modifier.ABSTRACT | Modifier.STRICT);
    18.                 if ((mods & Modifier.PRIVATE) == 0) {
    19.                     dout.writeUTF("<init>");
    20.                     dout.writeInt(mods);
    21.                     dout.writeUTF(sig.signature.replace('/', '.'));
    22.                 }
    23.             }
  8. 【7】针对非私有成员方法，写入方法名、方法修饰符、方法签名，和上一步的逻辑基本相同；
    1.             MemberSignature[] methSigs = new MemberSignature[methods.length];
    2.             for (int i = 0; i < methods.length; i++) {
    3.                 methSigs[i] = new MemberSignature(methods[i]);
    4.             }
    5.             Arrays.sort(methSigs, new Comparator<MemberSignature>() {
    6.                 public int compare(MemberSignature ms1, MemberSignature ms2) {
    7.                     int comp = ms1.name.compareTo(ms2.name);
    8.                     if (comp == 0) {
    9.                         comp = ms1.signature.compareTo(ms2.signature);
    10.                     }
    11.                     return comp;
    12.                 }
    13.             });
    14.             for (int i = 0; i < methSigs.length; i++) {
    15.                 MemberSignature sig = methSigs[i];
    16.                 int mods = sig.member.getModifiers() &
    17.                     (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
    18.                      Modifier.STATIC | Modifier.FINAL |
    19.                      Modifier.SYNCHRONIZED | Modifier.NATIVE |
    20.                      Modifier.ABSTRACT | Modifier.STRICT);
    21.                 if ((mods & Modifier.PRIVATE) == 0) {
    22.                     dout.writeUTF(sig.name);
    23.                     dout.writeInt(mods);
    24.                     dout.writeUTF(sig.signature.replace('/', '.'));
    25.                 }
    26.             }
  9. 【8,9】最后按照JVM规范中描述的一样，计算serialVersionUID的值，这里的算法比较难理解，就不详细解析算法了，有兴趣的读者可通过示例去理解下边这段代码的执行流程以理解该算法，它对应了前一章节JVM规范部分最后那段代码；
    1.             MessageDigest md = MessageDigest.getInstance("SHA");
    2.             byte[] hashBytes = md.digest(bout.toByteArray());
    3.             long hash = 0;
    4.             for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
    5.                 hash = (hash << 8) | (hashBytes[i] & 0xFF);
    6.             }
    7.             return hash;
　　从上述的源代码中可以知道系统自动生成SUID的时候它的生成过程和JVM的序列化规范里定义的过程是一致的。
　　5）字段serialPersistentFields和成员属性元数据
　　上一个章节中提到过Java中如果一个类具有“可序列化”的语义可实现两个特定的接口，默认情况下若实现了Serializable接口，则非static和非transitent字段会被识别成默认的可序列化字段【成员属性】；但是如果一个类中重定义了字段serialPersistentFields，则可序列化字段默认的识别情况会被打破，那么在序列化的时候类中的可序列化字段必须按照serialPersistentFields定义中的数据来识别。
　　这个字段的定义如下： 
  1.     /** serialPersistentFields value indicating no serializable fields */
  2.     public static final ObjectStreamField[] NO_FIELDS =
  3.         new ObjectStreamField[0];
  4.     private static final ObjectStreamField[] serialPersistentFields =
  5.         NO_FIELDS;
　　既然看到了serialPersistentFields的定义，那么看看ObjectStreamClass类中唯一一个使用了该字段的方法getDeclaredSerialFields，这个方法的整体定义如下：
　　getDeclaredSerialFields 
  1.     private static ObjectStreamField[] getDeclaredSerialFields(Class<?> cl)
  2.         throws InvalidClassException
  3.     {
  4.         ObjectStreamField[] serialPersistentFields = null;
  5.         try {
  6.             Field f = cl.getDeclaredField("serialPersistentFields");
  7.             int mask = Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL;
  8.             if ((f.getModifiers() & mask) == mask) {
  9.                 f.setAccessible(true);
  10.                 serialPersistentFields = (ObjectStreamField[]) f.get(null);
  11.             }
  12.         } catch (Exception ex) {
  13.         }
  14.         if (serialPersistentFields == null) {
  15.             return null;
  16.         } else if (serialPersistentFields.length == 0) {
  17.             return NO_FIELDS;
  18.         }
  19.  
  20.         ObjectStreamField[] boundFields =
  21.             new ObjectStreamField[serialPersistentFields.length];
  22.         Set<String> fieldNames = new HashSet<>(serialPersistentFields.length);
  23.  
  24.         for (int i = 0; i < serialPersistentFields.length; i++) {
  25.             ObjectStreamField spf = serialPersistentFields[i];
  26.  
  27.             String fname = spf.getName();
  28.             if (fieldNames.contains(fname)) {
  29.                 throw new InvalidClassException(
  30.                     "multiple serializable fields named " + fname);
  31.             }
  32.             fieldNames.add(fname);
  33.  
  34.             try {
  35.                 Field f = cl.getDeclaredField(fname);
  36.                 if ((f.getType() == spf.getType()) &&
  37.                     ((f.getModifiers() & Modifier.STATIC) == 0))
  38.                 {
  39.                     boundFields[i] =
  40.                         new ObjectStreamField(f, spf.isUnshared(), true);
  41.                 }
  42.             } catch (NoSuchFieldException ex) {
  43.             }
  44.             if (boundFields[i] == null) {
  45.                 boundFields[i] = new ObjectStreamField(
  46.                     fname, spf.getType(), spf.isUnshared());
  47.             }
  48.         }
  49.         return boundFields;
  50.     }
　　上边这个方法用来提取实现Serializable接口的类中定的字段信息，如果实现类中定义了serialPersistentFields字段则调用上边的方法来获取该字段中定义的可序列化字段数组【类型ObjectStreamField[]】。上述代码中提取字段信息使用了两步：先从serialPersistentFields字段中获取一个字段名的数组，然后通过该字段名去获取字段本身的信息，而且在获取字段到时通过字段名发现重复字段则抛出异常信息。如果实现类中没有定义serialPersistentFields字段则调用下边的方法来获取默认的可序列化字段数组，在获取默认的可序列化字段数组时，static和transient的字段同样会被忽略。
　　getDefaultSerialFields 
  1.     private static ObjectStreamField[] getDefaultSerialFields(Class<?> cl) {
  2.         Field[] clFields = cl.getDeclaredFields();
  3.         ArrayList<ObjectStreamField> list = new ArrayList<>();
  4.         int mask = Modifier.STATIC | Modifier.TRANSIENT;
  5.  
  6.         for (int i = 0; i < clFields.length; i++) {
  7.             if ((clFields[i].getModifiers() & mask) == 0) {
  8.                 list.add(new ObjectStreamField(clFields[i], false, true));
  9.             }
  10.         }
  11.         int size = list.size();
  12.         return (size == 0) ? NO_FIELDS :
  13.             list.toArray(new ObjectStreamField[size]);
  14.     }
　　上述的两个方法都是从当前类中去获取可序列化成员属性的实现细节，这两个方法会被getSerialFields方法调用。
　　getSerialFields
 
  1.     private static ObjectStreamField[] getSerialFields(Class<?> cl)
  2.         throws InvalidClassException
  3.     {
  4.         ObjectStreamField[] fields;
  5.         if (Serializable.class.isAssignableFrom(cl) &&
  6.             !Externalizable.class.isAssignableFrom(cl) &&
  7.             !Proxy.isProxyClass(cl) &&
  8.             !cl.isInterface())
  9.         {
  10.             if ((fields = getDeclaredSerialFields(cl)) == null) {
  11.                 fields = getDefaultSerialFields(cl);
  12.             }
  13.             Arrays.sort(fields);
  14.         } else {
  15.             fields = NO_FIELDS;
  16.         }
  17.         return fields;
  18.     }
　　看完了三个方法的定义，总结一下这三个方法的实现细节以了解系统通过什么方式来获取成员属性的元数据信息：
  1. 在提取成员属性【字段】的元数据时，会先调用getSerialFields方法从一个类中获取可序列化字段元数据数组信息，这个方法会去调用前两个方法获取成员属性的元数据信息，其判断条件要求这个类满足下边条件：
    -- 该类必须实现了Serializable接口；
    -- 该类不能实现Externalizable接口；
    -- 该类不能是一个Java的动态代理类；
    -- 该类不能是一个接口；
  2. 在该类获取元数据的调用过程中，该方法会先调用getDeclaredSerialFields【上述代码中第一个】方法，当调用这个方法返回的值为null，也就是该类中没有定义serialPersistentFields字段的时候，就调用getDefaultSerialFields【上述代码中第二个】方法来获取ObjectStreamField[]数组；
  3. getDefaultSerialFields的方法就是一步到位，直接使用ArrayList<ObjectStreamField>类型的容器list获取该类中非static和非transitent的字段元数据集合信息，最后将list转化为一个ObjectStreamField[]类型；
  4. getDeclareSerialFields的方法主要包含两个步骤：先从传入的类中获取serialPersistentFields字段信息，如果serialPersistentFields中定义了重名的成员属性则抛出InvalidClassException异常信息，内部循环中有一个检测重复字段的代码段；随后代码会通过字段名规范化地获取的字段信息，此规范化的过程通过遍历获取的ObjectStreamField[]数组来生成一个新的ObjectStreamField[]类型的数组返回；
　　这个地方可以看到ObjectStreamField的二次构造过程，前边解析这个类的时候已经提到了，ObjectStreamField的构造函数有4个，只有1个使用了完整的构造流程，看看上边代码内部实例化ObjectStreamField的过程：
　　getDeclaredSerialFields中的ObjectStreamField实例化： 
new ObjectStreamField(f, spf.isUnshared(), true);
　　getDefaultSerialFields中ObjectStreamField的实例化： 
new ObjectStreamField(clFields[i], false, true)
　　上述两个类中创建ObjectStreamField实例的时候第一个参数的类型都是Field，证明它执行了二次构造过程，调用了default域中包含了完整构造流程的构造函数。
　　6）getField和字节流交互方法
　　前一个章节的代码解析已经解析了三个被解析类中的定义的获取可序列化成员属性的方法，ObjectStreamClass还有针对所有字段的获取方法集： 
  1.     ObjectStreamField[] getFields(boolean copy) {
  2.         return copy ? fields.clone() : fields;
  3.     }
  4.     ObjectStreamField getField(String name, Class<?> type) {
  5.         for (int i = 0; i < fields.length; i++) {
  6.             ObjectStreamField f = fields[i];
  7.             if (f.getName().equals(name)) {
  8.                 if (type == null ||
  9.                     (type == Object.class && !f.isPrimitive()))
  10.                 {
  11.                     return f;
  12.                 }
  13.                 Class<?> ftype = f.getType();
  14.                 if (ftype != null && type.isAssignableFrom(ftype)) {
  15.                     return f;
  16.                 }
  17.             }
  18.         }
  19.         return null;
  20.     }
  21.     public ObjectStreamField[] getFields() {
  22.         return getFields(true);
  23.     }
  24.     public ObjectStreamField getField(String name) {
  25.         return getField(name, null);
  26.     }
　　上述字段中获取被解析类的字段方法分为两种类型：getFields和getField方法，这两个方法都各自有一个重载方法；
　　getFields——该方法主要用于获取所有的成员属性元数据数组信息，default域的getFields方法中的copy参数告诉JVM是否要创建一个成员属性元数据数组的副本【拷贝】；
　　getField——该方法主要用于根据属性名称获取单个成员属性的元数据信息，default域的getField方法中第二个参数告诉JVM是否要创建一个成员属性元数据数组的副本【拷贝】；
　　上述内部类FieldReflector中包含了四个特殊的方法，这四个方法的详细信息前文介绍过，这里不介绍了，在ObjectStreamClass中同样包含了这四个方法，这四个方法会调用成员fieldRefl【FieldReflector类型】中的四个对应方法，其定义如下： 
  1.     void getPrimFieldValues(Object obj, byte[] buf) {
  2.         fieldRefl.getPrimFieldValues(obj, buf);
  3.     }
  4.     void setPrimFieldValues(Object obj, byte[] buf) {
  5.         fieldRefl.setPrimFieldValues(obj, buf);
  6.     }
  7.     void getObjFieldValues(Object obj, Object[] vals) {
  8.         fieldRefl.getObjFieldValues(obj, vals);
  9.     }
  10.     void setObjFieldValues(Object obj, Object[] vals) {
  11.         fieldRefl.setObjFieldValues(obj, vals);
  12.     }
　　7）成员属性：
　　ObjectStreamClass中所有的成员属性上边只解析了一个suid，该属性表示被解析类的serialVersionUID字段信息，接下来看看剩余的成员属性信息：
　　---------------------被解析类的基本信息----------------------- 
  1.     /** class associated with this descriptor (if any) */
  2.     private Class<?> cl;
  3.     /** name of class represented by this descriptor */
  4.     private String name;
  5.     /** serialVersionUID of represented class (null if not computed yet) */
  6.     private volatile Long suid;
　　上述三个成员属性为被解析类的基本描述信息：
  • cl——java.lang.Class<?>
    该成员属性主要用于解析类过程中提取类的元数据信息，因为涉及到“反射”的用法，所以该类型对应一个Class<?>类型；
  • name——java.lang.String
    该成员属性表示被解析类的类名信息；
  • suid——java.lang.Long
    该成员属性表示被解析类在序列化过程中的SUID；
　　---------------------类的SC_*标识----------------------
　　在前一个章节可知道Java序列化中有五个类级别的标记：SC_WRITE_METHOD、SC_BLOCKDATA、SC_SERIALIZABLE、SC_EXTERNALIZABLE、SC_ENUM，这几个标记虽然不会写入到字节流中，但这五个标记会在执行序列化和反序列化的过程中判断一个类使用什么方式处理，该标记在ObjectStreamClass中的定义如下： 
  1.     /** true if represents dynamic proxy class */
  2.     private boolean isProxy;
  3.     /** true if represents enum type */
  4.     private boolean isEnum;
  5.     /** true if represented class implements Serializable */
  6.     private boolean serializable;
  7.     /** true if represented class implements Externalizable */
  8.     private boolean externalizable;
  9.     /** true if desc has data written by class-defined writeObject method */
  10.     private boolean hasWriteObjectData;
  11.     /**
  12.      * true if desc has externalizable data written in block data format; this
  13.      * must be true by default to accommodate ObjectInputStream subclasses which
  14.      * override readClassDescriptor() to return class descriptors obtained from
  15.      * ObjectStreamClass.lookup() (see 4461737)
  16.      */
  17.     private boolean hasBlockExternalData = true;
  • isProxy——boolean
    该标记判断当前类是否是一个Java中的动态代理类；
  • isEnum——boolean
    该标记判断当前类是否是一个Java中的Enum枚举类；
  • serializable——boolean
    该标记判断当前类是否实现了Serializable接口；
  • externalizable——boolean
    该标记判断当前类是否实现了Externalizable接口；
  • hasWriteObjectData——boolean
    该标记判断当前类是否重写了writeObject方法，如果写入了则需要标记当前类为SC_WRITE_METHOD类型；
  • hasBlockExternalData——boolean
    该标记和SC_*的五个标记无关，它只是告诉系统当前解析的类会有额外的信息写入到字节流中；
　　---------------------该类包含的异常信息----------------------
　　ObjectStreamClass中拥有一个ExceptionInfo的内部类，主要用于描述类的元数据解析中的异常信息，看看下边和异常相关的成员属性： 
  1.     /** exception (if any) thrown while attempting to resolve class */
  2.     private ClassNotFoundException resolveEx;
  3.     /** exception (if any) to throw if non-enum deserialization attempted */
  4.     private ExceptionInfo deserializeEx;
  5.     /** exception (if any) to throw if non-enum serialization attempted */
  6.     private ExceptionInfo serializeEx;
  7.     /** exception (if any) to throw if default serialization attempted */
  8.     private ExceptionInfo defaultSerializeEx;
  • resolveEx——java.lang.ClassNotFoundException
    当ObjectStreamClass解析一个类的元数据时，如果解析的类在类加载器中找不到，则需要抛出该异常信息；
  • deserializeEx——java.io.ObjectStreamClass.ExceptionInfo
    当一个非Enum枚举类型的Java对象被反序列化的时候，若出现异常则将异常信息保存在deserializeEx成员属性中；
  • serializeEx——java.io.ObjectStreamClass.ExceptionInfo
    当一个非Enum枚举类型的Java对象被序列化的时候，若出现异常则将异常信息保存在serializeEx成员属性中；
  • defaultSerializeEx——java.io.ObjectStreamClass.ExceptionInfo
    在执行默认序列化的时候，如果出现了异常信息则异常信息保存在defaultSerializeEx成员属性中；
　　----------------------字段、类数据信息---------------------- 
  1.     /** serializable fields */
  2.     private ObjectStreamField[] fields;
  3.     /** aggregate marshalled size of primitive fields */
  4.     private int primDataSize;
  5.     /** number of non-primitive fields */
  6.     private int numObjFields;
  7.     /** reflector for setting/getting serializable field values */
  8.     private FieldReflector fieldRefl;
  9.     /** data layout of serialized objects described by this class desc */
  10.     private volatile ClassDataSlot[] dataLayout;
  • fields——java.io.ObjectStreamField[]
    当前ObjectStreamClass中包含的所有成员属性的元数据信息，上一个小章节中解析的三个和字段相关的方法其目的就是为了生成当前解析类的字段元数据数组；
  • primDataSize——int
    当前解析类中所有基础类型的成员属性所需要的数据大小；
  • numObjFields——int
    当前解析类中所有非基础类型的成员属性的数量；
  • fieldRefl——java.io.ObjectStreamClass.FieldReflector
    创建一个字段分析器，用于分析被解析类中所有成员属性【字段】的相关元数据信息；
  • dataLayout——java.io.ObjectStreamClass.ClassDataSlot[]
    创建一个类描述符相关到ClassDataSlot类型的数组；
　　----------------------类中构造函数、特殊方法----------------------
　　ObjectStreamClass中包含了被解析类中构造函数和定义的几个特殊可重写方法的成员函数信息： 
  1.     /** serialization-appropriate constructor, or null if none */
  2.     private Constructor cons;
  3.     /** class-defined writeObject method, or null if none */
  4.     private Method writeObjectMethod;
  5.     /** class-defined readObject method, or null if none */
  6.     private Method readObjectMethod;
  7.     /** class-defined readObjectNoData method, or null if none */
  8.     private Method readObjectNoDataMethod;
  9.     /** class-defined writeReplace method, or null if none */
  10.     private Method writeReplaceMethod;
  11.     /** class-defined readResolve method, or null if none */
  12.     private Method readResolveMethod;
  • cons——java.lang.reflect.Constructor
    被解析类的构造函数信息；
  • writeObjectMethod——java.lang.reflect.Method
    被解析类如果重写了writeObject方法则该成员属性是重写过的writeObject方法的元数据信息；
  • readObjectMethod——java.lang.reflect.Method
    被解析类如果重写了readObject方法则该成员属性是重写过的readObject方法的元元数据信息；
  • readObjectNoDataMethod——java.lang.reflect.Method
    被解析类如果重写了readObjectNoData方法则该成员属性是重写过的readObjectNoData方法的元数据信息；
  • writeReplaceMethod——java.lang.reflect.Method
    被解析类如果重写了writeReplace方法则该成员属性是重写过的writeReplace方法的元数据信息；
  • readResolveMethod——java.lang.reflect.Method
    被解析类如果重写了readResolve方法则该成员属性是重写过的readResolve方法的元数据信息；
　　----------------------类中描述信息----------------------
　　ObjectStreamClass中还定义了两个成员，该成员表示类被解析类的类描述信息： 
  1.     /** local class descriptor for represented class (may point to self) */
  2.     private ObjectStreamClass localDesc;
  3.     /** superclass descriptor appearing in stream */
  4.     private ObjectStreamClass superDesc;
  • localDesc——java.io.ObjectStreamClass
    该类描述信息表示被解析类的元数据信息，它可能直接引用自己【因为当前ObjectStreamClass描述的就是被解析类的元数据信息】；
  • superDesc——java.io.ObjectStreamClass
    该类描述信息表示被解析类的父类元数据信息。
　　8）Java Bean规范方法：
　　这部分枚举了ObjectStreamClass中所有遵循了Java Bean规范的方法，设置/获取函数：
　　Get方法定义清单
　　【*：注意Java Bean规范中boolean数据的Get方法的方法命名，而且该类中有些方法不符合Java Bean规范，本文中提到的Java Bean规范方法主要指没有太复杂的逻辑的Get方法以及Get方法的变种，把这些方法移除过后，针对这个类中其他源代码的阅读就简单多了。】 
  1.     public String getName() {
  2.         return name;
  3.     }
  4.     public Class<?> forClass() {
  5.         return cl;
  6.     }
  7.     ObjectStreamClass getSuperDesc() {
  8.         return superDesc;
  9.     }
  10.     ObjectStreamClass getLocalDesc() {
  11.         return localDesc;
  12.     }
  13.     boolean isProxy() {
  14.         return isProxy;
  15.     }
  16.     boolean isEnum() {
  17.         return isEnum;
  18.     }
  19.     boolean isExternalizable() {
  20.         return externalizable;
  21.     }
  22.     boolean isSerializable() {
  23.         return serializable;
  24.     }
  25.     boolean hasBlockExternalData() {
  26.         return hasBlockExternalData;
  27.     }
  28.     boolean hasWriteObjectData() {
  29.         return hasWriteObjectData;
  30.     }
  31.     boolean hasWriteObjectMethod() {
  32.         return (writeObjectMethod != null);
  33.     }
  34.     boolean hasReadObjectMethod() {
  35.         return (readObjectMethod != null);
  36.     }
  37.     boolean hasReadObjectNoDataMethod() {
  38.         return (readObjectNoDataMethod != null);
  39.     }
  40.     boolean hasWriteReplaceMethod() {
  41.         return (writeReplaceMethod != null);
  42.     }
  43.     boolean hasReadResolveMethod() {
  44.         return (readResolveMethod != null);
  45.     }
  46.     boolean isInstantiable() {
  47.         return (cons != null);
  48.     }
  49.     int getPrimDataSize() {
  50.         return primDataSize;
  51.     }
  52.     int getNumObjFields() {
  53.         return numObjFields;
  54.     }
  55.     ClassNotFoundException getResolveException() {
  56.         return resolveEx;
  57.     }
　　上边所有方法中，注意几个Method后缀方法，这些方法内部会判断Method后缀的成员是否为空，实际上这些方法主要用于判断被解析类是否重写了几个特殊的方法：writeObject、readObject、readObjectNoData、writeReplace、readResolve，同样的针对构造函数cons成员的判断也同样如此，如果为空则表示被解析类中没有定义这些信息。
　　9）序列化检测方法
　　ObjectStreamClass类中定义了三个序列化检测方法： 
  1.     void checkDeserialize() throws InvalidClassException {
  2.         if (deserializeEx != null) {
  3.             throw deserializeEx.newInvalidClassException();
  4.         }
  5.     }
  6.     void checkSerialize() throws InvalidClassException {
  7.         if (serializeEx != null) {
  8.             throw serializeEx.newInvalidClassException();
  9.         }
  10.     }
  11.     void checkDefaultSerialize() throws InvalidClassException {
  12.         if (defaultSerializeEx != null) {
  13.             throw defaultSerializeEx.newInvalidClassException();
  14.         }
  15.     }
　　上边三个方法主要用于检测被解析类的信息：
  • checkDeserialize
    如果被解析的类不支持被反序列化，则该方法会抛出一个InvalidClassException异常信息，但是该方法不针对Enum枚举类型；
  • checkSerialize
    如果被解析的类不支持被序列化，则该方法会抛出一个InvalidClassException异常信息，该方法同样不针对Enum枚举类型；
  • checkDefaultSerialize
    如果被解析的类不支持使用Java中的默认序列化机制，则会抛出一个InvalidClassException异常信息，该方法不针对Enum枚举类型；
　　10）构造函数、成员函数
　　ObjectStreamClass在解析一个类的时候，有四个专有方法来获得被解析类的构造函数和成员函数，它们的定义如下：
　　构造函数的获取：
　　getExternalizableConstructor、getSerializableConstructor 
  1.     private static Constructor getExternalizableConstructor(Class<?> cl) {
  2.         try {
  3.             Constructor cons = cl.getDeclaredConstructor((Class<?>[]) null);
  4.             cons.setAccessible(true);
  5.             return ((cons.getModifiers() & Modifier.PUBLIC) != 0) ?
  6.                 cons : null;
  7.         } catch (NoSuchMethodException ex) {
  8.             return null;
  9.         }
  10.     }
  11.     private static Constructor getSerializableConstructor(Class<?> cl) {
  12.         Class<?> initCl = cl;
  13.         while (Serializable.class.isAssignableFrom(initCl)) {
  14.             if ((initCl = initCl.getSuperclass()) == null) {
  15.                 return null;
  16.             }
  17.         }
  18.         try {
  19.             Constructor cons = initCl.getDeclaredConstructor((Class<?>[]) null);
  20.             int mods = cons.getModifiers();
  21.             if ((mods & Modifier.PRIVATE) != 0 ||
  22.                 ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0 &&
  23.                  !packageEquals(cl, initCl)))
  24.             {
  25.                 return null;
  26.             }
  27.             cons = reflFactory.newConstructorForSerialization(cl, cons);
  28.             cons.setAccessible(true);
  29.             return cons;
  30.         } catch (NoSuchMethodException ex) {
  31.             return null;
  32.         }
  33.     }
　　上述方法中getExternalizableConstructor方法用于获取被解析类的public无参构造函数，这个函数可针对所有的类获取它的public无参构造函数，但是从方法定义的名字上看主要是为了处理外部化的类。而getSerializableConstructor方法用于获取被解析类的无参构造函数，这个方法会从当前被解析类不断递归检索直到第一个不可序列化的父类为止。在构造函数的获取中系统调用了一个上边未提及的静态变量： 
  1.     /** reflection factory for obtaining serialization constructors */
  2.     private static final ReflectionFactory reflFactory =
  3.         AccessController.doPrivileged(
  4.             new ReflectionFactory.GetReflectionFactoryAction());
　　这个变量的类型是sun.reflect.ReflectionFactory类型，它在初始化的时候通过访问控制器检查了代码的执行权限，这个类可以通过不调用构造函数的方式去实例化一个对象，后边解析序列化流程的时候再来看里面的代码细节，从其含义上讲，需要“不通过构造函数”创建对象的情况会在反序列化中使用，所以这里的ReflectionFactory类很有可能是在反序列化通过对象的状态数据重建对象的时候使用，也可以这样理解Java的序列化机制在处理可序列化的类时不会调用可序列化类的构造函数。
　　成员函数的获取：
　　getInheritableMethod、getPrivateMethod 
  1.     private static Method getInheritableMethod(Class<?> cl, String name,
  2.                                                Class<?>[] argTypes,
  3.                                                Class<?> returnType)
  4.     {
  5.         Method meth = null;
  6.         Class<?> defCl = cl;
  7.         while (defCl != null) {
  8.             try {
  9.                 meth = defCl.getDeclaredMethod(name, argTypes);
  10.                 break;
  11.             } catch (NoSuchMethodException ex) {
  12.                 defCl = defCl.getSuperclass();
  13.             }
  14.         }
  15.  
  16.         if ((meth == null) || (meth.getReturnType() != returnType)) {
  17.             return null;
  18.         }
  19.         meth.setAccessible(true);
  20.         int mods = meth.getModifiers();
  21.         if ((mods & (Modifier.STATIC | Modifier.ABSTRACT)) != 0) {
  22.             return null;
  23.         } else if ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0) {
  24.             return meth;
  25.         } else if ((mods & Modifier.PRIVATE) != 0) {
  26.             return (cl == defCl) ? meth : null;
  27.         } else {
  28.             return packageEquals(cl, defCl) ? meth : null;
  29.         }
  30.     }
  31.     private static Method getPrivateMethod(Class<?> cl, String name,
  32.                                            Class<?>[] argTypes,
  33.                                            Class<?> returnType)
  34.     {
  35.         try {
  36.             Method meth = cl.getDeclaredMethod(name, argTypes);
  37.             meth.setAccessible(true);
  38.             int mods = meth.getModifiers();
  39.             return ((meth.getReturnType() == returnType) &&
  40.                     ((mods & Modifier.STATIC) == 0) &&
  41.                     ((mods & Modifier.PRIVATE) != 0)) ? meth : null;
  42.         } catch (NoSuchMethodException ex) {
  43.             return null;
  44.         }
  45.     }
　　上述两个方法用于解析类并且获取其成员函数，getPrivateMethod方法用于获取非静态私有成员方法，getInheritableMethod方法用于获取非静态、非抽象的成员方法。这个成员函数有四个参数：
  • cl——java.lang.Class<?>
    该成员函数所属的类；
  • name——java.lang.String
    该成员函数的名称；
  • argTypes——java.lang.Class<?>[]
    该成员函数的参数表；
  • returnType——java.lang.Class<?>
    该成员函数的返回值；
　　简单看看上述函数的执行细节：
  1. 函数在执行过程会先去获取成员函数的信息，返回一个Method类型的引用；
  2. 然后该函数会检查函数的返回值以确认得到的Method引用指向的成员函数是否匹配的；
  3. 其次该函数会打开访问控制：meth.setAccessible(true)；
  4. 其实上述成员函数的返回部分比较复杂，它分为以下几种情况：
    -- 如果该方法是static或abstract修饰的，则返回null；
    -- 如果该方法是public和protected修饰的，则返回方法本身；
    -- 如果该方法是private的，并且传入cl和defCl表示的类引用相等，则返回该私有方法，否则就返回null；
    -- 其他情况则对比该方法所属类的包名是否相同，若相同则返回获取的成员函数，否则返回null；
　　理解了getInheritableMethod方法的详细流程过后，再来理解getPrivateMethod方法就更加容易了，这里就不解析getPrivateMethod方法的源代码了。
　　11）调用特殊方法
　　ObjectStreamClass定义了五个调用特殊方法的成员函数，主要负责调用被解析类中重写过的五个特殊方法。
　　invokeWriteObject——调用writeObject方法： 
  1.     void invokeWriteObject(Object obj, ObjectOutputStream out)
  2.         throws IOException, UnsupportedOperationException
  3.     {
  4.         if (writeObjectMethod != null) {
  5.             try {
  6.                 writeObjectMethod.invoke(obj, new Object[]{ out });
  7.             } catch (InvocationTargetException ex) {
  8.                 Throwable th = ex.getTargetException();
  9.                 if (th instanceof IOException) {
  10.                     throw (IOException) th;
  11.                 } else {
  12.                     throwMiscException(th);
  13.                 }
  14.             } catch (IllegalAccessException ex) {
  15.                 // should not occur, as access checks have been suppressed
  16.                 throw new InternalError();
  17.             }
  18.         } else {
  19.             throw new UnsupportedOperationException();
  20.         }
  21.     }
　　看看invokeWriteObject方法，该方法调用了ObjectStreamClass的成员属性writeObjectMethod，这个成员属性会引用被解析类中重写过的writeObject方法，writeObject方法的参数为ObjectOutputStream，除了成员属性writeObjectMethod以外，invokeWriteObject方法包含了下边两个参数：
  • obj——java.lang.Object
    该参数表示需要调用writeObject成员函数的对象，即为一个重写了writeObject方法的类对应的实例；
  • out——java.io.ObjectOutputStream
    该参数会作为writeObject成员函数的参数执行传递；
　　该方法在调用writeObject方法的时候注意其异常的抛出：
  • 如果成员属性writeObjectMethod方法为空，则抛出UnsupportedOperationException异常；
  • 如果调用方法过程出现了错误则抛出InvocationTargetException异常，这种情况需要判断是IOException还是其他异常信息，其他异常使用辅助函数throwMiscException处理；
  • 如果调用方法是无法通过访问控制的检测则抛出IllegalAccessException异常，这个时候该方法会抛出一个InternalError的错误信息；
　　这里解析了writeObject方法的执行细节，有了这个执行细节，这里就没有必要解析后边四个方法的执行细节了。
　　invokeReadObject——调用readObject方法： 
  1.     void invokeReadObject(Object obj, ObjectInputStream in)
  2.         throws ClassNotFoundException, IOException,
  3.                UnsupportedOperationException
  4.     {
  5.         if (readObjectMethod != null) {
  6.             try {
  7.                 readObjectMethod.invoke(obj, new Object[]{ in });
  8.             } catch (InvocationTargetException ex) {
  9.                 Throwable th = ex.getTargetException();
  10.                 if (th instanceof ClassNotFoundException) {
  11.                     throw (ClassNotFoundException) th;
  12.                 } else if (th instanceof IOException) {
  13.                     throw (IOException) th;
  14.                 } else {
  15.                     throwMiscException(th);
  16.                 }
  17.             } catch (IllegalAccessException ex) {
  18.                 // should not occur, as access checks have been suppressed
  19.                 throw new InternalError();
  20.             }
  21.         } else {
  22.             throw new UnsupportedOperationException();
  23.         }
  24.     }
　　invokeReadObjectNoData——调用readObjectNoData方法： 
  1.     void invokeReadObjectNoData(Object obj)
  2.         throws IOException, UnsupportedOperationException
  3.     {
  4.         if (readObjectNoDataMethod != null) {
  5.             try {
  6.                 readObjectNoDataMethod.invoke(obj, (Object[]) null);
  7.             } catch (InvocationTargetException ex) {
  8.                 Throwable th = ex.getTargetException();
  9.                 if (th instanceof ObjectStreamException) {
  10.                     throw (ObjectStreamException) th;
  11.                 } else {
  12.                     throwMiscException(th);
  13.                 }
  14.             } catch (IllegalAccessException ex) {
  15.                 // should not occur, as access checks have been suppressed
  16.                 throw new InternalError();
  17.             }
  18.         } else {
  19.             throw new UnsupportedOperationException();
  20.         }
  21.     }
　　invokeWriteReplace——调用writeReplace方法： 
  1.     Object invokeWriteReplace(Object obj)
  2.         throws IOException, UnsupportedOperationException
  3.     {
  4.         if (writeReplaceMethod != null) {
  5.             try {
  6.                 return writeReplaceMethod.invoke(obj, (Object[]) null);
  7.             } catch (InvocationTargetException ex) {
  8.                 Throwable th = ex.getTargetException();
  9.                 if (th instanceof ObjectStreamException) {
  10.                     throw (ObjectStreamException) th;
  11.                 } else {
  12.                     throwMiscException(th);
  13.                     throw new InternalError();  // never reached
  14.                 }
  15.             } catch (IllegalAccessException ex) {
  16.                 // should not occur, as access checks have been suppressed
  17.                 throw new InternalError();
  18.             }
  19.         } else {
  20.             throw new UnsupportedOperationException();
  21.         }
  22.     }
　　invokeReadResolve——调用readResolve方法： 
  1.     Object invokeReadResolve(Object obj)
  2.         throws IOException, UnsupportedOperationException
  3.     {
  4.         if (readResolveMethod != null) {
  5.             try {
  6.                 return readResolveMethod.invoke(obj, (Object[]) null);
  7.             } catch (InvocationTargetException ex) {
  8.                 Throwable th = ex.getTargetException();
  9.                 if (th instanceof ObjectStreamException) {
  10.                     throw (ObjectStreamException) th;
  11.                 } else {
  12.                     throwMiscException(th);
  13.                     throw new InternalError();  // never reached
  14.                 }
  15.             } catch (IllegalAccessException ex) {
  16.                 // should not occur, as access checks have been suppressed
  17.                 throw new InternalError();
  18.             }
  19.         } else {
  20.             throw new UnsupportedOperationException();
  21.         }
  22.     }
　　12）辅助方法
　　因为后边需要分析的方法越来越接近解析类的元数据相关的逻辑，所以这里先介绍该类中定义的几个重要的辅助方法，这些辅助方法在该类中会经常性被调用。
　　processQueue方法——该方法主要用于移除ReferenceQueue队列中的引用，从其参数定义可以知道主要用于操作Caches类中的成员，这个方法有两个参数：
  • queue——java.lang.ref.ReferenceQueue<Class<?>>
    该参数一般会传入一个队列类型的数据结构，Caches中有两个成员是“Queue”类型；
  • map——java.util.concurrent.ConcurrentMap<? extends java.lang.ref.WeakReference<Class<?>>,?>
    该参数表示一个缓存的结构，这个结构和Caches中定义的另外两个缓存成员是一致的；
  1.     static void processQueue(ReferenceQueue<Class<?>> queue,
  2.                              ConcurrentMap<? extends
  3.                              WeakReference<Class<?>>, ?> map)
  4.     {
  5.         Reference<? extends Class<?>> ref;
  6.         while((ref = queue.poll()) != null) {
  7.             map.remove(ref);
  8.         }
  9.     }
　　throwMiscException方法——该方法是一个用于抛出异常信息的方法，主要抛出三个特殊异常：RuntimeException、Error、IOException异常，其定义如下： 
  1.     private static void throwMiscException(Throwable th) throws IOException {
  2.         if (th instanceof RuntimeException) {
  3.             throw (RuntimeException) th;
  4.         } else if (th instanceof Error) {
  5.             throw (Error) th;
  6.         } else {
  7.             IOException ex = new IOException("unexpected exception type");
  8.             ex.initCause(th);
  9.             throw ex;
  10.         }
  11.     }
　　classNamesEqual方法——该方法用于检查传入的两个类名是否相等，需要注意的是这个方法检查的是类名而非类全名，即不是检查包含了包名的类全名信息，其定义如下： 
  1.     private static boolean classNamesEqual(String name1, String name2) {
  2.         name1 = name1.substring(name1.lastIndexOf('.') + 1);
  3.         name2 = name2.substring(name2.lastIndexOf('.') + 1);
  4.         return name1.equals(name2);
  5.     }
　　packageEquals方法——该方法用于检测传入的两个Class<?>的实例的包名是否相等，相等返回true，否则返回false，其定义如下： 
  1.     private static boolean packageEquals(Class<?> cl1, Class<?> cl2) {
  2.         return (cl1.getClassLoader() == cl2.getClassLoader() &&
  3.                 getPackageName(cl1).equals(getPackageName(cl2)));
  4.     }
　　getPackageName方法——该方法用于获取传入的Class<?>实例的包名，前边一个方法就调用了该成员函数，其定义如下： 
  1.     private static String getPackageName(Class<?> cl) {
  2.         String s = cl.getName();
  3.         int i = s.lastIndexOf('[');
  4.         if (i >= 0) {
  5.             s = s.substring(i + 2);
  6.         }
  7.         i = s.lastIndexOf('.');
  8.         return (i >= 0) ? s.substring(0, i) : "";
  9.     }
　　computeFieldOffsets方法——该方法用于计算以及设置可序列化字段的偏移量，其定义如下： 
  1.     private void computeFieldOffsets() throws InvalidClassException {
  2.         primDataSize = 0;
  3.         numObjFields = 0;
  4.         int firstObjIndex = -1;
  5.  
  6.         for (int i = 0; i < fields.length; i++) {
  7.             ObjectStreamField f = fields[i];
  8.             switch (f.getTypeCode()) {
  9.                 case 'Z':
  10.                 case 'B':
  11.                     f.setOffset(primDataSize++);
  12.                     break;
  13.  
  14.                 case 'C':
  15.                 case 'S':
  16.                     f.setOffset(primDataSize);
  17.                     primDataSize += 2;
  18.                     break;
  19.  
  20.                 case 'I':
  21.                 case 'F':
  22.                     f.setOffset(primDataSize);
  23.                     primDataSize += 4;
  24.                     break;
  25.  
  26.                 case 'J':
  27.                 case 'D':
  28.                     f.setOffset(primDataSize);
  29.                     primDataSize += 8;
  30.                     break;
  31.  
  32.                 case '[':
  33.                 case 'L':
  34.                     f.setOffset(numObjFields++);
  35.                     if (firstObjIndex == -1) {
  36.                         firstObjIndex = i;
  37.                     }
  38.                     break;
  39.  
  40.                 default:
  41.                     throw new InternalError();
  42.             }
  43.         }
  44.         if (firstObjIndex != -1 &&
  45.             firstObjIndex + numObjFields != fields.length)
  46.         {
  47.             throw new InvalidClassException(name, "illegal field order");
  48.         }
  49.     }
　　关于偏移量的计算需要注意数据类型，偏移量的计算会改变成员属性primDataSize和numObjFields的大小，如果遇到一个基础类型primDataSize会根据其类型所占字节数进行统计，如果遇到非基础类型的数据则numObjFields的大小也会递增。看看每种数据的计算规则：
  • boolean【Z】、byte【B】
    ——占用1个字节，primDataSize每次增加1，numObjFields不变；
  • char【C】、short【S】
    ——占用2个字节，primDataSize每次增加2，numObjFields不变；
  • int【I】、float【F】
    ——占用4个字节，primDataSize每次增加4，numObjFields不变；
  • long【J】、double【D】
    ——占用8个字节，primDataSize每次增加8，numObjFields不变；
  • 数组array【[】、对象object【L】
    ——primDataSize不变，numObjFields每次增加1
　　toString方法——这个方法不讲解了，读者直接看它的定义就明白了。 
  1.     public String toString() {
  2.         return name + ": static final long serialVersionUID = " +
  3.             getSerialVersionUID() + "L;";
  4.     }
　　getVariantFor方法——该方法用于获取当前ObjectStreamClass的实例引用，如果传入类和当前实例中解析的类相等，则返回当前ObjectStreamClass，否则需要通过传入的cl【Class<?>】去生成一个新的ObjectStreamClass实例，其定义如下： 
  1.     private ObjectStreamClass getVariantFor(Class<?> cl)
  2.         throws InvalidClassException
  3.     {
  4.         if (this.cl == cl) {
  5.             return this;
  6.         }
  7.         ObjectStreamClass desc = new ObjectStreamClass();
  8.         if (isProxy) {
  9.             desc.initProxy(cl, null, superDesc);
  10.         } else {
  11.             desc.initNonProxy(this, cl, null, superDesc);
  12.         }
  13.         return desc;
  14.     }
　　getReflector方法——该成员函数通过字段元数据数组【ObjectStreamField[]类型】和当前类的元数据【ObjectStreamClass类型】获取一个FieldReflector，该FieldReflector实例会匹配传入的字段元数据数组和传入的类中的字段元数据数组是否一致，如果不一致要么返回字段默认值，要么放弃提供的值。实际上在Java的序列化规范中，有很多规则是使用默认值填充成员属性【字段】的数据信息，那么FieldReflector处理的就是基于成员属性的基本比较，它会告诉JVM是应该直接使用提供值还是使用默认值或者索性放弃，它影响了字段基本的序列化和反序列化的策略。
　　该方法定义如下： 
  1.     private static FieldReflector getReflector(ObjectStreamField[] fields,
  2.                                                ObjectStreamClass localDesc)
  3.         throws InvalidClassException
  4.     {
  5.         // class irrelevant if no fields
  6.         Class<?> cl = (localDesc != null && fields.length > 0) ?
  7.             localDesc.cl : null;
  8.         processQueue(Caches.reflectorsQueue, Caches.reflectors);
  9.         FieldReflectorKey key = new FieldReflectorKey(cl, fields,
  10.                                                       Caches.reflectorsQueue);
  11.         Reference<?> ref = Caches.reflectors.get(key);
  12.         Object entry = null;
  13.         if (ref != null) {
  14.             entry = ref.get();
  15.         }
  16.         EntryFuture future = null;
  17.         if (entry == null) {
  18.             EntryFuture newEntry = new EntryFuture();
  19.             Reference<?> newRef = new SoftReference<>(newEntry);
  20.             do {
  21.                 if (ref != null) {
  22.                     Caches.reflectors.remove(key, ref);
  23.                 }
  24.                 ref = Caches.reflectors.putIfAbsent(key, newRef);
  25.                 if (ref != null) {
  26.                     entry = ref.get();
  27.                 }
  28.             } while (ref != null && entry == null);
  29.             if (entry == null) {
  30.                 future = newEntry;
  31.             }
  32.         }
  33.  
  34.         if (entry instanceof FieldReflector) {  // check common case first
  35.             return (FieldReflector) entry;
  36.         } else if (entry instanceof EntryFuture) {
  37.             entry = ((EntryFuture) entry).get();
  38.         } else if (entry == null) {
  39.             try {
  40.                 entry = new FieldReflector(matchFields(fields, localDesc));
  41.             } catch (Throwable th) {
  42.                 entry = th;
  43.             }
  44.             future.set(entry);
  45.             Caches.reflectors.put(key, new SoftReference<Object>(entry));
  46.         }
  47.  
  48.         if (entry instanceof FieldReflector) {
  49.             return (FieldReflector) entry;
  50.         } else if (entry instanceof InvalidClassException) {
  51.             throw (InvalidClassException) entry;
  52.         } else if (entry instanceof RuntimeException) {
  53.             throw (RuntimeException) entry;
  54.         } else if (entry instanceof Error) {
  55.             throw (Error) entry;
  56.         } else {
  57.             throw new InternalError("unexpected entry: " + entry);
  58.         }
  59.     }
　　matchFields方法——上述FieldReflector获取过程中调用了此方法对本地类中字段元数据和传入的字段元数据直接比较，这里不重复，此方法的定义如下： 
  1.     private static ObjectStreamField[] matchFields(ObjectStreamField[] fields,
  2.                                                    ObjectStreamClass localDesc)
  3.         throws InvalidClassException
  4.     {
  5.         ObjectStreamField[] localFields = (localDesc != null) ?
  6.             localDesc.fields : NO_FIELDS;
  7.  
  8.         /*
  9.          * Even if fields == localFields, we cannot simply return localFields
  10.          * here.  In previous implementations of serialization,
  11.          * ObjectStreamField.getType() returned Object.class if the
  12.          * ObjectStreamField represented a non-primitive field and belonged to
  13.          * a non-local class descriptor.  To preserve this (questionable)
  14.          * behavior, the ObjectStreamField instances returned by matchFields
  15.          * cannot report non-primitive types other than Object.class; hence
  16.          * localFields cannot be returned directly.
  17.          */
  18.  
  19.         ObjectStreamField[] matches = new ObjectStreamField[fields.length];
  20.         for (int i = 0; i < fields.length; i++) {
  21.             ObjectStreamField f = fields[i], m = null;
  22.             for (int j = 0; j < localFields.length; j++) {
  23.                 ObjectStreamField lf = localFields[j];
  24.                 if (f.getName().equals(lf.getName())) {
  25.                     if ((f.isPrimitive() || lf.isPrimitive()) &&
  26.                         f.getTypeCode() != lf.getTypeCode())
  27.                     {
  28.                         throw new InvalidClassException(localDesc.name,
  29.                             "incompatible types for field " + f.getName());
  30.                     }
  31.                     if (lf.getField() != null) {
  32.                         m = new ObjectStreamField(
  33.                             lf.getField(), lf.isUnshared(), false);
  34.                     } else {
  35.                         m = new ObjectStreamField(
  36.                             lf.getName(), lf.getSignature(), lf.isUnshared());
  37.                     }
  38.                 }
  39.             }
  40.             if (m == null) {
  41.                 m = new ObjectStreamField(
  42.                     f.getName(), f.getSignature(), false);
  43.             }
  44.             m.setOffset(f.getOffset());
  45.             matches[i] = m;
  46.         }
  47.         return matches;
  48.     }
　　newInstance方法——这个方法相信读者都不会陌生，只是需要知道这里的newInstance创建的实例不是ObjectStreamClass的实例，而是被解析类的实例，也就是说当它去解析某个类获取类的元数据时，这个方法创建的是被解析类的实例，创建方式是调用被解析类的构造函数，和前边sun.reflect.ReflectionFactory的创建方式不一样。它的调用规则如下：
  • 如果被解析的类是实现了Externalizable接口可外部化的一个类，则调用它的public无参构造函数；
  • 如果被解析的类是实现了Serializable接口可序列化的一个类，则调用先调用它的父类的无参构造函数直到当前类实现递归调用；
  • 如果当前的类对应元数据信息和关联类不匹配则抛出UnsupportedOperationException异常；
  • 如果被解析的类不具有“可序列化”的语义，或者它的无参构造函数不能调用，则同样抛出UnsupportedOperationException异常；
　　该方法的定义如下： 
  1.     Object newInstance()
  2.         throws InstantiationException, InvocationTargetException,
  3.                UnsupportedOperationException
  4.     {
  5.         if (cons != null) {
  6.             try {
  7.                 return cons.newInstance();
  8.             } catch (IllegalAccessException ex) {
  9.                 // should not occur, as access checks have been suppressed
  10.                 throw new InternalError();
  11.             }
  12.         } else {
  13.             throw new UnsupportedOperationException();
  14.         }
  15.     }
　　13）ClassDataSlot相关
　　在ObjectStreamClass分析过程中，遇到了一个ClassDataSlot类，这个类具体做什么用呢？先看看和它相关的两个成员函数【getClassDataLayout和getClassDataLayout0】定义，然后来看看它里面的结构。
　　getClassDataLayout方法定义如下： 
  1.     ClassDataSlot[] getClassDataLayout() throws InvalidClassException {
  2.         // REMIND: synchronize instead of relying on volatile?
  3.         if (dataLayout == null) {
  4.             dataLayout = getClassDataLayout0();
  5.         }
  6.         return dataLayout;
  7.     }
　　getClassDataLayout0方法定义如下： 
  1.     private ClassDataSlot[] getClassDataLayout0()
  2.         throws InvalidClassException
  3.     {
  4.         ArrayList<ClassDataSlot> slots = new ArrayList<>();
  5.         Class<?> start = cl, end = cl;
  6.  
  7.         // locate closest non-serializable superclass
  8.         while (end != null && Serializable.class.isAssignableFrom(end)) {
  9.             end = end.getSuperclass();
  10.         }
  11.  
  12.         for (ObjectStreamClass d = this; d != null; d = d.superDesc) {
  13.  
  14.             // search up inheritance hierarchy for class with matching name
  15.             String searchName = (d.cl != null) ? d.cl.getName() : d.name;
  16.             Class<?> match = null;
  17.             for (Class<?> c = start; c != end; c = c.getSuperclass()) {
  18.                 if (searchName.equals(c.getName())) {
  19.                     match = c;
  20.                     break;
  21.                 }
  22.             }
  23.  
  24.             // add "no data" slot for each unmatched class below match
  25.             if (match != null) {
  26.                 for (Class<?> c = start; c != match; c = c.getSuperclass()) {
  27.                     slots.add(new ClassDataSlot(
  28.                         ObjectStreamClass.lookup(c, true), false));
  29.                 }
  30.                 start = match.getSuperclass();
  31.             }
  32.  
  33.             // record descriptor/class pairing
  34.             slots.add(new ClassDataSlot(d.getVariantFor(match), true));
  35.         }
  36.  
  37.         // add "no data" slot for any leftover unmatched classes
  38.         for (Class<?> c = start; c != end; c = c.getSuperclass()) {
  39.             slots.add(new ClassDataSlot(
  40.                 ObjectStreamClass.lookup(c, true), false));
  41.         }
  42.  
  43.         // order slots from superclass -> subclass
  44.         Collections.reverse(slots);
  45.         return slots.toArray(new ClassDataSlot[slots.size()]);
  46.     }
　　上述两个方法都和ClassDataSlot相关，至于getClassDataLayout类不用讲解，它调用的就是getClassDataLayout0方法，看看getClassDataLayout0方法究竟做了些什么。实际上这个类的含义很简单，本文解析了序列化一个Java对象的顺序，而且在序列化输出一个Java对象的类描述符的时候，不知读者是否还记得它的顺序是从顶级父类 -> 当前类，而ClassDataSlot的内部类中核心属性就是desc【ObjectStreamClass】，那么答案就出来了：getClassDataLayout0递归获取当前序列化对象的父类的元数据信息直到当前类，并且把所有元数据信息保存在一个数组中，这个数组中的元素是ClassDataSlot类型，该类型使用“组合”方式封装了ObjectStreamClass类型。实际上正因为有了这两个方法，在序列化一个对象的时候才能实现针对它的顶级父类到当前类的类的元数据的从上至下递归序列化。
　　14）look*方法：
　　look*方法主要有三个，其中有两个是外部可使用的ObjectStreamClass的API，这个方法主要用于分析传入的类获取传入类的ObjectStreamClass实例【传入类的元数据信息】，ObjectStreamClass不仅仅可以分析构造函数传入类生成一个传入类的元数据信息——也就是自身类【成员属性cl】的元数据信息，而且可以通过lookup成员API去分析任何一个类获取任何一个类的ObjectStreamClass实例以取得传入类的元数据信息。先看看lookup方法的代码定义：
　　lookup、lookupAny 
  1.     public static ObjectStreamClass lookup(Class<?> cl) {
  2.         return lookup(cl, false);
  3.     }
  4.     public static ObjectStreamClass lookupAny(Class<?> cl) {
  5.         return lookup(cl, true);
  6.     }
  7.     static ObjectStreamClass lookup(Class<?> cl, boolean all) {
  8.         if (!(all || Serializable.class.isAssignableFrom(cl))) {
  9.             return null;
  10.         }
  11.         processQueue(Caches.localDescsQueue, Caches.localDescs);
  12.         WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);
  13.         Reference<?> ref = Caches.localDescs.get(key);
  14.         Object entry = null;
  15.         if (ref != null) {
  16.             entry = ref.get();
  17.         }
  18.         EntryFuture future = null;
  19.         if (entry == null) {
  20.             EntryFuture newEntry = new EntryFuture();
  21.             Reference<?> newRef = new SoftReference<>(newEntry);
  22.             do {
  23.                 if (ref != null) {
  24.                     Caches.localDescs.remove(key, ref);
  25.                 }
  26.                 ref = Caches.localDescs.putIfAbsent(key, newRef);
  27.                 if (ref != null) {
  28.                     entry = ref.get();
  29.                 }
  30.             } while (ref != null && entry == null);
  31.             if (entry == null) {
  32.                 future = newEntry;
  33.             }
  34.         }
  35.  
  36.  
  37.         if (entry instanceof ObjectStreamClass) {  // check common case first
  38.             return (ObjectStreamClass) entry;
  39.         }
  40.         if (entry instanceof EntryFuture) {
  41.             future = (EntryFuture) entry;
  42.             if (future.getOwner() == Thread.currentThread()) {
  43.                 /*
  44.                  * Handle nested call situation described by 4803747: waiting
  45.                  * for future value to be set by a lookup() call further up the
  46.                  * stack will result in deadlock, so calculate and set the
  47.                  * future value here instead.
  48.                  */
  49.                 entry = null;
  50.             } else {
  51.                 entry = future.get();
  52.             }
  53.         }
  54.         if (entry == null) {
  55.             try {
  56.                 entry = new ObjectStreamClass(cl);
  57.             } catch (Throwable th) {
  58.                 entry = th;
  59.             }
  60.             if (future.set(entry)) {
  61.                 Caches.localDescs.put(key, new SoftReference<Object>(entry));
  62.             } else {
  63.                 // nested lookup call already set future
  64.                 entry = future.get();
  65.             }
  66.         }
  67.  
  68.  
  69.         if (entry instanceof ObjectStreamClass) {
  70.             return (ObjectStreamClass) entry;
  71.         } else if (entry instanceof RuntimeException) {
  72.             throw (RuntimeException) entry;
  73.         } else if (entry instanceof Error) {
  74.             throw (Error) entry;
  75.         } else {
  76.             throw new InternalError("unexpected entry: " + entry);
  77.         }
  78.     }
　　look*方法对外的两个API【lookup和lookupAny】实际上也就是调用了默认default域中的方法，所以只要理解了default域的lookup方法就等于理解了ObjectStreamClass中的look*方法，看看下边的代码流程：
  1. 先检查传入的类是否支持序列化，第二个参数告诉ObjectStreamClass实例是否需要检测传入类的可序列化语义，lookup对外的API方法调用时传入的第二个参数为false，lookupAny对外的API方法调用时传入的第二个参数为true——实际上第二个参数若为false就必须检查被解析类是否具有“可序列化”的语义【这里的可序列化语义仅仅检查传入类是否实现了Serializable接口】；
    1.         if (!(all || Serializable.class.isAssignableFrom(cl))) {
    2.             return null;
    3.         }
  2. 使用processQueue方法清空Caches类中的缓存哈希表localDescs，其缓存清除的哈希表键值是保存于一个ReferenceQueue队列localDescsQueue中，清除这个Caches类中的缓存哈希表时，需要根据ReferenceQueue中保存的键值来清除缓存中的项，从这一点可以知道Caches类中的四个成员是成对使用的，一对用于分析类，另外一对用于分析成员属性；
            processQueue(Caches.localDescsQueue, Caches.localDescs);
  3. 通过传入的cl参数以及Caches中的localDescsQueue属性构造一个新的WeakClassKey对象key，这个引用key会在后边作为缓存哈希表的键值；
    WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);
  4. 利用上一步创建的WeakClassKey对象作为哈希表键值，尝试先从缓存Caches.localDescs的哈希表中获取一个存在的引用ref；
            Reference<?> ref = Caches.localDescs.get(key);
  5. 创建一个新的Object引用entry，赋值为null；若第四步获取的ref引用不为空，则直接将ref指向的对象【缓存中】赋给entry；
    1.         Object entry = null;
    2.         if (ref != null) {
    3.             entry = ref.get();
    4.         }
  6. 创建一个新的EntryFuture引用future，如果entry为null的时候则配合Caches中的缓存localDescs初始化entry；
    1.         EntryFuture future = null;
    2.         if (entry == null) {
    3.             EntryFuture newEntry = new EntryFuture();
    4.             Reference<?> newRef = new SoftReference<>(newEntry);
    5.             do {
    6.                 if (ref != null) {
    7.                     Caches.localDescs.remove(key, ref);
    8.                 }
    9.                 ref = Caches.localDescs.putIfAbsent(key, newRef);
    10.                 if (ref != null) {
    11.                     entry = ref.get();
    12.                 }
    13.             } while (ref != null && entry == null);
    14.             if (entry == null) {
    15.                 future = newEntry;
    16.             }
    17.         }
  7. 如果从缓存中拿到的entry类型本身就是ObjectStreamClass则直接返回这个entry；
    1.         if (entry instanceof ObjectStreamClass) {  // check common case first
    2.             return (ObjectStreamClass) entry;
    3.         }
  8. 如果从缓存中拿到的entry类型为EntryFuture，则从EntryFuture中去获取entry；
    1.         if (entry instanceof EntryFuture) {
    2.             future = (EntryFuture) entry;
    3.             if (future.getOwner() == Thread.currentThread()) {
    4.                 /*
    5.                  * Handle nested call situation described by 4803747: waiting
    6.                  * for future value to be set by a lookup() call further up the
    7.                  * stack will result in deadlock, so calculate and set the
    8.                  * future value here instead.
    9.                  */
    10.                 entry = null;
    11.             } else {
    12.                 entry = future.get();
    13.             }
    14.         }
  9. 到目前为止拿到的entry还是一个null的时候就直接使用当前的cl参数构造一个新的ObjectStreamClass，构造完成过后将entry放入localDescs缓存中；
    1.         if (entry == null) {
    2.             try {
    3.                 entry = new ObjectStreamClass(cl);
    4.             } catch (Throwable th) {
    5.                 entry = th;
    6.             }
    7.             if (future.set(entry)) {
    8.                 Caches.localDescs.put(key, new SoftReference<Object>(entry));
    9.             } else {
    10.                 // nested lookup call already set future
    11.                 entry = future.get();
    12.             }
    13.         }
  10. 最终判断entry的类型执行异常处理或者返回；
    1.         if (entry instanceof ObjectStreamClass) {
    2.             return (ObjectStreamClass) entry;
    3.         } else if (entry instanceof RuntimeException) {
    4.             throw (RuntimeException) entry;
    5.         } else if (entry instanceof Error) {
    6.             throw (Error) entry;
    7.         } else {
    8.             throw new InternalError("unexpected entry: " + entry);
    9.         }
　　15）构造函数
　　ObjectStreamClass到这里其实代码执行流程的内容都还没怎么解析，接下来看看该类的构造函数。该类有两个构造函数，先看看它的构造函数定义： 
  1.     private ObjectStreamClass(final Class<?> cl) {
  2.         this.cl = cl;
  3.         name = cl.getName();
  4.         isProxy = Proxy.isProxyClass(cl);
  5.         isEnum = Enum.class.isAssignableFrom(cl);
  6.         serializable = Serializable.class.isAssignableFrom(cl);
  7.         externalizable = Externalizable.class.isAssignableFrom(cl);
  8.  
  9.         Class<?> superCl = cl.getSuperclass();
  10.         superDesc = (superCl != null) ? lookup(superCl, false) : null;
  11.         localDesc = this;
  12.  
  13.         if (serializable) {
  14.             AccessController.doPrivileged(new PrivilegedAction<Void>() {
  15.                 public Void run() {
  16.                     if (isEnum) {
  17.                         suid = Long.valueOf(0);
  18.                         fields = NO_FIELDS;
  19.                         return null;
  20.                     }
  21.                     if (cl.isArray()) {
  22.                         fields = NO_FIELDS;
  23.                         return null;
  24.                     }
  25.  
  26.                     suid = getDeclaredSUID(cl);
  27.                     try {
  28.                         fields = getSerialFields(cl);
  29.                         computeFieldOffsets();
  30.                     } catch (InvalidClassException e) {
  31.                         serializeEx = deserializeEx =
  32.                             new ExceptionInfo(e.classname, e.getMessage());
  33.                         fields = NO_FIELDS;
  34.                     }
  35.  
  36.                     if (externalizable) {
  37.                         cons = getExternalizableConstructor(cl);
  38.                     } else {
  39.                         cons = getSerializableConstructor(cl);
  40.                         writeObjectMethod = getPrivateMethod(cl, "writeObject",
  41.                             new Class<?>[] { ObjectOutputStream.class },
  42.                             Void.TYPE);
  43.                         readObjectMethod = getPrivateMethod(cl, "readObject",
  44.                             new Class<?>[] { ObjectInputStream.class },
  45.                             Void.TYPE);
  46.                         readObjectNoDataMethod = getPrivateMethod(
  47.                             cl, "readObjectNoData", null, Void.TYPE);
  48.                         hasWriteObjectData = (writeObjectMethod != null);
  49.                     }
  50.                     writeReplaceMethod = getInheritableMethod(
  51.                         cl, "writeReplace", null, Object.class);
  52.                     readResolveMethod = getInheritableMethod(
  53.                         cl, "readResolve", null, Object.class);
  54.                     return null;
  55.                 }
  56.             });
  57.         } else {
  58.             suid = Long.valueOf(0);
  59.             fields = NO_FIELDS;
  60.         }
  61.  
  62.         try {
  63.             fieldRefl = getReflector(fields, this);
  64.         } catch (InvalidClassException ex) {
  65.             // field mismatches impossible when matching local fields vs. self
  66.             throw new InternalError();
  67.         }
  68.  
  69.         if (deserializeEx == null) {
  70.             if (isEnum) {
  71.                 deserializeEx = new ExceptionInfo(name, "enum type");
  72.             } else if (cons == null) {
  73.                 deserializeEx = new ExceptionInfo(name, "no valid constructor");
  74.             }
  75.         }
  76.         for (int i = 0; i < fields.length; i++) {
  77.             if (fields[i].getField() == null) {
  78.                 defaultSerializeEx = new ExceptionInfo(
  79.                     name, "unmatched serializable field(s) declared");
  80.             }
  81.         }
  82.     }
  83.     ObjectStreamClass() {
  84.     }
　　从上边的代码可以知道，第二个构造函数没有必要解析，ObjectStreamClass的无参构造函数用于构造一个空白的类描述信息，若创建了这样的一个实例，则需要在之后调用initProxy、initNonProxy和readNonProxy方法来执行类的元数据初始化操作。那么这里看看第一个构造函数究竟做了些什么事：
  1. 设置成员属性的基本信息，传入的是一个Class<?>类型的参数cl，可以通过Java反射获得基本成员属性的信息：
    cl——直接将该引用指向传入的类；
    name——获取传入类的类名；
    isProxy——调用java.lang.reflect.Proxy的isProxyClass方法判断传入类是否是一个Java中的动态代理类；
    isEnum——判断当前类是否是一个Enum枚举的类；
    serializable——判断当前类是否实现了Serializable接口；
    externalizable——判断当前类是否实现了Externalizable接口；
  2. 设置localDesc和superDesc两个成员属性：
    superDesc——通过getSuperclass方法获取当前类的父类，然后通过lookup方法获取父类的元数据信息，生成一个ObjectStreamClass实例，第二个参数为false表示要求检测父类是否实现了Serializable接口的；
    localDesc——直接将当前ObjectStreamClass引用this赋值给localDesc引用；
  3. 然后需要判断当前解析类是否支持可序列化【实现Serializable接口】，这个时候不需要通过Serializable类来判断被解析类的“可序列化”的语义，直接检查成员属性serializable即可——注意这里会有一个包含关系，如果一个类是实现了Externalizable接口的，那么这个类一定实现了Serializable接口的，前文提到过Serializable接口是Externalizable的父接口；
    如果当前解析类没有实现Serializable接口，则设置成员属性suid和fields的值：
    suid——0L；
    fields——NO_FIELDS；
  4. 如果当前解析类实现了Serializable接口，代码会先调用Java语言中的访问控制器来判断代码是否拥有执行权限；
  5. 通过Java的访问控制器过后，则同样需要设置可序列化的情况下成员属性suid和fields的值，先看看设置这两个成员属性设置的过程：
    1.                     if (isEnum) {
    2.                         suid = Long.valueOf(0);
    3.                         fields = NO_FIELDS;
    4.                         return null;
    5.                     }
    6.                     if (cl.isArray()) {
    7.                         fields = NO_FIELDS;
    8.                         return null;
    9.                     }
    10.  
    11.                     suid = getDeclaredSUID(cl);
    12.                     try {
    13.                         fields = getSerialFields(cl);
    14.                         computeFieldOffsets();
    15.                     } catch (InvalidClassException e) {
    16.                         serializeEx = deserializeEx =
    17.                             new ExceptionInfo(e.classname, e.getMessage());
    18.                         fields = NO_FIELDS;
    19.                     }
    从上述代码可以看到，这段代码的设置如下：
    如果被解析类是枚举类型——suid的值为0L，fields的值为NO_FIELDS；
    如果被解析类是数组类型——fields的值为NO_FIELDS，suid的值会继续运算；
    suid的值的计算——getDeclaredSUID方法运算，前文分析过getDeclaredSUID方法的代码细节，这里不重复；
    fields的值的计算——getSerialFields方法运算，前文分析过getSerialFields方法的代码细节，这里不重复；
    *：这个地方有个小细节，在代码中调用了computeFieldOffsets方法，这个方法调用过后，两个成员属性primDataSize和numObjFields的值也就有了【不针对枚举类型和数组类型】；
  6. 在设置了suid和fields两个成员属性的值过后，则需要设置下边几个成员属性：
    cons、writeObjectMethod、readObjectMethod、readObjectNoDataMethod、hasWriteObjectData、writeReplaceMethod、readResolveMethod；
    1.                     if (externalizable) {
    2.                         cons = getExternalizableConstructor(cl);
    3.                     } else {
    4.                         cons = getSerializableConstructor(cl);
    5.                         writeObjectMethod = getPrivateMethod(cl, "writeObject",
    6.                             new Class<?>[] { ObjectOutputStream.class },
    7.                             Void.TYPE);
    8.                         readObjectMethod = getPrivateMethod(cl, "readObject",
    9.                             new Class<?>[] { ObjectInputStream.class },
    10.                             Void.TYPE);
    11.                         readObjectNoDataMethod = getPrivateMethod(
    12.                             cl, "readObjectNoData", null, Void.TYPE);
    13.                         hasWriteObjectData = (writeObjectMethod != null);
    14.                     }
    15.                     writeReplaceMethod = getInheritableMethod(
    16.                         cl, "writeReplace", null, Object.class);
    17.                     readResolveMethod = getInheritableMethod(
    18.                         cl, "readResolve", null, Object.class);
    19.                     return null;
    相信不需要解释上边代码的含义了。代码执行到这里，大部分成员属性的构造初始化过程都完成了；
  7. 接下来就初始化fields以及fieldRefl两个成员属性，通过调用getReflector方法来计算这两个属性的值，回顾一下上边的getReflector方法传入的参数fields是传的引用，所以在执行getReflector方法后传入的fields的值就被初始化了，而且该方法的返回对象的引用会传给fieldRefl——getReflector方法执行过后具有“二义性”，它不是单纯地返回了一个FieldReflector，在执行过程中还修改了fields引用的对象的值；
  8. 最后看看剩余的几个和异常信息相关的成员属性的初始化：
    1.         if (deserializeEx == null) {
    2.             if (isEnum) {
    3.                 deserializeEx = new ExceptionInfo(name, "enum type");
    4.             } else if (cons == null) {
    5.                 deserializeEx = new ExceptionInfo(name, "no valid constructor");
    6.             }
    7.         }
    8.         for (int i = 0; i < fields.length; i++) {
    9.             if (fields[i].getField() == null) {
    10.                 defaultSerializeEx = new ExceptionInfo(
    11.                     name, "unmatched serializable field(s) declared");
    12.             }
    13.         }
    前文中虽然讲过几个异常信息类，这里先看看第5步解析的代码中的catch块的内容：
    1.                         serializeEx = deserializeEx =
    2.                             new ExceptionInfo(e.classname, e.getMessage());
    3.                         fields = NO_FIELDS;
    从上边这段代码中可以看到serializeEx和deserializeEx会在获取被解析类的可序列化字段元数据过程中因为出现异常而设置；其实isEnum为空的语句是一句“防御式”的编程，在前边调用过程如果isEnum判断为真则serializeEx和deserializeEx都会为null，而这里再作判断的情况可能就属于十分稀有的情况了；
　　16）初始化方法
　　到这里ObjectStreamClass中就只剩下4个成员函数没有解析了：initProxy、initNonProxy、readNonProxy、writeNonProxy，这四个方法属于ObjectStreamClass中的核心方法，所以这四个方法会在接下来重点解析。本章节先看看初始化解析方法——initProxy和initNonProxy成员函数，initProxy负责解析动态代理类，initNonProxy负责解析非动态代理类，这两个方法会用于初始化当前ObjectStreamClass元数据实例。
　　initProxy成员函数： 
  1.     void initProxy(Class<?> cl,
  2.                    ClassNotFoundException resolveEx,
  3.                    ObjectStreamClass superDesc)
  4.         throws InvalidClassException
  5.     {
  6.         this.cl = cl;
  7.         this.resolveEx = resolveEx;
  8.         this.superDesc = superDesc;
  9.         isProxy = true;
  10.         serializable = true;
  11.         suid = Long.valueOf(0);
  12.         fields = NO_FIELDS;
  13.  
  14.         if (cl != null) {
  15.             localDesc = lookup(cl, true);
  16.             if (!localDesc.isProxy) {
  17.                 throw new InvalidClassException(
  18.                     "cannot bind proxy descriptor to a non-proxy class");
  19.             }
  20.             name = localDesc.name;
  21.             externalizable = localDesc.externalizable;
  22.             cons = localDesc.cons;
  23.             writeReplaceMethod = localDesc.writeReplaceMethod;
  24.             readResolveMethod = localDesc.readResolveMethod;
  25.             deserializeEx = localDesc.deserializeEx;
  26.         }
  27.         fieldRefl = getReflector(fields, localDesc);
  28.     }
　　initProxy主要用于解析动态代理类初始化ObjectStreamClass实例，这个成员函数有三个参数，先看看这三个参数的含义：
  • cl——java.lang.Class<?>
    该参数表示需要被解析类，该方法解析的元数据信息就是从这个类中提取的；
  • resolveEx——java.lang.ClassNotFoundException
    该参数用于处理启用”resolve”功能时的异常信息；
  • superDesc——java.io.ObjectStreamClass
    该参数表示当前类对应的父类的元数据信息；
　　看看这个函数中的细节代码流程，看看究竟initProxy初始化的时候做了些什么。
  1. 看看设置成员函数的过程：
    cl——将传入的Class<?>类型的参数赋给成员属性cl；
    resolveEx——将传入的ClassNotFoundException类型的参数赋给成员属性resolveExt；
    superDesc——将传入的ObjectStreamClass类型的参数赋给成员属性superDesc；
    isProxy——因为这个成员函数的作用就是解析动态代理类，所以isProxy设置为true；
    serializable——标识当前解析类是可序列化的，设置值为true；
    suid——因为解析类是动态代理类，所以suid为0L；
    fields——同上述理由，设置fields的值为NO_FIELDS；
  2. 如果成员函数cl不为null，则执行额外逻辑：
    localDesc——调用lookup方法解析传入类，获取该类的元数据信息，并将该元数据引用赋给localDesc，localDesc赋值过后，判断解析类是否为一个动态代理类，如果不是动态代理类则抛出InvalidClassException异常；
    下边的几个成员属性直接从localDesc中读取：
    name、externalizable、cons、writeReplaceMethod、readResolveMethod、deserializable
  3. 最后设置成员属性fieldRefls，直接调用getReflector方法获得；
　　initNonProxy成员函数： 
  1.     void initNonProxy(ObjectStreamClass model,
  2.                       Class<?> cl,
  3.                       ClassNotFoundException resolveEx,
  4.                       ObjectStreamClass superDesc)
  5.         throws InvalidClassException
  6.     {
  7.         this.cl = cl;
  8.         this.resolveEx = resolveEx;
  9.         this.superDesc = superDesc;
  10.         name = model.name;
  11.         suid = Long.valueOf(model.getSerialVersionUID());
  12.         isProxy = false;
  13.         isEnum = model.isEnum;
  14.         serializable = model.serializable;
  15.         externalizable = model.externalizable;
  16.         hasBlockExternalData = model.hasBlockExternalData;
  17.         hasWriteObjectData = model.hasWriteObjectData;
  18.         fields = model.fields;
  19.         primDataSize = model.primDataSize;
  20.         numObjFields = model.numObjFields;
  21.  
  22.         if (cl != null) {
  23.             localDesc = lookup(cl, true);
  24.             if (localDesc.isProxy) {
  25.                 throw new InvalidClassException(
  26.                     "cannot bind non-proxy descriptor to a proxy class");
  27.             }
  28.             if (isEnum != localDesc.isEnum) {
  29.                 throw new InvalidClassException(isEnum ?
  30.                     "cannot bind enum descriptor to a non-enum class" :
  31.                     "cannot bind non-enum descriptor to an enum class");
  32.             }
  33.  
  34.             if (serializable == localDesc.serializable &&
  35.                 !cl.isArray() &&
  36.                 suid.longValue() != localDesc.getSerialVersionUID())
  37.             {
  38.                 throw new InvalidClassException(localDesc.name,
  39.                     "local class incompatible: " +
  40.                     "stream classdesc serialVersionUID = " + suid +
  41.                     ", local class serialVersionUID = " +
  42.                     localDesc.getSerialVersionUID());
  43.             }
  44.  
  45.             if (!classNamesEqual(name, localDesc.name)) {
  46.                 throw new InvalidClassException(localDesc.name,
  47.                     "local class name incompatible with stream class " +
  48.                     "name \"" + name + "\"");
  49.             }
  50.  
  51.             if (!isEnum) {
  52.                 if ((serializable == localDesc.serializable) &&
  53.                     (externalizable != localDesc.externalizable))
  54.                 {
  55.                     throw new InvalidClassException(localDesc.name,
  56.                         "Serializable incompatible with Externalizable");
  57.                 }
  58.  
  59.                 if ((serializable != localDesc.serializable) ||
  60.                     (externalizable != localDesc.externalizable) ||
  61.                     !(serializable || externalizable))
  62.                 {
  63.                     deserializeEx = new ExceptionInfo(
  64.                         localDesc.name, "class invalid for deserialization");
  65.                 }
  66.             }
  67.  
  68.             cons = localDesc.cons;
  69.             writeObjectMethod = localDesc.writeObjectMethod;
  70.             readObjectMethod = localDesc.readObjectMethod;
  71.             readObjectNoDataMethod = localDesc.readObjectNoDataMethod;
  72.             writeReplaceMethod = localDesc.writeReplaceMethod;
  73.             readResolveMethod = localDesc.readResolveMethod;
  74.             if (deserializeEx == null) {
  75.                 deserializeEx = localDesc.deserializeEx;
  76.             }
  77.         }
  78.         fieldRefl = getReflector(fields, localDesc);
  79.         // reassign to matched fields so as to reflect local unshared settings
  80.         fields = fieldRefl.getFields();
  81.     }
　　initNonProxy成员函数用于解析非动态代理类初始化ObjectStreamClass实例，这个成员函数比initProxy成员函数多了一个参数：
  • model——java.io.ObjectStreamClass
    该参数表示需要传入的元数据信息，调用该成员函数的时候会利用传入的元数据信息为当前实例赋值；
　　看看这个成员函数的细节代码流程，并且对比initProxy函数看看二者有什么不同：
  1. 成员属性cl、resolveEx、superDesc和initProxy使用相同的方式赋值；
  2. 成员属性name、isEnum、serializable、externalizable、hasBlockExternalData、hasWriteObjectData、fields、primDataSize、numObjects直接从传入参数model中取得；
  3. 成员属性suid和isProxy的设置稍有不同，suid通过调用model的getSerialVersionUID方法获得，isProxy直接设置成false——因为initNonProxy成员函数的目的是解析非动态代理类，所以直接为isProxy赋值；
  4. 当成员cl不为null时，initNonProxy的执行流程和initProxy差不多，唯一不同的是多了许多异常信息，看看抛出异常的情况：
    ——如果被解析类为动态代理类则抛出异常；
    ——如果model中的isEnum【第二步已经赋值给isEnum了】和localDesc中的isEnum不相等则抛出异常；
    ——如果model中的serializable和localDesc中的serializable相等、并且cl不是数组、并且model中suid的值和localDesc中suid的值不相等时，则抛出异常【前边三个条件同时满足才行】；
    ——如果model中的name和localDesc中的name不相等时则抛出异常；
    ——如果被解析类不是枚举类型时抛异常的情况分为下边两种：
    　　(1) 如果model中serializable和localDesc中的serializable相等，但externalizable不相等则抛出异常；
    　　(2) 如果model和localDesc描述的类任何一个类没有序列化语义则抛出异常【未实现Serializable或者Externalizable接口】；
  5. fieldRefl成员属性的赋值和initProxy一样；
  6. initNonProxy成员属性多了下边这行代码，至于目的可见注释部分内容：
    1.         // reassign to matched fields so as to reflect local unshared settings
    2.         fields = fieldRefl.getFields();
　　17）序列化 & 反序列化
　　ObjectStreamClass类中最后需要解析的成员函数是writeNonProxy和readNonProxy，这两个成员函数负责序列化和反序列化操作，在ObjectOutputStream中会调用这两个方法针对对象所属类的元数据执行序列化或反序列化操作【*：这个类中只包含了非动态代理类的序列化和反序列化方法，所以名称后缀为NonProxy】。这两个函数的参数一个是ObjectOutputStream类型，另外一个参数是ObjectInputStream类型，这两个类后边会解析，这里不详讲。
　　writeNonProxy序列化函数： 
  1.     void writeNonProxy(ObjectOutputStream out) throws IOException {
  2.         out.writeUTF(name);
  3.         out.writeLong(getSerialVersionUID());
  4.  
  5.         byte flags = 0;
  6.         if (externalizable) {
  7.             flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
  8.             int protocol = out.getProtocolVersion();
  9.             if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {
  10.                 flags |= ObjectStreamConstants.SC_BLOCK_DATA;
  11.             }
  12.         } else if (serializable) {
  13.             flags |= ObjectStreamConstants.SC_SERIALIZABLE;
  14.         }
  15.         if (hasWriteObjectData) {
  16.             flags |= ObjectStreamConstants.SC_WRITE_METHOD;
  17.         }
  18.         if (isEnum) {
  19.             flags |= ObjectStreamConstants.SC_ENUM;
  20.         }
  21.         out.writeByte(flags);
  22.  
  23.         out.writeShort(fields.length);
  24.         for (int i = 0; i < fields.length; i++) {
  25.             ObjectStreamField f = fields[i];
  26.             out.writeByte(f.getTypeCode());
  27.             out.writeUTF(f.getName());
  28.             if (!f.isPrimitive()) {
  29.                 out.writeTypeString(f.getTypeString());
  30.             }
  31.         }
  32.     }
　　看看这个方法的代码流程：
  1. 先调用writeUTF方法写入类名到字节流，这里的类名为带了包名的类全名：
            out.writeUTF(name);
  2. 然后调用writeLong方法写入suid的值到字节流，也就是前边解析二进制序列时serialVersionUID的值；
            out.writeLong(getSerialVersionUID());
  3. 写入标记到字节流，这里的标记为前文提到的五个SC_*标记，注意这个标记只占一个字节的数据，flags的类型为byte，至于标记的运算细节很简单，读者可仔细阅读下边的代码：
    1.         byte flags = 0;
    2.         if (externalizable) {
    3.             flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
    4.             int protocol = out.getProtocolVersion();
    5.             if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {
    6.                 flags |= ObjectStreamConstants.SC_BLOCK_DATA;
    7.             }
    8.         } else if (serializable) {
    9.             flags |= ObjectStreamConstants.SC_SERIALIZABLE;
    10.         }
    11.         if (hasWriteObjectData) {
    12.             flags |= ObjectStreamConstants.SC_WRITE_METHOD;
    13.         }
    14.         if (isEnum) {
    15.             flags |= ObjectStreamConstants.SC_ENUM;
    16.         }
    17.         out.writeByte(flags);
  4. 写入当前类中成员属性的数量信息到字节流：
            out.writeShort(fields.length);
  5. 最后写入每一个字段的信息，字段信息包含三部分内容：类型代码、字段名、字段类型字符串【该信息不适用于基础类型的数据】
    1.         for (int i = 0; i < fields.length; i++) {
    2.             ObjectStreamField f = fields[i];
    3.             out.writeByte(f.getTypeCode());
    4.             out.writeUTF(f.getName());
    5.             if (!f.isPrimitive()) {
    6.                 out.writeTypeString(f.getTypeString());
    7.             }
    8.         }
　　readNonProxy反序列化函数： 
  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.     }
　　看看这个方法的代码流程：
  1. 先从字节流中读取类名信息：
    name = in.readUTF();
  2. 其次从字节流中读取suid的信息，即类的serialVersionUID信息：
            suid = Long.valueOf(in.readLong());
  3. 从字节流中读取SC_*标记信息，通过该标记信息设置对应的成员属性：
    1.         byte flags = in.readByte();
    2.         hasWriteObjectData =
    3.             ((flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0);
    4.         hasBlockExternalData =
    5.             ((flags & ObjectStreamConstants.SC_BLOCK_DATA) != 0);
    6.         externalizable =
    7.             ((flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0);
    8.         boolean sflag =
    9.             ((flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0);
    10.         if (externalizable && sflag) {
    11.             throw new InvalidClassException(
    12.                 name, "serializable and externalizable flags conflict");
    13.         }
    14.         serializable = externalizable || sflag;
    15.         isEnum = ((flags & ObjectStreamConstants.SC_ENUM) != 0);
    16.         if (isEnum && suid.longValue() != 0L) {
    17.             throw new InvalidClassException(name,
    18.                 "enum descriptor has non-zero serialVersionUID: " + suid);
    19.         }
  4. 从字节流中读取成员属性的数量信息：
    1.         int numFields = in.readShort();
    2.         if (isEnum && numFields != 0) {
    3.             throw new InvalidClassException(name,
    4.                 "enum descriptor has non-zero field count: " + numFields);
    5.         }
  5. 最后从字节流中读取每一个字段的信息，字段信息包括：类型代码、字段名、字段类型字符串【非基础类型数据】：
    1.         fields = (numFields > 0) ?
    2.             new ObjectStreamField[numFields] : NO_FIELDS;
    3.         for (int i = 0; i < numFields; i++) {
    4.             char tcode = (char) in.readByte();
    5.             String fname = in.readUTF();
    6.             String signature = ((tcode == 'L') || (tcode == '[')) ?
    7.                 in.readTypeString() : new String(new char[] { tcode });
    8.             try {
    9.                 fields[i] = new ObjectStreamField(fname, signature, false);
    10.             } catch (RuntimeException e) {
    11.                 throw (IOException) new InvalidClassException(name,
    12.                     "invalid descriptor for field " + fname).initCause(e);
    13.             }
    14.         }
　　至于readNonProxy方法和writeNonProxy方法到异同，请读者结合上边解析过的代码仔细理解。
　　到这里，ObjectSreamClass的内容就全部解析完成了，阅读了这么多内容读者是否还是很困惑呢？前文内容庞大，所以在此先总结一下。ObjectStreamClass和ObjectStreamField两个类充当了解析过程中容器的作用，ObjectStreamClass实例表示被解析类的元数据信息，ObjectStreamField实例表示成员属性的元数据信息，所有上文提到的代码中，只有ObjectStreamClass中有两个真正和序列化以及反序列化过程相关的方法，就是writeNonProxy和readNonProxy。ObjectStreamClass以及ObjectStreamField使用得最多的概念就是“封装”，不仅仅是这两个类，实际上ObjectStreamClass的内部类也封装了很多信息，至于这两个类中错综复杂的结构只是为了提供统一的方式来解析元数据。整体的概念需要注意的点如下：
  • 签名信息
    ——包括：成员属性签名、成员函数签名、构造函数签名，结合代码中的signature去理解；
  • 关于类型
    ——区分：类型、类型代码、类型字符串的概念；
  • 五个SC标记
    ——SC_WRITE_METHOD、SC_BLOCKDATA、SC_SERIALIZABLE、SC_EXTERNALIZABLE、SC_ENUM，这五个标记的概念在源代码中多次涉及到；
  • 缓存
    ——理解ObjectStreamClass中的Caches类，通过本文的截图理解缓存的数据结构；
  • 两种Key：WeakClassKey & FieldReflectorKey
    ——理解两个内部类WeakClassKey和FieldRefectorKey的用法，这两个Key一般作为哈希表缓存的键值使用；
  • ClassDataSlot
    ——理解ClassDataSlot在源代码中的概念；
  • SUID
    ——结合前文JVM的序列化规范中提及的SUID理解源代码中针对SUID的计算方法；
  • FieldReflector
    ——理解源代码中内部类FieldReflector的用法，看看它是如何去分析类中的各个字段的；
  • serialPersistentFields
    ——这是一个Java类处理可序列化成员属性的另外一种方式，理解ObjectStreamClass中如何处理该字段；
  • 字段数组
    ——源代码中多次获取了ObjectStreamField[]的字段元数据数组，理解源代码中和这点相关的所有方法；
  • 特殊方法
    ——可序列化的类中包含了五个特殊方法，看看这五个特殊方法在源代码中如何处理：writeObject、readObject、readObjectNoData、writeReplace、readResolve；
  • 异常管理
    ——管理系统中的所有异常信息，理解如何在源代码中处理异常信息；
  • lookup
    ——理解ObjectStreamClass中的lookup方法，对比这两个方法和构造函数如何设置成员属性的相关信息；
  • Java语言基础
    ——若要理解上述源代码需要准备的Java知识：反射、动态代理类、安全检测、数据类型、基础算法等；
　　列举出这些代码相关的内容，希望读者以上述内容作为索引去理解源代码的内容，下一个章节开始我们就来看看序列化和反序列化中的另外两个核心类。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/201778
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号